diff options
| author | Eugene Sandulenko | 2012-04-28 01:00:14 +0300 |
|---|---|---|
| committer | Einar Johan Trøan Sømåen | 2012-06-02 12:42:08 +0200 |
| commit | 28c78b956dac6ee59d066f7ff2499569fe9877c7 (patch) | |
| tree | 07e37e79e5610d3f21d22a8243083b78e09f8542 /engines/wintermute/scriptables | |
| parent | 84fd9d0daca1846829b077aa18a7634df5e5ef9e (diff) | |
| download | scummvm-rg350-28c78b956dac6ee59d066f7ff2499569fe9877c7.tar.gz scummvm-rg350-28c78b956dac6ee59d066f7ff2499569fe9877c7.tar.bz2 scummvm-rg350-28c78b956dac6ee59d066f7ff2499569fe9877c7.zip | |
WINTERMUTE: Mass rename m_FooBar -> _fooBar
Diffstat (limited to 'engines/wintermute/scriptables')
20 files changed, 1548 insertions, 1548 deletions
diff --git a/engines/wintermute/scriptables/SXArray.cpp b/engines/wintermute/scriptables/SXArray.cpp index 5203945053..978de4ae52 100644 --- a/engines/wintermute/scriptables/SXArray.cpp +++ b/engines/wintermute/scriptables/SXArray.cpp @@ -38,33 +38,33 @@ IMPLEMENT_PERSISTENT(CSXArray, false) //////////////////////////////////////////////////////////////////////////
CSXArray::CSXArray(CBGame *inGame, CScStack *Stack): CBScriptable(inGame) {
- m_Length = 0;
- m_Values = new CScValue(Game);
+ _length = 0;
+ _values = new CScValue(Game);
int NumParams = Stack->Pop()->GetInt(0);
- if (NumParams == 1) m_Length = Stack->Pop()->GetInt(0);
+ if (NumParams == 1) _length = Stack->Pop()->GetInt(0);
else if (NumParams > 1) {
- m_Length = NumParams;
+ _length = NumParams;
char ParamName[20];
for (int i = 0; i < NumParams; i++) {
sprintf(ParamName, "%d", i);
- m_Values->SetProp(ParamName, Stack->Pop());
+ _values->SetProp(ParamName, Stack->Pop());
}
}
}
//////////////////////////////////////////////////////////////////////////
CSXArray::CSXArray(CBGame *inGame): CBScriptable(inGame) {
- m_Length = 0;
- m_Values = new CScValue(Game);
+ _length = 0;
+ _values = new CScValue(Game);
}
//////////////////////////////////////////////////////////////////////////
CSXArray::~CSXArray() {
- delete m_Values;
- m_Values = NULL;
+ delete _values;
+ _values = NULL;
}
@@ -73,16 +73,16 @@ char *CSXArray::ScToString() { static char Dummy[32768];
strcpy(Dummy, "");
char PropName[20];
- for (int i = 0; i < m_Length; i++) {
+ for (int i = 0; i < _length; i++) {
sprintf(PropName, "%d", i);
- CScValue *val = m_Values->GetProp(PropName);
+ CScValue *val = _values->GetProp(PropName);
if (val) {
if (strlen(Dummy) + strlen(val->GetString()) < 32768) {
strcat(Dummy, val->GetString());
}
}
- if (i < m_Length - 1 && strlen(Dummy) + 1 < 32768) strcat(Dummy, ",");
+ if (i < _length - 1 && strlen(Dummy) + 1 < 32768) strcat(Dummy, ",");
}
return Dummy;
}
@@ -98,11 +98,11 @@ HRESULT CSXArray::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Thi char ParamName[20];
for (int i = 0; i < NumParams; i++) {
- m_Length++;
- sprintf(ParamName, "%d", m_Length - 1);
- m_Values->SetProp(ParamName, Stack->Pop(), true);
+ _length++;
+ sprintf(ParamName, "%d", _length - 1);
+ _values->SetProp(ParamName, Stack->Pop(), true);
}
- Stack->PushInt(m_Length);
+ Stack->PushInt(_length);
return S_OK;
}
@@ -114,12 +114,12 @@ HRESULT CSXArray::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Thi Stack->CorrectParams(0);
- if (m_Length > 0) {
+ if (_length > 0) {
char ParamName[20];
- sprintf(ParamName, "%d", m_Length - 1);
- Stack->Push(m_Values->GetProp(ParamName));
- m_Values->DeleteProp(ParamName);
- m_Length--;
+ sprintf(ParamName, "%d", _length - 1);
+ Stack->Push(_values->GetProp(ParamName));
+ _values->DeleteProp(ParamName);
+ _length--;
} else Stack->PushNULL();
return S_OK;
@@ -131,22 +131,22 @@ HRESULT CSXArray::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Thi //////////////////////////////////////////////////////////////////////////
CScValue *CSXArray::ScGetProperty(char *Name) {
- m_ScValue->SetNULL();
+ _scValue->SetNULL();
//////////////////////////////////////////////////////////////////////////
// Type
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Type") == 0) {
- m_ScValue->SetString("array");
- return m_ScValue;
+ _scValue->SetString("array");
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Length
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "Length") == 0) {
- m_ScValue->SetInt(m_Length);
- return m_ScValue;
+ _scValue->SetInt(_length);
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
@@ -155,8 +155,8 @@ CScValue *CSXArray::ScGetProperty(char *Name) { else {
char ParamName[20];
if (ValidNumber(Name, ParamName)) {
- return m_Values->GetProp(ParamName);
- } else return m_ScValue;
+ return _values->GetProp(ParamName);
+ } else return _scValue;
}
}
@@ -167,14 +167,14 @@ HRESULT CSXArray::ScSetProperty(char *Name, CScValue *Value) { // Length
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Length") == 0) {
- int OrigLength = m_Length;
- m_Length = MAX(Value->GetInt(0), 0);
+ int OrigLength = _length;
+ _length = MAX(Value->GetInt(0), 0);
char PropName[20];
- if (m_Length < OrigLength) {
- for (int i = m_Length; i < OrigLength; i++) {
+ if (_length < OrigLength) {
+ for (int i = _length; i < OrigLength; i++) {
sprintf(PropName, "%d", i);
- m_Values->DeleteProp(PropName);
+ _values->DeleteProp(PropName);
}
}
return S_OK;
@@ -187,8 +187,8 @@ HRESULT CSXArray::ScSetProperty(char *Name, CScValue *Value) { char ParamName[20];
if (ValidNumber(Name, ParamName)) {
int Index = atoi(ParamName);
- if (Index >= m_Length) m_Length = Index + 1;
- return m_Values->SetProp(ParamName, Value);
+ if (Index >= _length) _length = Index + 1;
+ return _values->SetProp(ParamName, Value);
} else return E_FAIL;
}
}
@@ -198,8 +198,8 @@ HRESULT CSXArray::ScSetProperty(char *Name, CScValue *Value) { HRESULT CSXArray::Persist(CBPersistMgr *PersistMgr) {
CBScriptable::Persist(PersistMgr);
- PersistMgr->Transfer(TMEMBER(m_Length));
- PersistMgr->Transfer(TMEMBER(m_Values));
+ PersistMgr->Transfer(TMEMBER(_length));
+ PersistMgr->Transfer(TMEMBER(_values));
return S_OK;
}
@@ -225,9 +225,9 @@ bool CSXArray::ValidNumber(const char *OrigStr, char *OutStr) { //////////////////////////////////////////////////////////////////////////
HRESULT CSXArray::Push(CScValue *Val) {
char ParamName[20];
- m_Length++;
- sprintf(ParamName, "%d", m_Length - 1);
- m_Values->SetProp(ParamName, Val, true);
+ _length++;
+ sprintf(ParamName, "%d", _length - 1);
+ _values->SetProp(ParamName, Val, true);
return S_OK;
}
diff --git a/engines/wintermute/scriptables/SXArray.h b/engines/wintermute/scriptables/SXArray.h index 5283db2efb..0605d6c4f8 100644 --- a/engines/wintermute/scriptables/SXArray.h +++ b/engines/wintermute/scriptables/SXArray.h @@ -45,8 +45,8 @@ public: HRESULT ScSetProperty(char *Name, CScValue *Value);
HRESULT ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisStack, char *Name);
char *ScToString();
- int m_Length;
- CScValue *m_Values;
+ int _length;
+ CScValue *_values;
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/scriptables/SXDate.cpp b/engines/wintermute/scriptables/SXDate.cpp index 232f2beefd..65e6a43782 100644 --- a/engines/wintermute/scriptables/SXDate.cpp +++ b/engines/wintermute/scriptables/SXDate.cpp @@ -35,23 +35,23 @@ IMPLEMENT_PERSISTENT(CSXDate, false) CSXDate::CSXDate(CBGame *inGame, CScStack *Stack): CBScriptable(inGame) {
Stack->CorrectParams(6);
#if 0
- memset(&m_tm, 0, sizeof(m_tm));
+ memset(&_tm, 0, sizeof(_tm));
CScValue *valYear = Stack->Pop();
- m_tm.tm_year = valYear->GetInt() - 1900;
- m_tm.tm_mon = Stack->Pop()->GetInt() - 1;
- m_tm.tm_mday = Stack->Pop()->GetInt();
- m_tm.tm_hour = Stack->Pop()->GetInt();
- m_tm.tm_min = Stack->Pop()->GetInt();
- m_tm.tm_sec = Stack->Pop()->GetInt();
+ _tm.t_year = valYear->GetInt() - 1900;
+ _tm.t_mon = Stack->Pop()->GetInt() - 1;
+ _tm.t_mday = Stack->Pop()->GetInt();
+ _tm.t_hour = Stack->Pop()->GetInt();
+ _tm.t_min = Stack->Pop()->GetInt();
+ _tm.t_sec = Stack->Pop()->GetInt();
if (valYear->IsNULL()) {
time_t TimeNow;
time(&TimeNow);
- memcpy(&m_tm, localtime(&TimeNow), sizeof(m_tm));
+ memcpy(&_tm, localtime(&TimeNow), sizeof(_tm));
}
- mktime(&m_tm);
+ mktime(&_tm);
#endif
}
@@ -65,7 +65,7 @@ CSXDate::~CSXDate() { //////////////////////////////////////////////////////////////////////////
char *CSXDate::ScToString() {
#if 0
- return asctime(&m_tm);
+ return asctime(&_tm);
#endif
return "";
}
@@ -79,7 +79,7 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "GetYear") == 0) {
Stack->CorrectParams(0);
- Stack->PushInt(m_tm.tm_year + 1900);
+ Stack->PushInt(_tm.t_year + 1900);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
@@ -87,7 +87,7 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "GetMonth") == 0) {
Stack->CorrectParams(0);
- Stack->PushInt(m_tm.tm_mon + 1);
+ Stack->PushInt(_tm.t_mon + 1);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
@@ -95,7 +95,7 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "GetDate") == 0) {
Stack->CorrectParams(0);
- Stack->PushInt(m_tm.tm_mday);
+ Stack->PushInt(_tm.t_mday);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
@@ -103,7 +103,7 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "GetHours") == 0) {
Stack->CorrectParams(0);
- Stack->PushInt(m_tm.tm_hour);
+ Stack->PushInt(_tm.t_hour);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
@@ -111,7 +111,7 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "GetMinutes") == 0) {
Stack->CorrectParams(0);
- Stack->PushInt(m_tm.tm_min);
+ Stack->PushInt(_tm.t_min);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
@@ -119,7 +119,7 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "GetSeconds") == 0) {
Stack->CorrectParams(0);
- Stack->PushInt(m_tm.tm_sec);
+ Stack->PushInt(_tm.t_sec);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
@@ -127,7 +127,7 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "GetWeekday") == 0) {
Stack->CorrectParams(0);
- Stack->PushInt(m_tm.tm_wday);
+ Stack->PushInt(_tm.t_wday);
return S_OK;
}
@@ -137,8 +137,8 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "SetYear") == 0) {
Stack->CorrectParams(1);
- m_tm.tm_year = Stack->Pop()->GetInt() - 1900;
- mktime(&m_tm);
+ _tm.t_year = Stack->Pop()->GetInt() - 1900;
+ mktime(&_tm);
Stack->PushNULL();
return S_OK;
}
@@ -147,8 +147,8 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "SetMonth") == 0) {
Stack->CorrectParams(1);
- m_tm.tm_mon = Stack->Pop()->GetInt() - 1;
- mktime(&m_tm);
+ _tm.t_mon = Stack->Pop()->GetInt() - 1;
+ mktime(&_tm);
Stack->PushNULL();
return S_OK;
}
@@ -157,8 +157,8 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "SetDate") == 0) {
Stack->CorrectParams(1);
- m_tm.tm_mday = Stack->Pop()->GetInt();
- mktime(&m_tm);
+ _tm.t_mday = Stack->Pop()->GetInt();
+ mktime(&_tm);
Stack->PushNULL();
return S_OK;
}
@@ -167,8 +167,8 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "SetHours") == 0) {
Stack->CorrectParams(1);
- m_tm.tm_hour = Stack->Pop()->GetInt();
- mktime(&m_tm);
+ _tm.t_hour = Stack->Pop()->GetInt();
+ mktime(&_tm);
Stack->PushNULL();
return S_OK;
}
@@ -177,8 +177,8 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "SetMinutes") == 0) {
Stack->CorrectParams(1);
- m_tm.tm_min = Stack->Pop()->GetInt();
- mktime(&m_tm);
+ _tm.t_min = Stack->Pop()->GetInt();
+ mktime(&_tm);
Stack->PushNULL();
return S_OK;
}
@@ -187,8 +187,8 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "SetSeconds") == 0) {
Stack->CorrectParams(1);
- m_tm.tm_sec = Stack->Pop()->GetInt();
- mktime(&m_tm);
+ _tm.t_sec = Stack->Pop()->GetInt();
+ mktime(&_tm);
Stack->PushNULL();
return S_OK;
}
@@ -201,8 +201,8 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(0);
time_t TimeNow;
time(&TimeNow);
- memcpy(&m_tm, localtime(&TimeNow), sizeof(m_tm));
- mktime(&m_tm);
+ memcpy(&_tm, localtime(&TimeNow), sizeof(_tm));
+ mktime(&_tm);
Stack->PushNULL();
return S_OK;
}
@@ -215,17 +215,17 @@ HRESULT CSXDate::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
CScValue *CSXDate::ScGetProperty(char *Name) {
- m_ScValue->SetNULL();
+ _scValue->SetNULL();
//////////////////////////////////////////////////////////////////////////
// Type
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Type") == 0) {
- m_ScValue->SetString("date");
- return m_ScValue;
+ _scValue->SetString("date");
+ return _scValue;
}
- else return m_ScValue;
+ else return _scValue;
}
@@ -249,10 +249,10 @@ HRESULT CSXDate::Persist(CBPersistMgr *PersistMgr) { CBScriptable::Persist(PersistMgr);
#if 0
- if (PersistMgr->m_Saving)
- PersistMgr->PutBytes((byte *)&m_tm, sizeof(m_tm));
+ if (PersistMgr->_saving)
+ PersistMgr->PutBytes((byte *)&_tm, sizeof(_tm));
else
- PersistMgr->GetBytes((byte *)&m_tm, sizeof(m_tm));
+ PersistMgr->GetBytes((byte *)&_tm, sizeof(_tm));
#endif
return S_OK;
}
@@ -261,8 +261,8 @@ HRESULT CSXDate::Persist(CBPersistMgr *PersistMgr) { //////////////////////////////////////////////////////////////////////////
int CSXDate::ScCompare(CBScriptable *Value) {
#if 0
- time_t time1 = mktime(&m_tm);
- time_t time2 = mktime(&((CSXDate *)Value)->m_tm);
+ time_t time1 = mktime(&_tm);
+ time_t time2 = mktime(&((CSXDate *)Value)->_tm);
if (time1 < time2) return -1;
else if (time1 > time2) return 1;
diff --git a/engines/wintermute/scriptables/SXDate.h b/engines/wintermute/scriptables/SXDate.h index 638816b6d1..677b7e7dd1 100644 --- a/engines/wintermute/scriptables/SXDate.h +++ b/engines/wintermute/scriptables/SXDate.h @@ -44,8 +44,8 @@ public: HRESULT ScSetProperty(char *Name, CScValue *Value);
HRESULT ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisStack, char *Name);
char *ScToString();
- char *m_String;
- //struct tm m_tm; // TODO!
+ char *_string;
+ //struct tm _tm; // TODO!
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/scriptables/SXFile.cpp b/engines/wintermute/scriptables/SXFile.cpp index 8e38e2608a..19b60043da 100644 --- a/engines/wintermute/scriptables/SXFile.cpp +++ b/engines/wintermute/scriptables/SXFile.cpp @@ -44,14 +44,14 @@ CSXFile::CSXFile(CBGame *inGame, CScStack *Stack): CBScriptable(inGame) { Stack->CorrectParams(1);
CScValue *Val = Stack->Pop();
- m_Filename = NULL;
- if (!Val->IsNULL()) CBUtils::SetString(&m_Filename, Val->GetString());
+ _filename = NULL;
+ if (!Val->IsNULL()) CBUtils::SetString(&_filename, Val->GetString());
- m_ReadFile = NULL;
- m_WriteFile = NULL;
+ _readFile = NULL;
+ _writeFile = NULL;
- m_Mode = 0;
- m_TextMode = false;
+ _mode = 0;
+ _textMode = false;
}
@@ -62,29 +62,29 @@ CSXFile::~CSXFile() { //////////////////////////////////////////////////////////////////////////
void CSXFile::Cleanup() {
- delete[] m_Filename;
- m_Filename = NULL;
+ delete[] _filename;
+ _filename = NULL;
Close();
}
//////////////////////////////////////////////////////////////////////////
void CSXFile::Close() {
- if (m_ReadFile) {
- Game->m_FileManager->CloseFile(m_ReadFile);
- m_ReadFile = NULL;
+ if (_readFile) {
+ Game->_fileManager->CloseFile(_readFile);
+ _readFile = NULL;
}
- if (m_WriteFile) {
- fclose(m_WriteFile);
- m_WriteFile = NULL;
+ if (_writeFile) {
+ fclose(_writeFile);
+ _writeFile = NULL;
}
- m_Mode = 0;
- m_TextMode = false;
+ _mode = 0;
+ _textMode = false;
}
//////////////////////////////////////////////////////////////////////////
char *CSXFile::ScToString() {
- if (m_Filename) return m_Filename;
+ if (_filename) return _filename;
else return "[file object]";
}
@@ -98,7 +98,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
char *Filename = Stack->Pop()->GetString();
Cleanup();
- CBUtils::SetString(&m_Filename, Filename);
+ CBUtils::SetString(&_filename, Filename);
Stack->PushNULL();
return S_OK;
}
@@ -109,33 +109,33 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This else if (strcmp(Name, "OpenAsText") == 0 || strcmp(Name, "OpenAsBinary") == 0) {
Stack->CorrectParams(1);
Close();
- m_Mode = Stack->Pop()->GetInt(1);
- if (m_Mode < 1 || m_Mode > 3) {
+ _mode = Stack->Pop()->GetInt(1);
+ if (_mode < 1 || _mode > 3) {
Script->RuntimeError("File.%s: invalid access mode. Setting read mode.", Name);
- m_Mode = 1;
+ _mode = 1;
}
- if (m_Mode == 1) {
- m_ReadFile = Game->m_FileManager->OpenFile(m_Filename);
- if (!m_ReadFile) {
- //Script->RuntimeError("File.%s: Error opening file '%s' for reading.", Name, m_Filename);
+ if (_mode == 1) {
+ _readFile = Game->_fileManager->OpenFile(_filename);
+ if (!_readFile) {
+ //Script->RuntimeError("File.%s: Error opening file '%s' for reading.", Name, _filename);
Close();
- } else m_TextMode = strcmp(Name, "OpenAsText") == 0;
+ } else _textMode = strcmp(Name, "OpenAsText") == 0;
} else {
if (strcmp(Name, "OpenAsText") == 0) {
- if (m_Mode == 2) m_WriteFile = fopen(m_Filename, "w+");
- else m_WriteFile = fopen(m_Filename, "a+");
+ if (_mode == 2) _writeFile = fopen(_filename, "w+");
+ else _writeFile = fopen(_filename, "a+");
} else {
- if (m_Mode == 2) m_WriteFile = fopen(m_Filename, "wb+");
- else m_WriteFile = fopen(m_Filename, "ab+");
+ if (_mode == 2) _writeFile = fopen(_filename, "wb+");
+ else _writeFile = fopen(_filename, "ab+");
}
- if (!m_WriteFile) {
- //Script->RuntimeError("File.%s: Error opening file '%s' for writing.", Name, m_Filename);
+ if (!_writeFile) {
+ //Script->RuntimeError("File.%s: Error opening file '%s' for writing.", Name, _filename);
Close();
- } else m_TextMode = strcmp(Name, "OpenAsText") == 0;
+ } else _textMode = strcmp(Name, "OpenAsText") == 0;
}
- if (m_ReadFile || m_WriteFile) Stack->PushBool(true);
+ if (_readFile || _writeFile) Stack->PushBool(true);
else Stack->PushBool(false);
return S_OK;
@@ -156,7 +156,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "SetPosition") == 0) {
Stack->CorrectParams(1);
- if (m_Mode == 0) {
+ if (_mode == 0) {
Script->RuntimeError("File.%s: File is not open", Name);
Stack->PushBool(false);
} else {
@@ -172,7 +172,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This else if (strcmp(Name, "Delete") == 0) {
Stack->CorrectParams(0);
Close();
- Stack->PushBool(CBPlatform::DeleteFile(m_Filename) != FALSE);
+ Stack->PushBool(CBPlatform::DeleteFile(_filename) != FALSE);
return S_OK;
}
@@ -185,7 +185,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This bool Overwrite = Stack->Pop()->GetBool(true);
Close();
- Stack->PushBool(CBPlatform::CopyFile(m_Filename, Dest, !Overwrite) != FALSE);
+ Stack->PushBool(CBPlatform::CopyFile(_filename, Dest, !Overwrite) != FALSE);
return S_OK;
}
@@ -194,7 +194,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadLine") == 0) {
Stack->CorrectParams(0);
- if (!m_TextMode || !m_ReadFile) {
+ if (!_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open in text mode.", Name);
Stack->PushNULL();
return S_OK;
@@ -206,7 +206,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This bool FoundNewLine = false;
HRESULT Ret = E_FAIL;
do {
- Ret = m_ReadFile->Read(&b, 1);
+ Ret = _readFile->Read(&b, 1);
if (FAILED(Ret)) break;
if (Counter > BufSize) {
@@ -245,7 +245,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
int TextLen = Stack->Pop()->GetInt();
- if (!m_TextMode || !m_ReadFile) {
+ if (!_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open in text mode.", Name);
Stack->PushNULL();
return S_OK;
@@ -257,7 +257,7 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This HRESULT Ret = E_FAIL;
while (Counter < TextLen) {
- Ret = m_ReadFile->Read(&b, 1);
+ Ret = _readFile->Read(&b, 1);
if (FAILED(Ret)) break;
if (Counter > BufSize) {
@@ -291,15 +291,15 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This else if (strcmp(Name, "WriteLine") == 0 || strcmp(Name, "WriteText") == 0) {
Stack->CorrectParams(1);
char *Line = Stack->Pop()->GetString();
- if (!m_TextMode || !m_WriteFile) {
+ if (!_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in text mode.", Name);
Stack->PushBool(false);
return S_OK;
}
if (strcmp(Name, "WriteLine") == 0)
- fprintf(m_WriteFile, "%s\n", Line);
+ fprintf(_writeFile, "%s\n", Line);
else
- fprintf(m_WriteFile, "%s", Line);
+ fprintf(_writeFile, "%s", Line);
Stack->PushBool(true);
@@ -312,13 +312,13 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadBool") == 0) {
Stack->CorrectParams(0);
- if (m_TextMode || !m_ReadFile) {
+ if (_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open for reading in binary mode.", Name);
Stack->PushNULL();
return S_OK;
}
bool Val;
- if (SUCCEEDED(m_ReadFile->Read(&Val, sizeof(bool)))) Stack->PushBool(Val);
+ if (SUCCEEDED(_readFile->Read(&Val, sizeof(bool)))) Stack->PushBool(Val);
else Stack->PushNULL();
return S_OK;
@@ -329,13 +329,13 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadByte") == 0) {
Stack->CorrectParams(0);
- if (m_TextMode || !m_ReadFile) {
+ if (_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open for reading in binary mode.", Name);
Stack->PushNULL();
return S_OK;
}
byte Val;
- if (SUCCEEDED(m_ReadFile->Read(&Val, sizeof(byte )))) Stack->PushInt(Val);
+ if (SUCCEEDED(_readFile->Read(&Val, sizeof(byte )))) Stack->PushInt(Val);
else Stack->PushNULL();
return S_OK;
@@ -346,13 +346,13 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadShort") == 0) {
Stack->CorrectParams(0);
- if (m_TextMode || !m_ReadFile) {
+ if (_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open for reading in binary mode.", Name);
Stack->PushNULL();
return S_OK;
}
short Val;
- if (SUCCEEDED(m_ReadFile->Read(&Val, sizeof(short)))) Stack->PushInt(65536 + Val);
+ if (SUCCEEDED(_readFile->Read(&Val, sizeof(short)))) Stack->PushInt(65536 + Val);
else Stack->PushNULL();
return S_OK;
@@ -363,13 +363,13 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadInt") == 0 || strcmp(Name, "ReadLong") == 0) {
Stack->CorrectParams(0);
- if (m_TextMode || !m_ReadFile) {
+ if (_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open for reading in binary mode.", Name);
Stack->PushNULL();
return S_OK;
}
int Val;
- if (SUCCEEDED(m_ReadFile->Read(&Val, sizeof(int)))) Stack->PushInt(Val);
+ if (SUCCEEDED(_readFile->Read(&Val, sizeof(int)))) Stack->PushInt(Val);
else Stack->PushNULL();
return S_OK;
@@ -380,13 +380,13 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadFloat") == 0) {
Stack->CorrectParams(0);
- if (m_TextMode || !m_ReadFile) {
+ if (_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open for reading in binary mode.", Name);
Stack->PushNULL();
return S_OK;
}
float Val;
- if (SUCCEEDED(m_ReadFile->Read(&Val, sizeof(float)))) Stack->PushFloat(Val);
+ if (SUCCEEDED(_readFile->Read(&Val, sizeof(float)))) Stack->PushFloat(Val);
else Stack->PushNULL();
return S_OK;
@@ -397,13 +397,13 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadDouble") == 0) {
Stack->CorrectParams(0);
- if (m_TextMode || !m_ReadFile) {
+ if (_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open for reading in binary mode.", Name);
Stack->PushNULL();
return S_OK;
}
double Val;
- if (SUCCEEDED(m_ReadFile->Read(&Val, sizeof(double)))) Stack->PushFloat(Val);
+ if (SUCCEEDED(_readFile->Read(&Val, sizeof(double)))) Stack->PushFloat(Val);
else Stack->PushNULL();
return S_OK;
@@ -414,16 +414,16 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "ReadString") == 0) {
Stack->CorrectParams(0);
- if (m_TextMode || !m_ReadFile) {
+ if (_textMode || !_readFile) {
Script->RuntimeError("File.%s: File must be open for reading in binary mode.", Name);
Stack->PushNULL();
return S_OK;
}
uint32 Size;
- if (SUCCEEDED(m_ReadFile->Read(&Size, sizeof(uint32)))) {
+ if (SUCCEEDED(_readFile->Read(&Size, sizeof(uint32)))) {
byte *Str = new byte[Size + 1];
if (Str) {
- if (SUCCEEDED(m_ReadFile->Read(Str, Size))) {
+ if (SUCCEEDED(_readFile->Read(Str, Size))) {
Str[Size] = '\0';
Stack->PushString((char *)Str);
}
@@ -441,12 +441,12 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
bool Val = Stack->Pop()->GetBool();
- if (m_TextMode || !m_WriteFile) {
+ if (_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in binary mode.", Name);
Stack->PushBool(false);
return S_OK;
}
- fwrite(&Val, sizeof(Val), 1, m_WriteFile);
+ fwrite(&Val, sizeof(Val), 1, _writeFile);
Stack->PushBool(true);
return S_OK;
@@ -459,12 +459,12 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
byte Val = Stack->Pop()->GetInt();
- if (m_TextMode || !m_WriteFile) {
+ if (_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in binary mode.", Name);
Stack->PushBool(false);
return S_OK;
}
- fwrite(&Val, sizeof(Val), 1, m_WriteFile);
+ fwrite(&Val, sizeof(Val), 1, _writeFile);
Stack->PushBool(true);
return S_OK;
@@ -477,12 +477,12 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
short Val = Stack->Pop()->GetInt();
- if (m_TextMode || !m_WriteFile) {
+ if (_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in binary mode.", Name);
Stack->PushBool(false);
return S_OK;
}
- fwrite(&Val, sizeof(Val), 1, m_WriteFile);
+ fwrite(&Val, sizeof(Val), 1, _writeFile);
Stack->PushBool(true);
return S_OK;
@@ -495,12 +495,12 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
int Val = Stack->Pop()->GetInt();
- if (m_TextMode || !m_WriteFile) {
+ if (_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in binary mode.", Name);
Stack->PushBool(false);
return S_OK;
}
- fwrite(&Val, sizeof(Val), 1, m_WriteFile);
+ fwrite(&Val, sizeof(Val), 1, _writeFile);
Stack->PushBool(true);
return S_OK;
@@ -513,12 +513,12 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
float Val = Stack->Pop()->GetFloat();
- if (m_TextMode || !m_WriteFile) {
+ if (_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in binary mode.", Name);
Stack->PushBool(false);
return S_OK;
}
- fwrite(&Val, sizeof(Val), 1, m_WriteFile);
+ fwrite(&Val, sizeof(Val), 1, _writeFile);
Stack->PushBool(true);
return S_OK;
@@ -531,12 +531,12 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
double Val = Stack->Pop()->GetFloat();
- if (m_TextMode || !m_WriteFile) {
+ if (_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in binary mode.", Name);
Stack->PushBool(false);
return S_OK;
}
- fwrite(&Val, sizeof(Val), 1, m_WriteFile);
+ fwrite(&Val, sizeof(Val), 1, _writeFile);
Stack->PushBool(true);
return S_OK;
@@ -549,15 +549,15 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This Stack->CorrectParams(1);
char *Val = Stack->Pop()->GetString();
- if (m_TextMode || !m_WriteFile) {
+ if (_textMode || !_writeFile) {
Script->RuntimeError("File.%s: File must be open for writing in binary mode.", Name);
Stack->PushBool(false);
return S_OK;
}
uint32 Size = strlen(Val);
- fwrite(&Size, sizeof(Size), 1, m_WriteFile);
- fwrite(Val, Size, 1, m_WriteFile);
+ fwrite(&Size, sizeof(Size), 1, _writeFile);
+ fwrite(Val, Size, 1, _writeFile);
Stack->PushBool(true);
@@ -571,54 +571,54 @@ HRESULT CSXFile::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
CScValue *CSXFile::ScGetProperty(char *Name) {
- m_ScValue->SetNULL();
+ _scValue->SetNULL();
//////////////////////////////////////////////////////////////////////////
// Type (RO)
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Type") == 0) {
- m_ScValue->SetString("file");
- return m_ScValue;
+ _scValue->SetString("file");
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Filename (RO)
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Filename") == 0) {
- m_ScValue->SetString(m_Filename);
- return m_ScValue;
+ _scValue->SetString(_filename);
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Position (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "Position") == 0) {
- m_ScValue->SetInt(GetPos());
- return m_ScValue;
+ _scValue->SetInt(GetPos());
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Length (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "Length") == 0) {
- m_ScValue->SetInt(GetLength());
- return m_ScValue;
+ _scValue->SetInt(GetLength());
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// TextMode (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "TextMode") == 0) {
- m_ScValue->SetBool(m_TextMode);
- return m_ScValue;
+ _scValue->SetBool(_textMode);
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// AccessMode (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "AccessMode") == 0) {
- m_ScValue->SetInt(m_Mode);
- return m_ScValue;
+ _scValue->SetInt(_mode);
+ return _scValue;
}
else return CBScriptable::ScGetProperty(Name);
@@ -632,14 +632,14 @@ HRESULT CSXFile::ScSetProperty(char *Name, CScValue *Value) { // Length
//////////////////////////////////////////////////////////////////////////
if(strcmp(Name, "Length")==0){
- int OrigLength = m_Length;
- m_Length = max(Value->GetInt(0), 0);
+ int OrigLength = _length;
+ _length = max(Value->GetInt(0), 0);
char PropName[20];
- if(m_Length < OrigLength){
- for(int i=m_Length; i<OrigLength; i++){
+ if(_length < OrigLength){
+ for(int i=_length; i<OrigLength; i++){
sprintf(PropName, "%d", i);
- m_Values->DeleteProp(PropName);
+ _values->DeleteProp(PropName);
}
}
return S_OK;
@@ -649,26 +649,26 @@ HRESULT CSXFile::ScSetProperty(char *Name, CScValue *Value) { //////////////////////////////////////////////////////////////////////////
uint32 CSXFile::GetPos() {
- if (m_Mode == 1 && m_ReadFile) return m_ReadFile->GetPos();
- else if ((m_Mode == 2 || m_Mode == 3) && m_WriteFile) return ftell(m_WriteFile);
+ if (_mode == 1 && _readFile) return _readFile->GetPos();
+ else if ((_mode == 2 || _mode == 3) && _writeFile) return ftell(_writeFile);
else return 0;
}
//////////////////////////////////////////////////////////////////////////
bool CSXFile::SetPos(uint32 Pos, TSeek Origin) {
- if (m_Mode == 1 && m_ReadFile) return SUCCEEDED(m_ReadFile->Seek(Pos, Origin));
- else if ((m_Mode == 2 || m_Mode == 3) && m_WriteFile) return fseek(m_WriteFile, Pos, (int)Origin) == 0;
+ if (_mode == 1 && _readFile) return SUCCEEDED(_readFile->Seek(Pos, Origin));
+ else if ((_mode == 2 || _mode == 3) && _writeFile) return fseek(_writeFile, Pos, (int)Origin) == 0;
else return false;
}
//////////////////////////////////////////////////////////////////////////
uint32 CSXFile::GetLength() {
- if (m_Mode == 1 && m_ReadFile) return m_ReadFile->GetSize();
- else if ((m_Mode == 2 || m_Mode == 3) && m_WriteFile) {
- uint32 CurrentPos = ftell(m_WriteFile);
- fseek(m_WriteFile, 0, SEEK_END);
- int Ret = ftell(m_WriteFile);
- fseek(m_WriteFile, CurrentPos, SEEK_SET);
+ if (_mode == 1 && _readFile) return _readFile->GetSize();
+ else if ((_mode == 2 || _mode == 3) && _writeFile) {
+ uint32 CurrentPos = ftell(_writeFile);
+ fseek(_writeFile, 0, SEEK_END);
+ int Ret = ftell(_writeFile);
+ fseek(_writeFile, CurrentPos, SEEK_SET);
return Ret;
} else return 0;
}
@@ -678,37 +678,37 @@ HRESULT CSXFile::Persist(CBPersistMgr *PersistMgr) { CBScriptable::Persist(PersistMgr);
- PersistMgr->Transfer(TMEMBER(m_Filename));
- PersistMgr->Transfer(TMEMBER(m_Mode));
- PersistMgr->Transfer(TMEMBER(m_TextMode));
+ PersistMgr->Transfer(TMEMBER(_filename));
+ PersistMgr->Transfer(TMEMBER(_mode));
+ PersistMgr->Transfer(TMEMBER(_textMode));
uint32 Pos = 0;
- if (PersistMgr->m_Saving) {
+ if (PersistMgr->_saving) {
Pos = GetPos();
PersistMgr->Transfer(TMEMBER(Pos));
} else {
PersistMgr->Transfer(TMEMBER(Pos));
// try to re-open file if needed
- m_WriteFile = NULL;
- m_ReadFile = NULL;
+ _writeFile = NULL;
+ _readFile = NULL;
- if (m_Mode != 0) {
+ if (_mode != 0) {
// open for reading
- if (m_Mode == 1) {
- m_ReadFile = Game->m_FileManager->OpenFile(m_Filename);
- if (!m_ReadFile) Close();
+ if (_mode == 1) {
+ _readFile = Game->_fileManager->OpenFile(_filename);
+ if (!_readFile) Close();
}
// open for writing / appending
else {
- if (m_TextMode) {
- if (m_Mode == 2) m_WriteFile = fopen(m_Filename, "w+");
- else m_WriteFile = fopen(m_Filename, "a+");
+ if (_textMode) {
+ if (_mode == 2) _writeFile = fopen(_filename, "w+");
+ else _writeFile = fopen(_filename, "a+");
} else {
- if (m_Mode == 2) m_WriteFile = fopen(m_Filename, "wb+");
- else m_WriteFile = fopen(m_Filename, "ab+");
+ if (_mode == 2) _writeFile = fopen(_filename, "wb+");
+ else _writeFile = fopen(_filename, "ab+");
}
- if (m_WriteFile) Close();
+ if (_writeFile) Close();
}
SetPos(Pos);
}
diff --git a/engines/wintermute/scriptables/SXFile.h b/engines/wintermute/scriptables/SXFile.h index 0ab1acb32c..085700d0e1 100644 --- a/engines/wintermute/scriptables/SXFile.h +++ b/engines/wintermute/scriptables/SXFile.h @@ -43,16 +43,16 @@ public: CSXFile(CBGame *inGame, CScStack *Stack);
virtual ~CSXFile();
private:
- CBFile *m_ReadFile;
- FILE *m_WriteFile;
- int m_Mode; // 0..none, 1..read, 2..write, 3..append
- bool m_TextMode;
+ CBFile *_readFile;
+ FILE *_writeFile;
+ int _mode; // 0..none, 1..read, 2..write, 3..append
+ bool _textMode;
void Close();
void Cleanup();
uint32 GetPos();
uint32 GetLength();
bool SetPos(uint32 Pos, TSeek Origin = SEEK_TO_BEGIN);
- char *m_Filename;
+ char *_filename;
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/scriptables/SXMath.cpp b/engines/wintermute/scriptables/SXMath.cpp index 48e722a02c..fcc85d527c 100644 --- a/engines/wintermute/scriptables/SXMath.cpp +++ b/engines/wintermute/scriptables/SXMath.cpp @@ -246,25 +246,25 @@ HRESULT CSXMath::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *This //////////////////////////////////////////////////////////////////////////
CScValue *CSXMath::ScGetProperty(char *Name) {
- m_ScValue->SetNULL();
+ _scValue->SetNULL();
//////////////////////////////////////////////////////////////////////////
// Type
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Type") == 0) {
- m_ScValue->SetString("math");
- return m_ScValue;
+ _scValue->SetString("math");
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// PI
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "PI") == 0) {
- m_ScValue->SetFloat(PI);
- return m_ScValue;
+ _scValue->SetFloat(PI);
+ return _scValue;
}
- else return m_ScValue;
+ else return _scValue;
}
diff --git a/engines/wintermute/scriptables/SXMemBuffer.cpp b/engines/wintermute/scriptables/SXMemBuffer.cpp index 874aa2c9d1..6215d9c4e3 100644 --- a/engines/wintermute/scriptables/SXMemBuffer.cpp +++ b/engines/wintermute/scriptables/SXMemBuffer.cpp @@ -39,8 +39,8 @@ IMPLEMENT_PERSISTENT(CSXMemBuffer, false) //////////////////////////////////////////////////////////////////////////
CSXMemBuffer::CSXMemBuffer(CBGame *inGame, CScStack *Stack): CBScriptable(inGame) {
Stack->CorrectParams(1);
- m_Buffer = NULL;
- m_Size = 0;
+ _buffer = NULL;
+ _size = 0;
int NewSize = Stack->Pop()->GetInt();
Resize(MAX(0, NewSize));
@@ -48,8 +48,8 @@ CSXMemBuffer::CSXMemBuffer(CBGame *inGame, CScStack *Stack): CBScriptable(inGame //////////////////////////////////////////////////////////////////////////
CSXMemBuffer::CSXMemBuffer(CBGame *inGame, void *Buffer): CBScriptable(inGame) {
- m_Size = NULL;
- m_Buffer = Buffer;
+ _size = NULL;
+ _buffer = Buffer;
}
@@ -60,51 +60,51 @@ CSXMemBuffer::~CSXMemBuffer() { //////////////////////////////////////////////////////////////////////////
void *CSXMemBuffer::ScToMemBuffer() {
- return m_Buffer;
+ return _buffer;
}
//////////////////////////////////////////////////////////////////////////
void CSXMemBuffer::Cleanup() {
- if (m_Size) free(m_Buffer);
- m_Buffer = NULL;
- m_Size = 0;
+ if (_size) free(_buffer);
+ _buffer = NULL;
+ _size = 0;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CSXMemBuffer::Resize(int NewSize) {
- int OldSize = m_Size;
+ int OldSize = _size;
- if (m_Size == 0) {
- m_Buffer = malloc(NewSize);
- if (m_Buffer) m_Size = NewSize;
+ if (_size == 0) {
+ _buffer = malloc(NewSize);
+ if (_buffer) _size = NewSize;
} else {
- void *NewBuf = realloc(m_Buffer, NewSize);
+ void *NewBuf = realloc(_buffer, NewSize);
if (!NewBuf) {
if (NewSize == 0) {
- m_Buffer = NewBuf;
- m_Size = NewSize;
+ _buffer = NewBuf;
+ _size = NewSize;
} else return E_FAIL;
} else {
- m_Buffer = NewBuf;
- m_Size = NewSize;
+ _buffer = NewBuf;
+ _size = NewSize;
}
}
- if (m_Buffer && m_Size > OldSize) {
- memset((byte *)m_Buffer + OldSize, 0, m_Size - OldSize);
+ if (_buffer && _size > OldSize) {
+ memset((byte *)_buffer + OldSize, 0, _size - OldSize);
}
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
bool CSXMemBuffer::CheckBounds(CScScript *Script, int Start, int Length) {
- if (m_Buffer == NULL) {
+ if (_buffer == NULL) {
Script->RuntimeError("Cannot use Set/Get methods on an uninitialized memory buffer");
return false;
}
- if (m_Size == 0) return true;
+ if (_size == 0) return true;
- if (Start < 0 || Length == 0 || Start + Length > m_Size) {
+ if (Start < 0 || Length == 0 || Start + Length > _size) {
Script->RuntimeError("Set/Get method call is out of bounds");
return false;
} else return true;
@@ -138,7 +138,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack Stack->CorrectParams(1);
int Start = Stack->Pop()->GetInt();
if (!CheckBounds(Script, Start, sizeof(bool))) Stack->PushNULL();
- else Stack->PushBool(*(bool *)((byte *)m_Buffer + Start));
+ else Stack->PushBool(*(bool *)((byte *)_buffer + Start));
return S_OK;
}
@@ -150,7 +150,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack Stack->CorrectParams(1);
int Start = Stack->Pop()->GetInt();
if (!CheckBounds(Script, Start, sizeof(byte ))) Stack->PushNULL();
- else Stack->PushInt(*(byte *)((byte *)m_Buffer + Start));
+ else Stack->PushInt(*(byte *)((byte *)_buffer + Start));
return S_OK;
}
@@ -162,7 +162,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack Stack->CorrectParams(1);
int Start = Stack->Pop()->GetInt();
if (!CheckBounds(Script, Start, sizeof(short))) Stack->PushNULL();
- else Stack->PushInt(65536 + * (short *)((byte *)m_Buffer + Start));
+ else Stack->PushInt(65536 + * (short *)((byte *)_buffer + Start));
return S_OK;
}
@@ -174,7 +174,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack Stack->CorrectParams(1);
int Start = Stack->Pop()->GetInt();
if (!CheckBounds(Script, Start, sizeof(int))) Stack->PushNULL();
- else Stack->PushInt(*(int *)((byte *)m_Buffer + Start));
+ else Stack->PushInt(*(int *)((byte *)_buffer + Start));
return S_OK;
}
@@ -186,7 +186,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack Stack->CorrectParams(1);
int Start = Stack->Pop()->GetInt();
if (!CheckBounds(Script, Start, sizeof(float))) Stack->PushNULL();
- else Stack->PushFloat(*(float *)((byte *)m_Buffer + Start));
+ else Stack->PushFloat(*(float *)((byte *)_buffer + Start));
return S_OK;
}
@@ -198,7 +198,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack Stack->CorrectParams(1);
int Start = Stack->Pop()->GetInt();
if (!CheckBounds(Script, Start, sizeof(double))) Stack->PushNULL();
- else Stack->PushFloat(*(double *)((byte *)m_Buffer + Start));
+ else Stack->PushFloat(*(double *)((byte *)_buffer + Start));
return S_OK;
}
@@ -212,9 +212,9 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack int Length = Stack->Pop()->GetInt();
// find end of string
- if (Length == 0 && Start >= 0 && Start < m_Size) {
- for (int i = Start; i < m_Size; i++) {
- if (((char *)m_Buffer)[i] == '\0') {
+ if (Length == 0 && Start >= 0 && Start < _size) {
+ for (int i = Start; i < _size; i++) {
+ if (((char *)_buffer)[i] == '\0') {
Length = i - Start;
break;
}
@@ -224,7 +224,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, Length)) Stack->PushNULL();
else {
char *Str = new char[Length + 1];
- strncpy(Str, (const char *)m_Buffer + Start, Length);
+ strncpy(Str, (const char *)_buffer + Start, Length);
Str[Length] = '\0';
Stack->PushString(Str);
delete [] Str;
@@ -240,7 +240,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack int Start = Stack->Pop()->GetInt();
if (!CheckBounds(Script, Start, sizeof(void *))) Stack->PushNULL();
else {
- void *Pointer = *(void **)((byte *)m_Buffer + Start);
+ void *Pointer = *(void **)((byte *)_buffer + Start);
CSXMemBuffer *Buf = new CSXMemBuffer(Game, Pointer);
Stack->PushNative(Buf, false);
}
@@ -257,7 +257,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, sizeof(bool))) Stack->PushBool(false);
else {
- *(bool *)((byte *)m_Buffer + Start) = Val;
+ *(bool *)((byte *)_buffer + Start) = Val;
Stack->PushBool(true);
}
return S_OK;
@@ -273,7 +273,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, sizeof(byte ))) Stack->PushBool(false);
else {
- *(byte *)((byte *)m_Buffer + Start) = Val;
+ *(byte *)((byte *)_buffer + Start) = Val;
Stack->PushBool(true);
}
return S_OK;
@@ -289,7 +289,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, sizeof(short))) Stack->PushBool(false);
else {
- *(short *)((byte *)m_Buffer + Start) = Val;
+ *(short *)((byte *)_buffer + Start) = Val;
Stack->PushBool(true);
}
return S_OK;
@@ -305,7 +305,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, sizeof(int))) Stack->PushBool(false);
else {
- *(int *)((byte *)m_Buffer + Start) = Val;
+ *(int *)((byte *)_buffer + Start) = Val;
Stack->PushBool(true);
}
return S_OK;
@@ -321,7 +321,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, sizeof(float))) Stack->PushBool(false);
else {
- *(float *)((byte *)m_Buffer + Start) = Val;
+ *(float *)((byte *)_buffer + Start) = Val;
Stack->PushBool(true);
}
return S_OK;
@@ -337,7 +337,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, sizeof(double))) Stack->PushBool(false);
else {
- *(double *)((byte *)m_Buffer + Start) = Val;
+ *(double *)((byte *)_buffer + Start) = Val;
Stack->PushBool(true);
}
return S_OK;
@@ -353,7 +353,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack if (!CheckBounds(Script, Start, strlen(Val) + 1)) Stack->PushBool(false);
else {
- memcpy((byte *)m_Buffer + Start, Val, strlen(Val) + 1);
+ memcpy((byte *)_buffer + Start, Val, strlen(Val) + 1);
Stack->PushBool(true);
}
return S_OK;
@@ -371,7 +371,7 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack else {
/*
int Pointer = (int)Val->GetMemBuffer();
- memcpy((byte *)m_Buffer+Start, &Pointer, sizeof(void*));
+ memcpy((byte *)_buffer+Start, &Pointer, sizeof(void*));
Stack->PushBool(true);
*/
// TODO fix
@@ -386,9 +386,9 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack //////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "DEBUG_Dump") == 0) {
Stack->CorrectParams(0);
- if (m_Buffer && m_Size) {
+ if (_buffer && _size) {
FILE *f = fopen("c:\\!!buffer.bin", "wb");
- fwrite(m_Buffer, m_Size, 1, f);
+ fwrite(_buffer, _size, 1, f);
fclose(f);
}
Stack->PushNULL();
@@ -401,22 +401,22 @@ HRESULT CSXMemBuffer::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack //////////////////////////////////////////////////////////////////////////
CScValue *CSXMemBuffer::ScGetProperty(char *Name) {
- m_ScValue->SetNULL();
+ _scValue->SetNULL();
//////////////////////////////////////////////////////////////////////////
// Type (RO)
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Type") == 0) {
- m_ScValue->SetString("membuffer");
- return m_ScValue;
+ _scValue->SetString("membuffer");
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Size (RO)
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Size") == 0) {
- m_ScValue->SetInt(m_Size);
- return m_ScValue;
+ _scValue->SetInt(_size);
+ return _scValue;
}
else return CBScriptable::ScGetProperty(Name);
@@ -430,14 +430,14 @@ HRESULT CSXMemBuffer::ScSetProperty(char *Name, CScValue *Value) { // Length
//////////////////////////////////////////////////////////////////////////
if(strcmp(Name, "Length")==0){
- int OrigLength = m_Length;
- m_Length = max(Value->GetInt(0), 0);
+ int OrigLength = _length;
+ _length = max(Value->GetInt(0), 0);
char PropName[20];
- if(m_Length < OrigLength){
- for(int i=m_Length; i<OrigLength; i++){
+ if(_length < OrigLength){
+ for(int i=_length; i<OrigLength; i++){
sprintf(PropName, "%d", i);
- m_Values->DeleteProp(PropName);
+ _values->DeleteProp(PropName);
}
}
return S_OK;
@@ -451,15 +451,15 @@ HRESULT CSXMemBuffer::Persist(CBPersistMgr *PersistMgr) { CBScriptable::Persist(PersistMgr);
- PersistMgr->Transfer(TMEMBER(m_Size));
+ PersistMgr->Transfer(TMEMBER(_size));
- if (PersistMgr->m_Saving) {
- if (m_Size > 0) PersistMgr->PutBytes((byte *)m_Buffer, m_Size);
+ if (PersistMgr->_saving) {
+ if (_size > 0) PersistMgr->PutBytes((byte *)_buffer, _size);
} else {
- if (m_Size > 0) {
- m_Buffer = malloc(m_Size);
- PersistMgr->GetBytes((byte *)m_Buffer, m_Size);
- } else m_Buffer = NULL;
+ if (_size > 0) {
+ _buffer = malloc(_size);
+ PersistMgr->GetBytes((byte *)_buffer, _size);
+ } else _buffer = NULL;
}
return S_OK;
@@ -468,7 +468,7 @@ HRESULT CSXMemBuffer::Persist(CBPersistMgr *PersistMgr) { //////////////////////////////////////////////////////////////////////////
int CSXMemBuffer::ScCompare(CBScriptable *Val) {
- if (m_Buffer == Val->ScToMemBuffer()) return 0;
+ if (_buffer == Val->ScToMemBuffer()) return 0;
else return 1;
}
diff --git a/engines/wintermute/scriptables/SXMemBuffer.h b/engines/wintermute/scriptables/SXMemBuffer.h index e44761b723..715d860302 100644 --- a/engines/wintermute/scriptables/SXMemBuffer.h +++ b/engines/wintermute/scriptables/SXMemBuffer.h @@ -46,10 +46,10 @@ public: CSXMemBuffer(CBGame *inGame, void *Buffer);
virtual ~CSXMemBuffer();
virtual void *ScToMemBuffer();
- int m_Size;
+ int _size;
private:
HRESULT Resize(int NewSize);
- void *m_Buffer;
+ void *_buffer;
void Cleanup();
bool CheckBounds(CScScript *Script, int Start, int Length);
};
diff --git a/engines/wintermute/scriptables/SXStore.cpp b/engines/wintermute/scriptables/SXStore.cpp index cdd62599d4..74217b9907 100644 --- a/engines/wintermute/scriptables/SXStore.cpp +++ b/engines/wintermute/scriptables/SXStore.cpp @@ -45,10 +45,10 @@ CSXStore::CSXStore(CBGame *inGame) : CBObject(inGame) { StoreKit_SetExternalData((void *)this);
#endif
- m_EventsEnabled = false;
- m_LastProductRequestOwner = NULL;
- m_LastPurchaseOwner = NULL;
- m_LastRestoreOwner = NULL;
+ _eventsEnabled = false;
+ _lastProductRequestOwner = NULL;
+ _lastPurchaseOwner = NULL;
+ _lastRestoreOwner = NULL;
}
@@ -61,19 +61,19 @@ CSXStore::~CSXStore() { void CSXStore::Cleanup() {
SetEventsEnabled(NULL, false);
- for (int i = 0; i < m_ValidProducts.GetSize(); i++) {
- delete m_ValidProducts[i];
+ for (int i = 0; i < _validProducts.GetSize(); i++) {
+ delete _validProducts[i];
}
- m_ValidProducts.RemoveAll();
+ _validProducts.RemoveAll();
- for (int i = 0; i < m_Transactions.GetSize(); i++) {
- delete m_Transactions[i];
+ for (int i = 0; i < _transactions.GetSize(); i++) {
+ delete _transactions[i];
}
- m_Transactions.RemoveAll();
+ _transactions.RemoveAll();
- m_LastProductRequestOwner = m_LastPurchaseOwner = m_LastRestoreOwner = NULL;
+ _lastProductRequestOwner = _lastPurchaseOwner = _lastRestoreOwner = NULL;
}
//////////////////////////////////////////////////////////////////////////
@@ -102,7 +102,7 @@ HRESULT CSXStore::ScCallMethod(CScScript *script, CScStack *stack, CScStack *thi else if (strcmp(name, "ValidateProducts") == 0) {
stack->CorrectParams(1);
char *prodIdList = stack->Pop()->GetString();
- m_LastProductRequestOwner = script->m_Owner;
+ _lastProductRequestOwner = script->_owner;
ValidateProducts(prodIdList);
stack->PushNULL();
return S_OK;
@@ -113,13 +113,13 @@ HRESULT CSXStore::ScCallMethod(CScScript *script, CScStack *stack, CScStack *thi else if (strcmp(name, "GetValidProduct") == 0) {
stack->CorrectParams(1);
int index = stack->Pop()->GetInt();
- if (index >= 0 && index < m_ValidProducts.GetSize()) {
+ if (index >= 0 && index < _validProducts.GetSize()) {
CScValue *prod = stack->GetPushValue();
if (prod) {
- prod->SetProperty("Id", m_ValidProducts[index]->GetId());
- prod->SetProperty("Name", m_ValidProducts[index]->GetName());
- prod->SetProperty("Description", m_ValidProducts[index]->GetDesc());
- prod->SetProperty("Price", m_ValidProducts[index]->GetPrice());
+ prod->SetProperty("Id", _validProducts[index]->GetId());
+ prod->SetProperty("Name", _validProducts[index]->GetName());
+ prod->SetProperty("Description", _validProducts[index]->GetDesc());
+ prod->SetProperty("Price", _validProducts[index]->GetPrice());
}
} else
stack->PushNULL();
@@ -132,8 +132,8 @@ HRESULT CSXStore::ScCallMethod(CScScript *script, CScStack *stack, CScStack *thi else if (strcmp(name, "GetInvalidProduct") == 0) {
stack->CorrectParams(1);
int index = stack->Pop()->GetInt();
- if (index >= 0 && index < m_InvalidProducts.size())
- stack->PushString(m_InvalidProducts[index].c_str());
+ if (index >= 0 && index < _invalidProducts.size())
+ stack->PushString(_invalidProducts[index].c_str());
else
stack->PushNULL();
@@ -145,12 +145,12 @@ HRESULT CSXStore::ScCallMethod(CScScript *script, CScStack *stack, CScStack *thi else if (strcmp(name, "GetTransaction") == 0) {
stack->CorrectParams(1);
int index = stack->Pop()->GetInt();
- if (index >= 0 && index < m_Transactions.GetSize()) {
+ if (index >= 0 && index < _transactions.GetSize()) {
CScValue *trans = stack->GetPushValue();
if (trans) {
- trans->SetProperty("Id", m_Transactions[index]->GetId());
- trans->SetProperty("ProductId", m_Transactions[index]->GetProductId());
- trans->SetProperty("State", m_Transactions[index]->GetState());
+ trans->SetProperty("Id", _transactions[index]->GetId());
+ trans->SetProperty("ProductId", _transactions[index]->GetProductId());
+ trans->SetProperty("State", _transactions[index]->GetState());
}
} else
stack->PushNULL();
@@ -195,8 +195,8 @@ HRESULT CSXStore::ScCallMethod(CScScript *script, CScStack *stack, CScStack *thi stack->CorrectParams(1);
char *prodId = stack->Pop()->GetString();
- Game->m_Registry->WriteBool("Purchases", prodId, true);
- Game->m_Registry->SaveValues();
+ Game->_registry->WriteBool("Purchases", prodId, true);
+ Game->_registry->SaveValues();
stack->PushBool(true);
@@ -210,7 +210,7 @@ HRESULT CSXStore::ScCallMethod(CScScript *script, CScStack *stack, CScStack *thi stack->CorrectParams(1);
char *prodId = stack->Pop()->GetString();
- stack->PushBool(Game->m_Registry->ReadBool("Purchases", prodId, false));
+ stack->PushBool(Game->_registry->ReadBool("Purchases", prodId, false));
return S_OK;
}
@@ -221,80 +221,80 @@ HRESULT CSXStore::ScCallMethod(CScScript *script, CScStack *stack, CScStack *thi //////////////////////////////////////////////////////////////////////////
CScValue *CSXStore::ScGetProperty(char *name) {
- m_ScValue->SetNULL();
+ _scValue->SetNULL();
//////////////////////////////////////////////////////////////////////////
// Type
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "Type") == 0) {
- m_ScValue->SetString("store");
- return m_ScValue;
+ _scValue->SetString("store");
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Available (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "Available") == 0) {
- m_ScValue->SetBool(IsAvailable());
- return m_ScValue;
+ _scValue->SetBool(IsAvailable());
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// EventsEnabled (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "EventsEnabled") == 0) {
- m_ScValue->SetBool(GetEventsEnabled());
- return m_ScValue;
+ _scValue->SetBool(GetEventsEnabled());
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// NumValidProducts (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "NumValidProducts") == 0) {
- m_ScValue->SetInt(m_ValidProducts.GetSize());
- return m_ScValue;
+ _scValue->SetInt(_validProducts.GetSize());
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// NumInvalidProducts (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "NumInvalidProducts") == 0) {
- m_ScValue->SetInt(m_InvalidProducts.size());
- return m_ScValue;
+ _scValue->SetInt(_invalidProducts.size());
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// NumTransactions (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "NumTransactions") == 0) {
- m_ScValue->SetInt(m_Transactions.GetSize());
- return m_ScValue;
+ _scValue->SetInt(_transactions.GetSize());
+ return _scValue;
}
- else return m_ScValue;
+ else return _scValue;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CSXStore::Persist(CBPersistMgr *PersistMgr) {
- if (!PersistMgr->m_Saving) Cleanup();
+ if (!PersistMgr->_saving) Cleanup();
CBObject::Persist(PersistMgr);
- PersistMgr->Transfer(TMEMBER(m_EventsEnabled));
- PersistMgr->Transfer(TMEMBER(m_LastProductRequestOwner));
- PersistMgr->Transfer(TMEMBER(m_LastPurchaseOwner));
- PersistMgr->Transfer(TMEMBER(m_LastRestoreOwner));
- PersistMgr->Transfer(TMEMBER(m_InvalidProducts));
+ PersistMgr->Transfer(TMEMBER(_eventsEnabled));
+ PersistMgr->Transfer(TMEMBER(_lastProductRequestOwner));
+ PersistMgr->Transfer(TMEMBER(_lastPurchaseOwner));
+ PersistMgr->Transfer(TMEMBER(_lastRestoreOwner));
+ PersistMgr->Transfer(TMEMBER(_invalidProducts));
// persist valid products
int numProducts;
- if (PersistMgr->m_Saving) {
- numProducts = m_ValidProducts.GetSize();
+ if (PersistMgr->_saving) {
+ numProducts = _validProducts.GetSize();
PersistMgr->Transfer(TMEMBER(numProducts));
- for (int i = 0; i < numProducts; i++) m_ValidProducts[i]->Persist(PersistMgr);
+ for (int i = 0; i < numProducts; i++) _validProducts[i]->Persist(PersistMgr);
} else {
- numProducts = m_ValidProducts.GetSize();
+ numProducts = _validProducts.GetSize();
PersistMgr->Transfer(TMEMBER(numProducts));
for (int i = 0; i < numProducts; i++) {
CBStoreProduct *prod = new CBStoreProduct;
prod->Persist(PersistMgr);
- m_ValidProducts.Add(prod);
+ _validProducts.Add(prod);
}
}
@@ -304,7 +304,7 @@ HRESULT CSXStore::Persist(CBPersistMgr *PersistMgr) { //////////////////////////////////////////////////////////////////////////
void CSXStore::AfterLoad() {
- if (m_EventsEnabled) {
+ if (_eventsEnabled) {
SetEventsEnabled(NULL, true);
}
#ifdef __IPHONEOS__
@@ -314,22 +314,22 @@ void CSXStore::AfterLoad() { //////////////////////////////////////////////////////////////////////////
void CSXStore::OnObjectDestroyed(CBScriptHolder *obj) {
- if (m_LastProductRequestOwner == obj) m_LastProductRequestOwner = NULL;
- if (m_LastPurchaseOwner == obj) m_LastPurchaseOwner = NULL;
- if (m_LastRestoreOwner == obj) m_LastRestoreOwner = NULL;
+ if (_lastProductRequestOwner == obj) _lastProductRequestOwner = NULL;
+ if (_lastPurchaseOwner == obj) _lastPurchaseOwner = NULL;
+ if (_lastRestoreOwner == obj) _lastRestoreOwner = NULL;
}
//////////////////////////////////////////////////////////////////////////
void CSXStore::SetEventsEnabled(CScScript *script, bool val) {
- m_EventsEnabled = val;
+ _eventsEnabled = val;
if (val) {
- if (script) m_LastPurchaseOwner = script->m_Owner;
+ if (script) _lastPurchaseOwner = script->_owner;
#ifdef __IPHONEOS__
StoreKit_EnableEvents();
#endif
} else {
- m_LastPurchaseOwner = NULL;
+ _lastPurchaseOwner = NULL;
#ifdef __IPHONEOS__
StoreKit_DisableEvents();
#endif
@@ -354,48 +354,48 @@ bool CSXStore::IsAvailable() { //////////////////////////////////////////////////////////////////////////
void CSXStore::ReceiveProductsStart() {
- for (int i = 0; i < m_ValidProducts.GetSize(); i++) {
- delete m_ValidProducts[i];
+ for (int i = 0; i < _validProducts.GetSize(); i++) {
+ delete _validProducts[i];
}
- m_ValidProducts.RemoveAll();
+ _validProducts.RemoveAll();
- m_InvalidProducts.clear();
+ _invalidProducts.clear();
}
//////////////////////////////////////////////////////////////////////////
void CSXStore::ReceiveProductsEnd() {
- if (m_LastProductRequestOwner) m_LastProductRequestOwner->ApplyEvent("ProductsValidated");
+ if (_lastProductRequestOwner) _lastProductRequestOwner->ApplyEvent("ProductsValidated");
}
//////////////////////////////////////////////////////////////////////////
void CSXStore::AddValidProduct(const char *id, const char *name, const char *desc, const char *price) {
CBStoreProduct *prod = new CBStoreProduct(id, name, desc, price);
- m_ValidProducts.Add(prod);
+ _validProducts.Add(prod);
}
//////////////////////////////////////////////////////////////////////////
void CSXStore::AddInvalidProduct(const char *id) {
- m_InvalidProducts.push_back(id);
+ _invalidProducts.push_back(id);
}
//////////////////////////////////////////////////////////////////////////
void CSXStore::ReceiveTransactionsStart() {
- for (int i = 0; i < m_Transactions.GetSize(); i++) {
- delete m_Transactions[i];
+ for (int i = 0; i < _transactions.GetSize(); i++) {
+ delete _transactions[i];
}
- m_Transactions.RemoveAll();
+ _transactions.RemoveAll();
}
//////////////////////////////////////////////////////////////////////////
void CSXStore::ReceiveTransactionsEnd() {
- if (m_LastPurchaseOwner) m_LastPurchaseOwner->ApplyEvent("TransactionsUpdated");
+ if (_lastPurchaseOwner) _lastPurchaseOwner->ApplyEvent("TransactionsUpdated");
else Game->ApplyEvent("TransactionsUpdated");
}
//////////////////////////////////////////////////////////////////////////
void CSXStore::AddTransaction(const char *id, const char *productId, const char *state) {
CBStoreTransaction *trans = new CBStoreTransaction(id, productId, state);
- m_Transactions.Add(trans);
+ _transactions.Add(trans);
}
//////////////////////////////////////////////////////////////////////////
@@ -403,9 +403,9 @@ bool CSXStore::Purchase(CScScript *script, const char *productId) { if (!productId) return false;
#ifdef __IPHONEOS__
- for (int i = 0; i < m_ValidProducts.GetSize(); i++) {
- if (strcmp(productId, m_ValidProducts[i]->GetId()) == 0) {
- m_LastPurchaseOwner = script->m_Owner;
+ for (int i = 0; i < _validProducts.GetSize(); i++) {
+ if (strcmp(productId, _validProducts[i]->GetId()) == 0) {
+ _lastPurchaseOwner = script->_owner;
StoreKit_Purchase(productId);
return true;
@@ -420,11 +420,11 @@ bool CSXStore::Purchase(CScScript *script, const char *productId) { bool CSXStore::FinishTransaction(CScScript *script, const char *transId) {
if (!transId) return false;
#ifdef __IPHONEOS__
- for (int i = 0; i < m_Transactions.GetSize(); i++) {
- if (strcmp(transId, m_Transactions[i]->GetId()) == 0) {
+ for (int i = 0; i < _transactions.GetSize(); i++) {
+ if (strcmp(transId, _transactions[i]->GetId()) == 0) {
if (StoreKit_FinishTransaction(transId) > 0) {
- SAFE_DELETE(m_Transactions[i]);
- m_Transactions.RemoveAt(i);
+ SAFE_DELETE(_transactions[i]);
+ _transactions.RemoveAt(i);
return true;
} else return false;
}
@@ -436,7 +436,7 @@ bool CSXStore::FinishTransaction(CScScript *script, const char *transId) { //////////////////////////////////////////////////////////////////////////
void CSXStore::RestoreTransactions(CScScript *script) {
- m_LastRestoreOwner = script->m_Owner;
+ _lastRestoreOwner = script->_owner;
#ifdef __IPHONEOS__
StoreKit_RestoreTransactions();
#endif
@@ -444,9 +444,9 @@ void CSXStore::RestoreTransactions(CScScript *script) { //////////////////////////////////////////////////////////////////////////
void CSXStore::OnRestoreFinished(bool error) {
- if (m_LastRestoreOwner) {
- if (error) m_LastRestoreOwner->ApplyEvent("TransactionsRestoreFailed");
- else m_LastRestoreOwner->ApplyEvent("TransactionsRestoreFinished");
+ if (_lastRestoreOwner) {
+ if (error) _lastRestoreOwner->ApplyEvent("TransactionsRestoreFailed");
+ else _lastRestoreOwner->ApplyEvent("TransactionsRestoreFinished");
}
}
diff --git a/engines/wintermute/scriptables/SXStore.h b/engines/wintermute/scriptables/SXStore.h index f6a13e9eeb..dd11416a0f 100644 --- a/engines/wintermute/scriptables/SXStore.h +++ b/engines/wintermute/scriptables/SXStore.h @@ -38,88 +38,88 @@ public: class CBStoreProduct {
public:
CBStoreProduct() {
- m_Id = m_Name = m_Desc = m_Price = NULL;
+ _id = _name = _desc = _price = NULL;
}
CBStoreProduct(const char *id, const char *name, const char *desc, const char *price) {
- m_Id = m_Name = m_Desc = m_Price = NULL;
+ _id = _name = _desc = _price = NULL;
- CBUtils::SetString(&m_Id, id);
- CBUtils::SetString(&m_Name, name);
- CBUtils::SetString(&m_Desc, desc);
- CBUtils::SetString(&m_Price, price);
+ CBUtils::SetString(&_id, id);
+ CBUtils::SetString(&_name, name);
+ CBUtils::SetString(&_desc, desc);
+ CBUtils::SetString(&_price, price);
}
~CBStoreProduct() {
- delete [] m_Id;
- delete [] m_Name;
- delete [] m_Desc;
- delete [] m_Price;
+ delete [] _id;
+ delete [] _name;
+ delete [] _desc;
+ delete [] _price;
}
HRESULT Persist(CBPersistMgr *PersistMgr) {
- PersistMgr->Transfer(TMEMBER(m_Id));
- PersistMgr->Transfer(TMEMBER(m_Name));
- PersistMgr->Transfer(TMEMBER(m_Desc));
- PersistMgr->Transfer(TMEMBER(m_Price));
+ PersistMgr->Transfer(TMEMBER(_id));
+ PersistMgr->Transfer(TMEMBER(_name));
+ PersistMgr->Transfer(TMEMBER(_desc));
+ PersistMgr->Transfer(TMEMBER(_price));
return S_OK;
}
const char *GetId() {
- return m_Id;
+ return _id;
}
const char *GetName() {
- return m_Name;
+ return _name;
}
const char *GetDesc() {
- return m_Desc;
+ return _desc;
}
const char *GetPrice() {
- return m_Price;
+ return _price;
}
private:
- char *m_Id;
- char *m_Name;
- char *m_Desc;
- char *m_Price;
+ char *_id;
+ char *_name;
+ char *_desc;
+ char *_price;
};
//////////////////////////////////////////////////////////////////////////
class CBStoreTransaction {
public:
CBStoreTransaction() {
- m_Id = m_ProductId = m_State = NULL;
+ _id = _productId = _state = NULL;
}
CBStoreTransaction(const char *id, const char *productId, const char *state) {
- m_Id = m_ProductId = m_State = NULL;
+ _id = _productId = _state = NULL;
- CBUtils::SetString(&m_Id, id);
- CBUtils::SetString(&m_ProductId, productId);
- CBUtils::SetString(&m_State, state);
+ CBUtils::SetString(&_id, id);
+ CBUtils::SetString(&_productId, productId);
+ CBUtils::SetString(&_state, state);
}
~CBStoreTransaction() {
- delete [] m_Id;
- delete [] m_ProductId;
- delete [] m_State;
+ delete [] _id;
+ delete [] _productId;
+ delete [] _state;
}
const char *GetId() {
- return m_Id;
+ return _id;
}
const char *GetProductId() {
- return m_ProductId;
+ return _productId;
}
const char *GetState() {
- return m_State;
+ return _state;
}
private:
- char *m_Id;
- char *m_ProductId;
- char *m_State;
+ char *_id;
+ char *_productId;
+ char *_state;
};
@@ -135,7 +135,7 @@ public: bool IsAvailable();
void SetEventsEnabled(CScScript *script, bool val);
bool GetEventsEnabled() const {
- return m_EventsEnabled;
+ return _eventsEnabled;
}
void ValidateProducts(const char *prodIdList);
@@ -156,14 +156,14 @@ private: bool FinishTransaction(CScScript *script, const char *transId);
void RestoreTransactions(CScScript *script);
- bool m_EventsEnabled;
- CBArray<CBStoreProduct *, CBStoreProduct *> m_ValidProducts;
- AnsiStringArray m_InvalidProducts;
- CBScriptHolder *m_LastProductRequestOwner;
- CBScriptHolder *m_LastPurchaseOwner;
- CBScriptHolder *m_LastRestoreOwner;
+ bool _eventsEnabled;
+ CBArray<CBStoreProduct *, CBStoreProduct *> _validProducts;
+ AnsiStringArray _invalidProducts;
+ CBScriptHolder *_lastProductRequestOwner;
+ CBScriptHolder *_lastPurchaseOwner;
+ CBScriptHolder *_lastRestoreOwner;
- CBArray<CBStoreTransaction *, CBStoreTransaction *> m_Transactions;
+ CBArray<CBStoreTransaction *, CBStoreTransaction *> _transactions;
};
diff --git a/engines/wintermute/scriptables/SXString.cpp b/engines/wintermute/scriptables/SXString.cpp index 0e4daf02aa..4c9f4db146 100644 --- a/engines/wintermute/scriptables/SXString.cpp +++ b/engines/wintermute/scriptables/SXString.cpp @@ -104,7 +104,7 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th //try {
WideString str;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
str = StringUtil::Utf8ToWide(_string);
else
str = StringUtil::AnsiToWide(_string);
@@ -112,7 +112,7 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th //WideString subStr = str.substr(start, end - start + 1);
WideString subStr(str.c_str() + start, end - start + 1);
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
Stack->PushString(StringUtil::WideToUtf8(subStr).c_str());
else
Stack->PushString(StringUtil::WideToAnsi(subStr).c_str());
@@ -142,7 +142,7 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th // try {
WideString str;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
str = StringUtil::Utf8ToWide(_string);
else
str = StringUtil::AnsiToWide(_string);
@@ -150,7 +150,7 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th // WideString subStr = str.substr(start, len);
WideString subStr(str.c_str() + start, len);
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
Stack->PushString(StringUtil::WideToUtf8(subStr).c_str());
else
Stack->PushString(StringUtil::WideToAnsi(subStr).c_str());
@@ -168,14 +168,14 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th Stack->CorrectParams(0);
WideString str;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
str = StringUtil::Utf8ToWide(_string);
else
str = StringUtil::AnsiToWide(_string);
StringUtil::ToUpperCase(str);
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
Stack->PushString(StringUtil::WideToUtf8(str).c_str());
else
Stack->PushString(StringUtil::WideToAnsi(str).c_str());
@@ -190,14 +190,14 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th Stack->CorrectParams(0);
WideString str;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
str = StringUtil::Utf8ToWide(_string);
else
str = StringUtil::AnsiToWide(_string);
StringUtil::ToLowerCase(str);
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
Stack->PushString(StringUtil::WideToUtf8(str).c_str());
else
Stack->PushString(StringUtil::WideToAnsi(str).c_str());
@@ -215,13 +215,13 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th int index = Stack->Pop()->GetInt();
WideString str;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
str = StringUtil::Utf8ToWide(_string);
else
str = StringUtil::AnsiToWide(_string);
WideString toFind;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
toFind = StringUtil::Utf8ToWide(strToFind);
else
toFind = StringUtil::AnsiToWide(strToFind);
@@ -249,13 +249,13 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th WideString str;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
str = StringUtil::Utf8ToWide(_string);
else
str = StringUtil::AnsiToWide(_string);
WideString delims;
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
delims = StringUtil::Utf8ToWide(Separators);
else
delims = StringUtil::AnsiToWide(Separators);
@@ -285,7 +285,7 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th for (Common::Array<WideString>::iterator it = parts.begin(); it != parts.end(); ++it) {
WideString &part = (*it);
- if (Game->m_TextEncoding == TEXT_UTF8)
+ if (Game->_textEncoding == TEXT_UTF8)
Val = new CScValue(Game, StringUtil::WideToUtf8(part).c_str());
else
Val = new CScValue(Game, StringUtil::WideToAnsi(part).c_str());
@@ -305,36 +305,36 @@ HRESULT CSXString::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *Th //////////////////////////////////////////////////////////////////////////
CScValue *CSXString::ScGetProperty(char *Name) {
- m_ScValue->SetNULL();
+ _scValue->SetNULL();
//////////////////////////////////////////////////////////////////////////
// Type (RO)
//////////////////////////////////////////////////////////////////////////
if (strcmp(Name, "Type") == 0) {
- m_ScValue->SetString("string");
- return m_ScValue;
+ _scValue->SetString("string");
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Length (RO)
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "Length") == 0) {
- if (Game->m_TextEncoding == TEXT_UTF8) {
+ if (Game->_textEncoding == TEXT_UTF8) {
WideString wstr = StringUtil::Utf8ToWide(_string);
- m_ScValue->SetInt(wstr.size());
+ _scValue->SetInt(wstr.size());
} else
- m_ScValue->SetInt(strlen(_string));
+ _scValue->SetInt(strlen(_string));
- return m_ScValue;
+ return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Capacity
//////////////////////////////////////////////////////////////////////////
else if (strcmp(Name, "Capacity") == 0) {
- m_ScValue->SetInt(_capacity);
- return m_ScValue;
+ _scValue->SetInt(_capacity);
+ return _scValue;
}
- else return m_ScValue;
+ else return _scValue;
}
@@ -370,7 +370,7 @@ HRESULT CSXString::Persist(CBPersistMgr *PersistMgr) { PersistMgr->Transfer(TMEMBER(_capacity));
- if (PersistMgr->m_Saving) {
+ if (PersistMgr->_saving) {
if (_capacity > 0) PersistMgr->PutBytes((byte *)_string, _capacity);
} else {
if (_capacity > 0) {
diff --git a/engines/wintermute/scriptables/ScEngine.cpp b/engines/wintermute/scriptables/ScEngine.cpp index 24272766c2..20716cfd04 100644 --- a/engines/wintermute/scriptables/ScEngine.cpp +++ b/engines/wintermute/scriptables/ScEngine.cpp @@ -54,31 +54,31 @@ CScEngine::CScEngine(CBGame *inGame): CBBase(inGame) { char CompilerPath[MAX_PATH];
strcpy(CompilerPath, COMPILER_DLL);
- m_CompilerDLL = ::LoadLibrary(CompilerPath);
- if (m_CompilerDLL == NULL) {
+ _compilerDLL = ::LoadLibrary(CompilerPath);
+ if (_compilerDLL == NULL) {
char ModuleName[MAX_PATH];
::GetModuleFileName(NULL, ModuleName, MAX_PATH);
// switch to exe's dir
char *ExeDir = CBUtils::GetPath(ModuleName);
sprintf(CompilerPath, "%s%s", ExeDir, COMPILER_DLL);
- m_CompilerDLL = ::LoadLibrary(CompilerPath);
+ _compilerDLL = ::LoadLibrary(CompilerPath);
delete [] ExeDir;
}
- if (m_CompilerDLL != NULL) {
+ if (_compilerDLL != NULL) {
// bind compiler's functionality
- ExtCompileBuffer = (DLL_COMPILE_BUFFER) ::GetProcAddress(m_CompilerDLL, "CompileBuffer");
- ExtCompileFile = (DLL_COMPILE_FILE) ::GetProcAddress(m_CompilerDLL, "CompileFile");
- ExtReleaseBuffer = (DLL_RELEASE_BUFFER) ::GetProcAddress(m_CompilerDLL, "ReleaseBuffer");
- ExtSetCallbacks = (DLL_SET_CALLBACKS) ::GetProcAddress(m_CompilerDLL, "SetCallbacks");
- ExtDefineFunction = (DLL_DEFINE_FUNCTION)::GetProcAddress(m_CompilerDLL, "DefineFunction");
- ExtDefineVariable = (DLL_DEFINE_VARIABLE)::GetProcAddress(m_CompilerDLL, "DefineVariable");
+ ExtCompileBuffer = (DLL_COMPILE_BUFFER) ::GetProcAddress(_compilerDLL, "CompileBuffer");
+ ExtCompileFile = (DLL_COMPILE_FILE) ::GetProcAddress(_compilerDLL, "CompileFile");
+ ExtReleaseBuffer = (DLL_RELEASE_BUFFER) ::GetProcAddress(_compilerDLL, "ReleaseBuffer");
+ ExtSetCallbacks = (DLL_SET_CALLBACKS) ::GetProcAddress(_compilerDLL, "SetCallbacks");
+ ExtDefineFunction = (DLL_DEFINE_FUNCTION)::GetProcAddress(_compilerDLL, "DefineFunction");
+ ExtDefineVariable = (DLL_DEFINE_VARIABLE)::GetProcAddress(_compilerDLL, "DefineVariable");
if (!ExtCompileBuffer || !ExtCompileFile || !ExtReleaseBuffer || !ExtSetCallbacks || !ExtDefineFunction || !ExtDefineVariable) {
- m_CompilerAvailable = false;
- ::FreeLibrary(m_CompilerDLL);
- m_CompilerDLL = NULL;
+ _compilerAvailable = false;
+ ::FreeLibrary(_compilerDLL);
+ _compilerDLL = NULL;
} else {
/*
// publish external methods to the compiler
@@ -89,50 +89,50 @@ CScEngine::CScEngine(CBGame *inGame): CBBase(inGame) { ExtSetCallbacks(&c, Game);
*/
- m_CompilerAvailable = true;
+ _compilerAvailable = true;
}
- } else m_CompilerAvailable = false;
+ } else _compilerAvailable = false;
#else
- m_CompilerAvailable = false;
- m_CompilerDLL = NULL;
+ _compilerAvailable = false;
+ _compilerDLL = NULL;
#endif
- if (m_CompilerAvailable) Game->LOG(0, " Script compiler bound successfuly");
+ if (_compilerAvailable) Game->LOG(0, " Script compiler bound successfuly");
else Game->LOG(0, " Script compiler is NOT available");
- m_Globals = new CScValue(Game);
+ _globals = new CScValue(Game);
// register 'Game' as global variable
- if (!m_Globals->PropExists("Game")) {
+ if (!_globals->PropExists("Game")) {
CScValue val(Game);
val.SetNative(Game, true);
- m_Globals->SetProp("Game", &val);
+ _globals->SetProp("Game", &val);
}
// register 'Math' as global variable
- if (!m_Globals->PropExists("Math")) {
+ if (!_globals->PropExists("Math")) {
CScValue val(Game);
- val.SetNative(Game->m_MathClass, true);
- m_Globals->SetProp("Math", &val);
+ val.SetNative(Game->_mathClass, true);
+ _globals->SetProp("Math", &val);
}
// prepare script cache
- for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) m_CachedScripts[i] = NULL;
+ for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) _cachedScripts[i] = NULL;
- m_CurrentScript = NULL;
+ _currentScript = NULL;
- m_FileToCompile = NULL;
+ _fileToCompile = NULL;
- m_CompileErrorCallback = NULL;
- m_CompileErrorCallbackData = NULL;
+ _compileErrorCallback = NULL;
+ _compileErrorCallbackData = NULL;
- m_ParseElementCallback = NULL;
- m_ParseElementCallbackData = NULL;
+ _parseElementCallback = NULL;
+ _parseElementCallbackData = NULL;
- m_IsProfiling = false;
- m_ProfilingStartTime = 0;
+ _isProfiling = false;
+ _profilingStartTime = 0;
//EnableProfiling();
}
@@ -145,44 +145,44 @@ CScEngine::~CScEngine() { DisableProfiling();
#ifdef __WIN32__
- if (m_CompilerAvailable && m_CompilerDLL) ::FreeLibrary(m_CompilerDLL);
+ if (_compilerAvailable && _compilerDLL) ::FreeLibrary(_compilerDLL);
#endif
Cleanup();
- for (int i = 0; i < m_Breakpoints.GetSize(); i++) {
- delete m_Breakpoints[i];
- m_Breakpoints[i] = NULL;
+ for (int i = 0; i < _breakpoints.GetSize(); i++) {
+ delete _breakpoints[i];
+ _breakpoints[i] = NULL;
}
- m_Breakpoints.RemoveAll();
+ _breakpoints.RemoveAll();
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::Cleanup() {
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (!m_Scripts[i]->m_Thread && m_Scripts[i]->m_Owner) m_Scripts[i]->m_Owner->RemoveScript(m_Scripts[i]);
- delete m_Scripts[i];
- m_Scripts.RemoveAt(i);
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (!_scripts[i]->_thread && _scripts[i]->_owner) _scripts[i]->_owner->RemoveScript(_scripts[i]);
+ delete _scripts[i];
+ _scripts.RemoveAt(i);
i--;
}
- m_Scripts.RemoveAll();
+ _scripts.RemoveAll();
- delete m_Globals;
- m_Globals = NULL;
+ delete _globals;
+ _globals = NULL;
EmptyScriptCache();
- m_CurrentScript = NULL; // ref only
+ _currentScript = NULL; // ref only
- delete[] m_FileToCompile;
- m_FileToCompile = NULL;
+ delete[] _fileToCompile;
+ _fileToCompile = NULL;
- m_CompileErrorCallback = NULL;
- m_CompileErrorCallbackData = NULL;
+ _compileErrorCallback = NULL;
+ _compileErrorCallbackData = NULL;
- m_ParseElementCallback = NULL;
- m_ParseElementCallbackData = NULL;
+ _parseElementCallback = NULL;
+ _parseElementCallbackData = NULL;
return S_OK;
}
@@ -191,7 +191,7 @@ HRESULT CScEngine::Cleanup() { //////////////////////////////////////////////////////////////////////////
byte *WINAPI CScEngine::LoadFile(void *Data, char *Filename, uint32 *Size) {
CBGame *Game = (CBGame *)Data;
- return Game->m_FileManager->ReadWholeFile(Filename, Size);
+ return Game->_fileManager->ReadWholeFile(Filename, Size);
}
@@ -205,14 +205,14 @@ void WINAPI CScEngine::AddError(void *Data, int Line, char *Text) { CBGame *Game = (CBGame *)Data;
if (Game) {
- if (Game->m_ScEngine && Game->m_ScEngine->m_FileToCompile)
- Game->LOG(0, "Compiling script '%s'...", Game->m_ScEngine->m_FileToCompile);
+ if (Game->_scEngine && Game->_scEngine->_fileToCompile)
+ Game->LOG(0, "Compiling script '%s'...", Game->_scEngine->_fileToCompile);
Game->LOG(0, " Error@line %d: %s", Line, Text);
// redirect to an engine's own callback
- if (Game->m_ScEngine && Game->m_ScEngine->m_CompileErrorCallback) {
- Game->m_ScEngine->m_CompileErrorCallback(Line, Text, Game->m_ScEngine->m_CompileErrorCallbackData);
+ if (Game->_scEngine && Game->_scEngine->_compileErrorCallback) {
+ Game->_scEngine->_compileErrorCallback(Line, Text, Game->_scEngine->_compileErrorCallbackData);
}
}
}
@@ -224,8 +224,8 @@ void WINAPI CScEngine::ParseElement(void *Data, int Line, int Type, void *Elemen if (Game) {
// redirect to an engine's own callback
- if (Game->m_ScEngine && Game->m_ScEngine->m_ParseElementCallback) {
- Game->m_ScEngine->m_ParseElementCallback(Line, Type, ElementData, Game->m_ScEngine->m_CompileErrorCallbackData);
+ if (Game->_scEngine && Game->_scEngine->_parseElementCallback) {
+ Game->_scEngine->_parseElementCallback(Line, Type, ElementData, Game->_scEngine->_compileErrorCallbackData);
}
}
}
@@ -253,10 +253,10 @@ CScScript *CScEngine::RunScript(char *Filename, CBScriptHolder *Owner) { if (Owner)val.SetNative(Owner, true);
else val.SetNULL();
- script->m_Globals->SetProp("self", &val);
- script->m_Globals->SetProp("this", &val);
+ script->_globals->SetProp("self", &val);
+ script->_globals->SetProp("this", &val);
- m_Scripts.Add(script);
+ _scripts.Add(script);
Game->GetDebugMgr()->OnScriptInit(script);
return script;
@@ -271,10 +271,10 @@ byte *CScEngine::GetCompiledScript(char *Filename, uint32 *OutSize, bool IgnoreC // is script in cache?
if (!IgnoreCache) {
for (i = 0; i < MAX_CACHED_SCRIPTS; i++) {
- if (m_CachedScripts[i] && scumm_stricmp(m_CachedScripts[i]->m_Filename, Filename) == 0) {
- m_CachedScripts[i]->m_Timestamp = CBPlatform::GetTime();
- *OutSize = m_CachedScripts[i]->m_Size;
- return m_CachedScripts[i]->m_Buffer;
+ if (_cachedScripts[i] && scumm_stricmp(_cachedScripts[i]->_filename, Filename) == 0) {
+ _cachedScripts[i]->_timestamp = CBPlatform::GetTime();
+ *OutSize = _cachedScripts[i]->_size;
+ return _cachedScripts[i]->_buffer;
}
}
}
@@ -286,7 +286,7 @@ byte *CScEngine::GetCompiledScript(char *Filename, uint32 *OutSize, bool IgnoreC uint32 Size;
- byte *Buffer = Game->m_FileManager->ReadWholeFile(Filename, &Size);
+ byte *Buffer = Game->_fileManager->ReadWholeFile(Filename, &Size);
if (!Buffer) {
Game->LOG(0, "CScEngine::GetCompiledScript - error opening script '%s'", Filename);
return NULL;
@@ -297,7 +297,7 @@ byte *CScEngine::GetCompiledScript(char *Filename, uint32 *OutSize, bool IgnoreC CompBuffer = Buffer;
CompSize = Size;
} else {
- if (!m_CompilerAvailable) {
+ if (!_compilerAvailable) {
Game->LOG(0, "CScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", Filename);
delete [] Buffer;
return NULL;
@@ -333,20 +333,20 @@ byte *CScEngine::GetCompiledScript(char *Filename, uint32 *OutSize, bool IgnoreC int index;
uint32 MinTime = CBPlatform::GetTime();
for (i = 0; i < MAX_CACHED_SCRIPTS; i++) {
- if (m_CachedScripts[i] == NULL) {
+ if (_cachedScripts[i] == NULL) {
index = i;
break;
- } else if (m_CachedScripts[i]->m_Timestamp <= MinTime) {
- MinTime = m_CachedScripts[i]->m_Timestamp;
+ } else if (_cachedScripts[i]->_timestamp <= MinTime) {
+ MinTime = _cachedScripts[i]->_timestamp;
index = i;
}
}
- if (m_CachedScripts[index] != NULL) delete m_CachedScripts[index];
- m_CachedScripts[index] = CachedScript;
+ if (_cachedScripts[index] != NULL) delete _cachedScripts[index];
+ _cachedScripts[index] = CachedScript;
- ret = CachedScript->m_Buffer;
- *OutSize = CachedScript->m_Size;
+ ret = CachedScript->_buffer;
+ *OutSize = CachedScript->_size;
}
@@ -363,55 +363,55 @@ byte *CScEngine::GetCompiledScript(char *Filename, uint32 *OutSize, bool IgnoreC HRESULT CScEngine::Tick() {
int i;
- if (m_Scripts.GetSize() == 0) return S_OK;
+ if (_scripts.GetSize() == 0) return S_OK;
// resolve waiting scripts
- for (i = 0; i < m_Scripts.GetSize(); i++) {
+ for (i = 0; i < _scripts.GetSize(); i++) {
- switch (m_Scripts[i]->m_State) {
+ switch (_scripts[i]->_state) {
case SCRIPT_WAITING: {
/*
bool obj_found=false;
- for(int j=0; j<Game->m_RegObjects.GetSize(); j++)
+ for(int j=0; j<Game->_regObjects.GetSize(); j++)
{
- if(Game->m_RegObjects[j] == m_Scripts[i]->m_WaitObject)
+ if(Game->_regObjects[j] == _scripts[i]->_waitObject)
{
- if(Game->m_RegObjects[j]->IsReady()) m_Scripts[i]->Run();
+ if(Game->_regObjects[j]->IsReady()) _scripts[i]->Run();
obj_found = true;
break;
}
}
- if(!obj_found) m_Scripts[i]->Finish(); // m_WaitObject no longer exists
+ if(!obj_found) _scripts[i]->Finish(); // _waitObject no longer exists
*/
- if (Game->ValidObject(m_Scripts[i]->m_WaitObject)) {
- if (m_Scripts[i]->m_WaitObject->IsReady()) m_Scripts[i]->Run();
- } else m_Scripts[i]->Finish();
+ if (Game->ValidObject(_scripts[i]->_waitObject)) {
+ if (_scripts[i]->_waitObject->IsReady()) _scripts[i]->Run();
+ } else _scripts[i]->Finish();
break;
}
case SCRIPT_SLEEPING: {
- if (m_Scripts[i]->m_WaitFrozen) {
- if (m_Scripts[i]->m_WaitTime <= CBPlatform::GetTime()) m_Scripts[i]->Run();
+ if (_scripts[i]->_waitFrozen) {
+ if (_scripts[i]->_waitTime <= CBPlatform::GetTime()) _scripts[i]->Run();
} else {
- if (m_Scripts[i]->m_WaitTime <= Game->m_Timer) m_Scripts[i]->Run();
+ if (_scripts[i]->_waitTime <= Game->_timer) _scripts[i]->Run();
}
break;
}
case SCRIPT_WAITING_SCRIPT: {
- if (!IsValidScript(m_Scripts[i]->m_WaitScript) || m_Scripts[i]->m_WaitScript->m_State == SCRIPT_ERROR) {
+ if (!IsValidScript(_scripts[i]->_waitScript) || _scripts[i]->_waitScript->_state == SCRIPT_ERROR) {
// fake return value
- m_Scripts[i]->m_Stack->PushNULL();
- m_Scripts[i]->m_WaitScript = NULL;
- m_Scripts[i]->Run();
+ _scripts[i]->_stack->PushNULL();
+ _scripts[i]->_waitScript = NULL;
+ _scripts[i]->Run();
} else {
- if (m_Scripts[i]->m_WaitScript->m_State == SCRIPT_THREAD_FINISHED) {
+ if (_scripts[i]->_waitScript->_state == SCRIPT_THREAD_FINISHED) {
// copy return value
- m_Scripts[i]->m_Stack->Push(m_Scripts[i]->m_WaitScript->m_Stack->Pop());
- m_Scripts[i]->Run();
- m_Scripts[i]->m_WaitScript->Finish();
- m_Scripts[i]->m_WaitScript = NULL;
+ _scripts[i]->_stack->Push(_scripts[i]->_waitScript->_stack->Pop());
+ _scripts[i]->Run();
+ _scripts[i]->_waitScript->Finish();
+ _scripts[i]->_waitScript = NULL;
}
}
break;
@@ -421,34 +421,34 @@ HRESULT CScEngine::Tick() { // execute scripts
- for (i = 0; i < m_Scripts.GetSize(); i++) {
+ for (i = 0; i < _scripts.GetSize(); i++) {
// skip paused scripts
- if (m_Scripts[i]->m_State == SCRIPT_PAUSED) continue;
+ if (_scripts[i]->_state == SCRIPT_PAUSED) continue;
// time sliced script
- if (m_Scripts[i]->m_TimeSlice > 0) {
+ if (_scripts[i]->_timeSlice > 0) {
uint32 StartTime = CBPlatform::GetTime();
- while (m_Scripts[i]->m_State == SCRIPT_RUNNING && CBPlatform::GetTime() - StartTime < m_Scripts[i]->m_TimeSlice) {
- m_CurrentScript = m_Scripts[i];
- m_Scripts[i]->ExecuteInstruction();
+ while (_scripts[i]->_state == SCRIPT_RUNNING && CBPlatform::GetTime() - StartTime < _scripts[i]->_timeSlice) {
+ _currentScript = _scripts[i];
+ _scripts[i]->ExecuteInstruction();
}
- if (m_IsProfiling && m_Scripts[i]->m_Filename) AddScriptTime(m_Scripts[i]->m_Filename, CBPlatform::GetTime() - StartTime);
+ if (_isProfiling && _scripts[i]->_filename) AddScriptTime(_scripts[i]->_filename, CBPlatform::GetTime() - StartTime);
}
// normal script
else {
uint32 StartTime;
- bool isProfiling = m_IsProfiling;
+ bool isProfiling = _isProfiling;
if (isProfiling) StartTime = CBPlatform::GetTime();
- while (m_Scripts[i]->m_State == SCRIPT_RUNNING) {
- m_CurrentScript = m_Scripts[i];
- m_Scripts[i]->ExecuteInstruction();
+ while (_scripts[i]->_state == SCRIPT_RUNNING) {
+ _currentScript = _scripts[i];
+ _scripts[i]->ExecuteInstruction();
}
- if (isProfiling && m_Scripts[i]->m_Filename) AddScriptTime(m_Scripts[i]->m_Filename, CBPlatform::GetTime() - StartTime);
+ if (isProfiling && _scripts[i]->_filename) AddScriptTime(_scripts[i]->_filename, CBPlatform::GetTime() - StartTime);
}
- m_CurrentScript = NULL;
+ _currentScript = NULL;
}
RemoveFinishedScripts();
@@ -460,15 +460,15 @@ HRESULT CScEngine::Tick() { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::TickUnbreakable() {
// execute unbreakable scripts
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (!m_Scripts[i]->m_Unbreakable) continue;
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (!_scripts[i]->_unbreakable) continue;
- while (m_Scripts[i]->m_State == SCRIPT_RUNNING) {
- m_CurrentScript = m_Scripts[i];
- m_Scripts[i]->ExecuteInstruction();
+ while (_scripts[i]->_state == SCRIPT_RUNNING) {
+ _currentScript = _scripts[i];
+ _scripts[i]->ExecuteInstruction();
}
- m_Scripts[i]->Finish();
- m_CurrentScript = NULL;
+ _scripts[i]->Finish();
+ _currentScript = NULL;
}
RemoveFinishedScripts();
@@ -479,12 +479,12 @@ HRESULT CScEngine::TickUnbreakable() { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::RemoveFinishedScripts() {
// remove finished scripts
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i]->m_State == SCRIPT_FINISHED || m_Scripts[i]->m_State == SCRIPT_ERROR) {
- if (!m_Scripts[i]->m_Thread && m_Scripts[i]->m_Owner) m_Scripts[i]->m_Owner->RemoveScript(m_Scripts[i]);
- Game->GetDebugMgr()->OnScriptShutdown(m_Scripts[i]);
- delete m_Scripts[i];
- m_Scripts.RemoveAt(i);
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR) {
+ if (!_scripts[i]->_thread && _scripts[i]->_owner) _scripts[i]->_owner->RemoveScript(_scripts[i]);
+ Game->GetDebugMgr()->OnScriptShutdown(_scripts[i]);
+ delete _scripts[i];
+ _scripts.RemoveAt(i);
i--;
}
}
@@ -496,9 +496,9 @@ HRESULT CScEngine::RemoveFinishedScripts() { int CScEngine::GetNumScripts(int *Running, int *Waiting, int *Persistent) {
int running = 0, waiting = 0, persistent = 0, total = 0;
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i]->m_State == SCRIPT_FINISHED) continue;
- switch (m_Scripts[i]->m_State) {
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i]->_state == SCRIPT_FINISHED) continue;
+ switch (_scripts[i]->_state) {
case SCRIPT_RUNNING:
case SCRIPT_SLEEPING:
case SCRIPT_PAUSED:
@@ -524,9 +524,9 @@ int CScEngine::GetNumScripts(int *Running, int *Waiting, int *Persistent) { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::EmptyScriptCache() {
for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
- if (m_CachedScripts[i]) {
- delete m_CachedScripts[i];
- m_CachedScripts[i] = NULL;
+ if (_cachedScripts[i]) {
+ delete _cachedScripts[i];
+ _cachedScripts[i] = NULL;
}
}
return S_OK;
@@ -536,12 +536,12 @@ HRESULT CScEngine::EmptyScriptCache() { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ResetObject(CBObject *Object) {
// terminate all scripts waiting for this object
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i]->m_State == SCRIPT_WAITING && m_Scripts[i]->m_WaitObject == Object) {
- if (!Game->m_CompatKillMethodThreads) ResetScript(m_Scripts[i]);
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i]->_state == SCRIPT_WAITING && _scripts[i]->_waitObject == Object) {
+ if (!Game->_compatKillMethodThreads) ResetScript(_scripts[i]);
- bool IsThread = m_Scripts[i]->m_MethodThread || m_Scripts[i]->m_Thread;
- m_Scripts[i]->Finish(!IsThread); // 1.9b1 - top-level script kills its threads as well
+ bool IsThread = _scripts[i]->_methodThread || _scripts[i]->_thread;
+ _scripts[i]->Finish(!IsThread); // 1.9b1 - top-level script kills its threads as well
}
}
return S_OK;
@@ -550,9 +550,9 @@ HRESULT CScEngine::ResetObject(CBObject *Object) { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ResetScript(CScScript *Script) {
// terminate all scripts waiting for this script
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i]->m_State == SCRIPT_WAITING_SCRIPT && m_Scripts[i]->m_WaitScript == Script) {
- m_Scripts[i]->Finish();
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i]->_state == SCRIPT_WAITING_SCRIPT && _scripts[i]->_waitScript == Script) {
+ _scripts[i]->Finish();
}
}
return S_OK;
@@ -560,13 +560,13 @@ HRESULT CScEngine::ResetScript(CScScript *Script) { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::Persist(CBPersistMgr *PersistMgr) {
- if (!PersistMgr->m_Saving) Cleanup();
+ if (!PersistMgr->_saving) Cleanup();
PersistMgr->Transfer(TMEMBER(Game));
- PersistMgr->Transfer(TMEMBER(m_CurrentScript));
- PersistMgr->Transfer(TMEMBER(m_FileToCompile));
- PersistMgr->Transfer(TMEMBER(m_Globals));
- m_Scripts.Persist(PersistMgr);
+ PersistMgr->Transfer(TMEMBER(_currentScript));
+ PersistMgr->Transfer(TMEMBER(_fileToCompile));
+ PersistMgr->Transfer(TMEMBER(_globals));
+ _scripts.Persist(PersistMgr);
return S_OK;
}
@@ -574,10 +574,10 @@ HRESULT CScEngine::Persist(CBPersistMgr *PersistMgr) { //////////////////////////////////////////////////////////////////////////
void CScEngine::EditorCleanup() {
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i]->m_Owner == NULL && (m_Scripts[i]->m_State == SCRIPT_FINISHED || m_Scripts[i]->m_State == SCRIPT_ERROR)) {
- delete m_Scripts[i];
- m_Scripts.RemoveAt(i);
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i]->_owner == NULL && (_scripts[i]->_state == SCRIPT_FINISHED || _scripts[i]->_state == SCRIPT_ERROR)) {
+ delete _scripts[i];
+ _scripts.RemoveAt(i);
i--;
}
}
@@ -586,8 +586,8 @@ void CScEngine::EditorCleanup() { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::PauseAll() {
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i] != m_CurrentScript) m_Scripts[i]->Pause();
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i] != _currentScript) _scripts[i]->Pause();
}
return S_OK;
@@ -596,8 +596,8 @@ HRESULT CScEngine::PauseAll() { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ResumeAll() {
- for (int i = 0; i < m_Scripts.GetSize(); i++)
- m_Scripts[i]->Resume();
+ for (int i = 0; i < _scripts.GetSize(); i++)
+ _scripts[i]->Resume();
return S_OK;
}
@@ -605,10 +605,10 @@ HRESULT CScEngine::ResumeAll() { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::SetFileToCompile(char *Filename) {
- delete[] m_FileToCompile;
- m_FileToCompile = new char[strlen(Filename) + 1];
- if (m_FileToCompile) {
- strcpy(m_FileToCompile, Filename);
+ delete[] _fileToCompile;
+ _fileToCompile = new char[strlen(Filename) + 1];
+ if (_fileToCompile) {
+ strcpy(_fileToCompile, Filename);
return S_OK;
} else return E_FAIL;
}
@@ -616,46 +616,46 @@ HRESULT CScEngine::SetFileToCompile(char *Filename) { //////////////////////////////////////////////////////////////////////////
void CScEngine::SetCompileErrorCallback(COMPILE_ERROR_CALLBACK Callback, void *Data) {
- m_CompileErrorCallback = Callback;
- m_CompileErrorCallbackData = Data;
+ _compileErrorCallback = Callback;
+ _compileErrorCallbackData = Data;
}
//////////////////////////////////////////////////////////////////////////
void CScEngine::SetParseElementCallback(PARSE_ELEMENT_CALLBACK Callback, void *Data) {
- m_ParseElementCallback = Callback;
- m_ParseElementCallbackData = Data;
+ _parseElementCallback = Callback;
+ _parseElementCallbackData = Data;
}
//////////////////////////////////////////////////////////////////////////
bool CScEngine::IsValidScript(CScScript *Script) {
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i] == Script) return true;
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i] == Script) return true;
}
return false;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::ClearGlobals(bool IncludingNatives) {
- m_Globals->CleanProps(IncludingNatives);
+ _globals->CleanProps(IncludingNatives);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::DbgSendScripts(IWmeDebugClient *Client) {
// send global variables
- m_Globals->DbgSendVariables(Client, WME_DBGVAR_GLOBAL, NULL, 0);
+ _globals->DbgSendVariables(Client, WME_DBGVAR_GLOBAL, NULL, 0);
// process normal scripts first
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i]->m_Thread || m_Scripts[i]->m_MethodThread) continue;
- m_Scripts[i]->DbgSendScript(Client);
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i]->_thread || _scripts[i]->_methodThread) continue;
+ _scripts[i]->DbgSendScript(Client);
}
// and threads later
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- if (m_Scripts[i]->m_Thread || m_Scripts[i]->m_MethodThread)
- m_Scripts[i]->DbgSendScript(Client);
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ if (_scripts[i]->_thread || _scripts[i]->_methodThread)
+ _scripts[i]->DbgSendScript(Client);
}
return S_OK;
@@ -663,24 +663,24 @@ HRESULT CScEngine::DbgSendScripts(IWmeDebugClient *Client) { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::AddBreakpoint(char *ScriptFilename, int Line) {
- if (!Game->GetDebugMgr()->m_Enabled) return S_OK;
+ if (!Game->GetDebugMgr()->_enabled) return S_OK;
CScBreakpoint *Bp = NULL;
- for (int i = 0; i < m_Breakpoints.GetSize(); i++) {
- if (scumm_stricmp(m_Breakpoints[i]->m_Filename, ScriptFilename) == 0) {
- Bp = m_Breakpoints[i];
+ for (int i = 0; i < _breakpoints.GetSize(); i++) {
+ if (scumm_stricmp(_breakpoints[i]->_filename, ScriptFilename) == 0) {
+ Bp = _breakpoints[i];
break;
}
}
if (Bp == NULL) {
Bp = new CScBreakpoint(ScriptFilename);
- m_Breakpoints.Add(Bp);
+ _breakpoints.Add(Bp);
}
bool Found = false;
- for (int i = 0; i < Bp->m_Lines.GetSize(); i++) {
- if (Bp->m_Lines[i] == Line) return S_OK;
+ for (int i = 0; i < Bp->_lines.GetSize(); i++) {
+ if (Bp->_lines[i] == Line) return S_OK;
}
- Bp->m_Lines.Add(Line);
+ Bp->_lines.Add(Line);
// refresh changes
RefreshScriptBreakpoints();
@@ -690,16 +690,16 @@ HRESULT CScEngine::AddBreakpoint(char *ScriptFilename, int Line) { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::RemoveBreakpoint(char *ScriptFilename, int Line) {
- if (!Game->GetDebugMgr()->m_Enabled) return S_OK;
-
- for (int i = 0; i < m_Breakpoints.GetSize(); i++) {
- if (scumm_stricmp(m_Breakpoints[i]->m_Filename, ScriptFilename) == 0) {
- for (int j = 0; j < m_Breakpoints[i]->m_Lines.GetSize(); j++) {
- if (m_Breakpoints[i]->m_Lines[j] == Line) {
- m_Breakpoints[i]->m_Lines.RemoveAt(j);
- if (m_Breakpoints[i]->m_Lines.GetSize() == 0) {
- delete m_Breakpoints[i];
- m_Breakpoints.RemoveAt(i);
+ if (!Game->GetDebugMgr()->_enabled) return S_OK;
+
+ for (int i = 0; i < _breakpoints.GetSize(); i++) {
+ if (scumm_stricmp(_breakpoints[i]->_filename, ScriptFilename) == 0) {
+ for (int j = 0; j < _breakpoints[i]->_lines.GetSize(); j++) {
+ if (_breakpoints[i]->_lines[j] == Line) {
+ _breakpoints[i]->_lines.RemoveAt(j);
+ if (_breakpoints[i]->_lines.GetSize() == 0) {
+ delete _breakpoints[i];
+ _breakpoints.RemoveAt(i);
}
// refresh changes
RefreshScriptBreakpoints();
@@ -715,65 +715,65 @@ HRESULT CScEngine::RemoveBreakpoint(char *ScriptFilename, int Line) { //////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::RefreshScriptBreakpoints() {
- if (!Game->GetDebugMgr()->m_Enabled) return S_OK;
+ if (!Game->GetDebugMgr()->_enabled) return S_OK;
- for (int i = 0; i < m_Scripts.GetSize(); i++) {
- RefreshScriptBreakpoints(m_Scripts[i]);
+ for (int i = 0; i < _scripts.GetSize(); i++) {
+ RefreshScriptBreakpoints(_scripts[i]);
}
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::RefreshScriptBreakpoints(CScScript *Script) {
- if (!Game->GetDebugMgr()->m_Enabled) return S_OK;
+ if (!Game->GetDebugMgr()->_enabled) return S_OK;
- if (!Script || !Script->m_Filename) return E_FAIL;
+ if (!Script || !Script->_filename) return E_FAIL;
- for (int i = 0; i < m_Breakpoints.GetSize(); i++) {
- if (scumm_stricmp(m_Breakpoints[i]->m_Filename, Script->m_Filename) == 0) {
- Script->m_Breakpoints.Copy(m_Breakpoints[i]->m_Lines);
+ for (int i = 0; i < _breakpoints.GetSize(); i++) {
+ if (scumm_stricmp(_breakpoints[i]->_filename, Script->_filename) == 0) {
+ Script->_breakpoints.Copy(_breakpoints[i]->_lines);
return S_OK;
}
}
- if (Script->m_Breakpoints.GetSize() > 0) Script->m_Breakpoints.RemoveAll();
+ if (Script->_breakpoints.GetSize() > 0) Script->_breakpoints.RemoveAll();
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::SaveBreakpoints() {
- if (!Game->GetDebugMgr()->m_Enabled) return S_OK;
+ if (!Game->GetDebugMgr()->_enabled) return S_OK;
char Text[512];
char Key[100];
int Count = 0;
- for (int i = 0; i < m_Breakpoints.GetSize(); i++) {
- for (int j = 0; j < m_Breakpoints[i]->m_Lines.GetSize(); j++) {
+ for (int i = 0; i < _breakpoints.GetSize(); i++) {
+ for (int j = 0; j < _breakpoints[i]->_lines.GetSize(); j++) {
Count++;
sprintf(Key, "Breakpoint%d", Count);
- sprintf(Text, "%s:%d", m_Breakpoints[i]->m_Filename, m_Breakpoints[i]->m_Lines[j]);
+ sprintf(Text, "%s:%d", _breakpoints[i]->_filename, _breakpoints[i]->_lines[j]);
- Game->m_Registry->WriteString("Debug", Key, Text);
+ Game->_registry->WriteString("Debug", Key, Text);
}
}
- Game->m_Registry->WriteInt("Debug", "NumBreakpoints", Count);
+ Game->_registry->WriteInt("Debug", "NumBreakpoints", Count);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScEngine::LoadBreakpoints() {
- if (!Game->GetDebugMgr()->m_Enabled) return S_OK;
+ if (!Game->GetDebugMgr()->_enabled) return S_OK;
char Key[100];
- int Count = Game->m_Registry->ReadInt("Debug", "NumBreakpoints", 0);
+ int Count = Game->_registry->ReadInt("Debug", "NumBreakpoints", 0);
for (int i = 1; i <= Count; i++) {
uint32 BufSize = 512;
sprintf(Key, "Breakpoint%d", i);
- AnsiString breakpoint = Game->m_Registry->ReadString("Debug", Key, "");
+ AnsiString breakpoint = Game->_registry->ReadString("Debug", Key, "");
char *Path = CBUtils::StrEntry(0, breakpoint.c_str(), ':');
char *Line = CBUtils::StrEntry(1, breakpoint.c_str(), ':');
@@ -791,45 +791,45 @@ HRESULT CScEngine::LoadBreakpoints() { //////////////////////////////////////////////////////////////////////////
void CScEngine::AddScriptTime(const char *Filename, uint32 Time) {
- if (!m_IsProfiling) return;
+ if (!_isProfiling) return;
AnsiString fileName = Filename;
StringUtil::ToLowerCase(fileName);
- m_ScriptTimes[fileName] += Time;
+ _scriptTimes[fileName] += Time;
}
//////////////////////////////////////////////////////////////////////////
void CScEngine::EnableProfiling() {
- if (m_IsProfiling) return;
+ if (_isProfiling) return;
// destroy old data, if any
- m_ScriptTimes.clear();
+ _scriptTimes.clear();
- m_ProfilingStartTime = CBPlatform::GetTime();
- m_IsProfiling = true;
+ _profilingStartTime = CBPlatform::GetTime();
+ _isProfiling = true;
}
//////////////////////////////////////////////////////////////////////////
void CScEngine::DisableProfiling() {
- if (!m_IsProfiling) return;
+ if (!_isProfiling) return;
DumpStats();
- m_IsProfiling = false;
+ _isProfiling = false;
}
//////////////////////////////////////////////////////////////////////////
void CScEngine::DumpStats() {
error("DumpStats not ported to ScummVM yet");
-/* uint32 totalTime = CBPlatform::GetTime() - m_ProfilingStartTime;
+/* uint32 totalTime = CBPlatform::GetTime() - _profilingStartTime;
typedef std::vector <std::pair<uint32, std::string> > TimeVector;
TimeVector times;
ScriptTimes::iterator it;
- for (it = m_ScriptTimes.begin(); it != m_ScriptTimes.end(); it++) {
+ for (it = _scriptTimes.begin(); it != _scriptTimes.end(); it++) {
times.push_back(std::pair<uint32, std::string> (it->_value, it->_key));
}
std::sort(times.begin(), times.end());
diff --git a/engines/wintermute/scriptables/ScEngine.h b/engines/wintermute/scriptables/ScEngine.h index 13103f6d3c..7be147b39e 100644 --- a/engines/wintermute/scriptables/ScEngine.h +++ b/engines/wintermute/scriptables/ScEngine.h @@ -58,39 +58,39 @@ public: class CScCachedScript {
public:
CScCachedScript(char *Filename, byte *Buffer, uint32 Size) {
- m_Timestamp = CBPlatform::GetTime();
- m_Buffer = new byte[Size];
- if (m_Buffer) memcpy(m_Buffer, Buffer, Size);
- m_Size = Size;
- m_Filename = new char[strlen(Filename) + 1];
- if (m_Filename) strcpy(m_Filename, Filename);
+ _timestamp = CBPlatform::GetTime();
+ _buffer = new byte[Size];
+ if (_buffer) memcpy(_buffer, Buffer, Size);
+ _size = Size;
+ _filename = new char[strlen(Filename) + 1];
+ if (_filename) strcpy(_filename, Filename);
};
~CScCachedScript() {
- if (m_Buffer) delete [] m_Buffer;
- if (m_Filename) delete [] m_Filename;
+ if (_buffer) delete [] _buffer;
+ if (_filename) delete [] _filename;
};
- uint32 m_Timestamp;
- byte *m_Buffer;
- uint32 m_Size;
- char *m_Filename;
+ uint32 _timestamp;
+ byte *_buffer;
+ uint32 _size;
+ char *_filename;
};
class CScBreakpoint {
public:
CScBreakpoint(const char *Filename) {
- m_Filename = NULL;
- CBUtils::SetString(&m_Filename, Filename);
+ _filename = NULL;
+ CBUtils::SetString(&_filename, Filename);
}
~CScBreakpoint() {
- if (m_Filename) delete [] m_Filename;
- m_Lines.RemoveAll();
+ if (_filename) delete [] _filename;
+ _lines.RemoveAll();
}
- char *m_Filename;
- CBArray<int, int> m_Lines;
+ char *_filename;
+ CBArray<int, int> _lines;
};
@@ -99,7 +99,7 @@ public: public:
HRESULT DbgSendScripts(IWmeDebugClient *Client);
- CBArray<CScBreakpoint *, CScBreakpoint *> m_Breakpoints;
+ CBArray<CScBreakpoint *, CScBreakpoint *> _breakpoints;
HRESULT AddBreakpoint(char *ScriptFilename, int Line);
HRESULT RemoveBreakpoint(char *ScriptFilename, int Line);
HRESULT RefreshScriptBreakpoints();
@@ -114,15 +114,15 @@ public: void SetCompileErrorCallback(COMPILE_ERROR_CALLBACK Callback, void *Data);
void SetParseElementCallback(PARSE_ELEMENT_CALLBACK Callback, void *Data);
- COMPILE_ERROR_CALLBACK m_CompileErrorCallback;
- void *m_CompileErrorCallbackData;
+ COMPILE_ERROR_CALLBACK _compileErrorCallback;
+ void *_compileErrorCallbackData;
- PARSE_ELEMENT_CALLBACK m_ParseElementCallback;
- void *m_ParseElementCallbackData;
+ PARSE_ELEMENT_CALLBACK _parseElementCallback;
+ void *_parseElementCallbackData;
HRESULT SetFileToCompile(char *Filename);
- char *m_FileToCompile;
- CScScript *m_CurrentScript;
+ char *_fileToCompile;
+ CScScript *_currentScript;
HRESULT ResumeAll();
HRESULT PauseAll();
void EditorCleanup();
@@ -134,10 +134,10 @@ public: HRESULT Cleanup();
int GetNumScripts(int *Running = NULL, int *Waiting = NULL, int *Persistent = NULL);
HRESULT Tick();
- CScValue *m_Globals;
+ CScValue *_globals;
CScScript *RunScript(char *Filename, CBScriptHolder *Owner = NULL);
- bool m_CompilerAvailable;
- HINSTANCE m_CompilerDLL;
+ bool _compilerAvailable;
+ HINSTANCE _compilerDLL;
CScEngine(CBGame *inGame);
virtual ~CScEngine();
static void WINAPI AddError(void *Data, int Line, char *Text);
@@ -151,12 +151,12 @@ public: DLL_DEFINE_FUNCTION ExtDefineFunction;
DLL_DEFINE_VARIABLE ExtDefineVariable;
- CBArray<CScScript *, CScScript *> m_Scripts;
+ CBArray<CScScript *, CScScript *> _scripts;
void EnableProfiling();
void DisableProfiling();
bool IsProfiling() {
- return m_IsProfiling;
+ return _isProfiling;
}
void AddScriptTime(const char *Filename, uint32 Time);
@@ -164,12 +164,12 @@ public: private:
- CScCachedScript *m_CachedScripts[MAX_CACHED_SCRIPTS];
- bool m_IsProfiling;
- uint32 m_ProfilingStartTime;
+ CScCachedScript *_cachedScripts[MAX_CACHED_SCRIPTS];
+ bool _isProfiling;
+ uint32 _profilingStartTime;
typedef Common::HashMap<Common::String, uint32> ScriptTimes;
- ScriptTimes m_ScriptTimes;
+ ScriptTimes _scriptTimes;
};
diff --git a/engines/wintermute/scriptables/ScScript.cpp b/engines/wintermute/scriptables/ScScript.cpp index e954fe9d9f..4d9edf9db4 100644 --- a/engines/wintermute/scriptables/ScScript.cpp +++ b/engines/wintermute/scriptables/ScScript.cpp @@ -39,59 +39,59 @@ IMPLEMENT_PERSISTENT(CScScript, false) //////////////////////////////////////////////////////////////////////////
CScScript::CScScript(CBGame *inGame, CScEngine *Engine): CBBase(inGame) {
- m_Buffer = NULL;
- m_BufferSize = m_IP = 0;
- m_Filename = NULL;
- m_CurrentLine = 0;
+ _buffer = NULL;
+ _bufferSize = _iP = 0;
+ _filename = NULL;
+ _currentLine = 0;
- m_Symbols = NULL;
- m_NumSymbols = 0;
+ _symbols = NULL;
+ _numSymbols = 0;
- m_Engine = Engine;
+ _engine = Engine;
- m_Globals = NULL;
+ _globals = NULL;
- m_ScopeStack = NULL;
- m_CallStack = NULL;
- m_ThisStack = NULL;
- m_Stack = NULL;
+ _scopeStack = NULL;
+ _callStack = NULL;
+ _thisStack = NULL;
+ _stack = NULL;
- m_Operand = NULL;
- m_Reg1 = NULL;
+ _operand = NULL;
+ _reg1 = NULL;
- m_Functions = NULL;
- m_NumFunctions = 0;
+ _functions = NULL;
+ _numFunctions = 0;
- m_Methods = NULL;
- m_NumMethods = 0;
+ _methods = NULL;
+ _numMethods = 0;
- m_Events = NULL;
- m_NumEvents = 0;
+ _events = NULL;
+ _numEvents = 0;
- m_Externals = NULL;
- m_NumExternals = 0;
+ _externals = NULL;
+ _numExternals = 0;
- m_State = SCRIPT_FINISHED;
- m_OrigState = SCRIPT_FINISHED;
+ _state = SCRIPT_FINISHED;
+ _origState = SCRIPT_FINISHED;
- m_WaitObject = NULL;
- m_WaitTime = 0;
- m_WaitFrozen = false;
- m_WaitScript = NULL;
+ _waitObject = NULL;
+ _waitTime = 0;
+ _waitFrozen = false;
+ _waitScript = NULL;
- m_TimeSlice = 0;
+ _timeSlice = 0;
- m_Thread = false;
- m_MethodThread = false;
- m_ThreadEvent = NULL;
+ _thread = false;
+ _methodThread = false;
+ _threadEvent = NULL;
- m_Freezable = true;
- m_Owner = NULL;
+ _freezable = true;
+ _owner = NULL;
- m_Unbreakable = false;
- m_ParentScript = NULL;
+ _unbreakable = false;
+ _parentScript = NULL;
- m_TracingMode = false;
+ _tracingMode = false;
}
@@ -104,15 +104,15 @@ CScScript::~CScScript() { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::InitScript() {
- TScriptHeader *Header = (TScriptHeader *)m_Buffer;
+ TScriptHeader *Header = (TScriptHeader *)_buffer;
if (Header->magic != SCRIPT_MAGIC) {
- Game->LOG(0, "File '%s' is not a valid compiled script", m_Filename);
+ Game->LOG(0, "File '%s' is not a valid compiled script", _filename);
Cleanup();
return E_FAIL;
}
if (Header->version > SCRIPT_VERSION) {
- Game->LOG(0, "Script '%s' has a wrong version %d.%d (expected %d.%d)", m_Filename, Header->version / 256, Header->version % 256, SCRIPT_VERSION / 256, SCRIPT_VERSION % 256);
+ Game->LOG(0, "Script '%s' has a wrong version %d.%d (expected %d.%d)", _filename, Header->version / 256, Header->version % 256, SCRIPT_VERSION / 256, SCRIPT_VERSION % 256);
Cleanup();
return E_FAIL;
}
@@ -120,25 +120,25 @@ HRESULT CScScript::InitScript() { InitTables();
// init stacks
- m_ScopeStack = new CScStack(Game);
- m_CallStack = new CScStack(Game);
- m_ThisStack = new CScStack(Game);
- m_Stack = new CScStack(Game);
+ _scopeStack = new CScStack(Game);
+ _callStack = new CScStack(Game);
+ _thisStack = new CScStack(Game);
+ _stack = new CScStack(Game);
- m_Operand = new CScValue(Game);
- m_Reg1 = new CScValue(Game);
+ _operand = new CScValue(Game);
+ _reg1 = new CScValue(Game);
// skip to the beginning
- m_IP = Header->code_start;
- m_CurrentLine = 0;
+ _iP = Header->code_start;
+ _currentLine = 0;
// init breakpoints
- m_Engine->RefreshScriptBreakpoints(this);
+ _engine->RefreshScriptBreakpoints(this);
// ready to rumble...
- m_State = SCRIPT_RUNNING;
+ _state = SCRIPT_RUNNING;
return S_OK;
}
@@ -146,77 +146,77 @@ HRESULT CScScript::InitScript() { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::InitTables() {
- uint32 OrigIP = m_IP;
+ uint32 OrigIP = _iP;
- TScriptHeader *Header = (TScriptHeader *)m_Buffer;
+ TScriptHeader *Header = (TScriptHeader *)_buffer;
uint32 i;
// load symbol table
- m_IP = Header->symbol_table;
+ _iP = Header->symbol_table;
- m_NumSymbols = GetDWORD();
- m_Symbols = new char*[m_NumSymbols];
- for (i = 0; i < m_NumSymbols; i++) {
+ _numSymbols = GetDWORD();
+ _symbols = new char*[_numSymbols];
+ for (i = 0; i < _numSymbols; i++) {
uint32 index = GetDWORD();
- m_Symbols[index] = GetString();
+ _symbols[index] = GetString();
}
// load functions table
- m_IP = Header->func_table;
+ _iP = Header->func_table;
- m_NumFunctions = GetDWORD();
- m_Functions = new TFunctionPos[m_NumFunctions];
- for (i = 0; i < m_NumFunctions; i++) {
- m_Functions[i].pos = GetDWORD();
- m_Functions[i].name = GetString();
+ _numFunctions = GetDWORD();
+ _functions = new TFunctionPos[_numFunctions];
+ for (i = 0; i < _numFunctions; i++) {
+ _functions[i].pos = GetDWORD();
+ _functions[i].name = GetString();
}
// load events table
- m_IP = Header->event_table;
+ _iP = Header->event_table;
- m_NumEvents = GetDWORD();
- m_Events = new TEventPos[m_NumEvents];
- for (i = 0; i < m_NumEvents; i++) {
- m_Events[i].pos = GetDWORD();
- m_Events[i].name = GetString();
+ _numEvents = GetDWORD();
+ _events = new TEventPos[_numEvents];
+ for (i = 0; i < _numEvents; i++) {
+ _events[i].pos = GetDWORD();
+ _events[i].name = GetString();
}
// load externals
if (Header->version >= 0x0101) {
- m_IP = Header->externals_table;
-
- m_NumExternals = GetDWORD();
- m_Externals = new TExternalFunction[m_NumExternals];
- for (i = 0; i < m_NumExternals; i++) {
- m_Externals[i].dll_name = GetString();
- m_Externals[i].name = GetString();
- m_Externals[i].call_type = (TCallType)GetDWORD();
- m_Externals[i].returns = (TExternalType)GetDWORD();
- m_Externals[i].num_params = GetDWORD();
- if (m_Externals[i].num_params > 0) {
- m_Externals[i].params = new TExternalType[m_Externals[i].num_params];
- for (int j = 0; j < m_Externals[i].num_params; j++) {
- m_Externals[i].params[j] = (TExternalType)GetDWORD();
+ _iP = Header->externals_table;
+
+ _numExternals = GetDWORD();
+ _externals = new TExternalFunction[_numExternals];
+ for (i = 0; i < _numExternals; i++) {
+ _externals[i].dll_name = GetString();
+ _externals[i].name = GetString();
+ _externals[i].call_type = (TCallType)GetDWORD();
+ _externals[i].returns = (TExternalType)GetDWORD();
+ _externals[i].nu_params = GetDWORD();
+ if (_externals[i].nu_params > 0) {
+ _externals[i].params = new TExternalType[_externals[i].nu_params];
+ for (int j = 0; j < _externals[i].nu_params; j++) {
+ _externals[i].params[j] = (TExternalType)GetDWORD();
}
}
}
}
// load method table
- m_IP = Header->method_table;
+ _iP = Header->method_table;
- m_NumMethods = GetDWORD();
- m_Methods = new TMethodPos[m_NumMethods];
- for (i = 0; i < m_NumMethods; i++) {
- m_Methods[i].pos = GetDWORD();
- m_Methods[i].name = GetString();
+ _numMethods = GetDWORD();
+ _methods = new TMethodPos[_numMethods];
+ for (i = 0; i < _numMethods; i++) {
+ _methods[i].pos = GetDWORD();
+ _methods[i].name = GetString();
}
- m_IP = OrigIP;
+ _iP = OrigIP;
return S_OK;
}
@@ -226,29 +226,29 @@ HRESULT CScScript::InitTables() { HRESULT CScScript::Create(char *Filename, byte *Buffer, uint32 Size, CBScriptHolder *Owner) {
Cleanup();
- m_Thread = false;
- m_MethodThread = false;
+ _thread = false;
+ _methodThread = false;
- delete[] m_ThreadEvent;
- m_ThreadEvent = NULL;
+ delete[] _threadEvent;
+ _threadEvent = NULL;
- m_Filename = new char[strlen(Filename) + 1];
- if (m_Filename) strcpy(m_Filename, Filename);
+ _filename = new char[strlen(Filename) + 1];
+ if (_filename) strcpy(_filename, Filename);
- m_Buffer = new byte [Size];
- if (!m_Buffer) return E_FAIL;
+ _buffer = new byte [Size];
+ if (!_buffer) return E_FAIL;
- memcpy(m_Buffer, Buffer, Size);
+ memcpy(_buffer, Buffer, Size);
- m_BufferSize = Size;
+ _bufferSize = Size;
HRESULT res = InitScript();
if (FAILED(res)) return res;
// establish global variables table
- m_Globals = new CScValue(Game);
+ _globals = new CScValue(Game);
- m_Owner = Owner;
+ _owner = Owner;
return S_OK;
}
@@ -258,38 +258,38 @@ HRESULT CScScript::Create(char *Filename, byte *Buffer, uint32 Size, CBScriptHol HRESULT CScScript::CreateThread(CScScript *Original, uint32 InitIP, const char *EventName) {
Cleanup();
- m_Thread = true;
- m_MethodThread = false;
- m_ThreadEvent = new char[strlen(EventName) + 1];
- if (m_ThreadEvent) strcpy(m_ThreadEvent, EventName);
+ _thread = true;
+ _methodThread = false;
+ _threadEvent = new char[strlen(EventName) + 1];
+ if (_threadEvent) strcpy(_threadEvent, EventName);
// copy filename
- m_Filename = new char[strlen(Original->m_Filename) + 1];
- if (m_Filename) strcpy(m_Filename, Original->m_Filename);
+ _filename = new char[strlen(Original->_filename) + 1];
+ if (_filename) strcpy(_filename, Original->_filename);
// copy buffer
- m_Buffer = new byte [Original->m_BufferSize];
- if (!m_Buffer) return E_FAIL;
+ _buffer = new byte [Original->_bufferSize];
+ if (!_buffer) return E_FAIL;
- memcpy(m_Buffer, Original->m_Buffer, Original->m_BufferSize);
- m_BufferSize = Original->m_BufferSize;
+ memcpy(_buffer, Original->_buffer, Original->_bufferSize);
+ _bufferSize = Original->_bufferSize;
// initialize
HRESULT res = InitScript();
if (FAILED(res)) return res;
// copy globals
- m_Globals = Original->m_Globals;
+ _globals = Original->_globals;
// skip to the beginning of the event
- m_IP = InitIP;
+ _iP = InitIP;
- m_TimeSlice = Original->m_TimeSlice;
- m_Freezable = Original->m_Freezable;
- m_Owner = Original->m_Owner;
+ _timeSlice = Original->_timeSlice;
+ _freezable = Original->_freezable;
+ _owner = Original->_owner;
- m_Engine = Original->m_Engine;
- m_ParentScript = Original;
+ _engine = Original->_engine;
+ _parentScript = Original;
return S_OK;
}
@@ -304,38 +304,38 @@ HRESULT CScScript::CreateMethodThread(CScScript *Original, const char *MethodNam Cleanup();
- m_Thread = true;
- m_MethodThread = true;
- m_ThreadEvent = new char[strlen(MethodName) + 1];
- if (m_ThreadEvent) strcpy(m_ThreadEvent, MethodName);
+ _thread = true;
+ _methodThread = true;
+ _threadEvent = new char[strlen(MethodName) + 1];
+ if (_threadEvent) strcpy(_threadEvent, MethodName);
// copy filename
- m_Filename = new char[strlen(Original->m_Filename) + 1];
- if (m_Filename) strcpy(m_Filename, Original->m_Filename);
+ _filename = new char[strlen(Original->_filename) + 1];
+ if (_filename) strcpy(_filename, Original->_filename);
// copy buffer
- m_Buffer = new byte [Original->m_BufferSize];
- if (!m_Buffer) return E_FAIL;
+ _buffer = new byte [Original->_bufferSize];
+ if (!_buffer) return E_FAIL;
- memcpy(m_Buffer, Original->m_Buffer, Original->m_BufferSize);
- m_BufferSize = Original->m_BufferSize;
+ memcpy(_buffer, Original->_buffer, Original->_bufferSize);
+ _bufferSize = Original->_bufferSize;
// initialize
HRESULT res = InitScript();
if (FAILED(res)) return res;
// copy globals
- m_Globals = Original->m_Globals;
+ _globals = Original->_globals;
// skip to the beginning of the event
- m_IP = IP;
+ _iP = IP;
- m_TimeSlice = Original->m_TimeSlice;
- m_Freezable = Original->m_Freezable;
- m_Owner = Original->m_Owner;
+ _timeSlice = Original->_timeSlice;
+ _freezable = Original->_freezable;
+ _owner = Original->_owner;
- m_Engine = Original->m_Engine;
- m_ParentScript = Original;
+ _engine = Original->_engine;
+ _parentScript = Original;
return S_OK;
}
@@ -343,76 +343,76 @@ HRESULT CScScript::CreateMethodThread(CScScript *Original, const char *MethodNam //////////////////////////////////////////////////////////////////////////
void CScScript::Cleanup() {
- if (m_Buffer) delete [] m_Buffer;
- m_Buffer = NULL;
+ if (_buffer) delete [] _buffer;
+ _buffer = NULL;
- if (m_Filename) delete [] m_Filename;
- m_Filename = NULL;
+ if (_filename) delete [] _filename;
+ _filename = NULL;
- if (m_Symbols) delete [] m_Symbols;
- m_Symbols = NULL;
- m_NumSymbols = 0;
+ if (_symbols) delete [] _symbols;
+ _symbols = NULL;
+ _numSymbols = 0;
- if (m_Globals && !m_Thread) delete m_Globals;
- m_Globals = NULL;
+ if (_globals && !_thread) delete _globals;
+ _globals = NULL;
- if (m_ScopeStack) delete m_ScopeStack;
- m_ScopeStack = NULL;
+ if (_scopeStack) delete _scopeStack;
+ _scopeStack = NULL;
- if (m_CallStack) delete m_CallStack;
- m_CallStack = NULL;
+ if (_callStack) delete _callStack;
+ _callStack = NULL;
- if (m_ThisStack) delete m_ThisStack;
- m_ThisStack = NULL;
+ if (_thisStack) delete _thisStack;
+ _thisStack = NULL;
- if (m_Stack) delete m_Stack;
- m_Stack = NULL;
+ if (_stack) delete _stack;
+ _stack = NULL;
- if (m_Functions) delete [] m_Functions;
- m_Functions = NULL;
- m_NumFunctions = 0;
+ if (_functions) delete [] _functions;
+ _functions = NULL;
+ _numFunctions = 0;
- if (m_Methods) delete [] m_Methods;
- m_Methods = NULL;
- m_NumMethods = 0;
+ if (_methods) delete [] _methods;
+ _methods = NULL;
+ _numMethods = 0;
- if (m_Events) delete [] m_Events;
- m_Events = NULL;
- m_NumEvents = 0;
+ if (_events) delete [] _events;
+ _events = NULL;
+ _numEvents = 0;
- if (m_Externals) {
- for (int i = 0; i < m_NumExternals; i++) {
- if (m_Externals[i].num_params > 0) delete [] m_Externals[i].params;
+ if (_externals) {
+ for (int i = 0; i < _numExternals; i++) {
+ if (_externals[i].nu_params > 0) delete [] _externals[i].params;
}
- delete [] m_Externals;
+ delete [] _externals;
}
- m_Externals = NULL;
- m_NumExternals = 0;
+ _externals = NULL;
+ _numExternals = 0;
- delete m_Operand;
- delete m_Reg1;
- m_Operand = NULL;
- m_Reg1 = NULL;
+ delete _operand;
+ delete _reg1;
+ _operand = NULL;
+ _reg1 = NULL;
- delete[] m_ThreadEvent;
- m_ThreadEvent = NULL;
+ delete[] _threadEvent;
+ _threadEvent = NULL;
- m_State = SCRIPT_FINISHED;
+ _state = SCRIPT_FINISHED;
- m_WaitObject = NULL;
- m_WaitTime = 0;
- m_WaitFrozen = false;
- m_WaitScript = NULL;
+ _waitObject = NULL;
+ _waitTime = 0;
+ _waitFrozen = false;
+ _waitScript = NULL;
- m_ParentScript = NULL; // ref only
+ _parentScript = NULL; // ref only
}
//////////////////////////////////////////////////////////////////////////
uint32 CScScript::GetDWORD() {
- uint32 ret = *(uint32 *)(m_Buffer + m_IP);
- m_IP += sizeof(uint32);
+ uint32 ret = *(uint32 *)(_buffer + _iP);
+ _iP += sizeof(uint32);
return ret;
}
@@ -420,8 +420,8 @@ uint32 CScScript::GetDWORD() { //////////////////////////////////////////////////////////////////////////
double CScScript::GetFloat() {
- double ret = *(double *)(m_Buffer + m_IP);
- m_IP += sizeof(double);
+ double ret = *(double *)(_buffer + _iP);
+ _iP += sizeof(double);
return ret;
}
@@ -429,9 +429,9 @@ double CScScript::GetFloat() { //////////////////////////////////////////////////////////////////////////
char *CScScript::GetString() {
- char *ret = (char *)(m_Buffer + m_IP);
- while (*(char *)(m_Buffer + m_IP) != '\0') m_IP++;
- m_IP++; // string terminator
+ char *ret = (char *)(_buffer + _iP);
+ while (*(char *)(_buffer + _iP) != '\0') _iP++;
+ _iP++; // string terminator
return ret;
}
@@ -445,7 +445,7 @@ HRESULT CScScript::ExecuteInstruction() { char *str;
//CScValue* op = new CScValue(Game);
- m_Operand->Cleanup();
+ _operand->Cleanup();
CScValue *op1;
CScValue *op2;
@@ -454,16 +454,16 @@ HRESULT CScScript::ExecuteInstruction() { switch (inst) {
case II_DEF_VAR:
- m_Operand->SetNULL();
+ _operand->SetNULL();
dw = GetDWORD();
- if (m_ScopeStack->m_SP < 0) {
- m_Globals->SetProp(m_Symbols[dw], m_Operand);
- if (Game->GetDebugMgr()->m_Enabled)
- Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_SCRIPT, this, NULL, m_Globals->GetProp(m_Symbols[dw]), m_Symbols[dw]);
+ if (_scopeStack->_sP < 0) {
+ _globals->SetProp(_symbols[dw], _operand);
+ if (Game->GetDebugMgr()->_enabled)
+ Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_SCRIPT, this, NULL, _globals->GetProp(_symbols[dw]), _symbols[dw]);
} else {
- m_ScopeStack->GetTop()->SetProp(m_Symbols[dw], m_Operand);
- if (Game->GetDebugMgr()->m_Enabled)
- Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_SCOPE, this, m_ScopeStack->GetTop(), m_ScopeStack->GetTop()->GetProp(m_Symbols[dw]), m_Symbols[dw]);
+ _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]);
}
break;
@@ -471,89 +471,89 @@ HRESULT CScScript::ExecuteInstruction() { case II_DEF_GLOB_VAR:
case II_DEF_CONST_VAR: {
dw = GetDWORD();
- char *Temp = m_Symbols[dw]; // TODO delete
+ char *Temp = _symbols[dw]; // TODO delete
// only create global var if it doesn't exist
- if (!m_Engine->m_Globals->PropExists(m_Symbols[dw])) {
- m_Operand->SetNULL();
- m_Engine->m_Globals->SetProp(m_Symbols[dw], m_Operand, false, inst == II_DEF_CONST_VAR);
+ if (!_engine->_globals->PropExists(_symbols[dw])) {
+ _operand->SetNULL();
+ _engine->_globals->SetProp(_symbols[dw], _operand, false, inst == II_DEF_CONST_VAR);
- if (Game->GetDebugMgr()->m_Enabled)
- Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_GLOBAL, this, NULL, m_Engine->m_Globals->GetProp(m_Symbols[dw]), m_Symbols[dw]);
+ if (Game->GetDebugMgr()->_enabled)
+ Game->GetDebugMgr()->OnVariableInit(WME_DBGVAR_GLOBAL, this, NULL, _engine->_globals->GetProp(_symbols[dw]), _symbols[dw]);
}
break;
}
case II_RET:
- if (m_ScopeStack->m_SP >= 0 && m_CallStack->m_SP >= 0) {
- Game->GetDebugMgr()->OnScriptShutdownScope(this, m_ScopeStack->GetTop());
+ if (_scopeStack->_sP >= 0 && _callStack->_sP >= 0) {
+ Game->GetDebugMgr()->OnScriptShutdownScope(this, _scopeStack->GetTop());
- m_ScopeStack->Pop();
- m_IP = (uint32)m_CallStack->Pop()->GetInt();
+ _scopeStack->Pop();
+ _iP = (uint32)_callStack->Pop()->GetInt();
- if (m_ScopeStack->m_SP < 0) Game->GetDebugMgr()->OnScriptChangeScope(this, NULL);
- else Game->GetDebugMgr()->OnScriptChangeScope(this, m_ScopeStack->GetTop());
+ if (_scopeStack->_sP < 0) Game->GetDebugMgr()->OnScriptChangeScope(this, NULL);
+ else Game->GetDebugMgr()->OnScriptChangeScope(this, _scopeStack->GetTop());
} else {
- if (m_Thread) {
- m_State = SCRIPT_THREAD_FINISHED;
+ if (_thread) {
+ _state = SCRIPT_THREAD_FINISHED;
} else {
- if (m_NumEvents == 0 && m_NumMethods == 0) m_State = SCRIPT_FINISHED;
- else m_State = SCRIPT_PERSISTENT;
+ if (_numEvents == 0 && _numMethods == 0) _state = SCRIPT_FINISHED;
+ else _state = SCRIPT_PERSISTENT;
}
}
break;
case II_RET_EVENT:
- m_State = SCRIPT_FINISHED;
+ _state = SCRIPT_FINISHED;
break;
case II_CALL:
dw = GetDWORD();
- m_Operand->SetInt(m_IP);
- m_CallStack->Push(m_Operand);
+ _operand->SetInt(_iP);
+ _callStack->Push(_operand);
- m_IP = dw;
+ _iP = dw;
break;
case II_CALL_BY_EXP: {
// push var
// push string
- str = m_Stack->Pop()->GetString();
+ str = _stack->Pop()->GetString();
char *MethodName = new char[strlen(str) + 1];
strcpy(MethodName, str);
- CScValue *var = m_Stack->Pop();
- if (var->m_Type == VAL_VARIABLE_REF) var = var->m_ValRef;
+ CScValue *var = _stack->Pop();
+ if (var->_type == VAL_VARIABLE_REF) var = var->_valRef;
HRESULT res = E_FAIL;
bool TriedNative = false;
// we are already calling this method, try native
- if (m_Thread && m_MethodThread && strcmp(MethodName, m_ThreadEvent) == 0 && var->m_Type == VAL_NATIVE && m_Owner == var->GetNative()) {
+ if (_thread && _methodThread && strcmp(MethodName, _threadEvent) == 0 && var->_type == VAL_NATIVE && _owner == var->GetNative()) {
TriedNative = true;
- res = var->m_ValNative->ScCallMethod(this, m_Stack, m_ThisStack, MethodName);
+ res = var->_valNative->ScCallMethod(this, _stack, _thisStack, MethodName);
}
if (FAILED(res)) {
if (var->IsNative() && var->GetNative()->CanHandleMethod(MethodName)) {
- if (!m_Unbreakable) {
- m_WaitScript = var->GetNative()->InvokeMethodThread(MethodName);
- if (!m_WaitScript) {
- m_Stack->CorrectParams(0);
+ if (!_unbreakable) {
+ _waitScript = var->GetNative()->InvokeMethodThread(MethodName);
+ if (!_waitScript) {
+ _stack->CorrectParams(0);
RuntimeError("Error invoking method '%s'.", MethodName);
- m_Stack->PushNULL();
+ _stack->PushNULL();
} else {
- m_State = SCRIPT_WAITING_SCRIPT;
- m_WaitScript->CopyParameters(m_Stack);
+ _state = SCRIPT_WAITING_SCRIPT;
+ _waitScript->CopyParameters(_stack);
}
} else {
// can call methods in unbreakable mode
- m_Stack->CorrectParams(0);
+ _stack->CorrectParams(0);
RuntimeError("Cannot call method '%s'. Ignored.", MethodName);
- m_Stack->PushNULL();
+ _stack->PushNULL();
}
delete [] MethodName;
break;
@@ -565,28 +565,28 @@ HRESULT CScScript::ExecuteInstruction() { if(dw==0){
TExternalFunction* f = GetExternal(val->GetString());
if(f){
- ExternalCall(m_Stack, m_ThisStack, f);
+ ExternalCall(_stack, _thisStack, f);
}
else{
// not an internal nor external, try for native function
- Game->ExternalCall(this, m_Stack, m_ThisStack, val->GetString());
+ Game->ExternalCall(this, _stack, _thisStack, val->GetString());
}
}
else{
- m_Operand->SetInt(m_IP);
- m_CallStack->Push(m_Operand);
- m_IP = dw;
+ _operand->SetInt(_iP);
+ _callStack->Push(_operand);
+ _iP = dw;
}
}
*/
else {
res = E_FAIL;
- if (var->m_Type == VAL_NATIVE && !TriedNative) res = var->m_ValNative->ScCallMethod(this, m_Stack, m_ThisStack, MethodName);
+ if (var->_type == VAL_NATIVE && !TriedNative) res = var->_valNative->ScCallMethod(this, _stack, _thisStack, MethodName);
if (FAILED(res)) {
- m_Stack->CorrectParams(0);
+ _stack->CorrectParams(0);
RuntimeError("Call to undefined method '%s'. Ignored.", MethodName);
- m_Stack->PushNULL();
+ _stack->PushNULL();
}
}
}
@@ -597,69 +597,69 @@ HRESULT CScScript::ExecuteInstruction() { case II_EXTERNAL_CALL: {
uint32 SymbolIndex = GetDWORD();
- TExternalFunction *f = GetExternal(m_Symbols[SymbolIndex]);
+ TExternalFunction *f = GetExternal(_symbols[SymbolIndex]);
if (f) {
- ExternalCall(m_Stack, m_ThisStack, f);
- } else Game->ExternalCall(this, m_Stack, m_ThisStack, m_Symbols[SymbolIndex]);
+ ExternalCall(_stack, _thisStack, f);
+ } else Game->ExternalCall(this, _stack, _thisStack, _symbols[SymbolIndex]);
break;
}
case II_SCOPE:
- m_Operand->SetNULL();
- m_ScopeStack->Push(m_Operand);
+ _operand->SetNULL();
+ _scopeStack->Push(_operand);
- if (m_ScopeStack->m_SP < 0) Game->GetDebugMgr()->OnScriptChangeScope(this, NULL);
- else Game->GetDebugMgr()->OnScriptChangeScope(this, m_ScopeStack->GetTop());
+ if (_scopeStack->_sP < 0) Game->GetDebugMgr()->OnScriptChangeScope(this, NULL);
+ else Game->GetDebugMgr()->OnScriptChangeScope(this, _scopeStack->GetTop());
break;
case II_CORRECT_STACK:
dw = GetDWORD(); // params expected
- m_Stack->CorrectParams(dw);
+ _stack->CorrectParams(dw);
break;
case II_CREATE_OBJECT:
- m_Operand->SetObject();
- m_Stack->Push(m_Operand);
+ _operand->SetObject();
+ _stack->Push(_operand);
break;
case II_POP_EMPTY:
- m_Stack->Pop();
+ _stack->Pop();
break;
case II_PUSH_VAR: {
- CScValue *var = GetVar(m_Symbols[GetDWORD()]);
- if (false && /*var->m_Type==VAL_OBJECT ||*/ var->m_Type == VAL_NATIVE) {
- m_Operand->SetReference(var);
- m_Stack->Push(m_Operand);
- } else m_Stack->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);
break;
}
case II_PUSH_VAR_REF: {
- CScValue *var = GetVar(m_Symbols[GetDWORD()]);
- m_Operand->SetReference(var);
- m_Stack->Push(m_Operand);
+ CScValue *var = GetVar(_symbols[GetDWORD()]);
+ _operand->SetReference(var);
+ _stack->Push(_operand);
break;
}
case II_POP_VAR: {
- char *VarName = m_Symbols[GetDWORD()];
+ char *VarName = _symbols[GetDWORD()];
CScValue *var = GetVar(VarName);
if (var) {
- CScValue *val = m_Stack->Pop();
+ CScValue *val = _stack->Pop();
if (!val) {
RuntimeError("Script stack corruption detected. Please report this script at WME bug reports forum.");
var->SetNULL();
} else {
- if (val->GetType() == VAL_VARIABLE_REF) val = val->m_ValRef;
- if (val->m_Type == VAL_NATIVE) var->SetValue(val);
+ if (val->GetType() == VAL_VARIABLE_REF) val = val->_valRef;
+ if (val->_type == VAL_NATIVE) var->SetValue(val);
else {
var->Copy(val);
}
}
- if (Game->GetDebugMgr()->m_Enabled)
+ if (Game->GetDebugMgr()->_enabled)
Game->GetDebugMgr()->OnVariableChangeValue(var, val);
}
@@ -667,339 +667,339 @@ HRESULT CScScript::ExecuteInstruction() { }
case II_PUSH_VAR_THIS:
- m_Stack->Push(m_ThisStack->GetTop());
+ _stack->Push(_thisStack->GetTop());
break;
case II_PUSH_INT:
- m_Stack->PushInt((int)GetDWORD());
+ _stack->PushInt((int)GetDWORD());
break;
case II_PUSH_FLOAT:
- m_Stack->PushFloat(GetFloat());
+ _stack->PushFloat(GetFloat());
break;
case II_PUSH_BOOL:
- m_Stack->PushBool(GetDWORD() != 0);
+ _stack->PushBool(GetDWORD() != 0);
break;
case II_PUSH_STRING:
- m_Stack->PushString(GetString());
+ _stack->PushString(GetString());
break;
case II_PUSH_NULL:
- m_Stack->PushNULL();
+ _stack->PushNULL();
break;
case II_PUSH_THIS_FROM_STACK:
- m_Operand->SetReference(m_Stack->GetTop());
- m_ThisStack->Push(m_Operand);
+ _operand->SetReference(_stack->GetTop());
+ _thisStack->Push(_operand);
break;
case II_PUSH_THIS:
- m_Operand->SetReference(GetVar(m_Symbols[GetDWORD()]));
- m_ThisStack->Push(m_Operand);
+ _operand->SetReference(GetVar(_symbols[GetDWORD()]));
+ _thisStack->Push(_operand);
break;
case II_POP_THIS:
- m_ThisStack->Pop();
+ _thisStack->Pop();
break;
case II_PUSH_BY_EXP: {
- str = m_Stack->Pop()->GetString();
- CScValue *val = m_Stack->Pop()->GetProp(str);
- if (val) m_Stack->Push(val);
- else m_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 = m_Stack->Pop()->GetString();
- CScValue *var = m_Stack->Pop();
- CScValue *val = m_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.");
var->SetNULL();
} else var->SetProp(str, val);
- if (Game->GetDebugMgr()->m_Enabled)
+ if (Game->GetDebugMgr()->_enabled)
Game->GetDebugMgr()->OnVariableChangeValue(var, NULL);
break;
}
case II_PUSH_REG1:
- m_Stack->Push(m_Reg1);
+ _stack->Push(_reg1);
break;
case II_POP_REG1:
- m_Reg1->Copy(m_Stack->Pop());
+ _reg1->Copy(_stack->Pop());
break;
case II_JMP:
- m_IP = GetDWORD();
+ _iP = GetDWORD();
break;
case II_JMP_FALSE: {
dw = GetDWORD();
- //if(!m_Stack->Pop()->GetBool()) m_IP = dw;
- CScValue *Val = m_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 {
- if (!Val->GetBool()) m_IP = dw;
+ if (!Val->GetBool()) _iP = dw;
}
break;
}
case II_ADD:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
- if (op1->IsNULL() || op2->IsNULL()) m_Operand->SetNULL();
+ if (op1->IsNULL() || op2->IsNULL()) _operand->SetNULL();
else if (op1->GetType() == VAL_STRING || op2->GetType() == VAL_STRING) {
str = new char [strlen(op1->GetString()) + strlen(op2->GetString()) + 1];
strcpy(str, op1->GetString());
strcat(str, op2->GetString());
- m_Operand->SetString(str);
+ _operand->SetString(str);
delete [] str;
} else if (op1->GetType() == VAL_INT && op2->GetType() == VAL_INT)
- m_Operand->SetInt(op1->GetInt() + op2->GetInt());
- else m_Operand->SetFloat(op1->GetFloat() + op2->GetFloat());
+ _operand->SetInt(op1->GetInt() + op2->GetInt());
+ else _operand->SetFloat(op1->GetFloat() + op2->GetFloat());
- m_Stack->Push(m_Operand);
+ _stack->Push(_operand);
break;
case II_SUB:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
- if (op1->IsNULL() || op2->IsNULL()) m_Operand->SetNULL();
+ if (op1->IsNULL() || op2->IsNULL()) _operand->SetNULL();
else if (op1->GetType() == VAL_INT && op2->GetType() == VAL_INT)
- m_Operand->SetInt(op1->GetInt() - op2->GetInt());
- else m_Operand->SetFloat(op1->GetFloat() - op2->GetFloat());
+ _operand->SetInt(op1->GetInt() - op2->GetInt());
+ else _operand->SetFloat(op1->GetFloat() - op2->GetFloat());
- m_Stack->Push(m_Operand);
+ _stack->Push(_operand);
break;
case II_MUL:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
- if (op1->IsNULL() || op2->IsNULL()) m_Operand->SetNULL();
+ if (op1->IsNULL() || op2->IsNULL()) _operand->SetNULL();
else if (op1->GetType() == VAL_INT && op2->GetType() == VAL_INT)
- m_Operand->SetInt(op1->GetInt() * op2->GetInt());
- else m_Operand->SetFloat(op1->GetFloat() * op2->GetFloat());
+ _operand->SetInt(op1->GetInt() * op2->GetInt());
+ else _operand->SetFloat(op1->GetFloat() * op2->GetFloat());
- m_Stack->Push(m_Operand);
+ _stack->Push(_operand);
break;
case II_DIV:
- op2 = m_Stack->Pop();
- op1 = m_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) m_Operand->SetNULL();
- else m_Operand->SetFloat(op1->GetFloat() / op2->GetFloat());
+ if (op1->IsNULL() || op2->IsNULL() || op2->GetFloat() == 0.0f) _operand->SetNULL();
+ else _operand->SetFloat(op1->GetFloat() / op2->GetFloat());
- m_Stack->Push(m_Operand);
+ _stack->Push(_operand);
break;
case II_MODULO:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
if (op2->GetInt() == 0) RuntimeError("Division by zero.");
- if (op1->IsNULL() || op2->IsNULL() || op2->GetInt() == 0) m_Operand->SetNULL();
- else m_Operand->SetInt(op1->GetInt() % op2->GetInt());
+ if (op1->IsNULL() || op2->IsNULL() || op2->GetInt() == 0) _operand->SetNULL();
+ else _operand->SetInt(op1->GetInt() % op2->GetInt());
- m_Stack->Push(m_Operand);
+ _stack->Push(_operand);
break;
case II_NOT:
- op1 = m_Stack->Pop();
- //if(op1->IsNULL()) m_Operand->SetNULL();
- if (op1->IsNULL()) m_Operand->SetBool(true);
- else m_Operand->SetBool(!op1->GetBool());
- m_Stack->Push(m_Operand);
+ op1 = _stack->Pop();
+ //if(op1->IsNULL()) _operand->SetNULL();
+ if (op1->IsNULL()) _operand->SetBool(true);
+ else _operand->SetBool(!op1->GetBool());
+ _stack->Push(_operand);
break;
case II_AND:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
if (op1 == NULL || op2 == NULL) {
RuntimeError("Script corruption detected. Did you use '=' instead of '==' for comparison?");
- m_Operand->SetBool(false);
+ _operand->SetBool(false);
} else {
- m_Operand->SetBool(op1->GetBool() && op2->GetBool());
+ _operand->SetBool(op1->GetBool() && op2->GetBool());
}
- m_Stack->Push(m_Operand);
+ _stack->Push(_operand);
break;
case II_OR:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
if (op1 == NULL || op2 == NULL) {
RuntimeError("Script corruption detected. Did you use '=' instead of '==' for comparison?");
- m_Operand->SetBool(false);
+ _operand->SetBool(false);
} else {
- m_Operand->SetBool(op1->GetBool() || op2->GetBool());
+ _operand->SetBool(op1->GetBool() || op2->GetBool());
}
- m_Stack->Push(m_Operand);
+ _stack->Push(_operand);
break;
case II_CMP_EQ:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
/*
- if((op1->IsNULL() && !op2->IsNULL()) || (!op1->IsNULL() && op2->IsNULL())) m_Operand->SetBool(false);
+ if((op1->IsNULL() && !op2->IsNULL()) || (!op1->IsNULL() && op2->IsNULL())) _operand->SetBool(false);
else if(op1->IsNative() && op2->IsNative()){
- m_Operand->SetBool(op1->GetNative() == op2->GetNative());
+ _operand->SetBool(op1->GetNative() == op2->GetNative());
}
else if(op1->GetType()==VAL_STRING || op2->GetType()==VAL_STRING){
- m_Operand->SetBool(scumm_stricmp(op1->GetString(), op2->GetString())==0);
+ _operand->SetBool(scumm_stricmp(op1->GetString(), op2->GetString())==0);
}
else if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){
- m_Operand->SetBool(op1->GetFloat() == op2->GetFloat());
+ _operand->SetBool(op1->GetFloat() == op2->GetFloat());
}
else{
- m_Operand->SetBool(op1->GetInt() == op2->GetInt());
+ _operand->SetBool(op1->GetInt() == op2->GetInt());
}
*/
- m_Operand->SetBool(CScValue::Compare(op1, op2) == 0);
- m_Stack->Push(m_Operand);
+ _operand->SetBool(CScValue::Compare(op1, op2) == 0);
+ _stack->Push(_operand);
break;
case II_CMP_NE:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
/*
- if((op1->IsNULL() && !op2->IsNULL()) || (!op1->IsNULL() && op2->IsNULL())) m_Operand->SetBool(true);
+ if((op1->IsNULL() && !op2->IsNULL()) || (!op1->IsNULL() && op2->IsNULL())) _operand->SetBool(true);
else if(op1->IsNative() && op2->IsNative()){
- m_Operand->SetBool(op1->GetNative() != op2->GetNative());
+ _operand->SetBool(op1->GetNative() != op2->GetNative());
}
else if(op1->GetType()==VAL_STRING || op2->GetType()==VAL_STRING){
- m_Operand->SetBool(scumm_stricmp(op1->GetString(), op2->GetString())!=0);
+ _operand->SetBool(scumm_stricmp(op1->GetString(), op2->GetString())!=0);
}
else if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){
- m_Operand->SetBool(op1->GetFloat() != op2->GetFloat());
+ _operand->SetBool(op1->GetFloat() != op2->GetFloat());
}
else{
- m_Operand->SetBool(op1->GetInt() != op2->GetInt());
+ _operand->SetBool(op1->GetInt() != op2->GetInt());
}
*/
- m_Operand->SetBool(CScValue::Compare(op1, op2) != 0);
- m_Stack->Push(m_Operand);
+ _operand->SetBool(CScValue::Compare(op1, op2) != 0);
+ _stack->Push(_operand);
break;
case II_CMP_L:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
/*
if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){
- m_Operand->SetBool(op1->GetFloat() < op2->GetFloat());
+ _operand->SetBool(op1->GetFloat() < op2->GetFloat());
}
- else m_Operand->SetBool(op1->GetInt() < op2->GetInt());
+ else _operand->SetBool(op1->GetInt() < op2->GetInt());
*/
- m_Operand->SetBool(CScValue::Compare(op1, op2) < 0);
- m_Stack->Push(m_Operand);
+ _operand->SetBool(CScValue::Compare(op1, op2) < 0);
+ _stack->Push(_operand);
break;
case II_CMP_G:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
/*
if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){
- m_Operand->SetBool(op1->GetFloat() > op2->GetFloat());
+ _operand->SetBool(op1->GetFloat() > op2->GetFloat());
}
- else m_Operand->SetBool(op1->GetInt() > op2->GetInt());
+ else _operand->SetBool(op1->GetInt() > op2->GetInt());
*/
- m_Operand->SetBool(CScValue::Compare(op1, op2) > 0);
- m_Stack->Push(m_Operand);
+ _operand->SetBool(CScValue::Compare(op1, op2) > 0);
+ _stack->Push(_operand);
break;
case II_CMP_LE:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
/*
if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){
- m_Operand->SetBool(op1->GetFloat() <= op2->GetFloat());
+ _operand->SetBool(op1->GetFloat() <= op2->GetFloat());
}
- else m_Operand->SetBool(op1->GetInt() <= op2->GetInt());
+ else _operand->SetBool(op1->GetInt() <= op2->GetInt());
*/
- m_Operand->SetBool(CScValue::Compare(op1, op2) <= 0);
- m_Stack->Push(m_Operand);
+ _operand->SetBool(CScValue::Compare(op1, op2) <= 0);
+ _stack->Push(_operand);
break;
case II_CMP_GE:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
/*
if(op1->GetType()==VAL_FLOAT && op2->GetType()==VAL_FLOAT){
- m_Operand->SetBool(op1->GetFloat() >= op2->GetFloat());
+ _operand->SetBool(op1->GetFloat() >= op2->GetFloat());
}
- else m_Operand->SetBool(op1->GetInt() >= op2->GetInt());
+ else _operand->SetBool(op1->GetInt() >= op2->GetInt());
*/
- m_Operand->SetBool(CScValue::Compare(op1, op2) >= 0);
- m_Stack->Push(m_Operand);
+ _operand->SetBool(CScValue::Compare(op1, op2) >= 0);
+ _stack->Push(_operand);
break;
case II_CMP_STRICT_EQ:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
- //m_Operand->SetBool(op1->GetType()==op2->GetType() && op1->GetFloat()==op2->GetFloat());
- m_Operand->SetBool(CScValue::CompareStrict(op1, op2) == 0);
- m_Stack->Push(m_Operand);
+ //_operand->SetBool(op1->GetType()==op2->GetType() && op1->GetFloat()==op2->GetFloat());
+ _operand->SetBool(CScValue::CompareStrict(op1, op2) == 0);
+ _stack->Push(_operand);
break;
case II_CMP_STRICT_NE:
- op2 = m_Stack->Pop();
- op1 = m_Stack->Pop();
+ op2 = _stack->Pop();
+ op1 = _stack->Pop();
- //m_Operand->SetBool(op1->GetType()!=op2->GetType() || op1->GetFloat()!=op2->GetFloat());
- m_Operand->SetBool(CScValue::CompareStrict(op1, op2) != 0);
- m_Stack->Push(m_Operand);
+ //_operand->SetBool(op1->GetType()!=op2->GetType() || op1->GetFloat()!=op2->GetFloat());
+ _operand->SetBool(CScValue::CompareStrict(op1, op2) != 0);
+ _stack->Push(_operand);
break;
case II_DBG_LINE: {
int NewLine = GetDWORD();
- if (NewLine != m_CurrentLine) {
- m_CurrentLine = NewLine;
- if (Game->GetDebugMgr()->m_Enabled) {
- Game->GetDebugMgr()->OnScriptChangeLine(this, m_CurrentLine);
- for (int i = 0; i < m_Breakpoints.GetSize(); i++) {
- if (m_Breakpoints[i] == m_CurrentLine) {
+ if (NewLine != _currentLine) {
+ _currentLine = NewLine;
+ if (Game->GetDebugMgr()->_enabled) {
+ Game->GetDebugMgr()->OnScriptChangeLine(this, _currentLine);
+ for (int i = 0; i < _breakpoints.GetSize(); i++) {
+ if (_breakpoints[i] == _currentLine) {
Game->GetDebugMgr()->OnScriptHitBreakpoint(this);
Sleep(0);
break;
}
}
- if (m_TracingMode) {
+ if (_tracingMode) {
Game->GetDebugMgr()->OnScriptHitBreakpoint(this);
Sleep(0);
break;
@@ -1010,8 +1010,8 @@ HRESULT CScScript::ExecuteInstruction() { }
default:
- Game->LOG(0, "Fatal: Invalid instruction %d ('%s', line %d, IP:0x%x)\n", inst, m_Filename, m_CurrentLine, m_IP - sizeof(uint32));
- m_State = SCRIPT_FINISHED;
+ Game->LOG(0, "Fatal: Invalid instruction %d ('%s', line %d, IP:0x%x)\n", inst, _filename, _currentLine, _iP - sizeof(uint32));
+ _state = SCRIPT_FINISHED;
ret = E_FAIL;
} // switch(instruction)
@@ -1023,8 +1023,8 @@ HRESULT CScScript::ExecuteInstruction() { //////////////////////////////////////////////////////////////////////////
uint32 CScScript::GetFuncPos(const char *Name) {
- for (int i = 0; i < m_NumFunctions; i++) {
- if (strcmp(Name, m_Functions[i].name) == 0) return m_Functions[i].pos;
+ for (int i = 0; i < _numFunctions; i++) {
+ if (strcmp(Name, _functions[i].name) == 0) return _functions[i].pos;
}
return 0;
}
@@ -1032,8 +1032,8 @@ uint32 CScScript::GetFuncPos(const char *Name) { //////////////////////////////////////////////////////////////////////////
uint32 CScScript::GetMethodPos(const char *Name) {
- for (int i = 0; i < m_NumMethods; i++) {
- if (strcmp(Name, m_Methods[i].name) == 0) return m_Methods[i].pos;
+ for (int i = 0; i < _numMethods; i++) {
+ if (strcmp(Name, _methods[i].name) == 0) return _methods[i].pos;
}
return 0;
}
@@ -1044,31 +1044,31 @@ CScValue *CScScript::GetVar(char *Name) { CScValue *ret = NULL;
// scope locals
- if (m_ScopeStack->m_SP >= 0) {
- if (m_ScopeStack->GetTop()->PropExists(Name)) ret = m_ScopeStack->GetTop()->GetProp(Name);
+ if (_scopeStack->_sP >= 0) {
+ if (_scopeStack->GetTop()->PropExists(Name)) ret = _scopeStack->GetTop()->GetProp(Name);
}
// script globals
if (ret == NULL) {
- if (m_Globals->PropExists(Name)) ret = m_Globals->GetProp(Name);
+ if (_globals->PropExists(Name)) ret = _globals->GetProp(Name);
}
// engine globals
if (ret == NULL) {
- if (m_Engine->m_Globals->PropExists(Name)) ret = m_Engine->m_Globals->GetProp(Name);
+ if (_engine->_globals->PropExists(Name)) ret = _engine->_globals->GetProp(Name);
}
if (ret == NULL) {
//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, m_Filename, m_CurrentLine);
+ 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 = m_ScopeStack->GetTop();
+ CScValue *Scope = _scopeStack->GetTop();
if (Scope) {
Scope->SetProp(Name, Val);
- ret = m_ScopeStack->GetTop()->GetProp(Name);
+ ret = _scopeStack->GetTop()->GetProp(Name);
} else {
- m_Globals->SetProp(Name, Val);
- ret = m_Globals->GetProp(Name);
+ _globals->SetProp(Name, Val);
+ ret = _globals->GetProp(Name);
}
delete Val;
}
@@ -1079,38 +1079,38 @@ CScValue *CScScript::GetVar(char *Name) { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::WaitFor(CBObject *Object) {
- if (m_Unbreakable) {
+ if (_unbreakable) {
RuntimeError("Script cannot be interrupted.");
return S_OK;
}
- m_State = SCRIPT_WAITING;
- m_WaitObject = Object;
+ _state = SCRIPT_WAITING;
+ _waitObject = Object;
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScScript::WaitForExclusive(CBObject *Object) {
- m_Engine->ResetObject(Object);
+ _engine->ResetObject(Object);
return WaitFor(Object);
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScScript::Sleep(uint32 Duration) {
- if (m_Unbreakable) {
+ if (_unbreakable) {
RuntimeError("Script cannot be interrupted.");
return S_OK;
}
- m_State = SCRIPT_SLEEPING;
- if (Game->m_State == GAME_FROZEN) {
- m_WaitTime = CBPlatform::GetTime() + Duration;
- m_WaitFrozen = true;
+ _state = SCRIPT_SLEEPING;
+ if (Game->_state == GAME_FROZEN) {
+ _waitTime = CBPlatform::GetTime() + Duration;
+ _waitFrozen = true;
} else {
- m_WaitTime = Game->m_Timer + Duration;
- m_WaitFrozen = false;
+ _waitTime = Game->_timer + Duration;
+ _waitFrozen = false;
}
return S_OK;
}
@@ -1118,10 +1118,10 @@ HRESULT CScScript::Sleep(uint32 Duration) { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::Finish(bool IncludingThreads) {
- if (m_State != SCRIPT_FINISHED && IncludingThreads) {
- m_State = SCRIPT_FINISHED;
+ if (_state != SCRIPT_FINISHED && IncludingThreads) {
+ _state = SCRIPT_FINISHED;
FinishThreads();
- } else m_State = SCRIPT_FINISHED;
+ } else _state = SCRIPT_FINISHED;
return S_OK;
@@ -1130,7 +1130,7 @@ HRESULT CScScript::Finish(bool IncludingThreads) { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::Run() {
- m_State = SCRIPT_RUNNING;
+ _state = SCRIPT_RUNNING;
return S_OK;
}
@@ -1144,10 +1144,10 @@ void CScScript::RuntimeError(LPCSTR fmt, ...) { vsprintf(buff, fmt, va);
va_end(va);
- Game->LOG(0, "Runtime error. Script '%s', line %d", m_Filename, m_CurrentLine);
+ Game->LOG(0, "Runtime error. Script '%s', line %d", _filename, _currentLine);
Game->LOG(0, " %s", buff);
- if (!Game->m_SuppressScriptErrors)
+ if (!Game->_suppressScriptErrors)
Game->QuickMessage("Script runtime error. View log for details.");
}
@@ -1158,53 +1158,53 @@ HRESULT CScScript::Persist(CBPersistMgr *PersistMgr) { PersistMgr->Transfer(TMEMBER(Game));
// buffer
- if (PersistMgr->m_Saving) {
- if (m_State != SCRIPT_PERSISTENT && m_State != SCRIPT_FINISHED && m_State != SCRIPT_THREAD_FINISHED) {
- PersistMgr->Transfer(TMEMBER(m_BufferSize));
- PersistMgr->PutBytes(m_Buffer, m_BufferSize);
+ if (PersistMgr->_saving) {
+ if (_state != SCRIPT_PERSISTENT && _state != SCRIPT_FINISHED && _state != SCRIPT_THREAD_FINISHED) {
+ PersistMgr->Transfer(TMEMBER(_bufferSize));
+ PersistMgr->PutBytes(_buffer, _bufferSize);
} else {
// don't save idle/finished scripts
int bufferSize = 0;
PersistMgr->Transfer(TMEMBER(bufferSize));
}
} else {
- PersistMgr->Transfer(TMEMBER(m_BufferSize));
- if (m_BufferSize > 0) {
- m_Buffer = new byte[m_BufferSize];
- PersistMgr->GetBytes(m_Buffer, m_BufferSize);
+ PersistMgr->Transfer(TMEMBER(_bufferSize));
+ if (_bufferSize > 0) {
+ _buffer = new byte[_bufferSize];
+ PersistMgr->GetBytes(_buffer, _bufferSize);
InitTables();
- } else m_Buffer = NULL;
+ } else _buffer = NULL;
}
- PersistMgr->Transfer(TMEMBER(m_CallStack));
- PersistMgr->Transfer(TMEMBER(m_CurrentLine));
- PersistMgr->Transfer(TMEMBER(m_Engine));
- PersistMgr->Transfer(TMEMBER(m_Filename));
- PersistMgr->Transfer(TMEMBER(m_Freezable));
- PersistMgr->Transfer(TMEMBER(m_Globals));
- PersistMgr->Transfer(TMEMBER(m_IP));
- PersistMgr->Transfer(TMEMBER(m_ScopeStack));
- PersistMgr->Transfer(TMEMBER(m_Stack));
- PersistMgr->Transfer(TMEMBER_INT(m_State));
- PersistMgr->Transfer(TMEMBER(m_Operand));
- PersistMgr->Transfer(TMEMBER_INT(m_OrigState));
- PersistMgr->Transfer(TMEMBER(m_Owner));
- PersistMgr->Transfer(TMEMBER(m_Reg1));
- PersistMgr->Transfer(TMEMBER(m_Thread));
- PersistMgr->Transfer(TMEMBER(m_ThreadEvent));
- PersistMgr->Transfer(TMEMBER(m_ThisStack));
- PersistMgr->Transfer(TMEMBER(m_TimeSlice));
- PersistMgr->Transfer(TMEMBER(m_WaitObject));
- PersistMgr->Transfer(TMEMBER(m_WaitScript));
- PersistMgr->Transfer(TMEMBER(m_WaitTime));
- PersistMgr->Transfer(TMEMBER(m_WaitFrozen));
-
- PersistMgr->Transfer(TMEMBER(m_MethodThread));
- PersistMgr->Transfer(TMEMBER(m_MethodThread));
- PersistMgr->Transfer(TMEMBER(m_Unbreakable));
- PersistMgr->Transfer(TMEMBER(m_ParentScript));
-
- if (!PersistMgr->m_Saving) m_TracingMode = false;
+ PersistMgr->Transfer(TMEMBER(_callStack));
+ PersistMgr->Transfer(TMEMBER(_currentLine));
+ PersistMgr->Transfer(TMEMBER(_engine));
+ PersistMgr->Transfer(TMEMBER(_filename));
+ PersistMgr->Transfer(TMEMBER(_freezable));
+ PersistMgr->Transfer(TMEMBER(_globals));
+ PersistMgr->Transfer(TMEMBER(_iP));
+ PersistMgr->Transfer(TMEMBER(_scopeStack));
+ PersistMgr->Transfer(TMEMBER(_stack));
+ PersistMgr->Transfer(TMEMBER_INT(_state));
+ PersistMgr->Transfer(TMEMBER(_operand));
+ PersistMgr->Transfer(TMEMBER_INT(_origState));
+ PersistMgr->Transfer(TMEMBER(_owner));
+ PersistMgr->Transfer(TMEMBER(_reg1));
+ PersistMgr->Transfer(TMEMBER(_thread));
+ PersistMgr->Transfer(TMEMBER(_threadEvent));
+ PersistMgr->Transfer(TMEMBER(_thisStack));
+ PersistMgr->Transfer(TMEMBER(_timeSlice));
+ PersistMgr->Transfer(TMEMBER(_waitObject));
+ PersistMgr->Transfer(TMEMBER(_waitScript));
+ PersistMgr->Transfer(TMEMBER(_waitTime));
+ PersistMgr->Transfer(TMEMBER(_waitFrozen));
+
+ PersistMgr->Transfer(TMEMBER(_methodThread));
+ PersistMgr->Transfer(TMEMBER(_methodThread));
+ PersistMgr->Transfer(TMEMBER(_unbreakable));
+ PersistMgr->Transfer(TMEMBER(_parentScript));
+
+ if (!PersistMgr->_saving) _tracingMode = false;
return S_OK;
}
@@ -1212,17 +1212,17 @@ HRESULT CScScript::Persist(CBPersistMgr *PersistMgr) { //////////////////////////////////////////////////////////////////////////
CScScript *CScScript::InvokeEventHandler(const char *EventName, bool Unbreakable) {
- //if(m_State!=SCRIPT_PERSISTENT) return NULL;
+ //if(_state!=SCRIPT_PERSISTENT) return NULL;
uint32 pos = GetEventPos(EventName);
if (!pos) return NULL;
- CScScript *thread = new CScScript(Game, m_Engine);
+ CScScript *thread = new CScScript(Game, _engine);
if (thread) {
HRESULT ret = thread->CreateThread(this, pos, EventName);
if (SUCCEEDED(ret)) {
- thread->m_Unbreakable = Unbreakable;
- m_Engine->m_Scripts.Add(thread);
+ thread->_unbreakable = Unbreakable;
+ _engine->_scripts.Add(thread);
Game->GetDebugMgr()->OnScriptEventThreadInit(thread, this, EventName);
return thread;
} else {
@@ -1236,8 +1236,8 @@ CScScript *CScScript::InvokeEventHandler(const char *EventName, bool Unbreakable //////////////////////////////////////////////////////////////////////////
uint32 CScScript::GetEventPos(const char *Name) {
- for (int i = m_NumEvents - 1; i >= 0; i--) {
- if (scumm_stricmp(Name, m_Events[i].name) == 0) return m_Events[i].pos;
+ for (int i = _numEvents - 1; i >= 0; i--) {
+ if (scumm_stricmp(Name, _events[i].name) == 0) return _events[i].pos;
}
return 0;
}
@@ -1257,15 +1257,15 @@ bool CScScript::CanHandleMethod(char *MethodName) { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::Pause() {
- if (m_State == SCRIPT_PAUSED) {
- Game->LOG(0, "Attempting to pause a paused script ('%s', line %d)", m_Filename, m_CurrentLine);
+ if (_state == SCRIPT_PAUSED) {
+ Game->LOG(0, "Attempting to pause a paused script ('%s', line %d)", _filename, _currentLine);
return E_FAIL;
}
- if (!m_Freezable || m_State == SCRIPT_PERSISTENT) return S_OK;
+ if (!_freezable || _state == SCRIPT_PERSISTENT) return S_OK;
- m_OrigState = m_State;
- m_State = SCRIPT_PAUSED;
+ _origState = _state;
+ _state = SCRIPT_PAUSED;
return S_OK;
}
@@ -1273,17 +1273,17 @@ HRESULT CScScript::Pause() { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::Resume() {
- if (m_State != SCRIPT_PAUSED) return S_OK;
+ if (_state != SCRIPT_PAUSED) return S_OK;
- m_State = m_OrigState;
+ _state = _origState;
return S_OK;
}
//////////////////////////////////////////////////////////////////////////
CScScript::TExternalFunction *CScScript::GetExternal(char *Name) {
- for (int i = 0; i < m_NumExternals; i++) {
- if (strcmp(Name, m_Externals[i].name) == 0) return &m_Externals[i];
+ for (int i = 0; i < _numExternals; i++) {
+ if (strcmp(Name, _externals[i].name) == 0) return &_externals[i];
}
return NULL;
}
@@ -1309,10 +1309,10 @@ HRESULT CScScript::ExternalCall(CScStack *Stack, CScStack *ThisStack, CScScript: if (pFunc) {
int i;
Success = true;
- Stack->CorrectParams(Function->num_params);
+ Stack->CorrectParams(Function->nu_params);
CBDynBuffer *Buffer = new CBDynBuffer(Game, 20 * sizeof(uint32));
- for (i = 0; i < Function->num_params; i++) {
+ for (i = 0; i < Function->nu_params; i++) {
CScValue *Val = Stack->Pop();
switch (Function->params[i]) {
case TYPE_BOOL:
@@ -1353,10 +1353,10 @@ HRESULT CScScript::ExternalCall(CScStack *Stack, CScStack *ThisStack, CScScript: bool StackCorrupted = false;
switch (Function->call_type) {
case CALL_CDECL:
- ret = Call_cdecl(Buffer->m_Buffer, Buffer->GetSize(), (uint32)pFunc, &StackCorrupted);
+ ret = Call_cdecl(Buffer->_buffer, Buffer->GetSize(), (uint32)pFunc, &StackCorrupted);
break;
default:
- ret = Call_stdcall(Buffer->m_Buffer, Buffer->GetSize(), (uint32)pFunc, &StackCorrupted);
+ ret = Call_stdcall(Buffer->_buffer, Buffer->GetSize(), (uint32)pFunc, &StackCorrupted);
}
delete Buffer;
@@ -1493,9 +1493,9 @@ HRESULT CScScript::CopyParameters(CScStack *Stack) { int i;
int NumParams = Stack->Pop()->GetInt();
for (i = NumParams - 1; i >= 0; i--) {
- m_Stack->Push(Stack->GetAt(i));
+ _stack->Push(Stack->GetAt(i));
}
- m_Stack->PushInt(NumParams);
+ _stack->PushInt(NumParams);
for (i = 0; i < NumParams; i++) Stack->Pop();
@@ -1505,9 +1505,9 @@ HRESULT CScScript::CopyParameters(CScStack *Stack) { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::FinishThreads() {
- for (int i = 0; i < m_Engine->m_Scripts.GetSize(); i++) {
- CScScript *Scr = m_Engine->m_Scripts[i];
- if (Scr->m_Thread && Scr->m_State != SCRIPT_FINISHED && Scr->m_Owner == m_Owner && scumm_stricmp(Scr->m_Filename, m_Filename) == 0)
+ for (int i = 0; i < _engine->_scripts.GetSize(); i++) {
+ CScScript *Scr = _engine->_scripts[i];
+ if (Scr->_thread && Scr->_state != SCRIPT_FINISHED && Scr->_owner == _owner && scumm_stricmp(Scr->_filename, _filename) == 0)
Scr->Finish(true);
}
return S_OK;
@@ -1517,19 +1517,19 @@ HRESULT CScScript::FinishThreads() { //////////////////////////////////////////////////////////////////////////
// IWmeDebugScript interface implementation
int CScScript::DbgGetLine() {
- return m_CurrentLine;
+ return _currentLine;
}
//////////////////////////////////////////////////////////////////////////
const char *CScScript::DbgGetFilename() {
- return m_Filename;
+ return _filename;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScScript::DbgSendScript(IWmeDebugClient *Client) {
- if (m_MethodThread) Client->OnScriptMethodThreadInit(this, m_ParentScript, m_ThreadEvent);
- else if (m_Thread) Client->OnScriptEventThreadInit(this, m_ParentScript, m_ThreadEvent);
+ if (_methodThread) Client->OnScriptMethodThreadInit(this, _parentScript, _threadEvent);
+ else if (_thread) Client->OnScriptEventThreadInit(this, _parentScript, _threadEvent);
else Client->OnScriptInit(this);
return DbgSendVariables(Client);
@@ -1539,12 +1539,12 @@ HRESULT CScScript::DbgSendScript(IWmeDebugClient *Client) { //////////////////////////////////////////////////////////////////////////
HRESULT CScScript::DbgSendVariables(IWmeDebugClient *Client) {
// send script globals
- m_Globals->DbgSendVariables(Client, WME_DBGVAR_SCRIPT, this, 0);
+ _globals->DbgSendVariables(Client, WME_DBGVAR_SCRIPT, this, 0);
// send scope variables
- if (m_ScopeStack->m_SP >= 0) {
- for (int i = 0; i <= m_ScopeStack->m_SP; i++) {
- CScValue *Scope = m_ScopeStack->GetAt(i);
+ if (_scopeStack->_sP >= 0) {
+ for (int i = 0; i <= _scopeStack->_sP; i++) {
+ CScValue *Scope = _scopeStack->GetAt(i);
//Scope->DbgSendVariables(Client, WME_DBGVAR_SCOPE, this, (unsigned int)Scope);
}
}
@@ -1554,44 +1554,44 @@ HRESULT CScScript::DbgSendVariables(IWmeDebugClient *Client) { //////////////////////////////////////////////////////////////////////////
TScriptState CScScript::DbgGetState() {
- return m_State;
+ return _state;
}
//////////////////////////////////////////////////////////////////////////
int CScScript::DbgGetNumBreakpoints() {
- return m_Breakpoints.GetSize();
+ return _breakpoints.GetSize();
}
//////////////////////////////////////////////////////////////////////////
int CScScript::DbgGetBreakpoint(int Index) {
- if (Index >= 0 && Index < m_Breakpoints.GetSize()) return m_Breakpoints[Index];
+ if (Index >= 0 && Index < _breakpoints.GetSize()) return _breakpoints[Index];
else return -1;
}
//////////////////////////////////////////////////////////////////////////
bool CScScript::DbgSetTracingMode(bool IsTracing) {
- m_TracingMode = IsTracing;
+ _tracingMode = IsTracing;
return true;
}
//////////////////////////////////////////////////////////////////////////
bool CScScript::DbgGetTracingMode() {
- return m_TracingMode;
+ return _tracingMode;
}
//////////////////////////////////////////////////////////////////////////
void CScScript::AfterLoad() {
- if (m_Buffer == NULL) {
- byte *buffer = m_Engine->GetCompiledScript(m_Filename, &m_BufferSize);
+ if (_buffer == NULL) {
+ byte *buffer = _engine->GetCompiledScript(_filename, &_bufferSize);
if (!buffer) {
- Game->LOG(0, "Error reinitializing script '%s' after load. Script will be terminated.", m_Filename);
- m_State = SCRIPT_ERROR;
+ Game->LOG(0, "Error reinitializing script '%s' after load. Script will be terminated.", _filename);
+ _state = SCRIPT_ERROR;
return;
}
- m_Buffer = new byte [m_BufferSize];
- memcpy(m_Buffer, buffer, m_BufferSize);
+ _buffer = new byte [_bufferSize];
+ memcpy(_buffer, buffer, _bufferSize);
InitTables();
}
diff --git a/engines/wintermute/scriptables/ScScript.h b/engines/wintermute/scriptables/ScScript.h index 6f467437da..57baf8d92a 100644 --- a/engines/wintermute/scriptables/ScScript.h +++ b/engines/wintermute/scriptables/ScScript.h @@ -46,11 +46,11 @@ public: HRESULT DbgSendScript(IWmeDebugClient *Client);
HRESULT DbgSendVariables(IWmeDebugClient *Client);
- CBArray<int, int> m_Breakpoints;
- bool m_TracingMode;
+ CBArray<int, int> _breakpoints;
+ bool _tracingMode;
- CScScript *m_ParentScript;
- bool m_Unbreakable;
+ CScScript *_parentScript;
+ bool _unbreakable;
HRESULT FinishThreads();
HRESULT CopyParameters(CScStack *Stack);
@@ -63,9 +63,9 @@ public: static double GetST0Double(void);
#endif
- CScValue *m_Operand;
- CScValue *m_Reg1;
- bool m_Freezable;
+ CScValue *_operand;
+ CScValue *_reg1;
+ bool _freezable;
HRESULT Resume();
HRESULT Pause();
bool CanHandleEvent(char *EventName);
@@ -73,7 +73,7 @@ public: HRESULT CreateThread(CScScript *Original, uint32 InitIP, const char *EventName);
HRESULT CreateMethodThread(CScScript *Original, const char *MethodName);
CScScript *InvokeEventHandler(const char *EventName, bool Unbreakable = false);
- uint32 m_TimeSlice;
+ uint32 _timeSlice;
DECLARE_PERSISTENT(CScScript, CBBase)
void RuntimeError(LPCSTR fmt, ...);
HRESULT Run();
@@ -81,12 +81,12 @@ public: HRESULT Sleep(uint32 Duration);
HRESULT WaitForExclusive(CBObject *Object);
HRESULT WaitFor(CBObject *Object);
- uint32 m_WaitTime;
- bool m_WaitFrozen;
- CBObject *m_WaitObject;
- CScScript *m_WaitScript;
- TScriptState m_State;
- TScriptState m_OrigState;
+ uint32 _waitTime;
+ bool _waitFrozen;
+ CBObject *_waitObject;
+ CScScript *_waitScript;
+ TScriptState _state;
+ TScriptState _origState;
CScValue *GetVar(char *Name);
uint32 GetFuncPos(const char *Name);
uint32 GetEventPos(const char *Name);
@@ -123,44 +123,44 @@ public: char *dll_name;
TCallType call_type;
TExternalType returns;
- int num_params;
+ int nu_params;
TExternalType *params;
} TExternalFunction;
- CScStack *m_CallStack;
- CScStack *m_ThisStack;
- CScStack *m_ScopeStack;
- CScStack *m_Stack;
- CScValue *m_Globals;
- CScEngine *m_Engine;
- int m_CurrentLine;
+ CScStack *_callStack;
+ CScStack *_thisStack;
+ CScStack *_scopeStack;
+ CScStack *_stack;
+ CScValue *_globals;
+ CScEngine *_engine;
+ int _currentLine;
HRESULT ExecuteInstruction();
char *GetString();
uint32 GetDWORD();
double GetFloat();
void Cleanup();
HRESULT Create(char *Filename, byte *Buffer, uint32 Size, CBScriptHolder *Owner);
- uint32 m_IP;
- uint32 m_BufferSize;
- byte *m_Buffer;
+ uint32 _iP;
+ uint32 _bufferSize;
+ byte *_buffer;
CScScript(CBGame *inGame, CScEngine *Engine);
virtual ~CScScript();
- char *m_Filename;
- char **m_Symbols;
- int m_NumSymbols;
- TFunctionPos *m_Functions;
- TMethodPos *m_Methods;
- TEventPos *m_Events;
- int m_NumExternals;
- TExternalFunction *m_Externals;
- int m_NumFunctions;
- int m_NumMethods;
- int m_NumEvents;
- bool m_Thread;
- bool m_MethodThread;
- char *m_ThreadEvent;
- CBScriptHolder *m_Owner;
+ char *_filename;
+ char **_symbols;
+ int _numSymbols;
+ TFunctionPos *_functions;
+ TMethodPos *_methods;
+ TEventPos *_events;
+ int _numExternals;
+ TExternalFunction *_externals;
+ int _numFunctions;
+ int _numMethods;
+ int _numEvents;
+ bool _thread;
+ bool _methodThread;
+ char *_threadEvent;
+ CBScriptHolder *_owner;
CScScript::TExternalFunction *GetExternal(char *Name);
HRESULT ExternalCall(CScStack *Stack, CScStack *ThisStack, CScScript::TExternalFunction *Function);
private:
diff --git a/engines/wintermute/scriptables/ScStack.cpp b/engines/wintermute/scriptables/ScStack.cpp index 7975223516..c7b724e9b2 100644 --- a/engines/wintermute/scriptables/ScStack.cpp +++ b/engines/wintermute/scriptables/ScStack.cpp @@ -36,7 +36,7 @@ IMPLEMENT_PERSISTENT(CScStack, false) //////////////////////////////////////////////////////////////////////////
CScStack::CScStack(CBGame *inGame): CBBase(inGame) {
- m_SP = -1;
+ _sP = -1;
}
@@ -44,95 +44,95 @@ CScStack::CScStack(CBGame *inGame): CBBase(inGame) { CScStack::~CScStack() {
#if _DEBUG
- //Game->LOG(0, "STAT: Stack size: %d, SP=%d", m_Values.GetSize(), m_SP);
+ //Game->LOG(0, "STAT: Stack size: %d, SP=%d", _values.GetSize(), _sP);
#endif
- for (int i = 0; i < m_Values.GetSize(); i++) {
- delete m_Values[i];
+ for (int i = 0; i < _values.GetSize(); i++) {
+ delete _values[i];
}
- m_Values.RemoveAll();
+ _values.RemoveAll();
}
//////////////////////////////////////////////////////////////////////////
CScValue *CScStack::Pop() {
- if (m_SP < 0) {
+ if (_sP < 0) {
Game->LOG(0, "Fatal: Stack underflow");
return NULL;
}
- return m_Values[m_SP--];
+ return _values[_sP--];
}
//////////////////////////////////////////////////////////////////////////
void CScStack::Push(CScValue *Val) {
- m_SP++;
+ _sP++;
- if (m_SP < m_Values.GetSize()) {
- m_Values[m_SP]->Cleanup();
- m_Values[m_SP]->Copy(Val);
+ if (_sP < _values.GetSize()) {
+ _values[_sP]->Cleanup();
+ _values[_sP]->Copy(Val);
} else {
CScValue *val = new CScValue(Game);
val->Copy(Val);
- m_Values.Add(val);
+ _values.Add(val);
}
}
//////////////////////////////////////////////////////////////////////////
CScValue *CScStack::GetPushValue() {
- m_SP++;
+ _sP++;
- if (m_SP >= m_Values.GetSize()) {
+ if (_sP >= _values.GetSize()) {
CScValue *val = new CScValue(Game);
- m_Values.Add(val);
+ _values.Add(val);
}
- m_Values[m_SP]->Cleanup();
- return m_Values[m_SP];
+ _values[_sP]->Cleanup();
+ return _values[_sP];
}
//////////////////////////////////////////////////////////////////////////
CScValue *CScStack::GetTop() {
- if (m_SP < 0 || m_SP >= m_Values.GetSize()) return NULL;
- else return m_Values[m_SP];
+ if (_sP < 0 || _sP >= _values.GetSize()) return NULL;
+ else return _values[_sP];
}
//////////////////////////////////////////////////////////////////////////
CScValue *CScStack::GetAt(int Index) {
- Index = m_SP - Index;
- if (Index < 0 || Index >= m_Values.GetSize()) return NULL;
- else return m_Values[Index];
+ Index = _sP - Index;
+ if (Index < 0 || Index >= _values.GetSize()) return NULL;
+ else return _values[Index];
}
//////////////////////////////////////////////////////////////////////////
void CScStack::CorrectParams(uint32 expected_params) {
- int num_params = Pop()->GetInt();
+ int nu_params = Pop()->GetInt();
- if (expected_params < num_params) { // too many params
- while (expected_params < num_params) {
+ if (expected_params < nu_params) { // too many params
+ while (expected_params < nu_params) {
//Pop();
- delete m_Values[m_SP - expected_params];
- m_Values.RemoveAt(m_SP - expected_params);
- num_params--;
- m_SP--;
+ delete _values[_sP - expected_params];
+ _values.RemoveAt(_sP - expected_params);
+ nu_params--;
+ _sP--;
}
- } else if (expected_params > num_params) { // need more params
- while (expected_params > num_params) {
+ } else if (expected_params > nu_params) { // need more params
+ while (expected_params > nu_params) {
//Push(null_val);
CScValue *null_val = new CScValue(Game);
null_val->SetNULL();
- m_Values.InsertAt(m_SP - num_params + 1, null_val);
- num_params++;
- m_SP++;
+ _values.InsertAt(_sP - nu_params + 1, null_val);
+ nu_params++;
+ _sP++;
- if (m_Values.GetSize() > m_SP + 1) {
- delete m_Values[m_Values.GetSize() - 1];
- m_Values.RemoveAt(m_Values.GetSize() - 1);
+ if (_values.GetSize() > _sP + 1) {
+ delete _values[_values.GetSize() - 1];
+ _values.RemoveAt(_values.GetSize() - 1);
}
}
}
@@ -217,8 +217,8 @@ HRESULT CScStack::Persist(CBPersistMgr *PersistMgr) { PersistMgr->Transfer(TMEMBER(Game));
- PersistMgr->Transfer(TMEMBER(m_SP));
- m_Values.Persist(PersistMgr);
+ PersistMgr->Transfer(TMEMBER(_sP));
+ _values.Persist(PersistMgr);
return S_OK;
}
diff --git a/engines/wintermute/scriptables/ScStack.h b/engines/wintermute/scriptables/ScStack.h index 70d54cbbe4..113fb4c19f 100644 --- a/engines/wintermute/scriptables/ScStack.h +++ b/engines/wintermute/scriptables/ScStack.h @@ -56,8 +56,8 @@ public: CScValue *Pop();
CScStack(CBGame *inGame);
virtual ~CScStack();
- CBArray<CScValue *, CScValue *> m_Values;
- int m_SP;
+ CBArray<CScValue *, CScValue *> _values;
+ int _sP;
};
diff --git a/engines/wintermute/scriptables/ScValue.cpp b/engines/wintermute/scriptables/ScValue.cpp index b843e2032c..055f9830ad 100644 --- a/engines/wintermute/scriptables/ScValue.cpp +++ b/engines/wintermute/scriptables/ScValue.cpp @@ -44,77 +44,77 @@ IMPLEMENT_PERSISTENT(CScValue, false) //////////////////////////////////////////////////////////////////////////
CScValue::CScValue(CBGame *inGame): CBBase(inGame) {
- m_Type = VAL_NULL;
-
- m_ValBool = false;
- m_ValInt = 0;
- m_ValFloat = 0.0f;
- m_ValNative = NULL;
- m_ValString = NULL;
- m_ValRef = NULL;
- m_Persistent = false;
- m_IsConstVar = false;
+ _type = VAL_NULL;
+
+ _valBool = false;
+ _valInt = 0;
+ _valFloat = 0.0f;
+ _valNative = NULL;
+ _valString = NULL;
+ _valRef = NULL;
+ _persistent = false;
+ _isConstVar = false;
}
//////////////////////////////////////////////////////////////////////////
CScValue::CScValue(CBGame *inGame, bool Val): CBBase(inGame) {
- m_Type = VAL_BOOL;
- m_ValBool = Val;
-
- m_ValInt = 0;
- m_ValFloat = 0.0f;
- m_ValNative = NULL;
- m_ValString = NULL;
- m_ValRef = NULL;
- m_Persistent = false;
- m_IsConstVar = false;
+ _type = VAL_BOOL;
+ _valBool = Val;
+
+ _valInt = 0;
+ _valFloat = 0.0f;
+ _valNative = NULL;
+ _valString = NULL;
+ _valRef = NULL;
+ _persistent = false;
+ _isConstVar = false;
}
//////////////////////////////////////////////////////////////////////////
CScValue::CScValue(CBGame *inGame, int Val): CBBase(inGame) {
- m_Type = VAL_INT;
- m_ValInt = Val;
-
- m_ValFloat = 0.0f;
- m_ValBool = false;
- m_ValNative = NULL;
- m_ValString = NULL;
- m_ValRef = NULL;
- m_Persistent = false;
- m_IsConstVar = false;
+ _type = VAL_INT;
+ _valInt = Val;
+
+ _valFloat = 0.0f;
+ _valBool = false;
+ _valNative = NULL;
+ _valString = NULL;
+ _valRef = NULL;
+ _persistent = false;
+ _isConstVar = false;
}
//////////////////////////////////////////////////////////////////////////
CScValue::CScValue(CBGame *inGame, double Val): CBBase(inGame) {
- m_Type = VAL_FLOAT;
- m_ValFloat = Val;
-
- m_ValInt = 0;
- m_ValBool = false;
- m_ValNative = NULL;
- m_ValString = NULL;
- m_ValRef = NULL;
- m_Persistent = false;
- m_IsConstVar = false;
+ _type = VAL_FLOAT;
+ _valFloat = Val;
+
+ _valInt = 0;
+ _valBool = false;
+ _valNative = NULL;
+ _valString = NULL;
+ _valRef = NULL;
+ _persistent = false;
+ _isConstVar = false;
}
//////////////////////////////////////////////////////////////////////////
CScValue::CScValue(CBGame *inGame, const char *Val): CBBase(inGame) {
- m_Type = VAL_STRING;
- m_ValString = NULL;
+ _type = VAL_STRING;
+ _valString = NULL;
SetStringVal(Val);
- m_ValBool = false;
- m_ValInt = 0;
- m_ValFloat = 0.0f;
- m_ValNative = NULL;
- m_ValRef = NULL;
- m_Persistent = false;
- m_IsConstVar = false;
+ _valBool = false;
+ _valInt = 0;
+ _valFloat = 0.0f;
+ _valNative = NULL;
+ _valRef = NULL;
+ _persistent = false;
+ _isConstVar = false;
}
@@ -122,29 +122,29 @@ CScValue::CScValue(CBGame *inGame, const char *Val): CBBase(inGame) { void CScValue::Cleanup(bool IgnoreNatives) {
DeleteProps();
- if (m_ValString) delete [] m_ValString;
+ if (_valString) delete [] _valString;
if (!IgnoreNatives) {
- if (m_ValNative && !m_Persistent) {
- m_ValNative->m_RefCount--;
- if (m_ValNative->m_RefCount <= 0) {
- delete m_ValNative;
- m_ValNative = NULL;
+ if (_valNative && !_persistent) {
+ _valNative->_refCount--;
+ if (_valNative->_refCount <= 0) {
+ delete _valNative;
+ _valNative = NULL;
}
}
}
- m_Type = VAL_NULL;
+ _type = VAL_NULL;
- m_ValBool = false;
- m_ValInt = 0;
- m_ValFloat = 0.0f;
- m_ValNative = NULL;
- m_ValString = NULL;
- m_ValRef = NULL;
- m_Persistent = false;
- m_IsConstVar = false;
+ _valBool = false;
+ _valInt = 0;
+ _valFloat = 0.0f;
+ _valNative = NULL;
+ _valString = NULL;
+ _valRef = NULL;
+ _persistent = false;
+ _isConstVar = false;
}
@@ -157,44 +157,44 @@ CScValue::~CScValue() { //////////////////////////////////////////////////////////////////////////
CScValue *CScValue::GetProp(char *Name) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetProp(Name);
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetProp(Name);
- if (m_Type == VAL_STRING && strcmp(Name, "Length") == 0) {
- Game->m_ScValue->m_Type = VAL_INT;
+ if (_type == VAL_STRING && strcmp(Name, "Length") == 0) {
+ Game->_scValue->_type = VAL_INT;
#if 0 // TODO: Remove FreeType-dependency
- if (Game->m_TextEncoding == TEXT_ANSI) {
+ if (Game->_textEncoding == TEXT_ANSI) {
#else
if (true) {
#endif
- Game->m_ScValue->SetInt(strlen(m_ValString));
+ Game->_scValue->SetInt(strlen(_valString));
} else {
- WideString wstr = StringUtil::Utf8ToWide(m_ValString);
- Game->m_ScValue->SetInt(wstr.size());
+ WideString wstr = StringUtil::Utf8ToWide(_valString);
+ Game->_scValue->SetInt(wstr.size());
}
- return Game->m_ScValue;
+ return Game->_scValue;
}
CScValue *ret = NULL;
- if (m_Type == VAL_NATIVE && m_ValNative) ret = m_ValNative->ScGetProperty(Name);
+ if (_type == VAL_NATIVE && _valNative) ret = _valNative->ScGetProperty(Name);
if (ret == NULL) {
- m_ValIter = m_ValObject.find(Name);
- if (m_ValIter != m_ValObject.end()) ret = m_ValIter->_value;
+ _valIter = _valObject.find(Name);
+ if (_valIter != _valObject.end()) ret = _valIter->_value;
}
return ret;
}
//////////////////////////////////////////////////////////////////////////
HRESULT CScValue::DeleteProp(char *Name) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->DeleteProp(Name);
+ if (_type == VAL_VARIABLE_REF) return _valRef->DeleteProp(Name);
- m_ValIter = m_ValObject.find(Name);
- if (m_ValIter != m_ValObject.end()) {
- delete m_ValIter->_value;
- m_ValIter->_value = NULL;
+ _valIter = _valObject.find(Name);
+ if (_valIter != _valObject.end()) {
+ delete _valIter->_value;
+ _valIter->_value = NULL;
}
return S_OK;
@@ -204,41 +204,41 @@ HRESULT CScValue::DeleteProp(char *Name) { //////////////////////////////////////////////////////////////////////////
HRESULT CScValue::SetProp(char *Name, CScValue *Val, bool CopyWhole, bool SetAsConst) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->SetProp(Name, Val);
+ if (_type == VAL_VARIABLE_REF) return _valRef->SetProp(Name, Val);
HRESULT ret = E_FAIL;
- if (m_Type == VAL_NATIVE && m_ValNative) {
- ret = m_ValNative->ScSetProperty(Name, Val);
+ if (_type == VAL_NATIVE && _valNative) {
+ ret = _valNative->ScSetProperty(Name, Val);
}
if (FAILED(ret)) {
CScValue *val = NULL;
- m_ValIter = m_ValObject.find(Name);
- if (m_ValIter != m_ValObject.end()) {
- val = m_ValIter->_value;
+ _valIter = _valObject.find(Name);
+ if (_valIter != _valObject.end()) {
+ val = _valIter->_value;
}
if (!val) val = new CScValue(Game);
else val->Cleanup();
val->Copy(Val, CopyWhole);
- val->m_IsConstVar = SetAsConst;
- m_ValObject[Name] = val;
+ val->_isConstVar = SetAsConst;
+ _valObject[Name] = val;
- if (m_Type != VAL_NATIVE) m_Type = VAL_OBJECT;
+ if (_type != VAL_NATIVE) _type = VAL_OBJECT;
/*
- m_ValIter = m_ValObject.find(Name);
- if (m_ValIter != m_ValObject.end()){
- delete m_ValIter->_value;
- m_ValIter->_value = NULL;
+ _valIter = _valObject.find(Name);
+ if (_valIter != _valObject.end()){
+ delete _valIter->_value;
+ _valIter->_value = NULL;
}
CScValue* val = new CScValue(Game);
val->Copy(Val, CopyWhole);
- val->m_IsConstVar = SetAsConst;
- m_ValObject[Name] = val;
+ val->_isConstVar = SetAsConst;
+ _valObject[Name] = val;
- if(m_Type!=VAL_NATIVE) m_Type = VAL_OBJECT;
+ if(_type!=VAL_NATIVE) _type = VAL_OBJECT;
*/
}
@@ -248,265 +248,265 @@ HRESULT CScValue::SetProp(char *Name, CScValue *Val, bool CopyWhole, bool SetAsC //////////////////////////////////////////////////////////////////////////
bool CScValue::PropExists(char *Name) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->PropExists(Name);
- m_ValIter = m_ValObject.find(Name);
+ if (_type == VAL_VARIABLE_REF) return _valRef->PropExists(Name);
+ _valIter = _valObject.find(Name);
- return (m_ValIter != m_ValObject.end());
+ return (_valIter != _valObject.end());
}
//////////////////////////////////////////////////////////////////////////
void CScValue::DeleteProps() {
- m_ValIter = m_ValObject.begin();
- while (m_ValIter != m_ValObject.end()) {
- delete(CScValue *)m_ValIter->_value;
- m_ValIter++;
+ _valIter = _valObject.begin();
+ while (_valIter != _valObject.end()) {
+ delete(CScValue *)_valIter->_value;
+ _valIter++;
}
- m_ValObject.clear();
+ _valObject.clear();
}
//////////////////////////////////////////////////////////////////////////
void CScValue::CleanProps(bool IncludingNatives) {
- m_ValIter = m_ValObject.begin();
- while (m_ValIter != m_ValObject.end()) {
- if (!m_ValIter->_value->m_IsConstVar && (!m_ValIter->_value->IsNative() || IncludingNatives)) m_ValIter->_value->SetNULL();
- m_ValIter++;
+ _valIter = _valObject.begin();
+ while (_valIter != _valObject.end()) {
+ if (!_valIter->_value->_isConstVar && (!_valIter->_value->IsNative() || IncludingNatives)) _valIter->_value->SetNULL();
+ _valIter++;
}
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::IsNULL() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->IsNULL();
+ if (_type == VAL_VARIABLE_REF) return _valRef->IsNULL();
- return (m_Type == VAL_NULL);
+ return (_type == VAL_NULL);
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::IsNative() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->IsNative();
+ if (_type == VAL_VARIABLE_REF) return _valRef->IsNative();
- return (m_Type == VAL_NATIVE);
+ return (_type == VAL_NATIVE);
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::IsString() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->IsString();
+ if (_type == VAL_VARIABLE_REF) return _valRef->IsString();
- return (m_Type == VAL_STRING);
+ return (_type == VAL_STRING);
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::IsFloat() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->IsFloat();
+ if (_type == VAL_VARIABLE_REF) return _valRef->IsFloat();
- return (m_Type == VAL_FLOAT);
+ return (_type == VAL_FLOAT);
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::IsInt() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->IsInt();
+ if (_type == VAL_VARIABLE_REF) return _valRef->IsInt();
- return (m_Type == VAL_INT);
+ return (_type == VAL_INT);
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::IsBool() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->IsBool();
+ if (_type == VAL_VARIABLE_REF) return _valRef->IsBool();
- return (m_Type == VAL_BOOL);
+ return (_type == VAL_BOOL);
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::IsObject() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->IsObject();
+ if (_type == VAL_VARIABLE_REF) return _valRef->IsObject();
- return (m_Type == VAL_OBJECT);
+ return (_type == VAL_OBJECT);
}
//////////////////////////////////////////////////////////////////////////
TValType CScValue::GetTypeTolerant() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetType();
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetType();
- return m_Type;
+ return _type;
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetBool(bool Val) {
- if (m_Type == VAL_VARIABLE_REF) {
- m_ValRef->SetBool(Val);
+ if (_type == VAL_VARIABLE_REF) {
+ _valRef->SetBool(Val);
return;
}
- if (m_Type == VAL_NATIVE) {
- m_ValNative->ScSetBool(Val);
+ if (_type == VAL_NATIVE) {
+ _valNative->ScSetBool(Val);
return;
}
- m_ValBool = Val;
- m_Type = VAL_BOOL;
+ _valBool = Val;
+ _type = VAL_BOOL;
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetInt(int Val) {
- if (m_Type == VAL_VARIABLE_REF) {
- m_ValRef->SetInt(Val);
+ if (_type == VAL_VARIABLE_REF) {
+ _valRef->SetInt(Val);
return;
}
- if (m_Type == VAL_NATIVE) {
- m_ValNative->ScSetInt(Val);
+ if (_type == VAL_NATIVE) {
+ _valNative->ScSetInt(Val);
return;
}
- m_ValInt = Val;
- m_Type = VAL_INT;
+ _valInt = Val;
+ _type = VAL_INT;
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetFloat(double Val) {
- if (m_Type == VAL_VARIABLE_REF) {
- m_ValRef->SetFloat(Val);
+ if (_type == VAL_VARIABLE_REF) {
+ _valRef->SetFloat(Val);
return;
}
- if (m_Type == VAL_NATIVE) {
- m_ValNative->ScSetFloat(Val);
+ if (_type == VAL_NATIVE) {
+ _valNative->ScSetFloat(Val);
return;
}
- m_ValFloat = Val;
- m_Type = VAL_FLOAT;
+ _valFloat = Val;
+ _type = VAL_FLOAT;
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetString(const char *Val) {
- if (m_Type == VAL_VARIABLE_REF) {
- m_ValRef->SetString(Val);
+ if (_type == VAL_VARIABLE_REF) {
+ _valRef->SetString(Val);
return;
}
- if (m_Type == VAL_NATIVE) {
- m_ValNative->ScSetString(Val);
+ if (_type == VAL_NATIVE) {
+ _valNative->ScSetString(Val);
return;
}
SetStringVal(Val);
- if (m_ValString) m_Type = VAL_STRING;
- else m_Type = VAL_NULL;
+ if (_valString) _type = VAL_STRING;
+ else _type = VAL_NULL;
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetStringVal(const char *Val) {
- if (m_ValString) delete [] m_ValString;
+ if (_valString) delete [] _valString;
if (Val == NULL) {
- m_ValString = NULL;
+ _valString = NULL;
return;
}
- m_ValString = new char [strlen(Val) + 1];
- if (m_ValString) {
- strcpy(m_ValString, Val);
+ _valString = new char [strlen(Val) + 1];
+ if (_valString) {
+ strcpy(_valString, Val);
}
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetNULL() {
- if (m_Type == VAL_VARIABLE_REF) {
- m_ValRef->SetNULL();
+ if (_type == VAL_VARIABLE_REF) {
+ _valRef->SetNULL();
return;
}
- if (m_ValNative && !m_Persistent) {
- m_ValNative->m_RefCount--;
- if (m_ValNative->m_RefCount <= 0) delete m_ValNative;
+ if (_valNative && !_persistent) {
+ _valNative->_refCount--;
+ if (_valNative->_refCount <= 0) delete _valNative;
}
- m_ValNative = NULL;
+ _valNative = NULL;
DeleteProps();
- m_Type = VAL_NULL;
+ _type = VAL_NULL;
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetNative(CBScriptable *Val, bool Persistent) {
- if (m_Type == VAL_VARIABLE_REF) {
- m_ValRef->SetNative(Val, Persistent);
+ if (_type == VAL_VARIABLE_REF) {
+ _valRef->SetNative(Val, Persistent);
return;
}
if (Val == NULL) {
SetNULL();
} else {
- if (m_ValNative && !m_Persistent) {
- m_ValNative->m_RefCount--;
- if (m_ValNative->m_RefCount <= 0) {
- if (m_ValNative != Val) delete m_ValNative;
- m_ValNative = NULL;
+ if (_valNative && !_persistent) {
+ _valNative->_refCount--;
+ if (_valNative->_refCount <= 0) {
+ if (_valNative != Val) delete _valNative;
+ _valNative = NULL;
}
}
- m_Type = VAL_NATIVE;
- m_Persistent = Persistent;
+ _type = VAL_NATIVE;
+ _persistent = Persistent;
- m_ValNative = Val;
- if (m_ValNative && !m_Persistent) m_ValNative->m_RefCount++;
+ _valNative = Val;
+ if (_valNative && !_persistent) _valNative->_refCount++;
}
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetObject() {
- if (m_Type == VAL_VARIABLE_REF) {
- m_ValRef->SetObject();
+ if (_type == VAL_VARIABLE_REF) {
+ _valRef->SetObject();
return;
}
DeleteProps();
- m_Type = VAL_OBJECT;
+ _type = VAL_OBJECT;
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetReference(CScValue *Val) {
- m_ValRef = Val;
- m_Type = VAL_VARIABLE_REF;
+ _valRef = Val;
+ _type = VAL_VARIABLE_REF;
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::GetBool(bool Default) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetBool();
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetBool();
- switch (m_Type) {
+ switch (_type) {
case VAL_BOOL:
- return m_ValBool;
+ return _valBool;
case VAL_NATIVE:
- return m_ValNative->ScToBool();
+ return _valNative->ScToBool();
case VAL_INT:
- return (m_ValInt != 0);
+ return (_valInt != 0);
case VAL_FLOAT:
- return (m_ValFloat != 0.0f);
+ return (_valFloat != 0.0f);
case VAL_STRING:
- return (scumm_stricmp(m_ValString, "1") == 0 || scumm_stricmp(m_ValString, "yes") == 0 || scumm_stricmp(m_ValString, "true") == 0);
+ return (scumm_stricmp(_valString, "1") == 0 || scumm_stricmp(_valString, "yes") == 0 || scumm_stricmp(_valString, "true") == 0);
default:
return Default;
@@ -516,23 +516,23 @@ bool CScValue::GetBool(bool Default) { //////////////////////////////////////////////////////////////////////////
int CScValue::GetInt(int Default) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetInt();
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetInt();
- switch (m_Type) {
+ switch (_type) {
case VAL_BOOL:
- return m_ValBool ? 1 : 0;
+ return _valBool ? 1 : 0;
case VAL_NATIVE:
- return m_ValNative->ScToInt();
+ return _valNative->ScToInt();
case VAL_INT:
- return m_ValInt;
+ return _valInt;
case VAL_FLOAT:
- return (int)m_ValFloat;
+ return (int)_valFloat;
case VAL_STRING:
- return atoi(m_ValString);
+ return atoi(_valString);
default:
return Default;
@@ -542,23 +542,23 @@ int CScValue::GetInt(int Default) { //////////////////////////////////////////////////////////////////////////
double CScValue::GetFloat(double Default) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetFloat();
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetFloat();
- switch (m_Type) {
+ switch (_type) {
case VAL_BOOL:
- return m_ValBool ? 1.0f : 0.0f;
+ return _valBool ? 1.0f : 0.0f;
case VAL_NATIVE:
- return m_ValNative->ScToFloat();
+ return _valNative->ScToFloat();
case VAL_INT:
- return (double)m_ValInt;
+ return (double)_valInt;
case VAL_FLOAT:
- return m_ValFloat;
+ return _valFloat;
case VAL_STRING:
- return atof(m_ValString);
+ return atof(_valString);
default:
return Default;
@@ -567,18 +567,18 @@ double CScValue::GetFloat(double Default) { //////////////////////////////////////////////////////////////////////////
void *CScValue::GetMemBuffer() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetMemBuffer();
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetMemBuffer();
- if (m_Type == VAL_NATIVE) return m_ValNative->ScToMemBuffer();
+ if (_type == VAL_NATIVE) return _valNative->ScToMemBuffer();
else return (void *)NULL;
}
//////////////////////////////////////////////////////////////////////////
char *CScValue::GetString() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetString();
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetString();
- switch (m_Type) {
+ switch (_type) {
case VAL_OBJECT:
SetStringVal("[object]");
break;
@@ -588,26 +588,26 @@ char *CScValue::GetString() { break;
case VAL_NATIVE: {
- char *StrVal = m_ValNative->ScToString();
+ char *StrVal = _valNative->ScToString();
SetStringVal(StrVal);
return StrVal;
break;
}
case VAL_BOOL:
- SetStringVal(m_ValBool ? "yes" : "no");
+ SetStringVal(_valBool ? "yes" : "no");
break;
case VAL_INT: {
char dummy[50];
- sprintf(dummy, "%d", m_ValInt);
+ sprintf(dummy, "%d", _valInt);
SetStringVal(dummy);
break;
}
case VAL_FLOAT: {
char dummy[50];
- sprintf(dummy, "%f", m_ValFloat);
+ sprintf(dummy, "%f", _valFloat);
SetStringVal(dummy);
break;
}
@@ -619,22 +619,22 @@ char *CScValue::GetString() { SetStringVal("");
}
- return m_ValString;
+ return _valString;
}
//////////////////////////////////////////////////////////////////////////
CBScriptable *CScValue::GetNative() {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->GetNative();
+ if (_type == VAL_VARIABLE_REF) return _valRef->GetNative();
- if (m_Type == VAL_NATIVE) return m_ValNative;
+ if (_type == VAL_NATIVE) return _valNative;
else return NULL;
}
//////////////////////////////////////////////////////////////////////////
TValType CScValue::GetType() {
- return m_Type;
+ return _type;
}
@@ -642,64 +642,64 @@ TValType CScValue::GetType() { void CScValue::Copy(CScValue *orig, bool CopyWhole) {
Game = orig->Game;
- if (m_ValNative && !m_Persistent) {
- m_ValNative->m_RefCount--;
- if (m_ValNative->m_RefCount <= 0) {
- if (m_ValNative != orig->m_ValNative) delete m_ValNative;
- m_ValNative = NULL;
+ if (_valNative && !_persistent) {
+ _valNative->_refCount--;
+ if (_valNative->_refCount <= 0) {
+ if (_valNative != orig->_valNative) delete _valNative;
+ _valNative = NULL;
}
}
- if (orig->m_Type == VAL_VARIABLE_REF && orig->m_ValRef && CopyWhole) orig = orig->m_ValRef;
+ if (orig->_type == VAL_VARIABLE_REF && orig->_valRef && CopyWhole) orig = orig->_valRef;
Cleanup(true);
- m_Type = orig->m_Type;
- m_ValBool = orig->m_ValBool;
- m_ValInt = orig->m_ValInt;
- m_ValFloat = orig->m_ValFloat;
- SetStringVal(orig->m_ValString);
+ _type = orig->_type;
+ _valBool = orig->_valBool;
+ _valInt = orig->_valInt;
+ _valFloat = orig->_valFloat;
+ SetStringVal(orig->_valString);
- m_ValRef = orig->m_ValRef;
- m_Persistent = orig->m_Persistent;
+ _valRef = orig->_valRef;
+ _persistent = orig->_persistent;
- m_ValNative = orig->m_ValNative;
- if (m_ValNative && !m_Persistent) m_ValNative->m_RefCount++;
+ _valNative = orig->_valNative;
+ if (_valNative && !_persistent) _valNative->_refCount++;
//!!!! ref->native++
// copy properties
- if (orig->m_Type == VAL_OBJECT && orig->m_ValObject.size() > 0) {
- orig->m_ValIter = orig->m_ValObject.begin();
- while (orig->m_ValIter != orig->m_ValObject.end()) {
- m_ValObject[orig->m_ValIter->_key] = new CScValue(Game);
- m_ValObject[orig->m_ValIter->_key]->Copy(orig->m_ValIter->_value);
- orig->m_ValIter++;
+ if (orig->_type == VAL_OBJECT && orig->_valObject.size() > 0) {
+ orig->_valIter = orig->_valObject.begin();
+ while (orig->_valIter != orig->_valObject.end()) {
+ _valObject[orig->_valIter->_key] = new CScValue(Game);
+ _valObject[orig->_valIter->_key]->Copy(orig->_valIter->_value);
+ orig->_valIter++;
}
- } else m_ValObject.clear();
+ } else _valObject.clear();
}
//////////////////////////////////////////////////////////////////////////
void CScValue::SetValue(CScValue *Val) {
- if (Val->m_Type == VAL_VARIABLE_REF) {
- SetValue(Val->m_ValRef);
+ if (Val->_type == VAL_VARIABLE_REF) {
+ SetValue(Val->_valRef);
return;
}
// if being assigned a simple type, preserve native state
- if (m_Type == VAL_NATIVE && (Val->m_Type == VAL_INT || Val->m_Type == VAL_STRING || Val->m_Type == VAL_BOOL)) {
- switch (Val->m_Type) {
+ if (_type == VAL_NATIVE && (Val->_type == VAL_INT || Val->_type == VAL_STRING || Val->_type == VAL_BOOL)) {
+ switch (Val->_type) {
case VAL_INT:
- m_ValNative->ScSetInt(Val->GetInt());
+ _valNative->ScSetInt(Val->GetInt());
break;
case VAL_FLOAT:
- m_ValNative->ScSetFloat(Val->GetFloat());
+ _valNative->ScSetFloat(Val->GetFloat());
break;
case VAL_BOOL:
- m_ValNative->ScSetBool(Val->GetBool());
+ _valNative->ScSetBool(Val->GetBool());
break;
case VAL_STRING:
- m_ValNative->ScSetString(Val->GetString());
+ _valNative->ScSetString(Val->GetString());
break;
}
}
@@ -712,26 +712,26 @@ void CScValue::SetValue(CScValue *Val) { HRESULT CScValue::Persist(CBPersistMgr *PersistMgr) {
PersistMgr->Transfer(TMEMBER(Game));
- PersistMgr->Transfer(TMEMBER(m_Persistent));
- PersistMgr->Transfer(TMEMBER(m_IsConstVar));
- PersistMgr->Transfer(TMEMBER_INT(m_Type));
- PersistMgr->Transfer(TMEMBER(m_ValBool));
- PersistMgr->Transfer(TMEMBER(m_ValFloat));
- PersistMgr->Transfer(TMEMBER(m_ValInt));
- PersistMgr->Transfer(TMEMBER(m_ValNative));
+ PersistMgr->Transfer(TMEMBER(_persistent));
+ PersistMgr->Transfer(TMEMBER(_isConstVar));
+ PersistMgr->Transfer(TMEMBER_INT(_type));
+ PersistMgr->Transfer(TMEMBER(_valBool));
+ PersistMgr->Transfer(TMEMBER(_valFloat));
+ PersistMgr->Transfer(TMEMBER(_valInt));
+ PersistMgr->Transfer(TMEMBER(_valNative));
int size;
char *str;
- if (PersistMgr->m_Saving) {
- size = m_ValObject.size();
+ if (PersistMgr->_saving) {
+ size = _valObject.size();
PersistMgr->Transfer("", &size);
- m_ValIter = m_ValObject.begin();
- while (m_ValIter != m_ValObject.end()) {
- str = (char *)m_ValIter->_key.c_str();
+ _valIter = _valObject.begin();
+ while (_valIter != _valObject.end()) {
+ str = (char *)_valIter->_key.c_str();
PersistMgr->Transfer("", &str);
- PersistMgr->Transfer("", &m_ValIter->_value);
+ PersistMgr->Transfer("", &_valIter->_value);
- m_ValIter++;
+ _valIter++;
}
} else {
CScValue *val;
@@ -740,28 +740,28 @@ HRESULT CScValue::Persist(CBPersistMgr *PersistMgr) { PersistMgr->Transfer("", &str);
PersistMgr->Transfer("", &val);
- m_ValObject[str] = val;
+ _valObject[str] = val;
delete [] str;
}
}
- PersistMgr->Transfer(TMEMBER(m_ValRef));
- PersistMgr->Transfer(TMEMBER(m_ValString));
+ PersistMgr->Transfer(TMEMBER(_valRef));
+ PersistMgr->Transfer(TMEMBER(_valString));
/*
FILE* f = fopen("c:\\val.log", "a+");
- switch(m_Type)
+ switch(_type)
{
case VAL_STRING:
- fprintf(f, "str %s\n", m_ValString);
+ fprintf(f, "str %s\n", _valString);
break;
case VAL_INT:
- fprintf(f, "int %d\n", m_ValInt);
+ fprintf(f, "int %d\n", _valInt);
break;
case VAL_BOOL:
- fprintf(f, "bool %d\n", m_ValBool);
+ fprintf(f, "bool %d\n", _valBool);
break;
case VAL_NULL:
@@ -794,14 +794,14 @@ HRESULT CScValue::Persist(CBPersistMgr *PersistMgr) { //////////////////////////////////////////////////////////////////////////
HRESULT CScValue::SaveAsText(CBDynBuffer *Buffer, int Indent) {
- m_ValIter = m_ValObject.begin();
- while (m_ValIter != m_ValObject.end()) {
+ _valIter = _valObject.begin();
+ while (_valIter != _valObject.end()) {
Buffer->PutTextIndent(Indent, "PROPERTY {\n");
- Buffer->PutTextIndent(Indent + 2, "NAME=\"%s\"\n", (char *)m_ValIter->_key.c_str());
- Buffer->PutTextIndent(Indent + 2, "VALUE=\"%s\"\n", m_ValIter->_value->GetString());
+ Buffer->PutTextIndent(Indent + 2, "NAME=\"%s\"\n", (char *)_valIter->_key.c_str());
+ Buffer->PutTextIndent(Indent + 2, "VALUE=\"%s\"\n", _valIter->_value->GetString());
Buffer->PutTextIndent(Indent, "}\n\n");
- m_ValIter++;
+ _valIter++;
}
return S_OK;
}
@@ -853,10 +853,10 @@ int CScValue::CompareStrict(CScValue *Val1, CScValue *Val2) { //////////////////////////////////////////////////////////////////////////
HRESULT CScValue::DbgSendVariables(IWmeDebugClient *Client, EWmeDebuggerVariableType Type, CScScript *Script, unsigned int ScopeID) {
- m_ValIter = m_ValObject.begin();
- while (m_ValIter != m_ValObject.end()) {
- Client->OnVariableInit(Type, Script, ScopeID, m_ValIter->_value, m_ValIter->_key.c_str());
- m_ValIter++;
+ _valIter = _valObject.begin();
+ while (_valIter != _valObject.end()) {
+ Client->OnVariableInit(Type, Script, ScopeID, _valIter->_value, _valIter->_key.c_str());
+ _valIter++;
}
return S_OK;
}
@@ -987,23 +987,23 @@ bool CScValue::DbgSetVal() { //////////////////////////////////////////////////////////////////////////
int CScValue::DbgGetNumProperties() {
- if (m_ValNative && m_ValNative->m_ScProp) return m_ValNative->m_ScProp->DbgGetNumProperties();
- else return m_ValObject.size();
+ if (_valNative && _valNative->_scProp) return _valNative->_scProp->DbgGetNumProperties();
+ else return _valObject.size();
}
//////////////////////////////////////////////////////////////////////////
bool CScValue::DbgGetProperty(int Index, const char **Name, IWmeDebugProp **Value) {
- if (m_ValNative && m_ValNative->m_ScProp) return m_ValNative->m_ScProp->DbgGetProperty(Index, Name, Value);
+ if (_valNative && _valNative->_scProp) return _valNative->_scProp->DbgGetProperty(Index, Name, Value);
else {
int Count = 0;
- m_ValIter = m_ValObject.begin();
- while (m_ValIter != m_ValObject.end()) {
+ _valIter = _valObject.begin();
+ while (_valIter != _valObject.end()) {
if (Count == Index) {
- *Name = m_ValIter->_key.c_str();
- *Value = m_ValIter->_value;
+ *Name = _valIter->_key.c_str();
+ *Value = _valIter->_value;
return true;
}
- m_ValIter++;
+ _valIter++;
Count++;
}
return false;
@@ -1012,10 +1012,10 @@ bool CScValue::DbgGetProperty(int Index, const char **Name, IWmeDebugProp **Valu //////////////////////////////////////////////////////////////////////////
bool CScValue::DbgGetDescription(char *Buf, int BufSize) {
- if (m_Type == VAL_VARIABLE_REF) return m_ValRef->DbgGetDescription(Buf, BufSize);
+ if (_type == VAL_VARIABLE_REF) return _valRef->DbgGetDescription(Buf, BufSize);
- if (m_Type == VAL_NATIVE) {
- m_ValNative->ScDebuggerDesc(Buf, BufSize);
+ if (_type == VAL_NATIVE) {
+ _valNative->ScDebuggerDesc(Buf, BufSize);
} else {
strncpy(Buf, GetString(), BufSize);
}
diff --git a/engines/wintermute/scriptables/ScValue.h b/engines/wintermute/scriptables/ScValue.h index 3d0c69d3f7..992a220622 100644 --- a/engines/wintermute/scriptables/ScValue.h +++ b/engines/wintermute/scriptables/ScValue.h @@ -53,10 +53,10 @@ public: void Cleanup(bool IgnoreNatives = false);
DECLARE_PERSISTENT(CScValue, CBBase)
- bool m_IsConstVar;
+ bool _isConstVar;
HRESULT SaveAsText(CBDynBuffer *Buffer, int Indent);
void SetValue(CScValue *Val);
- bool m_Persistent;
+ bool _persistent;
bool PropExists(char *Name);
void Copy(CScValue *orig, bool CopyWhole = false);
void SetStringVal(const char *Val);
@@ -87,21 +87,21 @@ public: bool IsObject();
HRESULT SetProp(char *Name, CScValue *Val, bool CopyWhole = false, bool SetAsConst = false);
CScValue *GetProp(char *Name);
- CBScriptable *m_ValNative;
- CScValue *m_ValRef;
- bool m_ValBool;
- int m_ValInt;
- double m_ValFloat;
- char *m_ValString;
- TValType m_Type;
+ CBScriptable *_valNative;
+ CScValue *_valRef;
+ bool _valBool;
+ int _valInt;
+ double _valFloat;
+ char *_valString;
+ TValType _type;
CScValue(CBGame *inGame);
CScValue(CBGame *inGame, bool Val);
CScValue(CBGame *inGame, int Val);
CScValue(CBGame *inGame, double Val);
CScValue(CBGame *inGame, const char *Val);
virtual ~CScValue();
- Common::HashMap<Common::String, CScValue *> m_ValObject;
- Common::HashMap<Common::String, CScValue *>::iterator m_ValIter;
+ Common::HashMap<Common::String, CScValue *> _valObject;
+ Common::HashMap<Common::String, CScValue *>::iterator _valIter;
bool SetProperty(const char *PropName, int Value);
bool SetProperty(const char *PropName, const char *Value);
|