diff options
Diffstat (limited to 'src/CBot/CBotProgram.cpp')
| -rw-r--r-- | src/CBot/CBotProgram.cpp | 1462 |
1 files changed, 731 insertions, 731 deletions
diff --git a/src/CBot/CBotProgram.cpp b/src/CBot/CBotProgram.cpp index 5f1c021..d9be052 100644 --- a/src/CBot/CBotProgram.cpp +++ b/src/CBot/CBotProgram.cpp @@ -22,597 +22,597 @@ CBotProgram::CBotProgram() { - m_Prog = NULL; - m_pRun = NULL; - m_pClass = NULL; - m_pStack = NULL; - m_pInstance = NULL; - - m_ErrorCode = 0; - m_Ident = 0; - m_bDebugDD = 0; + m_Prog = NULL; + m_pRun = NULL; + m_pClass = NULL; + m_pStack = NULL; + m_pInstance = NULL; + + m_ErrorCode = 0; + m_Ident = 0; + m_bDebugDD = 0; } CBotProgram::CBotProgram(CBotVar* pInstance) { - m_Prog = NULL; - m_pRun = NULL; - m_pClass = NULL; - m_pStack = NULL; - m_pInstance = pInstance; - - m_ErrorCode = 0; - m_Ident = 0; - m_bDebugDD = 0; + m_Prog = NULL; + m_pRun = NULL; + m_pClass = NULL; + m_pStack = NULL; + m_pInstance = pInstance; + + m_ErrorCode = 0; + m_Ident = 0; + m_bDebugDD = 0; } CBotProgram::~CBotProgram() { -// delete m_pClass; - m_pClass->Purge(); - m_pClass = NULL; +// delete m_pClass; + m_pClass->Purge(); + m_pClass = NULL; - CBotClass::FreeLock(this); + CBotClass::FreeLock(this); - delete m_Prog; -#if STACKMEM - m_pStack->Delete(); + delete m_Prog; +#if STACKMEM + m_pStack->Delete(); #else - delete m_pStack; + delete m_pStack; #endif } bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, void* pUser ) { - int error = 0; - Stop(); - -// delete m_pClass; - m_pClass->Purge(); // purge the old definitions of classes - // but without destroying the object - m_pClass = NULL; - delete m_Prog; m_Prog= NULL; - - ListFonctions.SetSize(0); - m_ErrorCode = 0; - - if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL) - pUser = m_pInstance->m_pUserPtr; - - // transforms the program in Tokens - CBotToken* pBaseToken = CBotToken::CompileTokens(program, error); - if ( pBaseToken == NULL ) return false; - - - CBotCStack* pStack = new CBotCStack(NULL); - CBotToken* p = pBaseToken->GivNext(); // skips the first token (separator) - - pStack->SetBotCall(this); // defined used routines - CBotCall::SetPUser(pUser); - - // first made a quick pass just to take the headers of routines and classes - while ( pStack->IsOk() && p != NULL && p->GivType() != 0) - { - if ( IsOfType(p, ID_SEP) ) continue; // semicolons lurking - - if ( p->GivType() == ID_CLASS || - ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS )) - { - CBotClass* nxt = CBotClass::Compile1(p, pStack); - if (m_pClass == NULL ) m_pClass = nxt; - else m_pClass->AddNext(nxt); - } - else - { - CBotFunction* next = CBotFunction::Compile1(p, pStack, NULL); - if (m_Prog == NULL ) m_Prog = next; - else m_Prog->AddNext(next); - } - } - if ( !pStack->IsOk() ) - { - m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); - delete m_Prog; - m_Prog = NULL; - delete pBaseToken; - return false; - } - -// CBotFunction* temp = NULL; - CBotFunction* next = m_Prog; // rewind the list - - p = pBaseToken->GivNext(); // returns to the beginning - - while ( pStack->IsOk() && p != NULL && p->GivType() != 0 ) - { - if ( IsOfType(p, ID_SEP) ) continue; // semicolons lurking - - if ( p->GivType() == ID_CLASS || - ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS )) - { - m_bCompileClass = true; - CBotClass::Compile(p, pStack); // completes the definition of the class - } - else - { - m_bCompileClass = false; - CBotFunction::Compile(p, pStack, next); - if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/); - next->m_pProg = this; // keeps pointers to the module - next = next->Next(); - } - } - -// delete m_Prog; // the list of first pass -// m_Prog = temp; // list of the second pass - - if ( !pStack->IsOk() ) - { - m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); - delete m_Prog; - m_Prog = NULL; - } - - delete pBaseToken; - delete pStack; - - return (m_Prog != NULL); + int error = 0; + Stop(); + +// delete m_pClass; + m_pClass->Purge(); // purge the old definitions of classes + // but without destroying the object + m_pClass = NULL; + delete m_Prog; m_Prog= NULL; + + ListFonctions.SetSize(0); + m_ErrorCode = 0; + + if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL) + pUser = m_pInstance->m_pUserPtr; + + // transforms the program in Tokens + CBotToken* pBaseToken = CBotToken::CompileTokens(program, error); + if ( pBaseToken == NULL ) return false; + + + CBotCStack* pStack = new CBotCStack(NULL); + CBotToken* p = pBaseToken->GivNext(); // skips the first token (separator) + + pStack->SetBotCall(this); // defined used routines + CBotCall::SetPUser(pUser); + + // first made a quick pass just to take the headers of routines and classes + while ( pStack->IsOk() && p != NULL && p->GivType() != 0) + { + if ( IsOfType(p, ID_SEP) ) continue; // semicolons lurking + + if ( p->GivType() == ID_CLASS || + ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS )) + { + CBotClass* nxt = CBotClass::Compile1(p, pStack); + if (m_pClass == NULL ) m_pClass = nxt; + else m_pClass->AddNext(nxt); + } + else + { + CBotFunction* next = CBotFunction::Compile1(p, pStack, NULL); + if (m_Prog == NULL ) m_Prog = next; + else m_Prog->AddNext(next); + } + } + if ( !pStack->IsOk() ) + { + m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); + delete m_Prog; + m_Prog = NULL; + delete pBaseToken; + return false; + } + +// CBotFunction* temp = NULL; + CBotFunction* next = m_Prog; // rewind the list + + p = pBaseToken->GivNext(); // returns to the beginning + + while ( pStack->IsOk() && p != NULL && p->GivType() != 0 ) + { + if ( IsOfType(p, ID_SEP) ) continue; // semicolons lurking + + if ( p->GivType() == ID_CLASS || + ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS )) + { + m_bCompileClass = true; + CBotClass::Compile(p, pStack); // completes the definition of the class + } + else + { + m_bCompileClass = false; + CBotFunction::Compile(p, pStack, next); + if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/); + next->m_pProg = this; // keeps pointers to the module + next = next->Next(); + } + } + +// delete m_Prog; // the list of first pass +// m_Prog = temp; // list of the second pass + + if ( !pStack->IsOk() ) + { + m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); + delete m_Prog; + m_Prog = NULL; + } + + delete pBaseToken; + delete pStack; + + return (m_Prog != NULL); } bool CBotProgram::Start(const char* name) { -#if STACKMEM - m_pStack->Delete(); +#if STACKMEM + m_pStack->Delete(); #else - delete m_pStack; + delete m_pStack; #endif - m_pStack = NULL; - - m_pRun = m_Prog; - while (m_pRun != NULL) - { - if ( m_pRun->GivName() == name ) break; - m_pRun = m_pRun->m_next; - } - - if ( m_pRun == NULL ) - { - m_ErrorCode = TX_NORUN; - return false; - } - -#if STACKMEM - m_pStack = CBotStack::FirstStack(); + m_pStack = NULL; + + m_pRun = m_Prog; + while (m_pRun != NULL) + { + if ( m_pRun->GivName() == name ) break; + m_pRun = m_pRun->m_next; + } + + if ( m_pRun == NULL ) + { + m_ErrorCode = TX_NORUN; + return false; + } + +#if STACKMEM + m_pStack = CBotStack::FirstStack(); #else - m_pStack = new CBotStack(NULL); // creates an execution stack + m_pStack = new CBotStack(NULL); // creates an execution stack #endif - m_pStack->SetBotCall(this); // bases for routines + m_pStack->SetBotCall(this); // bases for routines - return true; // we are ready for Run () + return true; // we are ready for Run () } bool CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet modestart, CBotGet modestop) { - CBotFunction* p = m_Prog; - while (p != NULL) - { - if ( p->GivName() == name ) break; - p = p->m_next; - } + CBotFunction* p = m_Prog; + while (p != NULL) + { + if ( p->GivName() == name ) break; + p = p->m_next; + } - if ( p == NULL ) return false; + if ( p == NULL ) return false; - p->GetPosition(start, stop, modestart, modestop); - return true; + p->GetPosition(start, stop, modestart, modestop); + return true; } bool CBotProgram::Run(void* pUser, int timer) { - bool ok; - - if (m_pStack == NULL || m_pRun == NULL) goto error; - - m_ErrorCode = 0; - if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL) - pUser = m_pInstance->m_pUserPtr; - - m_pStack->Reset(pUser); // empty the possible previous error, and resets the timer - if ( timer >= 0 ) m_pStack->SetTimer(timer); - - m_pStack->SetBotCall(this); // bases for routines - -#if STACKRUN - // resumes execution on the top of the stack - ok = m_pStack->Execute(); - if ( ok ) - { -#ifdef _DEBUG - CBotVar* ppVar[3]; - ppVar[0] = CBotVar::Create("aa", CBotTypInt); - ppVar[1] = CBotVar::Create("bb", CBotTypInt); - ppVar[2] = NULL; - ok = m_pRun->Execute(ppVar, m_pStack, m_pInstance); + bool ok; + + if (m_pStack == NULL || m_pRun == NULL) goto error; + + m_ErrorCode = 0; + if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL) + pUser = m_pInstance->m_pUserPtr; + + m_pStack->Reset(pUser); // empty the possible previous error, and resets the timer + if ( timer >= 0 ) m_pStack->SetTimer(timer); + + m_pStack->SetBotCall(this); // bases for routines + +#if STACKRUN + // resumes execution on the top of the stack + ok = m_pStack->Execute(); + if ( ok ) + { +#ifdef _DEBUG + CBotVar* ppVar[3]; + ppVar[0] = CBotVar::Create("aa", CBotTypInt); + ppVar[1] = CBotVar::Create("bb", CBotTypInt); + ppVar[2] = NULL; + ok = m_pRun->Execute(ppVar, m_pStack, m_pInstance); #else - // returns to normal execution - ok = m_pRun->Execute(NULL, m_pStack, m_pInstance); + // returns to normal execution + ok = m_pRun->Execute(NULL, m_pStack, m_pInstance); #endif - } + } #else - ok = m_pRun->Execute(NULL, m_pStack, m_pInstance); + ok = m_pRun->Execute(NULL, m_pStack, m_pInstance); #endif - // completed on a mistake? - if (!ok && !m_pStack->IsOk()) - { - m_ErrorCode = m_pStack->GivError(m_ErrorStart, m_ErrorEnd); -#if STACKMEM - m_pStack->Delete(); + // completed on a mistake? + if (!ok && !m_pStack->IsOk()) + { + m_ErrorCode = m_pStack->GivError(m_ErrorStart, m_ErrorEnd); +#if STACKMEM + m_pStack->Delete(); #else - delete m_pStack; + delete m_pStack; #endif - m_pStack = NULL; - return true; // execution is finished! - } + m_pStack = NULL; + return true; // execution is finished! + } - if ( ok ) m_pRun = NULL; // more function in execution - return ok; + if ( ok ) m_pRun = NULL; // more function in execution + return ok; error: - m_ErrorCode = TX_NORUN; - return true; + m_ErrorCode = TX_NORUN; + return true; } void CBotProgram::Stop() { -#if STACKMEM - m_pStack->Delete(); +#if STACKMEM + m_pStack->Delete(); #else - delete m_pStack; + delete m_pStack; #endif - m_pStack = NULL; - m_pRun = NULL; + m_pStack = NULL; + m_pRun = NULL; } bool CBotProgram::GetRunPos(const char* &FunctionName, int &start, int &end) { - FunctionName = NULL; - start = end = 0; - if (m_pStack == NULL) return false; + FunctionName = NULL; + start = end = 0; + if (m_pStack == NULL) return false; - m_pStack->GetRunPos(FunctionName, start, end); - return true; + m_pStack->GetRunPos(FunctionName, start, end); + return true; } CBotVar* CBotProgram::GivStackVars(const char* &FunctionName, int level) { - FunctionName = NULL; - if (m_pStack == NULL) return NULL; + FunctionName = NULL; + if (m_pStack == NULL) return NULL; - return m_pStack->GivStackVars(FunctionName, level); + return m_pStack->GivStackVars(FunctionName, level); } void CBotProgram::SetTimer(int n) { - CBotStack::SetTimer( n ); + CBotStack::SetTimer( n ); } int CBotProgram::GivError() { - return m_ErrorCode; + return m_ErrorCode; } void CBotProgram::SetIdent(long n) { - m_Ident = n; + m_Ident = n; } long CBotProgram::GivIdent() { - return m_Ident; + return m_Ident; } bool CBotProgram::GetError(int& code, int& start, int& end) { - code = m_ErrorCode; - start = m_ErrorStart; - end = m_ErrorEnd; - return code > 0; + code = m_ErrorCode; + start = m_ErrorStart; + end = m_ErrorEnd; + return code > 0; } bool CBotProgram::GetError(int& code, int& start, int& end, CBotProgram* &pProg) { - code = m_ErrorCode; - start = m_ErrorStart; - end = m_ErrorEnd; - pProg = this; - return code > 0; + code = m_ErrorCode; + start = m_ErrorStart; + end = m_ErrorEnd; + pProg = this; + return code > 0; } CBotString CBotProgram::GivErrorText(int code) { - CBotString TextError; - - TextError.LoadString( code ); - if (TextError.IsEmpty()) - { - char buf[100]; - sprintf(buf, "Exception numéro %d.", code); - TextError = buf; - } - return TextError; + CBotString TextError; + + TextError.LoadString( code ); + if (TextError.IsEmpty()) + { + char buf[100]; + sprintf(buf, "Exception numéro %d.", code); + TextError = buf; + } + return TextError; } CBotFunction* CBotProgram::GivFunctions() { - return m_Prog; + return m_Prog; } bool CBotProgram::AddFunction(const char* name, - bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), - CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) + bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), + CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) { - // stores pointers to the two functions - return CBotCall::AddFunction(name, rExec, rCompile); + // stores pointers to the two functions + return CBotCall::AddFunction(name, rExec, rCompile); } bool WriteWord(FILE* pf, unsigned short w) { - size_t lg; + size_t lg; - lg = fwrite(&w, sizeof( unsigned short ), 1, pf ); + lg = fwrite(&w, sizeof( unsigned short ), 1, pf ); - return (lg == 1); + return (lg == 1); } bool ReadWord(FILE* pf, unsigned short& w) { - size_t lg; + size_t lg; - lg = fread(&w, sizeof( unsigned short ), 1, pf ); + lg = fread(&w, sizeof( unsigned short ), 1, pf ); - return (lg == 1); + return (lg == 1); } bool WriteFloat(FILE* pf, float w) { - size_t lg; + size_t lg; - lg = fwrite(&w, sizeof( float ), 1, pf ); + lg = fwrite(&w, sizeof( float ), 1, pf ); - return (lg == 1); + return (lg == 1); } bool ReadFloat(FILE* pf, float& w) { - size_t lg; + size_t lg; - lg = fread(&w, sizeof( float ), 1, pf ); + lg = fread(&w, sizeof( float ), 1, pf ); - return (lg == 1); + return (lg == 1); } bool WriteLong(FILE* pf, long w) { - size_t lg; + size_t lg; - lg = fwrite(&w, sizeof( long ), 1, pf ); + lg = fwrite(&w, sizeof( long ), 1, pf ); - return (lg == 1); + return (lg == 1); } bool ReadLong(FILE* pf, long& w) { - size_t lg; + size_t lg; - lg = fread(&w, sizeof( long ), 1, pf ); + lg = fread(&w, sizeof( long ), 1, pf ); - return (lg == 1); + return (lg == 1); } bool WriteString(FILE* pf, CBotString s) { - size_t lg1, lg2; + size_t lg1, lg2; - lg1 = s.GivLength(); - if (!WriteWord(pf, lg1)) return false; + lg1 = s.GivLength(); + if (!WriteWord(pf, lg1)) return false; - lg2 = fwrite(s, 1, lg1, pf ); - return (lg1 == lg2); + lg2 = fwrite(s, 1, lg1, pf ); + return (lg1 == lg2); } bool ReadString(FILE* pf, CBotString& s) { - unsigned short w; - char buf[1000]; - size_t lg1, lg2; + unsigned short w; + char buf[1000]; + size_t lg1, lg2; - if (!ReadWord(pf, w)) return false; - lg1 = w; - lg2 = fread(buf, 1, lg1, pf ); - buf[lg2] = 0; + if (!ReadWord(pf, w)) return false; + lg1 = w; + lg2 = fread(buf, 1, lg1, pf ); + buf[lg2] = 0; - s = buf; - return (lg1 == lg2); + s = buf; + return (lg1 == lg2); } bool WriteType(FILE* pf, CBotTypResult type) { - int typ = type.GivType(); - if ( typ == CBotTypIntrinsic ) typ = CBotTypClass; - if ( !WriteWord(pf, typ) ) return false; - if ( typ == CBotTypClass ) - { - CBotClass* p = type.GivClass(); - if ( !WriteString(pf, p->GivName()) ) return false; - } - if ( type.Eq( CBotTypArrayBody ) || - type.Eq( CBotTypArrayPointer ) ) - { - if ( !WriteWord(pf, type.GivLimite()) ) return false; - if ( !WriteType(pf, type.GivTypElem()) ) return false; - } - return true; + int typ = type.GivType(); + if ( typ == CBotTypIntrinsic ) typ = CBotTypClass; + if ( !WriteWord(pf, typ) ) return false; + if ( typ == CBotTypClass ) + { + CBotClass* p = type.GivClass(); + if ( !WriteString(pf, p->GivName()) ) return false; + } + if ( type.Eq( CBotTypArrayBody ) || + type.Eq( CBotTypArrayPointer ) ) + { + if ( !WriteWord(pf, type.GivLimite()) ) return false; + if ( !WriteType(pf, type.GivTypElem()) ) return false; + } + return true; } bool ReadType(FILE* pf, CBotTypResult& type) { - unsigned short w, ww; - if ( !ReadWord(pf, w) ) return false; - type.SetType(w); - - if ( type.Eq( CBotTypIntrinsic ) ) - { - type = CBotTypResult( w, "point" ); - } - - if ( type.Eq( CBotTypClass ) ) - { - CBotString s; - if ( !ReadString(pf, s) ) return false; - type = CBotTypResult( w, s ); - } - - if ( type.Eq( CBotTypArrayPointer ) || - type.Eq( CBotTypArrayBody ) ) - { - CBotTypResult r; - if ( !ReadWord(pf, ww) ) return false; - if ( !ReadType(pf, r) ) return false; - type = CBotTypResult( w, r ); - type.SetLimite((short)ww); - } - return true; + unsigned short w, ww; + if ( !ReadWord(pf, w) ) return false; + type.SetType(w); + + if ( type.Eq( CBotTypIntrinsic ) ) + { + type = CBotTypResult( w, "point" ); + } + + if ( type.Eq( CBotTypClass ) ) + { + CBotString s; + if ( !ReadString(pf, s) ) return false; + type = CBotTypResult( w, s ); + } + + if ( type.Eq( CBotTypArrayPointer ) || + type.Eq( CBotTypArrayBody ) ) + { + CBotTypResult r; + if ( !ReadWord(pf, ww) ) return false; + if ( !ReadType(pf, r) ) return false; + type = CBotTypResult( w, r ); + type.SetLimite((short)ww); + } + return true; } bool CBotProgram::DefineNum(const char* name, long val) { - return CBotToken::DefineNum(name, val); + return CBotToken::DefineNum(name, val); } bool CBotProgram::SaveState(FILE* pf) { - if (!WriteWord( pf, CBOTVERSION)) return false; - - - if ( m_pStack != NULL ) - { - if (!WriteWord( pf, 1)) return false; - if (!WriteString( pf, m_pRun->GivName() )) return false; - if (!m_pStack->SaveState(pf)) return false; - } - else - { - if (!WriteWord( pf, 0)) return false; - } - return true; + if (!WriteWord( pf, CBOTVERSION)) return false; + + + if ( m_pStack != NULL ) + { + if (!WriteWord( pf, 1)) return false; + if (!WriteString( pf, m_pRun->GivName() )) return false; + if (!m_pStack->SaveState(pf)) return false; + } + else + { + if (!WriteWord( pf, 0)) return false; + } + return true; } bool CBotProgram::RestoreState(FILE* pf) { - unsigned short w; - CBotString s; + unsigned short w; + CBotString s; - Stop(); + Stop(); - if (!ReadWord( pf, w )) return false; - if ( w != CBOTVERSION ) return false; + if (!ReadWord( pf, w )) return false; + if ( w != CBOTVERSION ) return false; - if (!ReadWord( pf, w )) return false; - if ( w == 0 ) return true; + if (!ReadWord( pf, w )) return false; + if ( w == 0 ) return true; - if (!ReadString( pf, s )) return false; - Start(s); // point de reprise + if (!ReadString( pf, s )) return false; + Start(s); // point de reprise -#if STACKMEM - m_pStack->Delete(); +#if STACKMEM + m_pStack->Delete(); #else - delete m_pStack; + delete m_pStack; #endif - m_pStack = NULL; + m_pStack = NULL; - // retrieves the stack from the memory - // uses a NULL pointer (m_pStack) but it's ok like that - if (!m_pStack->RestoreState(pf, m_pStack)) return false; - m_pStack->SetBotCall(this); // bases for routines + // retrieves the stack from the memory + // uses a NULL pointer (m_pStack) but it's ok like that + if (!m_pStack->RestoreState(pf, m_pStack)) return false; + m_pStack->SetBotCall(this); // bases for routines - // restored some states in the stack according to the structure - m_pRun->RestoreState(NULL, m_pStack, m_pInstance); - return true; + // restored some states in the stack according to the structure + m_pRun->RestoreState(NULL, m_pStack, m_pInstance); + return true; } int CBotProgram::GivVersion() { - return CBOTVERSION; + return CBOTVERSION; } ////////////////////////////////////////////////////////////////////////////////////////////////////// CBotCall* CBotCall::m_ListCalls = NULL; - + CBotCall::CBotCall(const char* name, - bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), - CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) + bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), + CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) { - m_name = name; - m_rExec = rExec; - m_rComp = rCompile; - m_next = NULL; - m_nFuncIdent = CBotVar::NextUniqNum(); + m_name = name; + m_rExec = rExec; + m_rComp = rCompile; + m_next = NULL; + m_nFuncIdent = CBotVar::NextUniqNum(); } CBotCall::~CBotCall() { - if (m_next) delete m_next; - m_next = NULL; + if (m_next) delete m_next; + m_next = NULL; } void CBotCall::Free() { - delete CBotCall::m_ListCalls; + delete CBotCall::m_ListCalls; } bool CBotCall::AddFunction(const char* name, - bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), - CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) + bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), + CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) { - CBotCall* p = m_ListCalls; - CBotCall* pp = NULL; - - if ( p != NULL ) while ( p->m_next != NULL ) - { - if ( p->GivName() == name ) - { - // frees redefined function - if ( pp ) pp->m_next = p->m_next; - else m_ListCalls = p->m_next; - pp = p; - p = p->m_next; - pp->m_next = NULL; // not to destroy the following list - delete pp; - continue; - } - pp = p; // previous pointer - p = p->m_next; - } - - pp = new CBotCall(name, rExec, rCompile); - - if (p) p->m_next = pp; - else m_ListCalls = pp; - - return true; + CBotCall* p = m_ListCalls; + CBotCall* pp = NULL; + + if ( p != NULL ) while ( p->m_next != NULL ) + { + if ( p->GivName() == name ) + { + // frees redefined function + if ( pp ) pp->m_next = p->m_next; + else m_ListCalls = p->m_next; + pp = p; + p = p->m_next; + pp->m_next = NULL; // not to destroy the following list + delete pp; + continue; + } + pp = p; // previous pointer + p = p->m_next; + } + + pp = new CBotCall(name, rExec, rCompile); + + if (p) p->m_next = pp; + else m_ListCalls = pp; + + return true; } @@ -620,25 +620,25 @@ bool CBotCall::AddFunction(const char* name, // in a chained list of variables CBotVar* MakeListVars(CBotVar** ppVars, bool bSetVal=false) { - int i = 0; - CBotVar* pVar = NULL; - - while( true ) - { - ppVars[i]; - if ( ppVars[i] == NULL ) break; - - CBotVar* pp = CBotVar::Create(ppVars[i]); - if (bSetVal) pp->Copy(ppVars[i]); - else - if ( ppVars[i]->GivType() == CBotTypPointer ) - pp->SetClass( ppVars[i]->GivClass()); + int i = 0; + CBotVar* pVar = NULL; + + while( true ) + { + ppVars[i]; + if ( ppVars[i] == NULL ) break; + + CBotVar* pp = CBotVar::Create(ppVars[i]); + if (bSetVal) pp->Copy(ppVars[i]); + else + if ( ppVars[i]->GivType() == CBotTypPointer ) + pp->SetClass( ppVars[i]->GivClass()); // copy the pointer according to indirections - if (pVar == NULL) pVar = pp; - else pVar->AddNext(pp); - i++; - } - return pVar; + if (pVar == NULL) pVar = pp; + else pVar->AddNext(pp); + i++; + } + return pVar; } // is acceptable by a call procedure name @@ -646,212 +646,212 @@ CBotVar* MakeListVars(CBotVar** ppVars, bool bSetVal=false) CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack* pStack, long& nIdent) { - nIdent = 0; - CBotCall* pt = m_ListCalls; - CBotString name = p->GivString(); - - while ( pt != NULL ) - { - if ( pt->m_name == name ) - { - CBotVar* pVar = MakeListVars(ppVar); - CBotVar* pVar2 = pVar; - CBotTypResult r = pt->m_rComp(pVar2, m_pUser); - int ret = r.GivType(); - - // if a class is returned, it is actually a pointer - if ( ret == CBotTypClass ) r.SetType( ret = CBotTypPointer ); - - if ( ret > 20 ) - { - if (pVar2) pStack->SetError(ret, p /*pVar2->GivToken()*/ ); - } - delete pVar; - nIdent = pt->m_nFuncIdent; - return r; - } - pt = pt->m_next; - } - return -1; + nIdent = 0; + CBotCall* pt = m_ListCalls; + CBotString name = p->GivString(); + + while ( pt != NULL ) + { + if ( pt->m_name == name ) + { + CBotVar* pVar = MakeListVars(ppVar); + CBotVar* pVar2 = pVar; + CBotTypResult r = pt->m_rComp(pVar2, m_pUser); + int ret = r.GivType(); + + // if a class is returned, it is actually a pointer + if ( ret == CBotTypClass ) r.SetType( ret = CBotTypPointer ); + + if ( ret > 20 ) + { + if (pVar2) pStack->SetError(ret, p /*pVar2->GivToken()*/ ); + } + delete pVar; + nIdent = pt->m_nFuncIdent; + return r; + } + pt = pt->m_next; + } + return -1; } void* CBotCall::m_pUser = NULL; void CBotCall::SetPUser(void* pUser) { - m_pUser = pUser; + m_pUser = pUser; } bool CBotCall::CheckCall(const char* name) { - CBotCall* p = m_ListCalls; - - while ( p != NULL ) - { - if ( name == p->GivName() ) return true; - p = p->m_next; - } - return false; + CBotCall* p = m_ListCalls; + + while ( p != NULL ) + { + if ( name == p->GivName() ) return true; + p = p->m_next; + } + return false; } CBotString CBotCall::GivName() { - return m_name; + return m_name; } CBotCall* CBotCall::Next() { - return m_next; + return m_next; } int CBotCall::DoCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack, CBotTypResult& rettype) { - CBotCall* pt = m_ListCalls; - - if ( nIdent ) while ( pt != NULL ) - { - if ( pt->m_nFuncIdent == nIdent ) - { - goto fund; - } - pt = pt->m_next; - } - - pt = m_ListCalls; - - if ( token != NULL ) - { - CBotString name = token->GivString(); - while ( pt != NULL ) - { - if ( pt->m_name == name ) - { - nIdent = pt->m_nFuncIdent; - goto fund; - } - pt = pt->m_next; - } - } - - return -1; + CBotCall* pt = m_ListCalls; + + if ( nIdent ) while ( pt != NULL ) + { + if ( pt->m_nFuncIdent == nIdent ) + { + goto fund; + } + pt = pt->m_next; + } + + pt = m_ListCalls; + + if ( token != NULL ) + { + CBotString name = token->GivString(); + while ( pt != NULL ) + { + if ( pt->m_name == name ) + { + nIdent = pt->m_nFuncIdent; + goto fund; + } + pt = pt->m_next; + } + } + + return -1; fund: #if !STACKRUN - // lists the parameters depending on the contents of the stack (pStackVar) - - CBotVar* pVar = MakeListVars(ppVar, true); - CBotVar* pVarToDelete = pVar; - - // creates a variable to the result - CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype); - - CBotVar* pRes = pResult; - int Exception = 0; - int res = pt->m_rExec(pVar, pResult, Exception, pStack->GivPUser()); - - if ( pResult != pRes ) delete pRes; // different result if made - delete pVarToDelete; - - if (res == false) - { - if (Exception!=0) - { - pStack->SetError(Exception, token); - } - delete pResult; - return false; - } - pStack->SetVar(pResult); - - if ( rettype.GivType() > 0 && pResult == NULL ) - { - pStack->SetError(TX_NORETVAL, token); - } - nIdent = pt->m_nFuncIdent; - return true; + // lists the parameters depending on the contents of the stack (pStackVar) + + CBotVar* pVar = MakeListVars(ppVar, true); + CBotVar* pVarToDelete = pVar; + + // creates a variable to the result + CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype); + + CBotVar* pRes = pResult; + int Exception = 0; + int res = pt->m_rExec(pVar, pResult, Exception, pStack->GivPUser()); + + if ( pResult != pRes ) delete pRes; // different result if made + delete pVarToDelete; + + if (res == false) + { + if (Exception!=0) + { + pStack->SetError(Exception, token); + } + delete pResult; + return false; + } + pStack->SetVar(pResult); + + if ( rettype.GivType() > 0 && pResult == NULL ) + { + pStack->SetError(TX_NORETVAL, token); + } + nIdent = pt->m_nFuncIdent; + return true; #else - CBotStack* pile = pStack->AddStackEOX(pt); - if ( pile == EOX ) return true; + CBotStack* pile = pStack->AddStackEOX(pt); + if ( pile == EOX ) return true; - // lists the parameters depending on the contents of the stack (pStackVar) + // lists the parameters depending on the contents of the stack (pStackVar) - CBotVar* pVar = MakeListVars(ppVar, true); - CBotVar* pVarToDelete = pVar; + CBotVar* pVar = MakeListVars(ppVar, true); + CBotVar* pVarToDelete = pVar; - // creates a variable to the result - CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype); + // creates a variable to the result + CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype); - pile->SetVar( pVar ); + pile->SetVar( pVar ); - CBotStack* pile2 = pile->AddStack(); - pile2->SetVar( pResult ); + CBotStack* pile2 = pile->AddStack(); + pile2->SetVar( pResult ); - pile->SetError(0, token); // for the position on error + away - return pt->Run( pStack ); + pile->SetError(0, token); // for the position on error + away + return pt->Run( pStack ); #endif } -#if STACKRUN +#if STACKRUN bool CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack) { - CBotCall* pt = m_ListCalls; - - { - CBotString name = token->GivString(); - while ( pt != NULL ) - { - if ( pt->m_name == name ) - { - nIdent = pt->m_nFuncIdent; - - CBotStack* pile = pStack->RestoreStackEOX(pt); - if ( pile == NULL ) return true; - - CBotStack* pile2 = pile->RestoreStack(); - return true; - } - pt = pt->m_next; - } - } - - return false; + CBotCall* pt = m_ListCalls; + + { + CBotString name = token->GivString(); + while ( pt != NULL ) + { + if ( pt->m_name == name ) + { + nIdent = pt->m_nFuncIdent; + + CBotStack* pile = pStack->RestoreStackEOX(pt); + if ( pile == NULL ) return true; + + CBotStack* pile2 = pile->RestoreStack(); + return true; + } + pt = pt->m_next; + } + } + + return false; } bool CBotCall::Run(CBotStack* pStack) { - CBotStack* pile = pStack->AddStackEOX(this); - if ( pile == EOX ) return true; - CBotVar* pVar = pile->GivVar(); - - CBotStack* pile2 = pile->AddStack(); - CBotVar* pResult = pile2->GivVar(); - CBotVar* pRes = pResult; - - int Exception = 0; - int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser()); - - if (res == false) - { - if (Exception!=0) - { - pStack->SetError(Exception); - } - if ( pResult != pRes ) delete pResult; // different result if made - return false; - } - - if ( pResult != NULL ) pStack->SetCopyVar( pResult ); - if ( pResult != pRes ) delete pResult; // different result if made - - return true; + CBotStack* pile = pStack->AddStackEOX(this); + if ( pile == EOX ) return true; + CBotVar* pVar = pile->GivVar(); + + CBotStack* pile2 = pile->AddStack(); + CBotVar* pResult = pile2->GivVar(); + CBotVar* pRes = pResult; + + int Exception = 0; + int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser()); + + if (res == false) + { + if (Exception!=0) + { + pStack->SetError(Exception); + } + if ( pResult != pRes ) delete pResult; // different result if made + return false; + } + + if ( pResult != NULL ) pStack->SetCopyVar( pResult ); + if ( pResult != pRes ) delete pResult; // different result if made + + return true; } #endif @@ -859,168 +859,168 @@ bool CBotCall::Run(CBotStack* pStack) /////////////////////////////////////////////////////////////////////////////////////// CBotCallMethode::CBotCallMethode(const char* name, - bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), - CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar)) + bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), + CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar)) { - m_name = name; - m_rExec = rExec; - m_rComp = rCompile; - m_next = NULL; - m_nFuncIdent = CBotVar::NextUniqNum(); + m_name = name; + m_rExec = rExec; + m_rComp = rCompile; + m_next = NULL; + m_nFuncIdent = CBotVar::NextUniqNum(); } CBotCallMethode::~CBotCallMethode() { - delete m_next; - m_next = NULL; + delete m_next; + m_next = NULL; } // is acceptable by a call procedure name // and given parameters CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis, - CBotVar** ppVar, CBotCStack* pStack, - long& nIdent) + CBotVar** ppVar, CBotCStack* pStack, + long& nIdent) { - CBotCallMethode* pt = this; - nIdent = 0; - - while ( pt != NULL ) - { - if ( pt->m_name == name ) - { - CBotVar* pVar = MakeListVars(ppVar, true); - CBotVar* pVar2 = pVar; - CBotTypResult r = pt->m_rComp(pThis, pVar2); - int ret = r.GivType(); - if ( ret > 20 ) - { - if (pVar2) pStack->SetError(ret, pVar2->GivToken()); - } - delete pVar; - nIdent = pt->m_nFuncIdent; - return r; - } - pt = pt->m_next; - } - return CBotTypResult(-1); + CBotCallMethode* pt = this; + nIdent = 0; + + while ( pt != NULL ) + { + if ( pt->m_name == name ) + { + CBotVar* pVar = MakeListVars(ppVar, true); + CBotVar* pVar2 = pVar; + CBotTypResult r = pt->m_rComp(pThis, pVar2); + int ret = r.GivType(); + if ( ret > 20 ) + { + if (pVar2) pStack->SetError(ret, pVar2->GivToken()); + } + delete pVar; + nIdent = pt->m_nFuncIdent; + return r; + } + pt = pt->m_next; + } + return CBotTypResult(-1); } CBotString CBotCallMethode::GivName() { - return m_name; + return m_name; } CBotCallMethode* CBotCallMethode::Next() { - return m_next; + return m_next; } void CBotCallMethode::AddNext(CBotCallMethode* pt) { - CBotCallMethode* p = this; - while ( p->m_next != NULL ) p = p->m_next; + CBotCallMethode* p = this; + while ( p->m_next != NULL ) p = p->m_next; - p->m_next = pt; + p->m_next = pt; } int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotVar* &pResult, CBotStack* pStack, CBotToken* pToken) { - CBotCallMethode* pt = this; - - // search by the identifier - - if ( nIdent ) while ( pt != NULL ) - { - if ( pt->m_nFuncIdent == nIdent ) - { - // lists the parameters depending on the contents of the stack (pStackVar) - - CBotVar* pVar = MakeListVars(ppVars, true); - CBotVar* pVarToDelete = pVar; - - // then calls the routine external to the module - - int Exception = 0; - int res = pt->m_rExec(pThis, pVar, pResult, Exception); - pStack->SetVar(pResult); - - if (res == false) - { - if (Exception!=0) - { -// pStack->SetError(Exception, pVar->GivToken()); - pStack->SetError(Exception, pToken); - } - delete pVarToDelete; - return false; - } - delete pVarToDelete; - return true; - } - pt = pt->m_next; - } - - // search by name - - while ( pt != NULL ) - { - if ( pt->m_name == name ) - { - // lists the parameters depending on the contents of the stack (pStackVar) - - CBotVar* pVar = MakeListVars(ppVars, true); - CBotVar* pVarToDelete = pVar; - - int Exception = 0; - int res = pt->m_rExec(pThis, pVar, pResult, Exception); - pStack->SetVar(pResult); - - if (res == false) - { - if (Exception!=0) - { -// pStack->SetError(Exception, pVar->GivToken()); - pStack->SetError(Exception, pToken); - } - delete pVarToDelete; - return false; - } - delete pVarToDelete; - nIdent = pt->m_nFuncIdent; - return true; - } - pt = pt->m_next; - } - - return -1; + CBotCallMethode* pt = this; + + // search by the identifier + + if ( nIdent ) while ( pt != NULL ) + { + if ( pt->m_nFuncIdent == nIdent ) + { + // lists the parameters depending on the contents of the stack (pStackVar) + + CBotVar* pVar = MakeListVars(ppVars, true); + CBotVar* pVarToDelete = pVar; + + // then calls the routine external to the module + + int Exception = 0; + int res = pt->m_rExec(pThis, pVar, pResult, Exception); + pStack->SetVar(pResult); + + if (res == false) + { + if (Exception!=0) + { +// pStack->SetError(Exception, pVar->GivToken()); + pStack->SetError(Exception, pToken); + } + delete pVarToDelete; + return false; + } + delete pVarToDelete; + return true; + } + pt = pt->m_next; + } + + // search by name + + while ( pt != NULL ) + { + if ( pt->m_name == name ) + { + // lists the parameters depending on the contents of the stack (pStackVar) + + CBotVar* pVar = MakeListVars(ppVars, true); + CBotVar* pVarToDelete = pVar; + + int Exception = 0; + int res = pt->m_rExec(pThis, pVar, pResult, Exception); + pStack->SetVar(pResult); + + if (res == false) + { + if (Exception!=0) + { +// pStack->SetError(Exception, pVar->GivToken()); + pStack->SetError(Exception, pToken); + } + delete pVarToDelete; + return false; + } + delete pVarToDelete; + nIdent = pt->m_nFuncIdent; + return true; + } + pt = pt->m_next; + } + + return -1; } bool rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) { - if ( pVar == NULL ) return TX_LOWPARAM; + if ( pVar == NULL ) return TX_LOWPARAM; - int i = 0; - pVar = pVar->GivItemList(); + int i = 0; + pVar = pVar->GivItemList(); - while ( pVar != NULL ) - { - i++; - pVar = pVar->GivNext(); - } + while ( pVar != NULL ) + { + i++; + pVar = pVar->GivNext(); + } - pResult->SetValInt(i); - return true; + pResult->SetValInt(i); + return true; } CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser ) { - if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM ); - if ( pVar->GivType() != CBotTypArrayPointer ) - return CBotTypResult( TX_BADPARAM ); - return CBotTypResult( CBotTypInt ); + if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM ); + if ( pVar->GivType() != CBotTypArrayPointer ) + return CBotTypResult( TX_BADPARAM ); + return CBotTypResult( CBotTypInt ); } @@ -1028,18 +1028,18 @@ CBotString CBotProgram::m_DebugVarStr = ""; bool rCBotDebug( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) { - pResult->SetValString( CBotProgram::m_DebugVarStr ); + pResult->SetValString( CBotProgram::m_DebugVarStr ); - return true; + return true; } CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser ) { - // no parameter - if ( pVar != NULL ) return CBotTypResult( TX_OVERPARAM ); + // no parameter + if ( pVar != NULL ) return CBotTypResult( TX_OVERPARAM ); - // function returns a result "string" - return CBotTypResult( CBotTypString ); + // function returns a result "string" + return CBotTypResult( CBotTypString ); } @@ -1047,58 +1047,58 @@ CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser ) void CBotProgram::Init() { - CBotToken::DefineNum( "CBotErrOpenPar", 5000) ; // missing the opening parenthesis - CBotToken::DefineNum( "CBotErrClosePar", 5001) ; // missing the closing parenthesis - CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ; // expression must be a boolean - CBotToken::DefineNum( "CBotErrUndefVar", 5003) ; // undeclared variable - CBotToken::DefineNum( "CBotErrBadLeft", 5004) ; // impossible assignment (5 = ...) - CBotToken::DefineNum( "CBotErrNoTerminator", 5005) ;// semicolon expected - CBotToken::DefineNum( "CBotErrCaseOut", 5006) ; // case outside a switch - CBotToken::DefineNum( "CBotErrCloseBlock", 5008) ; // missing " } " - CBotToken::DefineNum( "CBotErrElseWhitoutIf", 5009) ;// else without matching if - CBotToken::DefineNum( "CBotErrOpenBlock", 5010) ; // missing " { " - CBotToken::DefineNum( "CBotErrBadType1", 5011) ; // wrong type for the assignment - CBotToken::DefineNum( "CBotErrRedefVar", 5012) ; // redefinition of the variable - CBotToken::DefineNum( "CBotErrBadType2", 5013) ; // two operands are incompatible - CBotToken::DefineNum( "CBotErrUndefCall", 5014) ; // routine unknown - CBotToken::DefineNum( "CBotErrNoDoubleDots", 5015) ;// " : " expected - CBotToken::DefineNum( "CBotErrBreakOutside", 5017) ;// break outside of a loop - CBotToken::DefineNum( "CBotErrUndefLabel", 5019) ; // unknown label - CBotToken::DefineNum( "CBotErrLabel", 5018) ; // label can not get here - CBotToken::DefineNum( "CBotErrNoCase", 5020) ; // missing " case " - CBotToken::DefineNum( "CBotErrBadNum", 5021) ; // expected number - CBotToken::DefineNum( "CBotErrVoid", 5022) ; // " void " not possble here - CBotToken::DefineNum( "CBotErrNoType", 5023) ; // type declaration expected - CBotToken::DefineNum( "CBotErrNoVar", 5024) ; // variable name expected - CBotToken::DefineNum( "CBotErrNoFunc", 5025) ; // expected function name - CBotToken::DefineNum( "CBotErrOverParam", 5026) ; // too many parameters - CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ; // this function already exists - CBotToken::DefineNum( "CBotErrLowParam", 5028) ; // not enough parameters - CBotToken::DefineNum( "CBotErrBadParam", 5029) ; // mauvais types de paramètres - CBotToken::DefineNum( "CBotErrNbParam", 5030) ; // wrong number of parameters - CBotToken::DefineNum( "CBotErrUndefItem", 5031) ; // element does not exist in the class - CBotToken::DefineNum( "CBotErrUndefClass", 5032) ; // variable is not a class - CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ; // no appropriate constructor - CBotToken::DefineNum( "CBotErrRedefClass", 5034) ; // Class already exists - CBotToken::DefineNum( "CBotErrCloseIndex", 5035) ; // " ] " expected - CBotToken::DefineNum( "CBotErrReserved", 5036) ; // reserved word (for a DefineNum) + CBotToken::DefineNum( "CBotErrOpenPar", 5000) ; // missing the opening parenthesis + CBotToken::DefineNum( "CBotErrClosePar", 5001) ; // missing the closing parenthesis + CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ; // expression must be a boolean + CBotToken::DefineNum( "CBotErrUndefVar", 5003) ; // undeclared variable + CBotToken::DefineNum( "CBotErrBadLeft", 5004) ; // impossible assignment (5 = ...) + CBotToken::DefineNum( "CBotErrNoTerminator", 5005) ;// semicolon expected + CBotToken::DefineNum( "CBotErrCaseOut", 5006) ; // case outside a switch + CBotToken::DefineNum( "CBotErrCloseBlock", 5008) ; // missing " } " + CBotToken::DefineNum( "CBotErrElseWhitoutIf", 5009) ;// else without matching if + CBotToken::DefineNum( "CBotErrOpenBlock", 5010) ; // missing " { " + CBotToken::DefineNum( "CBotErrBadType1", 5011) ; // wrong type for the assignment + CBotToken::DefineNum( "CBotErrRedefVar", 5012) ; // redefinition of the variable + CBotToken::DefineNum( "CBotErrBadType2", 5013) ; // two operands are incompatible + CBotToken::DefineNum( "CBotErrUndefCall", 5014) ; // routine unknown + CBotToken::DefineNum( "CBotErrNoDoubleDots", 5015) ;// " : " expected + CBotToken::DefineNum( "CBotErrBreakOutside", 5017) ;// break outside of a loop + CBotToken::DefineNum( "CBotErrUndefLabel", 5019) ; // unknown label + CBotToken::DefineNum( "CBotErrLabel", 5018) ; // label can not get here + CBotToken::DefineNum( "CBotErrNoCase", 5020) ; // missing " case " + CBotToken::DefineNum( "CBotErrBadNum", 5021) ; // expected number + CBotToken::DefineNum( "CBotErrVoid", 5022) ; // " void " not possble here + CBotToken::DefineNum( "CBotErrNoType", 5023) ; // type declaration expected + CBotToken::DefineNum( "CBotErrNoVar", 5024) ; // variable name expected + CBotToken::DefineNum( "CBotErrNoFunc", 5025) ; // expected function name + CBotToken::DefineNum( "CBotErrOverParam", 5026) ; // too many parameters + CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ; // this function already exists + CBotToken::DefineNum( "CBotErrLowParam", 5028) ; // not enough parameters + CBotToken::DefineNum( "CBotErrBadParam", 5029) ; // mauvais types de paramètres + CBotToken::DefineNum( "CBotErrNbParam", 5030) ; // wrong number of parameters + CBotToken::DefineNum( "CBotErrUndefItem", 5031) ; // element does not exist in the class + CBotToken::DefineNum( "CBotErrUndefClass", 5032) ; // variable is not a class + CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ; // no appropriate constructor + CBotToken::DefineNum( "CBotErrRedefClass", 5034) ; // Class already exists + CBotToken::DefineNum( "CBotErrCloseIndex", 5035) ; // " ] " expected + CBotToken::DefineNum( "CBotErrReserved", 5036) ; // reserved word (for a DefineNum) // Here are the list of errors that can be returned by the module // for the execution - CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ; // division by zero - CBotToken::DefineNum( "CBotErrNotInit", 6001) ; // uninitialized variable - CBotToken::DefineNum( "CBotErrBadThrow", 6002) ; // throw a negative value - CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ; // function did not return results - CBotToken::DefineNum( "CBotErrNoRun", 6004) ; // active Run () without a function - CBotToken::DefineNum( "CBotErrUndefFunc", 6005) ; // Calling a function that no longer exists + CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ; // division by zero + CBotToken::DefineNum( "CBotErrNotInit", 6001) ; // uninitialized variable + CBotToken::DefineNum( "CBotErrBadThrow", 6002) ; // throw a negative value + CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ; // function did not return results + CBotToken::DefineNum( "CBotErrNoRun", 6004) ; // active Run () without a function + CBotToken::DefineNum( "CBotErrUndefFunc", 6005) ; // Calling a function that no longer exists - CBotProgram::AddFunction("sizeof", rSizeOf, cSizeOf ); + CBotProgram::AddFunction("sizeof", rSizeOf, cSizeOf ); - InitStringFunctions(); + InitStringFunctions(); - // just a function for various debug - CBotProgram::AddFunction("CBOTDEBUGDD", rCBotDebug, cCBotDebug); + // just a function for various debug + CBotProgram::AddFunction("CBOTDEBUGDD", rCBotDebug, cCBotDebug); //TODO implement this deletion // DeleteFile("CbotDebug.txt"); @@ -1106,8 +1106,8 @@ void CBotProgram::Init() void CBotProgram::Free() { - CBotToken::Free() ; - CBotCall ::Free() ; - CBotClass::Free() ; + CBotToken::Free() ; + CBotCall ::Free() ; + CBotClass::Free() ; } |