immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed code compilation without fpermissive flag. 

Removed Winapi, but now library don't work - work in progress.
Some translations.
dev-ui
Zaba999 2012-07-04 22:14:28 +02:00
parent fd6147bea0
commit dbd62c96aa
21 changed files with 1758 additions and 1760 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -13,8 +13,8 @@ find_package(SDL_image REQUIRED)
set(CMAKE_BUILD_TYPE debug) set(CMAKE_BUILD_TYPE debug)
# Global compile flags # Global compile flags
set(CMAKE_CXX_FLAGS_RELEASE "-O2") set(CMAKE_CXX_FLAGS_RELEASE "-O2 -Wall")
set(CMAKE_CXX_FLAGS_DEBUG "-w -g -O0") set(CMAKE_CXX_FLAGS_DEBUG "-w -g -O0 -Wall")
# Subdirectory with sources # Subdirectory with sources
add_subdirectory(src bin) add_subdirectory(src bin)

831
src/CBot/CBot.cpp
View File

File diff suppressed because it is too large Load Diff

522
src/CBot/CBot.h
View File

File diff suppressed because it is too large Load Diff

2
src/CBot/CBotAddExpr.cpp
View File

@ -93,7 +93,7 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack)
// fait l'opération d'addition ou de soustraction // fait l'opération d'addition ou de soustraction
BOOL CBotAddExpr::Execute(CBotStack* &pStack) bool CBotAddExpr::Execute(CBotStack* &pStack)
{ {
CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise

145
src/CBot/CBotClass.cpp
View File

@ -21,7 +21,7 @@
CBotClass* CBotClass::m_ExClass = NULL; CBotClass* CBotClass::m_ExClass = NULL;
CBotClass::CBotClass(const char* name, CBotClass* pPapa, BOOL bIntrinsic) CBotClass::CBotClass(const char* name, CBotClass* pPapa, bool bIntrinsic)
{ {
m_pParent = pPapa; m_pParent = pPapa;
m_name = name; m_name = name;
@ -30,7 +30,7 @@ CBotClass::CBotClass(const char* name, CBotClass* pPapa, BOOL bIntrinsic)
m_pCalls = NULL; m_pCalls = NULL;
m_pMethod = NULL; m_pMethod = NULL;
m_rMaj = NULL; m_rMaj = NULL;
m_IsDef = TRUE; m_IsDef = true;
m_bIntrinsic= bIntrinsic; m_bIntrinsic= bIntrinsic;
m_cptLock = 0; m_cptLock = 0;
m_cptOne = 0; m_cptOne = 0;
@ -86,7 +86,7 @@ void CBotClass::Purge()
m_pCalls = NULL; m_pCalls = NULL;
delete m_pMethod; delete m_pMethod;
m_pMethod = NULL; m_pMethod = NULL;
m_IsDef = FALSE; m_IsDef = false;
m_nbVar = m_pParent == NULL ? 0 : m_pParent->m_nbVar; m_nbVar = m_pParent == NULL ? 0 : m_pParent->m_nbVar;
@ -94,7 +94,7 @@ void CBotClass::Purge()
m_next = NULL; // n'appartient plus à cette chaîne m_next = NULL; // n'appartient plus à cette chaîne
} }
BOOL CBotClass::Lock(CBotProgram* p) bool CBotClass::Lock(CBotProgram* p)
{ {
int i = m_cptLock++; int i = m_cptLock++;
@ -102,13 +102,13 @@ BOOL CBotClass::Lock(CBotProgram* p)
{ {
m_cptOne = 1; m_cptOne = 1;
m_ProgInLock[0] = p; m_ProgInLock[0] = p;
return TRUE; return true;
} }
if ( p == m_ProgInLock[0] ) if ( p == m_ProgInLock[0] )
{ {
m_cptOne++; m_cptOne++;
m_cptLock--; // a déjà été compté m_cptLock--; // a déjà été compté
return TRUE; return true;
} }
for ( int j = 1 ; j <= i ; j++) for ( int j = 1 ; j <= i ; j++)
@ -116,7 +116,7 @@ BOOL CBotClass::Lock(CBotProgram* p)
if ( p == m_ProgInLock[j] ) if ( p == m_ProgInLock[j] )
{ {
m_cptLock--; m_cptLock--;
return FALSE; // déjà en attente return false; // déjà en attente
} }
} }
@ -127,7 +127,7 @@ BOOL CBotClass::Lock(CBotProgram* p)
else else
m_cptLock--; m_cptLock--;
return FALSE; return false;
} }
void CBotClass::Unlock() void CBotClass::Unlock()
@ -170,7 +170,7 @@ void CBotClass::FreeLock(CBotProgram* p)
BOOL CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate) bool CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate)
{ {
CBotToken token(name, CBotString()); CBotToken token(name, CBotString());
CBotClass* pClass = type.GivClass(); CBotClass* pClass = type.GivClass();
@ -194,14 +194,14 @@ BOOL CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate)
} }
BOOL CBotClass::AddItem(CBotVar* pVar) bool CBotClass::AddItem(CBotVar* pVar)
{ {
pVar->SetUniqNum(++m_nbVar); pVar->SetUniqNum(++m_nbVar);
if ( m_pVar == NULL ) m_pVar = pVar; if ( m_pVar == NULL ) m_pVar = pVar;
else m_pVar->AddNext(pVar); else m_pVar->AddNext(pVar);
return TRUE; return true;
} }
void CBotClass::AddNext(CBotClass* pClass) void CBotClass::AddNext(CBotClass* pClass)
@ -223,15 +223,15 @@ CBotClass* CBotClass::GivParent()
return m_pParent; return m_pParent;
} }
BOOL CBotClass::IsChildOf(CBotClass* pClass) bool CBotClass::IsChildOf(CBotClass* pClass)
{ {
CBotClass* p = this; CBotClass* p = this;
while ( p != NULL ) while ( p != NULL )
{ {
if ( p == pClass ) return TRUE; if ( p == pClass ) return true;
p = p->m_pParent; p = p->m_pParent;
} }
return FALSE; return false;
} }
@ -266,7 +266,7 @@ CBotVar* CBotClass::GivItemRef(int nIdent)
return NULL; return NULL;
} }
BOOL CBotClass::IsIntrinsic() bool CBotClass::IsIntrinsic()
{ {
return m_bIntrinsic; return m_bIntrinsic;
} }
@ -289,8 +289,8 @@ CBotClass* CBotClass::Find(const char* name)
return NULL; return NULL;
} }
BOOL CBotClass::AddFunction(const char* name, bool CBotClass::AddFunction(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar)) CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))
{ {
// mémorise les pointeurs aux deux fonctions // mémorise les pointeurs aux deux fonctions
@ -315,13 +315,13 @@ BOOL CBotClass::AddFunction(const char* name,
if (m_pCalls == NULL) m_pCalls = p; if (m_pCalls == NULL) m_pCalls = p;
else m_pCalls->AddNext(p); // ajoute à la liste else m_pCalls->AddNext(p); // ajoute à la liste
return TRUE; return true;
} }
BOOL CBotClass::AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) ) bool CBotClass::AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) )
{ {
m_rMaj = rMaj; m_rMaj = rMaj;
return TRUE; return true;
} }
// compile une méthode associée à une instance de classe // compile une méthode associée à une instance de classe
@ -348,7 +348,7 @@ CBotTypResult CBotClass::CompileMethode(const char* name,
// exécute une méthode // exécute une méthode
BOOL CBotClass::ExecuteMethode(long& nIdent, const char* name, bool CBotClass::ExecuteMethode(long& nIdent, const char* name,
CBotVar* pThis, CBotVar** ppParams, CBotVar* pThis, CBotVar** ppParams,
CBotVar* &pResult, CBotStack* &pStack, CBotVar* &pResult, CBotStack* &pStack,
CBotToken* pToken) CBotToken* pToken)
@ -371,77 +371,77 @@ void CBotClass::RestoreMethode(long& nIdent, const char* name, CBotVar* pThis,
BOOL CBotClass::SaveStaticState(FILE* pf) bool CBotClass::SaveStaticState(FILE* pf)
{ {
if (!WriteWord( pf, CBOTVERSION*2)) return FALSE; if (!WriteWord( pf, CBOTVERSION*2)) return false;
// sauve l'état des variables statiques dans les classes // sauve l'état des variables statiques dans les classes
CBotClass* p = m_ExClass; CBotClass* p = m_ExClass;
while ( p != NULL ) while ( p != NULL )
{ {
if (!WriteWord( pf, 1)) return FALSE; if (!WriteWord( pf, 1)) return false;
// enregistre le nom de la classe // enregistre le nom de la classe
if (!WriteString( pf, p->GivName() )) return FALSE; if (!WriteString( pf, p->GivName() )) return false;
CBotVar* pv = p->GivVar(); CBotVar* pv = p->GivVar();
while( pv != NULL ) while( pv != NULL )
{ {
if ( pv->IsStatic() ) if ( pv->IsStatic() )
{ {
if (!WriteWord( pf, 1)) return FALSE; if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, pv->GivName() )) return FALSE; if (!WriteString( pf, pv->GivName() )) return false;
if ( !pv->Save0State(pf)) return FALSE; // entête commune if ( !pv->Save0State(pf)) return false; // entête commune
if ( !pv->Save1State(pf) ) return FALSE; // sauve selon la classe fille if ( !pv->Save1State(pf) ) return false; // sauve selon la classe fille
if ( !WriteWord( pf, 0)) return FALSE; if ( !WriteWord( pf, 0)) return false;
} }
pv = pv->GivNext(); pv = pv->GivNext();
} }
if (!WriteWord( pf, 0)) return FALSE; if (!WriteWord( pf, 0)) return false;
p = p->m_ExNext; p = p->m_ExNext;
} }
if (!WriteWord( pf, 0)) return FALSE; if (!WriteWord( pf, 0)) return false;
return TRUE; return true;
} }
BOOL CBotClass::RestoreStaticState(FILE* pf) bool CBotClass::RestoreStaticState(FILE* pf)
{ {
CBotString ClassName, VarName; CBotString ClassName, VarName;
CBotClass* pClass; CBotClass* pClass;
WORD w; unsigned short w;
if (!ReadWord( pf, w )) return FALSE; if (!ReadWord( pf, w )) return false;
if ( w != CBOTVERSION*2 ) return FALSE; if ( w != CBOTVERSION*2 ) return false;
while (TRUE) while (true)
{ {
if (!ReadWord( pf, w )) return FALSE; if (!ReadWord( pf, w )) return false;
if ( w == 0 ) return TRUE; if ( w == 0 ) return true;
if (!ReadString( pf, ClassName )) return FALSE; if (!ReadString( pf, ClassName )) return false;
pClass = Find(ClassName); pClass = Find(ClassName);
while (TRUE) while (true)
{ {
if (!ReadWord( pf, w )) return FALSE; if (!ReadWord( pf, w )) return false;
if ( w == 0 ) break; if ( w == 0 ) break;
CBotVar* pVar = NULL; CBotVar* pVar = NULL;
CBotVar* pv = NULL; CBotVar* pv = NULL;
if (!ReadString( pf, VarName )) return FALSE; if (!ReadString( pf, VarName )) return false;
if ( pClass != NULL ) pVar = pClass->GivItem(VarName); if ( pClass != NULL ) pVar = pClass->GivItem(VarName);
if (!CBotVar::RestoreState(pf, pv)) return FALSE; // la variable temp if (!CBotVar::RestoreState(pf, pv)) return false; // la variable temp
if ( pVar != NULL ) pVar->Copy(pv); if ( pVar != NULL ) pVar->Copy(pv);
delete pv; delete pv;
} }
} }
return TRUE; return true;
} }
@ -453,7 +453,7 @@ CBotClassInst::CBotClassInst()
m_var = NULL; m_var = NULL;
m_Parameters = NULL; m_Parameters = NULL;
m_expr = NULL; m_expr = NULL;
m_hasParams = FALSE; m_hasParams = false;
m_nMethodeIdent = 0; m_nMethodeIdent = 0;
name = "CBotClassInst"; name = "CBotClassInst";
} }
@ -484,18 +484,17 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
p = p->GivNext(); p = p->GivNext();
} }
BOOL bIntrinsic = pClass->IsIntrinsic(); bool bIntrinsic = pClass->IsIntrinsic();
CBotTypResult CBotTypResult type = CBotTypResult( bIntrinsic ? CBotTypIntrinsic : CBotTypPointer, pClass );
type = CBotTypResult( bIntrinsic ? CBotTypIntrinsic : CBotTypPointer,
pClass );
CBotClassInst* inst = (CBotClassInst*)CompileArray(p, pStack, type); CBotClassInst* inst = (CBotClassInst*)CompileArray(p, pStack, type);
if ( inst != NULL || !pStack->IsOk() ) return inst; if ( inst != NULL || !pStack->IsOk() ) return inst;
CBotCStack* pStk = pStack->TokenStack(); CBotCStack* pStk = pStack->TokenStack();
inst = new CBotClassInst(); inst = new CBotClassInst();
/// \TODO Need to be revised and fixed after adding unit tests
inst->SetToken(&pClass->GivName(), p->GivStart(), p->GivEnd()); CBotToken token(pClass->GivName(), CBotString(), p->GivStart(), p->GivEnd());
inst->SetToken(&token);
CBotToken* vartoken = p; CBotToken* vartoken = p;
if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) ) if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
@ -601,7 +600,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
var->SetPointer( pvar ); // var déjà déclarée pointe l'instance var->SetPointer( pvar ); // var déjà déclarée pointe l'instance
delete pvar; // supprime le second pointeur delete pvar; // supprime le second pointeur
} }
var->SetInit(TRUE); // marque le pointeur comme init var->SetInit(true); // marque le pointeur comme init
} }
else if (inst->m_hasParams) else if (inst->m_hasParams)
{ {
@ -640,17 +639,17 @@ error:
// déclaration de l'instance d'une classe, par exemple: // déclaration de l'instance d'une classe, par exemple:
// CPoint A, B; // CPoint A, B;
BOOL CBotClassInst::Execute(CBotStack* &pj) bool CBotClassInst::Execute(CBotStack* &pj)
{ {
CBotVar* pThis = NULL; CBotVar* pThis = NULL;
CBotStack* pile = pj->AddStack(this);//indispensable pour SetState() CBotStack* pile = pj->AddStack(this);//indispensable pour SetState()
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
CBotToken* pt = &m_token; CBotToken* pt = &m_token;
CBotClass* pClass = CBotClass::Find(pt); CBotClass* pClass = CBotClass::Find(pt);
BOOL bIntrincic = pClass->IsIntrinsic(); bool bIntrincic = pClass->IsIntrinsic();
// crée la variable de type pointeur à l'objet // crée la variable de type pointeur à l'objet
@ -682,7 +681,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
if ( m_expr != NULL ) if ( m_expr != NULL )
{ {
// évalue l'expression pour l'assignation // évalue l'expression pour l'assignation
if (!m_expr->Execute(pile)) return FALSE; if (!m_expr->Execute(pile)) return false;
if ( bIntrincic ) if ( bIntrincic )
{ {
@ -692,7 +691,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
pile->SetError(TX_NULLPT, &m_token); pile->SetError(TX_NULLPT, &m_token);
return pj->Return(pile); return pj->Return(pile);
} }
pThis->Copy(pile->GivVar(), FALSE); pThis->Copy(pile->GivVar(), false);
} }
else else
{ {
@ -700,7 +699,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
pInstance = ((CBotVarPointer*)pile->GivVar())->GivPointer(); // valeur pour l'assignation pInstance = ((CBotVarPointer*)pile->GivVar())->GivPointer(); // valeur pour l'assignation
pThis->SetPointer(pInstance); pThis->SetPointer(pInstance);
} }
pThis->SetInit(TRUE); pThis->SetInit(true);
} }
else if ( m_hasParams ) else if ( m_hasParams )
@ -732,12 +731,12 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
// et place les valeurs sur la pile // et place les valeurs sur la pile
// pour pouvoir être interrompu n'importe quand // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE ) if ( p != NULL) while ( true )
{ {
pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
if ( pile2->GivState() == 0 ) if ( pile2->GivState() == 0 )
{ {
if (!p->Execute(pile2)) return FALSE; // interrompu ici ? if (!p->Execute(pile2)) return false; // interrompu ici ?
pile2->SetState(1); pile2->SetState(1);
} }
ppVars[i++] = pile2->GivVar(); ppVars[i++] = pile2->GivVar();
@ -751,9 +750,9 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(), if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(),
pThis, ppVars, pThis, ppVars,
pResult, pile2, GivToken())) return FALSE; // interrompu pResult, pile2, GivToken())) return false; // interrompu
pThis->SetInit(TRUE); pThis->SetInit(true);
pThis->ConstructorSet(); // signale que le constructeur a été appelé pThis->ConstructorSet(); // signale que le constructeur a été appelé
pile->Return(pile2); // libère un bout de pile pile->Return(pile2); // libère un bout de pile
@ -766,17 +765,17 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
pile->SetState(3); // fini cette partie pile->SetState(3); // fini cette partie
} }
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
if ( m_next2b != NULL && if ( m_next2b != NULL &&
!m_next2b->Execute(pile)) return FALSE; // autre(s) définition(s) !m_next2b->Execute(pile)) return false; // autre(s) définition(s)
return pj->Return( pile ); // transmet en dessous return pj->Return( pile ); // transmet en dessous
} }
void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
{ {
CBotVar* pThis = NULL; CBotVar* pThis = NULL;
@ -793,7 +792,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain)
CBotToken* pt = &m_token; CBotToken* pt = &m_token;
CBotClass* pClass = CBotClass::Find(pt); CBotClass* pClass = CBotClass::Find(pt);
BOOL bIntrincic = pClass->IsIntrinsic(); bool bIntrincic = pClass->IsIntrinsic();
if ( bMain && pile->GivState()<3) if ( bMain && pile->GivState()<3)
{ {
@ -827,7 +826,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain)
// et place les valeurs sur la pile // et place les valeurs sur la pile
// pour pouvoir être interrompu n'importe quand // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE ) if ( p != NULL) while ( true )
{ {
pile2 = pile2->RestoreStack(); // de la place sur la pile pour les résultats pile2 = pile2->RestoreStack(); // de la place sur la pile pour les résultats
if ( pile2 == NULL ) return; if ( pile2 == NULL ) return;
@ -858,11 +857,11 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain)
// test si un nom de procédure est déjà défini quelque part // test si un nom de procédure est déjà défini quelque part
BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) bool CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{ {
CBotString name = pToken->GivString(); CBotString name = pToken->GivString();
if ( CBotCall::CheckCall(name) ) return TRUE; if ( CBotCall::CheckCall(name) ) return true;
CBotFunction* pp = m_pMethod; CBotFunction* pp = m_pMethod;
while ( pp != NULL ) while ( pp != NULL )
@ -871,11 +870,11 @@ BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{ {
// les paramètres sont-ils exactement les mêmes ? // les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) ) if ( pp->CheckParam( pParam ) )
return TRUE; return true;
} }
pp = pp->Next(); pp = pp->Next();
} }
return FALSE; return false;
} }

2
src/CBot/CBotCompExpr.cpp
View File

@ -83,7 +83,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack)
// fait l'opération // fait l'opération
BOOL CBotCompExpr::Execute(CBotStack* &pStack) bool CBotCompExpr::Execute(CBotStack* &pStack)
{ {
CBotStack* pStk1 = pStack->AddStack(this); CBotStack* pStk1 = pStack->AddStack(this);
// if ( pStk1 == EOX ) return TRUE; // if ( pStk1 == EOX ) return TRUE;

466
src/CBot/CBotDll.h
View File

@ -19,10 +19,10 @@
//#include "stdafx.h" //#include "stdafx.h"
#include <windows.h> // #include <windows.h>
#include <stdio.h> #include <stdio.h>
#define DllExport __declspec( dllexport ) // #define DllExport __declspec( dllexport )
#define CBOTVERSION 104 #define CBOTVERSION 104
@ -93,62 +93,62 @@ private:
public: public:
// divers constructeurs selon les besoins // divers constructeurs selon les besoins
DllExport //DllExport
CBotTypResult(int type); CBotTypResult(int type);
// pour les types simples (CBotTypInt à CBotTypString) // pour les types simples (CBotTypInt à CBotTypString)
DllExport //DllExport
CBotTypResult(int type, const char* name); CBotTypResult(int type, const char* name);
// pour les types pointeur et classe intrinsic // pour les types pointeur et classe intrinsic
DllExport //DllExport
CBotTypResult(int type, CBotClass* pClass); CBotTypResult(int type, CBotClass* pClass);
// idem à partir de l'instance d'une classe // idem à partir de l'instance d'une classe
DllExport //DllExport
CBotTypResult(int type, CBotTypResult elem); CBotTypResult(int type, CBotTypResult elem);
// pour les tableaux de variables // pour les tableaux de variables
DllExport //DllExport
CBotTypResult(const CBotTypResult& typ); CBotTypResult(const CBotTypResult& typ);
// pour les assignations // pour les assignations
DllExport //DllExport
CBotTypResult(); CBotTypResult();
// pour par défaut // pour par défaut
DllExport //DllExport
~CBotTypResult(); ~CBotTypResult();
DllExport //DllExport
int GivType(int mode = 0) const; int GivType(int mode = 0) const;
// rend le type CBotTyp* du résultat // rend le type CBotTyp* du résultat
void SetType(int n); void SetType(int n);
// modifie le type // modifie le type
DllExport //DllExport
CBotClass* GivClass() const; CBotClass* GivClass() const;
// rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer) // rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer)
DllExport //DllExport
int GivLimite() const; int GivLimite() const;
// rend la taille limite du tableau (CBotTypArray) // rend la taille limite du tableau (CBotTypArray)
DllExport //DllExport
void SetLimite(int n); void SetLimite(int n);
// fixe une limite au tableau // fixe une limite au tableau
void SetArray(int* max ); void SetArray(int* max );
// idem avec une liste de dimension (tableaux de tableaux) // idem avec une liste de dimension (tableaux de tableaux)
DllExport //DllExport
CBotTypResult& GivTypElem() const; CBotTypResult& GivTypElem() const;
// rend le type des éléments du tableau (CBotTypArray) // rend le type des éléments du tableau (CBotTypArray)
DllExport //DllExport
BOOL Compare(const CBotTypResult& typ) const; bool Compare(const CBotTypResult& typ) const;
// compare si les types sont compatibles // compare si les types sont compatibles
DllExport //DllExport
BOOL Eq(int type) const; bool Eq(int type) const;
// compare le type // compare le type
DllExport //DllExport
CBotTypResult& CBotTypResult&
operator=(const CBotTypResult& src); operator=(const CBotTypResult& src);
// copie un type complet dans un autre // copie un type complet dans un autre
@ -259,102 +259,102 @@ class CBotString
private: private:
char* m_ptr; // pointeur à la chaine char* m_ptr; // pointeur à la chaine
int m_lg; // longueur de la chaine int m_lg; // longueur de la chaine
static // static
HINSTANCE m_hInstance; // HINSTANCE m_hInstance;
public: public:
DllExport //DllExport
CBotString(); CBotString();
DllExport //DllExport
CBotString(const char* p); CBotString(const char* p);
DllExport //DllExport
CBotString(const CBotString& p); CBotString(const CBotString& p);
DllExport //DllExport
~CBotString(); ~CBotString();
DllExport //DllExport
void Empty(); void Empty();
DllExport //DllExport
BOOL IsEmpty() const; bool IsEmpty() const;
DllExport //DllExport
int GivLength(); int GivLength();
DllExport //DllExport
int Find(const char c); int Find(const char c);
DllExport //DllExport
int Find(LPCTSTR lpsz); int Find(const char* lpsz);
DllExport //DllExport
int ReverseFind(const char c); int ReverseFind(const char c);
DllExport //DllExport
int ReverseFind(LPCTSTR lpsz); int ReverseFind(const char* lpsz);
DllExport //DllExport
BOOL LoadString(UINT id); bool LoadString(unsigned int id);
DllExport //DllExport
CBotString Mid(int nFirst, int nCount) const; CBotString Mid(int nFirst, int nCount) const;
DllExport //DllExport
CBotString Mid(int nFirst) const; CBotString Mid(int nFirst) const;
DllExport //DllExport
CBotString Left(int nCount) const; CBotString Left(int nCount) const;
DllExport //DllExport
CBotString Right(int nCount) const; CBotString Right(int nCount) const;
DllExport //DllExport
const CBotString& const CBotString&
operator=(const CBotString& stringSrc); operator=(const CBotString& stringSrc);
DllExport //DllExport
const CBotString& const CBotString&
operator=(const char ch); operator=(const char ch);
DllExport //DllExport
const CBotString& const CBotString&
operator=(const char* pString); operator=(const char* pString);
DllExport //DllExport
const CBotString& const CBotString&
operator+(const CBotString& str); operator+(const CBotString& str);
DllExport //DllExport
friend CBotString friend CBotString
operator+(const CBotString& string, LPCTSTR lpsz); operator+(const CBotString& string, const char* lpsz);
DllExport //DllExport
const CBotString& const CBotString&
operator+=(const char ch); operator+=(const char ch);
DllExport //DllExport
const CBotString& const CBotString&
operator+=(const CBotString& str); operator+=(const CBotString& str);
DllExport //DllExport
BOOL operator==(const CBotString& str); bool operator==(const CBotString& str);
DllExport //DllExport
BOOL operator==(const char* p); bool operator==(const char* p);
DllExport //DllExport
BOOL operator!=(const CBotString& str); bool operator!=(const CBotString& str);
DllExport //DllExport
BOOL operator!=(const char* p); bool operator!=(const char* p);
DllExport //DllExport
BOOL operator>(const CBotString& str); bool operator>(const CBotString& str);
DllExport //DllExport
BOOL operator>(const char* p); bool operator>(const char* p);
DllExport //DllExport
BOOL operator>=(const CBotString& str); bool operator>=(const CBotString& str);
DllExport //DllExport
BOOL operator>=(const char* p); bool operator>=(const char* p);
DllExport //DllExport
BOOL operator<(const CBotString& str); bool operator<(const CBotString& str);
DllExport //DllExport
BOOL operator<(const char* p); bool operator<(const char* p);
DllExport //DllExport
BOOL operator<=(const CBotString& str); bool operator<=(const CBotString& str);
DllExport //DllExport
BOOL operator<=(const char* p); bool operator<=(const char* p);
DllExport //DllExport
operator LPCTSTR() const; // as a C string operator const char*() const; // as a C string
int Compare(LPCTSTR lpsz) const; int Compare(const char* lpsz) const;
DllExport //DllExport
CBotString Mid(int start, int lg=-1); CBotString Mid(int start, int lg=-1);
DllExport //DllExport
void MakeUpper(); void MakeUpper();
DllExport //DllExport
void MakeLower(); void MakeLower();
}; };
@ -369,20 +369,20 @@ private:
CBotString* m_pData; // ^aux données CBotString* m_pData; // ^aux données
public: public:
DllExport //DllExport
CBotStringArray(); CBotStringArray();
DllExport //DllExport
~CBotStringArray(); ~CBotStringArray();
DllExport //DllExport
void SetSize(int nb); void SetSize(int nb);
DllExport //DllExport
int GivSize(); int GivSize();
DllExport //DllExport
void Add(const CBotString& str); void Add(const CBotString& str);
DllExport //DllExport
CBotString& operator[](int nIndex); CBotString& operator[](int nIndex);
DllExport //DllExport
CBotString& ElementAt(int nIndex); CBotString& ElementAt(int nIndex);
}; };
@ -418,87 +418,87 @@ private:
public: public:
static static
CBotString m_DebugVarStr; // a fin de debug CBotString m_DebugVarStr; // a fin de debug
BOOL m_bDebugDD; // idem déclanchable par robot bool m_bDebugDD; // idem déclanchable par robot
BOOL m_bCompileClass; bool m_bCompileClass;
public: public:
DllExport //DllExport
static static
void Init(); void Init();
// initialise le module (défini les mots clefs pour les erreurs) // initialise le module (défini les mots clefs pour les erreurs)
// doit être fait une fois (et une seule) au tout début // doit être fait une fois (et une seule) au tout début
DllExport //DllExport
static static
void Free(); void Free();
// libère les zones mémoires statiques // libère les zones mémoires statiques
DllExport //DllExport
static static
int GivVersion(); int GivVersion();
// donne la version de la librairie CBOT // donne la version de la librairie CBOT
DllExport //DllExport
CBotProgram(); CBotProgram();
DllExport //DllExport
CBotProgram(CBotVar* pInstance); CBotProgram(CBotVar* pInstance);
DllExport //DllExport
~CBotProgram(); ~CBotProgram();
DllExport //DllExport
BOOL Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL); bool Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
// compile le programme donné en texte // compile le programme donné en texte
// retourne FALSE s'il y a une erreur à la compilation // retourne false s'il y a une erreur à la compilation
// voir GetCompileError() pour récupérer l'erreur // voir GetCompileError() pour récupérer l'erreur
// ListFonctions retourne le nom des fonctions déclarées extern // ListFonctions retourne le nom des fonctions déclarées extern
// pUser permet de passer un pointeur pour les routines définies par AddFunction // pUser permet de passer un pointeur pour les routines définies par AddFunction
DllExport //DllExport
void SetIdent(long n); void SetIdent(long n);
// associe un identificateur avec l'instance CBotProgram // associe un identificateur avec l'instance CBotProgram
DllExport //DllExport
long GivIdent(); long GivIdent();
// redonne l'identificateur // redonne l'identificateur
DllExport //DllExport
int GivError(); int GivError();
DllExport //DllExport
BOOL GetError(int& code, int& start, int& end); bool GetError(int& code, int& start, int& end);
DllExport //DllExport
BOOL GetError(int& code, int& start, int& end, CBotProgram* &pProg); bool GetError(int& code, int& start, int& end, CBotProgram* &pProg);
// si TRUE // si true
// donne l'erreur trouvée à la compilation // donne l'erreur trouvée à la compilation
// ou à l'exécution // ou à l'exécution
// start et end délimite le bloc où se trouve l'erreur // start et end délimite le bloc où se trouve l'erreur
// pProg permet de savoir dans quel "module" s'est produite l'erreur d'exécution // pProg permet de savoir dans quel "module" s'est produite l'erreur d'exécution
DllExport //DllExport
static static
CBotString GivErrorText(int code); CBotString GivErrorText(int code);
DllExport //DllExport
BOOL Start(const char* name); bool Start(const char* name);
// définie quelle fonction doit être exécutée // définie quelle fonction doit être exécutée
// retourne FALSE si la fontion name n'est pas trouvée // retourne false si la fontion name n'est pas trouvée
// le programme ne fait rien, il faut appeller Run() pour cela // le programme ne fait rien, il faut appeller Run() pour cela
DllExport //DllExport
BOOL Run(void* pUser = NULL, int timer = -1); bool Run(void* pUser = NULL, int timer = -1);
// exécute le programme // exécute le programme
// retourne FALSE si le programme a été suspendu // retourne false si le programme a été suspendu
// retourne TRUE si le programme s'est terminé avec ou sans erreur // retourne true si le programme s'est terminé avec ou sans erreur
// timer = 0 permet de faire une avance pas à pas // timer = 0 permet de faire une avance pas à pas
DllExport //DllExport
BOOL GetRunPos(const char* &FunctionName, int &start, int &end); bool GetRunPos(const char* &FunctionName, int &start, int &end);
// donne la position dans le programme en exécution // donne la position dans le programme en exécution
// retourne FALSE si on n'est pas en exécution (programme terminé) // retourne false si on n'est pas en exécution (programme terminé)
// FunctionName est un pointeur rendu sur le nom de la fonction // FunctionName est un pointeur rendu sur le nom de la fonction
// start et end la position dans le texte du token en traitement // start et end la position dans le texte du token en traitement
DllExport //DllExport
CBotVar* GivStackVars(const char* &FunctionName, int level); CBotVar* GivStackVars(const char* &FunctionName, int level);
// permet d'obtenir le pointeur aux variables sur la pile d'exécution // permet d'obtenir le pointeur aux variables sur la pile d'exécution
// level est un paramètre d'entrée, 0 pour le dernier niveau, -1, -2, etc pour les autres niveau // level est un paramètre d'entrée, 0 pour le dernier niveau, -1, -2, etc pour les autres niveau
@ -507,41 +507,41 @@ public:
// FunctionName donne le nom de la fonction où se trouvent ces variables // FunctionName donne le nom de la fonction où se trouvent ces variables
// FunctionName == NULL signifiant qu'on est plus dans le programme (selon level) // FunctionName == NULL signifiant qu'on est plus dans le programme (selon level)
DllExport //DllExport
void Stop(); void Stop();
// arrête l'exécution du programme // arrête l'exécution du programme
// quitte donc le mode "suspendu" // quitte donc le mode "suspendu"
DllExport //DllExport
static static
void SetTimer(int n); void SetTimer(int n);
// défini le nombre de pas (parties d'instructions) à faire // défini le nombre de pas (parties d'instructions) à faire
// dans Run() avant de rendre la main "FALSE" // dans Run() avant de rendre la main "false"
DllExport //DllExport
static static
BOOL AddFunction(const char* name, bool AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser)); CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
// cet appel permet d'ajouter de manière externe (**) // cet appel permet d'ajouter de manière externe (**)
// une nouvelle fonction utilisable par le programme CBot // une nouvelle fonction utilisable par le programme CBot
DllExport //DllExport
static static
BOOL DefineNum(const char* name, long val); bool DefineNum(const char* name, long val);
DllExport //DllExport
BOOL SaveState(FILE* pf); bool SaveState(FILE* pf);
// sauvegarde l'état d'exécution dans le fichier // sauvegarde l'état d'exécution dans le fichier
// le fichier doit avoir été ouvert avec l'appel fopen de cette dll // le fichier doit avoir été ouvert avec l'appel fopen de cette dll
// sinon le système plante // sinon le système plante
DllExport //DllExport
BOOL RestoreState(FILE* pf); bool RestoreState(FILE* pf);
// rétablie l'état de l'exécution depuis le fichier // rétablie l'état de l'exécution depuis le fichier
// le programme compilé doit évidemment être identique // le programme compilé doit évidemment être identique
DllExport //DllExport
BOOL GetPosition(const char* name, int& start, int& stop, bool GetPosition(const char* name, int& start, int& stop,
CBotGet modestart = GetPosExtern, CBotGet modestart = GetPosExtern,
CBotGet modestop = GetPosBloc); CBotGet modestop = GetPosBloc);
// donne la position d'une routine dans le texte d'origine // donne la position d'une routine dans le texte d'origine
@ -555,13 +555,13 @@ public:
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// routines pour la gestion d'un fichier (FILE*) // routines pour la gestion d'un fichier (FILE*)
DllExport //DllExport
FILE* fOpen(const char* name, const char* mode); FILE* fOpen(const char* name, const char* mode);
DllExport //DllExport
int fClose(FILE* filehandle); int fClose(FILE* filehandle);
DllExport //DllExport
size_t fWrite(const void *buffer, size_t elemsize, size_t length, FILE* filehandle); size_t fWrite(const void *buffer, size_t elemsize, size_t length, FILE* filehandle);
DllExport //DllExport
size_t fRead(void *buffer, size_t elemsize, size_t length, FILE* filehandle); size_t fRead(void *buffer, size_t elemsize, size_t length, FILE* filehandle);
@ -594,7 +594,7 @@ int cMoyenne(CBotVar* &pVar, CBotString& ClassName)
} }
BOOL rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception) bool rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
float total = 0; float total = 0;
int nb = 0; int nb = 0;
@ -606,7 +606,7 @@ BOOL rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception)
} }
pResult->SetValFloat(total/nb); // retourne la valeur moyenne pResult->SetValFloat(total/nb); // retourne la valeur moyenne
return TRUE; // opération totalement terminée return true; // opération totalement terminée
} }
#endif #endif
@ -645,7 +645,7 @@ protected:
int m_binit; // pas initialisée ? int m_binit; // pas initialisée ?
CBotVarClass* m_pMyThis; // ^élément this correspondant CBotVarClass* m_pMyThis; // ^élément this correspondant
void* m_pUserPtr; // ^données user s'il y a lieu void* m_pUserPtr; // ^données user s'il y a lieu
BOOL m_bStatic; // élément static (dans une classe) bool m_bStatic; // élément static (dans une classe)
int m_mPrivate; // élément public, protected ou private ? int m_mPrivate; // élément public, protected ou private ?
CBotInstr* m_InitExpr; // expression pour le contenu initial CBotInstr* m_InitExpr; // expression pour le contenu initial
@ -663,17 +663,17 @@ public:
virtual ~CBotVar( ); // destructeur virtual ~CBotVar( ); // destructeur
/* DllExport /* //DllExport
static static
CBotVar* Create( const char* name, int type, const char* ClassName = NULL); CBotVar* Create( const char* name, int type, const char* ClassName = NULL);
// crée une variable selon son type,*/ // crée une variable selon son type,*/
DllExport //DllExport
static static
CBotVar* Create( const char* name, CBotTypResult type); CBotVar* Create( const char* name, CBotTypResult type);
// idem à partir du type complet // idem à partir du type complet
DllExport //DllExport
static static
CBotVar* Create( const char* name, CBotClass* pClass); CBotVar* Create( const char* name, CBotClass* pClass);
// idem pour une instance d'une classe connue // idem pour une instance d'une classe connue
@ -690,51 +690,51 @@ virtual ~CBotVar( ); // destructeur
CBotVar* Create( CBotVar* pVar ); CBotVar* Create( CBotVar* pVar );
DllExport //DllExport
void SetUserPtr(void* pUser); void SetUserPtr(void* pUser);
// associe un pointeur utilisateur à une instance // associe un pointeur utilisateur à une instance
DllExport //DllExport
virtual void SetIdent(long UniqId); virtual void SetIdent(long UniqId);
// associe un identificateur unique à une instance // associe un identificateur unique à une instance
// ( c'est à l'utilisateur de s'assurer que l'id est unique) // ( c'est à l'utilisateur de s'assurer que l'id est unique)
DllExport //DllExport
void* GivUserPtr(); void* GivUserPtr();
// rend le pointeur associé à la variable // rend le pointeur associé à la variable
DllExport //DllExport
CBotString GivName(); // le nom de la variable, s'il est connu CBotString GivName(); // le nom de la variable, s'il est connu
//////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////
void SetName(const char* name); // change le nom de la variable void SetName(const char* name); // change le nom de la variable
DllExport //DllExport
int GivType(int mode = 0); // rend le type de base (int) de la variable int GivType(int mode = 0); // rend le type de base (int) de la variable
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
DllExport //DllExport
CBotTypResult GivTypResult(int mode = 0); // rend le type complet de la variable CBotTypResult GivTypResult(int mode = 0); // rend le type complet de la variable
CBotToken* GivToken(); CBotToken* GivToken();
void SetType(CBotTypResult& type); void SetType(CBotTypResult& type);
DllExport //DllExport
void SetInit(int bInit); // met la variable dans l'état IS_UNDEF, IS_DEF, IS_NAN void SetInit(int bInit); // met la variable dans l'état IS_UNDEF, IS_DEF, IS_NAN
DllExport //DllExport
int GivInit(); // donne l'état de la variable int GivInit(); // donne l'état de la variable
DllExport //DllExport
void SetStatic(BOOL bStatic); void SetStatic(bool bStatic);
DllExport //DllExport
BOOL IsStatic(); bool IsStatic();
DllExport //DllExport
void SetPrivate(int mPrivate); void SetPrivate(int mPrivate);
DllExport //DllExport
BOOL IsPrivate(int mode = PR_PROTECT); bool IsPrivate(int mode = PR_PROTECT);
DllExport //DllExport
int GivPrivate(); int GivPrivate();
virtual virtual
@ -742,55 +742,55 @@ virtual ~CBotVar( ); // destructeur
void SetVal(CBotVar* var); // remprend une valeur void SetVal(CBotVar* var); // remprend une valeur
DllExport //DllExport
virtual virtual
CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*) CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
virtual virtual
CBotVar* GivItemRef(int nIdent); // idem à partir du n° ref CBotVar* GivItemRef(int nIdent); // idem à partir du n° ref
DllExport //DllExport
virtual virtual
CBotVar* GivItem(int row, BOOL bGrow = FALSE); CBotVar* GivItem(int row, bool bGrow = false);
DllExport //DllExport
virtual virtual
CBotVar* GivItemList(); // donne la liste des éléments CBotVar* GivItemList(); // donne la liste des éléments
DllExport //DllExport
CBotVar* GivStaticVar(); // rend le pointeur à la variable si elle est statique CBotVar* GivStaticVar(); // rend le pointeur à la variable si elle est statique
DllExport //DllExport
BOOL IsElemOfClass(const char* name); bool IsElemOfClass(const char* name);
// dit si l'élément appartient à la classe "name" // dit si l'élément appartient à la classe "name"
// rend TRUE si l'objet est d'une classe fille // rend true si l'objet est d'une classe fille
DllExport //DllExport
CBotVar* GivNext(); // prochaine variable dans la liste (paramètres) CBotVar* GivNext(); // prochaine variable dans la liste (paramètres)
//////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////
void AddNext(CBotVar* pVar); // ajoute dans une liste void AddNext(CBotVar* pVar); // ajoute dans une liste
virtual virtual
void Copy(CBotVar* pSrc, BOOL bName = TRUE); // fait une copie de la variable void Copy(CBotVar* pSrc, bool bName = true); // fait une copie de la variable
DllExport //DllExport
virtual void SetValInt(int val, const char* name = NULL); virtual void SetValInt(int val, const char* name = NULL);
// initialise avec une valeur entière (#) // initialise avec une valeur entière (#)
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
DllExport //DllExport
virtual void SetValFloat(float val); // initialise avec une valeur réelle (#) virtual void SetValFloat(float val); // initialise avec une valeur réelle (#)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
DllExport //DllExport
virtual void SetValString(const char* p);// initialise avec une valeur chaîne (#) virtual void SetValString(const char* p);// initialise avec une valeur chaîne (#)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
DllExport //DllExport
virtual int GivValInt(); // demande la valeur entière (#) virtual int GivValInt(); // demande la valeur entière (#)
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
DllExport //DllExport
virtual float GivValFloat(); // demande la valeur réelle (#) virtual float GivValFloat(); // demande la valeur réelle (#)
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
@ -814,12 +814,12 @@ virtual ~CBotVar( ); // destructeur
virtual int Modulo(CBotVar* left, CBotVar* right); // reste de division virtual int Modulo(CBotVar* left, CBotVar* right); // reste de division
virtual void Power(CBotVar* left, CBotVar* right); // puissance virtual void Power(CBotVar* left, CBotVar* right); // puissance
virtual BOOL Lo(CBotVar* left, CBotVar* right); virtual bool Lo(CBotVar* left, CBotVar* right);
virtual BOOL Hi(CBotVar* left, CBotVar* right); virtual bool Hi(CBotVar* left, CBotVar* right);
virtual BOOL Ls(CBotVar* left, CBotVar* right); virtual bool Ls(CBotVar* left, CBotVar* right);
virtual BOOL Hs(CBotVar* left, CBotVar* right); virtual bool Hs(CBotVar* left, CBotVar* right);
virtual BOOL Eq(CBotVar* left, CBotVar* right); virtual bool Eq(CBotVar* left, CBotVar* right);
virtual BOOL Ne(CBotVar* left, CBotVar* right); virtual bool Ne(CBotVar* left, CBotVar* right);
virtual void And(CBotVar* left, CBotVar* right); virtual void And(CBotVar* left, CBotVar* right);
virtual void Or(CBotVar* left, CBotVar* right); virtual void Or(CBotVar* left, CBotVar* right);
@ -834,19 +834,19 @@ virtual ~CBotVar( ); // destructeur
virtual void Dec(); virtual void Dec();
virtual BOOL Save0State(FILE* pf); virtual bool Save0State(FILE* pf);
virtual BOOL Save1State(FILE* pf); virtual bool Save1State(FILE* pf);
static BOOL RestoreState(FILE* pf, CBotVar* &pVar); static bool RestoreState(FILE* pf, CBotVar* &pVar);
DllExport //DllExport
void debug(); void debug();
// virtual // virtual
// CBotVar* GivMyThis(); // CBotVar* GivMyThis();
DllExport //DllExport
virtual virtual
void Maj(void* pUser = NULL, BOOL bContinue = TRUE); void Maj(void* pUser = NULL, bool bContinue = true);
void SetUniqNum(long n); void SetUniqNum(long n);
long GivUniqNum(); long GivUniqNum();
@ -888,7 +888,7 @@ private:
CBotString m_name; // nom de cette classe-ci CBotString m_name; // nom de cette classe-ci
int m_nbVar; // nombre de variables dans la chaîne int m_nbVar; // nombre de variables dans la chaîne
CBotVar* m_pVar; // contenu de la classe CBotVar* m_pVar; // contenu de la classe
BOOL m_bIntrinsic; // classe intrinsèque bool m_bIntrinsic; // classe intrinsèque
CBotClass* m_next; // chaine les classe CBotClass* m_next; // chaine les classe
CBotCallMethode* m_pCalls; // liste des méthodes définie en externe CBotCallMethode* m_pCalls; // liste des méthodes définie en externe
CBotFunction* m_pMethod; // liste des méthodes compilées CBotFunction* m_pMethod; // liste des méthodes compilées
@ -899,37 +899,37 @@ private:
CBotProgram* m_ProgInLock[5];// processus en attente pour synchro CBotProgram* m_ProgInLock[5];// processus en attente pour synchro
public: public:
BOOL m_IsDef; // marque si est définie ou pas encore bool m_IsDef; // marque si est définie ou pas encore
DllExport //DllExport
CBotClass( const char* name, CBotClass( const char* name,
CBotClass* pParent, BOOL bIntrinsic = FALSE ); // constructeur CBotClass* pParent, bool bIntrinsic = false ); // constructeur
// Dès qu'une classe est créée, elle est connue // Dès qu'une classe est créée, elle est connue
// partout dans CBot // partout dans CBot
// le mode intrinsic donne une classe qui n'est pas gérée par des pointeurs // le mode intrinsic donne une classe qui n'est pas gérée par des pointeurs
DllExport //DllExport
~CBotClass( ); // destructeur ~CBotClass( ); // destructeur
DllExport //DllExport
BOOL AddFunction(const char* name, bool AddFunction(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar)); CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));
// cet appel permet d'ajouter de manière externe (**) // cet appel permet d'ajouter de manière externe (**)
// une nouvelle méthode utilisable par les objets de cette classe // une nouvelle méthode utilisable par les objets de cette classe
DllExport //DllExport
BOOL AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) ); bool AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) );
// défini la routine qui sera appellée pour mettre à jour les élements de la classe // défini la routine qui sera appellée pour mettre à jour les élements de la classe
DllExport //DllExport
BOOL AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC); bool AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);
// ajoute un élément à la classe // ajoute un élément à la classe
// DllExport // //DllExport
// BOOL AddItem(CBotString name, CBotClass* pClass); // bool AddItem(CBotString name, CBotClass* pClass);
// idem pour des éléments appartenant à pClass // idem pour des éléments appartenant à pClass
DllExport //DllExport
BOOL AddItem(CBotVar* pVar); bool AddItem(CBotVar* pVar);
// idem en passant le pointeur à une instance d'une variable // idem en passant le pointeur à une instance d'une variable
// l'objet est pris tel quel, il ne faut donc pas le détruire // l'objet est pris tel quel, il ne faut donc pas le détruire
@ -938,20 +938,20 @@ public:
// idem en donnant un élément de type CBotVar // idem en donnant un élément de type CBotVar
void AddNext(CBotClass* pClass); void AddNext(CBotClass* pClass);
DllExport //DllExport
CBotString GivName(); // rend le nom de la classe CBotString GivName(); // rend le nom de la classe
DllExport //DllExport
CBotClass* GivParent(); // donne la classe père (ou NULL) CBotClass* GivParent(); // donne la classe père (ou NULL)
// dit si une classe est dérivée (Extends) d'une autre // dit si une classe est dérivée (Extends) d'une autre
// rend TRUE aussi si les classes sont identiques // rend true aussi si les classes sont identiques
DllExport //DllExport
BOOL IsChildOf(CBotClass* pClass); bool IsChildOf(CBotClass* pClass);
static static
CBotClass* Find(CBotToken* &pToken); // trouve une classe d'après son nom CBotClass* Find(CBotToken* &pToken); // trouve une classe d'après son nom
DllExport //DllExport
static static
CBotClass* Find(const char* name); CBotClass* Find(const char* name);
@ -962,7 +962,7 @@ public:
CBotTypResult CompileMethode(const char* name, CBotVar* pThis, CBotVar** ppParams, CBotTypResult CompileMethode(const char* name, CBotVar* pThis, CBotVar** ppParams,
CBotCStack* pStack, long& nIdent); CBotCStack* pStack, long& nIdent);
BOOL ExecuteMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotVar* &pResult, CBotStack* &pStack, CBotToken* pToken); bool ExecuteMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotVar* &pResult, CBotStack* &pStack, CBotToken* pToken);
void RestoreMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotStack* &pStack); void RestoreMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotStack* &pStack);
// compile une classe déclarée par l'utilisateur // compile une classe déclarée par l'utilisateur
@ -971,27 +971,27 @@ public:
static static
CBotClass* Compile1(CBotToken* &p, CBotCStack* pStack); CBotClass* Compile1(CBotToken* &p, CBotCStack* pStack);
BOOL CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond); bool CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond);
BOOL IsIntrinsic(); bool IsIntrinsic();
void Purge(); void Purge();
static static
void Free(); void Free();
DllExport //DllExport
static static
BOOL SaveStaticState(FILE* pf); bool SaveStaticState(FILE* pf);
DllExport //DllExport
static static
BOOL RestoreStaticState(FILE* pf); bool RestoreStaticState(FILE* pf);
BOOL Lock(CBotProgram* p); bool Lock(CBotProgram* p);
void Unlock(); void Unlock();
static static
void FreeLock(CBotProgram* p); void FreeLock(CBotProgram* p);
BOOL CheckCall(CBotToken* &pToken, CBotDefParam* pParam); bool CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
}; };
@ -1041,7 +1041,7 @@ private:
static static
int GivKeyWords(const char* w); // est-ce un mot clef ? int GivKeyWords(const char* w); // est-ce un mot clef ?
static static
BOOL GivKeyDefNum(const char* w, CBotToken* &token); bool GivKeyDefNum(const char* w, CBotToken* &token);
static static
void LoadKeyWords(); // fait la liste des mots clefs void LoadKeyWords(); // fait la liste des mots clefs
@ -1054,37 +1054,37 @@ public:
// constructeur // constructeur
~CBotToken(); // destructeur ~CBotToken(); // destructeur
DllExport //DllExport
int GivType(); // rend le type du token int GivType(); // rend le type du token
DllExport //DllExport
CBotString& GivString(); // rend la chaine correspondant à ce token CBotString& GivString(); // rend la chaine correspondant à ce token
DllExport //DllExport
CBotString& GivSep(); // rend le séparateur suivant le token CBotString& GivSep(); // rend le séparateur suivant le token
DllExport //DllExport
int GivStart(); // position du début dans le texte int GivStart(); // position du début dans le texte
DllExport //DllExport
int GivEnd(); // position de fin dans le texte int GivEnd(); // position de fin dans le texte
DllExport //DllExport
CBotToken* GivNext(); // rend le suivant dans la liste CBotToken* GivNext(); // rend le suivant dans la liste
DllExport //DllExport
CBotToken* GivPrev(); // rend le Précédent dans la liste CBotToken* GivPrev(); // rend le Précédent dans la liste
DllExport //DllExport
static static
CBotToken* CompileTokens(const char* p, int& error); CBotToken* CompileTokens(const char* p, int& error);
// transforme tout le programme // transforme tout le programme
DllExport //DllExport
static static
void Delete(CBotToken* pToken); // libère la liste void Delete(CBotToken* pToken); // libère la liste
// fonctions non utiles en export // fonctions non utiles en export
static static
BOOL DefineNum(const char* name, long val); bool DefineNum(const char* name, long val);
void SetString(const char* name); void SetString(const char* name);
void SetPos(int start, int end); void SetPos(int start, int end);
@ -1092,7 +1092,7 @@ public:
void AddNext(CBotToken* p); // ajoute un token (une copie) void AddNext(CBotToken* p); // ajoute un token (une copie)
static static
CBotToken* NextToken(char* &program, int& error, BOOL first = FALSE); CBotToken* NextToken(char* &program, int& error, bool first = false);
// trouve le prochain token // trouve le prochain token
const CBotToken& const CBotToken&
operator=(const CBotToken& src); operator=(const CBotToken& src);
@ -1163,7 +1163,7 @@ public:
// exécute le programme main // exécute le programme main
// ------------------------- // -------------------------
while( FALSE = m_pMonRobot->Execute( "main", pStack )) while( false = m_pMonRobot->Execute( "main", pStack ))
{ {
// programme suspendu // programme suspendu
// on pourrait passer la main à un autre (en sauvegardant pStack pour ce robot-là) // on pourrait passer la main à un autre (en sauvegardant pStack pour ce robot-là)
@ -1174,10 +1174,10 @@ public:
// routine implémentant l'instruction GOTO( CPoint pos ) // routine implémentant l'instruction GOTO( CPoint pos )
BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception ) bool rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
{ {
if (pVar->GivType() != CBotTypeClass || if (pVar->GivType() != CBotTypeClass ||
pVar->IsElemOfClas("CPoint") ) { exception = 6522; return FALSE; ) pVar->IsElemOfClas("CPoint") ) { exception = 6522; return false; )
// le paramètre n'est pas de la bonne classe ? // le paramètre n'est pas de la bonne classe ?
// NB en fait ce contrôle est déjà fait par la routine pour la compilation // NB en fait ce contrôle est déjà fait par la routine pour la compilation
@ -1193,8 +1193,8 @@ BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
ASSERT (temp != NULL && temp->GivType() == CBotTypFloat); ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
m_PosToGo.y = temp->GivValFloat(); m_PosToGo.y = temp->GivValFloat();
return (m_CurentPos == m_PosToGo); // rend TRUE si la position est atteinte return (m_CurentPos == m_PosToGo); // rend true si la position est atteinte
// rend FALSE s'il faut patienter encore // rend false s'il faut patienter encore
} }
#endif #endif

164
src/CBot/CBotFunction.cpp
View File

@ -25,14 +25,14 @@ CBotFunction::CBotFunction()
m_Param = NULL; // liste des paramètres vide m_Param = NULL; // liste des paramètres vide
m_Block = NULL; // le bloc d'instructions m_Block = NULL; // le bloc d'instructions
m_next = NULL; // les fonctions peuvent être chaînées m_next = NULL; // les fonctions peuvent être chaînées
m_bPublic = FALSE; // fonction non publique m_bPublic = false; // fonction non publique
m_bExtern = FALSE; // fonction non externe m_bExtern = false; // fonction non externe
m_nextpublic = NULL; m_nextpublic = NULL;
m_prevpublic = NULL; m_prevpublic = NULL;
m_pProg = NULL; m_pProg = NULL;
// m_nThisIdent = 0; // m_nThisIdent = 0;
m_nFuncIdent = 0; m_nFuncIdent = 0;
m_bSynchro = FALSE; m_bSynchro = false;
} }
CBotFunction* CBotFunction::m_listPublic = NULL; CBotFunction* CBotFunction::m_listPublic = NULL;
@ -62,17 +62,17 @@ CBotFunction::~CBotFunction()
} }
} }
BOOL CBotFunction::IsPublic() bool CBotFunction::IsPublic()
{ {
return m_bPublic; return m_bPublic;
} }
BOOL CBotFunction::IsExtern() bool CBotFunction::IsExtern()
{ {
return m_bExtern; return m_bExtern;
} }
BOOL CBotFunction::GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop) bool CBotFunction::GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop)
{ {
start = m_extern.GivStart(); start = m_extern.GivStart();
stop = m_closeblk.GivEnd(); stop = m_closeblk.GivEnd();
@ -110,7 +110,7 @@ BOOL CBotFunction::GetPosition(int& start, int& stop, CBotGet modestart, CBotGet
stop = m_closeblk.GivEnd(); stop = m_closeblk.GivEnd();
} }
return TRUE; return true;
} }
@ -168,7 +168,7 @@ CBotTypResult TypeParam(CBotToken* &p, CBotCStack* pile)
// compile une nouvelle fonction // compile une nouvelle fonction
// bLocal permet de mettre la déclaration des paramètres au même niveau // bLocal permet de mettre la déclaration des paramètres au même niveau
// que le éléments appartenant à la classe pour les méthodes // que le éléments appartenant à la classe pour les méthodes
CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* finput, BOOL bLocal) CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* finput, bool bLocal)
{ {
CBotToken* pp; CBotToken* pp;
CBotFunction* func = finput; CBotFunction* func = finput;
@ -178,19 +178,19 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
// func->m_nFuncIdent = CBotVar::NextUniqNum(); // func->m_nFuncIdent = CBotVar::NextUniqNum();
while (TRUE) while (true)
{ {
if ( IsOfType(p, ID_PUBLIC) ) if ( IsOfType(p, ID_PUBLIC) )
{ {
func->m_bPublic = TRUE; func->m_bPublic = true;
continue; continue;
} }
pp = p; pp = p;
if ( IsOfType(p, ID_EXTERN) ) if ( IsOfType(p, ID_EXTERN) )
{ {
func->m_extern = pp; // pour la position du mot "extern" func->m_extern = pp; // pour la position du mot "extern"
func->m_bExtern = TRUE; func->m_bExtern = true;
// func->m_bPublic = TRUE; // donc aussi publique! // func->m_bPublic = true; // donc aussi publique!
continue; continue;
} }
break; break;
@ -260,7 +260,7 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
// et compile le bloc d'instruction qui suit // et compile le bloc d'instruction qui suit
func->m_openblk = p; func->m_openblk = p;
func->m_Block = CBotBlock::Compile(p, pStk, FALSE); func->m_Block = CBotBlock::Compile(p, pStk, false);
func->m_closeblk = p->GivPrev(); func->m_closeblk = p->GivPrev();
if ( pStk->IsOk() ) if ( pStk->IsOk() )
{ {
@ -286,18 +286,18 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas
CBotFunction* func = new CBotFunction(); CBotFunction* func = new CBotFunction();
func->m_nFuncIdent = CBotVar::NextUniqNum(); func->m_nFuncIdent = CBotVar::NextUniqNum();
CBotCStack* pStk = pStack->TokenStack(p, TRUE); CBotCStack* pStk = pStack->TokenStack(p, true);
while (TRUE) while (true)
{ {
if ( IsOfType(p, ID_PUBLIC) ) if ( IsOfType(p, ID_PUBLIC) )
{ {
// func->m_bPublic = TRUE; // sera fait en passe 2 // func->m_bPublic = true; // sera fait en passe 2
continue; continue;
} }
if ( IsOfType(p, ID_EXTERN) ) if ( IsOfType(p, ID_EXTERN) )
{ {
func->m_bExtern = TRUE; func->m_bExtern = true;
continue; continue;
} }
break; break;
@ -367,16 +367,16 @@ bad:
static int xx = 0; static int xx = 0;
#endif #endif
BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance) bool CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
{ {
CBotStack* pile = pj->AddStack(this, 2); // un bout de pile local à cette fonction CBotStack* pile = pj->AddStack(this, 2); // un bout de pile local à cette fonction
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
pile->SetBotCall(m_pProg); // bases pour les routines pile->SetBotCall(m_pProg); // bases pour les routines
if ( pile->GivState() == 0 ) if ( pile->GivState() == 0 )
{ {
if ( !m_Param->Execute(ppVars, pile) ) return FALSE; // défini les paramètres if ( !m_Param->Execute(ppVars, pile) ) return false; // défini les paramètres
pile->IncState(); pile->IncState();
} }
@ -403,14 +403,14 @@ BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
pile->IncState(); pile->IncState();
} }
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
if ( !m_Block->Execute(pile) ) if ( !m_Block->Execute(pile) )
{ {
if ( pile->GivError() < 0 ) if ( pile->GivError() < 0 )
pile->SetError( 0 ); pile->SetError( 0 );
else else
return FALSE; return false;
} }
return pj->Return(pile); return pj->Return(pile);
@ -433,7 +433,7 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst
pile2->Delete(); pile2->Delete();
} }
m_Param->RestoreState(pile2, TRUE); // les paramètres m_Param->RestoreState(pile2, true); // les paramètres
if ( !m_MasterClass.IsEmpty() ) if ( !m_MasterClass.IsEmpty() )
{ {
@ -442,7 +442,7 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst
pThis->SetUniqNum(-2); pThis->SetUniqNum(-2);
} }
m_Block->RestoreState(pile2, TRUE); m_Block->RestoreState(pile2, true);
} }
void CBotFunction::AddNext(CBotFunction* p) void CBotFunction::AddNext(CBotFunction* p)
@ -467,7 +467,7 @@ CBotTypResult CBotFunction::CompileCall(const char* name, CBotVar** ppVars, long
// trouve une fonction selon son identificateur unique // trouve une fonction selon son identificateur unique
// si l'identificateur n'est pas trouvé, cherche selon le nom et les paramètres // si l'identificateur n'est pas trouvé, cherche selon le nom et les paramètres
CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, BOOL bPublic) CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, bool bPublic)
{ {
TypeOrError.SetType(TX_UNDEFCALL); // pas de routine de ce nom TypeOrError.SetType(TX_UNDEFCALL); // pas de routine de ce nom
CBotFunction* pt; CBotFunction* pt;
@ -632,13 +632,13 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS
if ( pt != NULL ) if ( pt != NULL )
{ {
CBotStack* pStk1 = pStack->AddStack(pt, 2); // pour mettre "this" CBotStack* pStk1 = pStack->AddStack(pt, 2); // pour mettre "this"
// if ( pStk1 == EOX ) return TRUE; // if ( pStk1 == EOX ) return true;
pStk1->SetBotCall(pt->m_pProg); // on a peut-être changé de module pStk1->SetBotCall(pt->m_pProg); // on a peut-être changé de module
if ( pStk1->IfStep() ) return FALSE; if ( pStk1->IfStep() ) return false;
CBotStack* pStk3 = pStk1->AddStack(NULL, TRUE); // paramètres CBotStack* pStk3 = pStk1->AddStack(NULL, true); // paramètres
// prépare les paramètres sur la pile // prépare les paramètres sur la pile
@ -680,11 +680,11 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS
if ( !pStk3->IsOk() && pt->m_pProg != m_pProg ) if ( !pStk3->IsOk() && pt->m_pProg != m_pProg )
{ {
#ifdef _DEBUG #ifdef _DEBUG
if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return FALSE; if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return false;
#endif #endif
pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure
} }
return FALSE; // interrompu ! return false; // interrompu !
} }
return pStack->Return( pStk3 ); return pStack->Return( pStk3 );
@ -738,13 +738,13 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars,
if ( pStk1->GivState() == 0 ) if ( pStk1->GivState() == 0 )
{ {
pt->m_Param->RestoreState(pStk3, TRUE); pt->m_Param->RestoreState(pStk3, true);
return; return;
} }
// initialise les variables selon paramètres // initialise les variables selon paramètres
pt->m_Param->RestoreState(pStk3, FALSE); pt->m_Param->RestoreState(pStk3, false);
pt->m_Block->RestoreState(pStk3, TRUE); pt->m_Block->RestoreState(pStk3, true);
} }
} }
@ -758,17 +758,17 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
CBotTypResult type; CBotTypResult type;
CBotProgram* pProgCurrent = pStack->GivBotCall(); CBotProgram* pProgCurrent = pStack->GivBotCall();
CBotFunction* pt = FindLocalOrPublic(nIdent, name, ppVars, type, FALSE); CBotFunction* pt = FindLocalOrPublic(nIdent, name, ppVars, type, false);
if ( pt != NULL ) if ( pt != NULL )
{ {
// DEBUG( "CBotFunction::DoCall" + pt->GivName(), 0, pStack); // DEBUG( "CBotFunction::DoCall" + pt->GivName(), 0, pStack);
CBotStack* pStk = pStack->AddStack(pt, 2); CBotStack* pStk = pStack->AddStack(pt, 2);
// if ( pStk == EOX ) return TRUE; // if ( pStk == EOX ) return true;
pStk->SetBotCall(pt->m_pProg); // on a peut-être changé de module pStk->SetBotCall(pt->m_pProg); // on a peut-être changé de module
CBotStack* pStk3 = pStk->AddStack(NULL, TRUE); // pour mettre les paramètres passés CBotStack* pStk3 = pStk->AddStack(NULL, true); // pour mettre les paramètres passés
// prépare les paramètres sur la pile // prépare les paramètres sur la pile
@ -776,7 +776,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
{ {
// met la variable "this" sur la pile // met la variable "this" sur la pile
CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer); CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer);
pthis->Copy(pThis, FALSE); pthis->Copy(pThis, false);
pthis->SetUniqNum(-2); // valeur spéciale pthis->SetUniqNum(-2); // valeur spéciale
pStk->AddVar(pthis); pStk->AddVar(pthis);
@ -785,7 +785,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
{ {
// met la variable "super" sur la pile // met la variable "super" sur la pile
CBotVar* psuper = CBotVar::Create("super", CBotTypNullPointer); CBotVar* psuper = CBotVar::Create("super", CBotTypNullPointer);
psuper->Copy(pThis, FALSE); // en fait identique à "this" psuper->Copy(pThis, false); // en fait identique à "this"
psuper->SetUniqNum(-3); // valeur spéciale psuper->SetUniqNum(-3); // valeur spéciale
pStk->AddVar(psuper); pStk->AddVar(psuper);
} }
@ -798,8 +798,8 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
{ {
if ( pt->m_bSynchro ) if ( pt->m_bSynchro )
{ {
CBotProgram* pProgBase = pStk->GivBotCall(TRUE); CBotProgram* pProgBase = pStk->GivBotCall(true);
if ( !pClass->Lock(pProgBase) ) return FALSE; // attend de pouvoir if ( !pClass->Lock(pProgBase) ) return false; // attend de pouvoir
} }
pStk->IncState(); pStk->IncState();
} }
@ -820,7 +820,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure
} }
} }
return FALSE; // interrompu ! return false; // interrompu !
} }
if ( pt->m_bSynchro ) if ( pt->m_bSynchro )
@ -850,30 +850,30 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar* pThis, C
CBotStack* pStk3 = pStk->RestoreStack(NULL); // pour mettre les paramètres passés CBotStack* pStk3 = pStk->RestoreStack(NULL); // pour mettre les paramètres passés
if ( pStk3 == NULL ) return; if ( pStk3 == NULL ) return;
pt->m_Param->RestoreState(pStk3, TRUE); // les paramètres pt->m_Param->RestoreState(pStk3, true); // les paramètres
if ( pStk->GivState() > 1 && // vérouillage est effectif ? if ( pStk->GivState() > 1 && // vérouillage est effectif ?
pt->m_bSynchro ) pt->m_bSynchro )
{ {
CBotProgram* pProgBase = pStk->GivBotCall(TRUE); CBotProgram* pProgBase = pStk->GivBotCall(true);
pClass->Lock(pProgBase); // vérouille la classe pClass->Lock(pProgBase); // vérouille la classe
} }
// finalement appelle la fonction trouvée // finalement appelle la fonction trouvée
pt->m_Block->RestoreState(pStk3, TRUE); // interrompu ! pt->m_Block->RestoreState(pStk3, true); // interrompu !
} }
} }
// regarde si la "signature" des paramètres est identique // regarde si la "signature" des paramètres est identique
BOOL CBotFunction::CheckParam(CBotDefParam* pParam) bool CBotFunction::CheckParam(CBotDefParam* pParam)
{ {
CBotDefParam* pp = m_Param; CBotDefParam* pp = m_Param;
while ( pp != NULL && pParam != NULL ) while ( pp != NULL && pParam != NULL )
{ {
CBotTypResult type1 = pp->GivType(); CBotTypResult type1 = pp->GivType();
CBotTypResult type2 = pParam->GivType(); CBotTypResult type2 = pParam->GivType();
if ( !type1.Compare(type2) ) return FALSE; if ( !type1.Compare(type2) ) return false;
pp = pp->GivNext(); pp = pp->GivNext();
pParam = pParam->GivNext(); pParam = pParam->GivNext();
} }
@ -1005,7 +1005,7 @@ void CBotDefParam::AddNext(CBotDefParam* p)
} }
BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj) bool CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
{ {
int i = 0; int i = 0;
CBotDefParam* p = this; CBotDefParam* p = this;
@ -1033,7 +1033,7 @@ BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
newvar->SetValInt(ppVars[i]->GivValInt()); newvar->SetValInt(ppVars[i]->GivValInt());
break; break;
case CBotTypIntrinsic: case CBotTypIntrinsic:
((CBotVarClass*)newvar)->Copy(ppVars[i], FALSE); ((CBotVarClass*)newvar)->Copy(ppVars[i], false);
break; break;
case CBotTypPointer: case CBotTypPointer:
case CBotTypArrayPointer: case CBotTypArrayPointer:
@ -1051,10 +1051,10 @@ BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
i++; i++;
} }
return TRUE; return true;
} }
void CBotDefParam::RestoreState(CBotStack* &pj, BOOL bMain) void CBotDefParam::RestoreState(CBotStack* &pj, bool bMain)
{ {
int i = 0; int i = 0;
CBotDefParam* p = this; CBotDefParam* p = this;
@ -1146,25 +1146,25 @@ CBotInstr* CBotReturn::Compile(CBotToken* &p, CBotCStack* pStack)
return NULL; // pas d'objet, l'erreur est sur la pile return NULL; // pas d'objet, l'erreur est sur la pile
} }
BOOL CBotReturn::Execute(CBotStack* &pj) bool CBotReturn::Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this); CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->GivState() == 0 ) if ( pile->GivState() == 0 )
{ {
if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return FALSE; // évalue le résultat if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return false; // évalue le résultat
// le résultat est sur la pile // le résultat est sur la pile
pile->IncState(); pile->IncState();
} }
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
pile->SetBreak(3, CBotString()); pile->SetBreak(3, CBotString());
return pj->Return(pile); return pj->Return(pile);
} }
void CBotReturn::RestoreState(CBotStack* &pj, BOOL bMain) void CBotReturn::RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
CBotStack* pile = pj->RestoreStack(this); CBotStack* pile = pj->RestoreStack(this);
@ -1211,7 +1211,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
inst->SetToken(pp); inst->SetToken(pp);
// compile la liste des paramètres // compile la liste des paramètres
if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE) if (!IsOfType(p, ID_CLOSEPAR)) while (true)
{ {
start = p->GivStart(); start = p->GivStart();
pile = pile->TokenStack(); // garde les résultats sur la pile pile = pile->TokenStack(); // garde les résultats sur la pile
@ -1278,7 +1278,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
return NULL; return NULL;
} }
BOOL CBotInstrCall::Execute(CBotStack* &pj) bool CBotInstrCall::Execute(CBotStack* &pj)
{ {
CBotVar* ppVars[1000]; CBotVar* ppVars[1000];
CBotStack* pile = pj->AddStack(this); CBotStack* pile = pj->AddStack(this);
@ -1292,12 +1292,12 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj)
// évalue les paramètres // évalue les paramètres
// et place les valeurs sur la pile // et place les valeurs sur la pile
// pour pouvoir être interrompu n'importe quand // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE ) if ( p != NULL) while ( true )
{ {
pile = pile->AddStack(); // de la place sur la pile pour les résultats pile = pile->AddStack(); // de la place sur la pile pour les résultats
if ( pile->GivState() == 0 ) if ( pile->GivState() == 0 )
{ {
if (!p->Execute(pile)) return FALSE; // interrompu ici ? if (!p->Execute(pile)) return false; // interrompu ici ?
pile->SetState(1); // marque spéciale pour reconnaîre les paramètres pile->SetState(1); // marque spéciale pour reconnaîre les paramètres
} }
ppVars[i++] = pile->GivVar(); ppVars[i++] = pile->GivVar();
@ -1307,14 +1307,14 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj)
ppVars[i] = NULL; ppVars[i] = NULL;
CBotStack* pile2 = pile->AddStack(); CBotStack* pile2 = pile->AddStack();
if ( pile2->IfStep() ) return FALSE; if ( pile2->IfStep() ) return false;
if ( !pile2->ExecuteCall(m_nFuncIdent, GivToken(), ppVars, m_typRes)) return FALSE; // interrompu if ( !pile2->ExecuteCall(m_nFuncIdent, GivToken(), ppVars, m_typRes)) return false; // interrompu
return pj->Return(pile2); // libère toute la pile return pj->Return(pile2); // libère toute la pile
} }
void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain) void CBotInstrCall::RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -1329,7 +1329,7 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain)
// évalue les paramètres // évalue les paramètres
// et place les valeurs sur la pile // et place les valeurs sur la pile
// pour pouvoir être interrompu n'importe quand // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE ) if ( p != NULL) while ( true )
{ {
pile = pile->RestoreStack(); // de la place sur la pile pour les résultats pile = pile->RestoreStack(); // de la place sur la pile pour les résultats
if ( pile == NULL ) return; if ( pile == NULL ) return;
@ -1394,7 +1394,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
#endif #endif
CBotClass* classe = (pOld == NULL) ? new CBotClass(name, pPapa) : pOld; CBotClass* classe = (pOld == NULL) ? new CBotClass(name, pPapa) : pOld;
classe->Purge(); // vide les anciennes définitions classe->Purge(); // vide les anciennes définitions
classe->m_IsDef = FALSE; // définition en cours classe->m_IsDef = false; // définition en cours
if ( !IsOfType( p, ID_OPBLK) ) if ( !IsOfType( p, ID_OPBLK) )
{ {
@ -1404,7 +1404,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) ) while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )
{ {
classe->CompileDefItem(p, pStack, FALSE); classe->CompileDefItem(p, pStack, false);
} }
if (pStack->IsOk()) return classe; if (pStack->IsOk()) return classe;
@ -1413,24 +1413,24 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
return NULL; return NULL;
} }
BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
{ {
BOOL bStatic = FALSE; bool bStatic = false;
int mProtect = PR_PUBLIC; int mProtect = PR_PUBLIC;
BOOL bSynchro = FALSE; bool bSynchro = false;
while (IsOfType(p, ID_SEP)) ; while (IsOfType(p, ID_SEP)) ;
CBotTypResult type( -1 ); CBotTypResult type( -1 );
if ( IsOfType(p, ID_SYNCHO) ) bSynchro = TRUE; if ( IsOfType(p, ID_SYNCHO) ) bSynchro = true;
CBotToken* pBase = p; CBotToken* pBase = p;
if ( IsOfType(p, ID_STATIC) ) bStatic = TRUE; if ( IsOfType(p, ID_STATIC) ) bStatic = true;
if ( IsOfType(p, ID_PUBLIC) ) mProtect = PR_PUBLIC; if ( IsOfType(p, ID_PUBLIC) ) mProtect = PR_PUBLIC;
if ( IsOfType(p, ID_PRIVATE) ) mProtect = PR_PRIVATE; if ( IsOfType(p, ID_PRIVATE) ) mProtect = PR_PRIVATE;
if ( IsOfType(p, ID_PROTECTED) ) mProtect = PR_PROTECT; if ( IsOfType(p, ID_PROTECTED) ) mProtect = PR_PROTECT;
if ( IsOfType(p, ID_STATIC) ) bStatic = TRUE; if ( IsOfType(p, ID_STATIC) ) bStatic = true;
// CBotClass* pClass = NULL; // CBotClass* pClass = NULL;
type = TypeParam(p, pStack); // type du résultat type = TypeParam(p, pStack); // type du résultat
@ -1438,7 +1438,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
if ( type.Eq(-1) ) if ( type.Eq(-1) )
{ {
pStack->SetError(TX_NOTYP, p); pStack->SetError(TX_NOTYP, p);
return FALSE; return false;
} }
while (pStack->IsOk()) while (pStack->IsOk())
@ -1463,14 +1463,14 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
if (!pStack->IsOk() || !IsOfType( p, ID_CLBRK ) ) if (!pStack->IsOk() || !IsOfType( p, ID_CLBRK ) )
{ {
pStack->SetError(TX_CLBRK, p->GivStart()); pStack->SetError(TX_CLBRK, p->GivStart());
return FALSE; return false;
} }
/* CBotVar* pv = pStack->GivVar(); /* CBotVar* pv = pStack->GivVar();
if ( pv->GivType()>= CBotTypBoolean ) if ( pv->GivType()>= CBotTypBoolean )
{ {
pStack->SetError(TX_BADTYPE, p->GivStart()); pStack->SetError(TX_BADTYPE, p->GivStart());
return FALSE; return false;
}*/ }*/
if (limites == NULL) limites = i; if (limites == NULL) limites = i;
@ -1485,7 +1485,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
CBotFunction* f = CBotFunction* f =
CBotFunction::Compile1(p, pStack, this); CBotFunction::Compile1(p, pStack, this);
if ( f == NULL ) return FALSE; if ( f == NULL ) return false;
if (m_pMethod == NULL) m_pMethod = f; if (m_pMethod == NULL) m_pMethod = f;
else m_pMethod->AddNext(f); else m_pMethod->AddNext(f);
@ -1502,8 +1502,8 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
pf = pf->Next(); pf = pf->Next();
} }
BOOL bConstructor = (pp->GivString() == GivName()); bool bConstructor = (pp->GivString() == GivName());
CBotCStack* pile = pStack->TokenStack(NULL, TRUE); CBotCStack* pile = pStack->TokenStack(NULL, true);
// rend "this" connu // rend "this" connu
CBotToken TokenThis(CBotString("this"), CBotString()); CBotToken TokenThis(CBotString("this"), CBotString());
@ -1540,7 +1540,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
// compile une méthode // compile une méthode
p = pBase; p = pBase;
CBotFunction* f = CBotFunction* f =
CBotFunction::Compile(p, pile, NULL/*, FALSE*/); CBotFunction::Compile(p, pile, NULL/*, false*/);
if ( f != NULL ) if ( f != NULL )
{ {
@ -1563,7 +1563,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
if (type.Eq(0)) if (type.Eq(0))
{ {
pStack->SetError(TX_ENDOF, p); pStack->SetError(TX_ENDOF, p);
return FALSE; return false;
} }
CBotInstr* i = NULL; CBotInstr* i = NULL;
@ -1578,7 +1578,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
// il y a une assignation à calculer // il y a une assignation à calculer
i = CBotTwoOpExpr::Compile(p, pStack); i = CBotTwoOpExpr::Compile(p, pStack);
} }
if ( !pStack->IsOk() ) return FALSE; if ( !pStack->IsOk() ) return false;
} }
@ -1637,10 +1637,10 @@ CBotClass* CBotClass::Compile(CBotToken* &p, CBotCStack* pStack)
while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) ) while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )
{ {
pOld->CompileDefItem(p, pStack, TRUE); pOld->CompileDefItem(p, pStack, true);
} }
pOld->m_IsDef = TRUE; // définition terminée pOld->m_IsDef = true; // définition terminée
if (pStack->IsOk()) return pOld; if (pStack->IsOk()) return pOld;
} }
pStack->SetError(TX_ENDOF, p); pStack->SetError(TX_ENDOF, p);

24
src/CBot/CBotIf.cpp
View File

@ -51,7 +51,7 @@ CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack)
{ {
// la condition existe bel et bien // la condition existe bel et bien
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
if ( pStk->IsOk() ) if ( pStk->IsOk() )
{ {
// le bloc d'instruction est ok (peut être vide) // le bloc d'instruction est ok (peut être vide)
@ -60,7 +60,7 @@ CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack)
if (IsOfType(p, ID_ELSE)) if (IsOfType(p, ID_ELSE))
{ {
// si oui, compile le bloc d'instruction qui suit // si oui, compile le bloc d'instruction qui suit
inst->m_BlockElse = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); inst->m_BlockElse = CBotBlock::CompileBlkOrInst( p, pStk, true );
if (!pStk->IsOk()) if (!pStk->IsOk())
{ {
// il n'y a pas de bloc correct après le else // il n'y a pas de bloc correct après le else
@ -84,19 +84,19 @@ CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack)
// exécution de l'instruction // exécution de l'instruction
BOOL CBotIf :: Execute(CBotStack* &pj) bool CBotIf :: Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
// selon la reprise, on peut être dans l'un des 2 états // selon la reprise, on peut être dans l'un des 2 états
if( pile->GivState() == 0 ) if( pile->GivState() == 0 )
{ {
// évalue la condition // évalue la condition
if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ? if ( !m_Condition->Execute(pile) ) return false; // interrompu ici ?
// termine s'il y a une erreur // termine s'il y a une erreur
if ( !pile->IsOk() ) if ( !pile->IsOk() )
@ -105,21 +105,21 @@ BOOL CBotIf :: Execute(CBotStack* &pj)
} }
// passe dans le second état // passe dans le second état
if (!pile->SetState(1)) return FALSE; // prêt pour la suite if (!pile->SetState(1)) return false; // prêt pour la suite
} }
// second état, évalue les instructions associées // second état, évalue les instructions associées
// le résultat de la condition est sur la pile // le résultat de la condition est sur la pile
if ( pile->GivVal() == TRUE ) // condition était vraie ? if ( pile->GivVal() == true ) // condition était vraie ?
{ {
if ( m_Block != NULL && // bloc peut être absent if ( m_Block != NULL && // bloc peut être absent
!m_Block->Execute(pile) ) return FALSE; // interrompu ici ? !m_Block->Execute(pile) ) return false; // interrompu ici ?
} }
else else
{ {
if ( m_BlockElse != NULL && // s'il existe un bloc alternatif if ( m_BlockElse != NULL && // s'il existe un bloc alternatif
!m_BlockElse->Execute(pile) ) return FALSE; // interrompu ici !m_BlockElse->Execute(pile) ) return false; // interrompu ici
} }
// transmet le résultat et libère la pile // transmet le résultat et libère la pile
@ -127,7 +127,7 @@ BOOL CBotIf :: Execute(CBotStack* &pj)
} }
void CBotIf :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotIf :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -145,7 +145,7 @@ void CBotIf :: RestoreState(CBotStack* &pj, BOOL bMain)
// second état, évalue les instructions associées // second état, évalue les instructions associées
// le résultat de la condition est sur la pile // le résultat de la condition est sur la pile
if ( pile->GivVal() == TRUE ) // condition était vraie ? if ( pile->GivVal() == true ) // condition était vraie ?
{ {
if ( m_Block != NULL ) // bloc peut être absent if ( m_Block != NULL ) // bloc peut être absent
m_Block->RestoreState(pile, bMain); // interrompu ici ! m_Block->RestoreState(pile, bMain); // interrompu ici !

211
src/CBot/CBotProgram.cpp
View File

@ -62,7 +62,7 @@ CBotProgram::~CBotProgram()
} }
BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, void* pUser ) bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, void* pUser )
{ {
int error = 0; int error = 0;
Stop(); Stop();
@ -81,7 +81,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
// transforme le programme en Tokens // transforme le programme en Tokens
CBotToken* pBaseToken = CBotToken::CompileTokens(program, error); CBotToken* pBaseToken = CBotToken::CompileTokens(program, error);
if ( pBaseToken == NULL ) return FALSE; if ( pBaseToken == NULL ) return false;
CBotCStack* pStack = new CBotCStack(NULL); CBotCStack* pStack = new CBotCStack(NULL);
@ -115,7 +115,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
delete m_Prog; delete m_Prog;
m_Prog = NULL; m_Prog = NULL;
delete pBaseToken; delete pBaseToken;
return FALSE; return false;
} }
// CBotFunction* temp = NULL; // CBotFunction* temp = NULL;
@ -130,12 +130,12 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
if ( p->GivType() == ID_CLASS || if ( p->GivType() == ID_CLASS ||
( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS )) ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))
{ {
m_bCompileClass = TRUE; m_bCompileClass = true;
CBotClass::Compile(p, pStack); // complète la définition de la classe CBotClass::Compile(p, pStack); // complète la définition de la classe
} }
else else
{ {
m_bCompileClass = FALSE; m_bCompileClass = false;
CBotFunction::Compile(p, pStack, next); CBotFunction::Compile(p, pStack, next);
if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/); if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/);
next->m_pProg = this; // garde le pointeur au module next->m_pProg = this; // garde le pointeur au module
@ -160,7 +160,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
} }
BOOL CBotProgram::Start(const char* name) bool CBotProgram::Start(const char* name)
{ {
#if STACKMEM #if STACKMEM
m_pStack->Delete(); m_pStack->Delete();
@ -179,7 +179,7 @@ BOOL CBotProgram::Start(const char* name)
if ( m_pRun == NULL ) if ( m_pRun == NULL )
{ {
m_ErrorCode = TX_NORUN; m_ErrorCode = TX_NORUN;
return FALSE; return false;
} }
#if STACKMEM #if STACKMEM
@ -190,10 +190,10 @@ BOOL CBotProgram::Start(const char* name)
m_pStack->SetBotCall(this); // bases pour les routines m_pStack->SetBotCall(this); // bases pour les routines
return TRUE; // on est prêt pour un Run() return true; // on est prêt pour un Run()
} }
BOOL CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet modestart, CBotGet modestop) bool CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet modestart, CBotGet modestop)
{ {
CBotFunction* p = m_Prog; CBotFunction* p = m_Prog;
while (p != NULL) while (p != NULL)
@ -202,15 +202,15 @@ BOOL CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet m
p = p->m_next; p = p->m_next;
} }
if ( p == NULL ) return FALSE; if ( p == NULL ) return false;
p->GetPosition(start, stop, modestart, modestop); p->GetPosition(start, stop, modestart, modestop);
return TRUE; return true;
} }
BOOL CBotProgram::Run(void* pUser, int timer) bool CBotProgram::Run(void* pUser, int timer)
{ {
BOOL ok; bool ok;
if (m_pStack == NULL || m_pRun == NULL) goto error; if (m_pStack == NULL || m_pRun == NULL) goto error;
@ -253,7 +253,7 @@ BOOL CBotProgram::Run(void* pUser, int timer)
delete m_pStack; delete m_pStack;
#endif #endif
m_pStack = NULL; m_pStack = NULL;
return TRUE; // exécution terminée !! return true; // exécution terminée !!
} }
if ( ok ) m_pRun = NULL; // plus de fonction en exécution if ( ok ) m_pRun = NULL; // plus de fonction en exécution
@ -261,7 +261,7 @@ BOOL CBotProgram::Run(void* pUser, int timer)
error: error:
m_ErrorCode = TX_NORUN; m_ErrorCode = TX_NORUN;
return TRUE; return true;
} }
void CBotProgram::Stop() void CBotProgram::Stop()
@ -277,14 +277,14 @@ void CBotProgram::Stop()
BOOL CBotProgram::GetRunPos(const char* &FunctionName, int &start, int &end) bool CBotProgram::GetRunPos(const char* &FunctionName, int &start, int &end)
{ {
FunctionName = NULL; FunctionName = NULL;
start = end = 0; start = end = 0;
if (m_pStack == NULL) return FALSE; if (m_pStack == NULL) return false;
m_pStack->GetRunPos(FunctionName, start, end); m_pStack->GetRunPos(FunctionName, start, end);
return TRUE; return true;
} }
CBotVar* CBotProgram::GivStackVars(const char* &FunctionName, int level) CBotVar* CBotProgram::GivStackVars(const char* &FunctionName, int level)
@ -321,7 +321,7 @@ long CBotProgram::GivIdent()
return m_Ident; return m_Ident;
} }
BOOL CBotProgram::GetError(int& code, int& start, int& end) bool CBotProgram::GetError(int& code, int& start, int& end)
{ {
code = m_ErrorCode; code = m_ErrorCode;
start = m_ErrorStart; start = m_ErrorStart;
@ -329,7 +329,7 @@ BOOL CBotProgram::GetError(int& code, int& start, int& end)
return code > 0; return code > 0;
} }
BOOL CBotProgram::GetError(int& code, int& start, int& end, CBotProgram* &pProg) bool CBotProgram::GetError(int& code, int& start, int& end, CBotProgram* &pProg)
{ {
code = m_ErrorCode; code = m_ErrorCode;
start = m_ErrorStart; start = m_ErrorStart;
@ -358,8 +358,8 @@ CBotFunction* CBotProgram::GivFunctions()
return m_Prog; return m_Prog;
} }
BOOL CBotProgram::AddFunction(const char* name, bool CBotProgram::AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
{ {
// mémorise les pointeurs aux deux fonctions // mémorise les pointeurs aux deux fonctions
@ -367,25 +367,25 @@ BOOL CBotProgram::AddFunction(const char* name,
} }
BOOL WriteWord(FILE* pf, WORD w) bool WriteWord(FILE* pf, unsigned short w)
{ {
size_t lg; size_t lg;
lg = fwrite(&w, sizeof( WORD ), 1, pf ); lg = fwrite(&w, sizeof( unsigned short ), 1, pf );
return (lg == 1); return (lg == 1);
} }
BOOL ReadWord(FILE* pf, WORD& w) bool ReadWord(FILE* pf, unsigned short& w)
{ {
size_t lg; size_t lg;
lg = fread(&w, sizeof( WORD ), 1, pf ); lg = fread(&w, sizeof( unsigned short ), 1, pf );
return (lg == 1); return (lg == 1);
} }
BOOL WriteFloat(FILE* pf, float w) bool WriteFloat(FILE* pf, float w)
{ {
size_t lg; size_t lg;
@ -394,7 +394,7 @@ BOOL WriteFloat(FILE* pf, float w)
return (lg == 1); return (lg == 1);
} }
BOOL ReadFloat(FILE* pf, float& w) bool ReadFloat(FILE* pf, float& w)
{ {
size_t lg; size_t lg;
@ -403,7 +403,7 @@ BOOL ReadFloat(FILE* pf, float& w)
return (lg == 1); return (lg == 1);
} }
BOOL WriteLong(FILE* pf, long w) bool WriteLong(FILE* pf, long w)
{ {
size_t lg; size_t lg;
@ -412,7 +412,7 @@ BOOL WriteLong(FILE* pf, long w)
return (lg == 1); return (lg == 1);
} }
BOOL ReadLong(FILE* pf, long& w) bool ReadLong(FILE* pf, long& w)
{ {
size_t lg; size_t lg;
@ -421,24 +421,24 @@ BOOL ReadLong(FILE* pf, long& w)
return (lg == 1); return (lg == 1);
} }
BOOL WriteString(FILE* pf, CBotString s) bool WriteString(FILE* pf, CBotString s)
{ {
size_t lg1, lg2; size_t lg1, lg2;
lg1 = s.GivLength(); lg1 = s.GivLength();
if (!WriteWord(pf, lg1)) return FALSE; if (!WriteWord(pf, lg1)) return false;
lg2 = fwrite(s, 1, lg1, pf ); lg2 = fwrite(s, 1, lg1, pf );
return (lg1 == lg2); return (lg1 == lg2);
} }
BOOL ReadString(FILE* pf, CBotString& s) bool ReadString(FILE* pf, CBotString& s)
{ {
WORD w; unsigned short w;
char buf[1000]; char buf[1000];
size_t lg1, lg2; size_t lg1, lg2;
if (!ReadWord(pf, w)) return FALSE; if (!ReadWord(pf, w)) return false;
lg1 = w; lg1 = w;
lg2 = fread(buf, 1, lg1, pf ); lg2 = fread(buf, 1, lg1, pf );
buf[lg2] = 0; buf[lg2] = 0;
@ -447,29 +447,29 @@ BOOL ReadString(FILE* pf, CBotString& s)
return (lg1 == lg2); return (lg1 == lg2);
} }
BOOL WriteType(FILE* pf, CBotTypResult type) bool WriteType(FILE* pf, CBotTypResult type)
{ {
int typ = type.GivType(); int typ = type.GivType();
if ( typ == CBotTypIntrinsic ) typ = CBotTypClass; if ( typ == CBotTypIntrinsic ) typ = CBotTypClass;
if ( !WriteWord(pf, typ) ) return FALSE; if ( !WriteWord(pf, typ) ) return false;
if ( typ == CBotTypClass ) if ( typ == CBotTypClass )
{ {
CBotClass* p = type.GivClass(); CBotClass* p = type.GivClass();
if ( !WriteString(pf, p->GivName()) ) return FALSE; if ( !WriteString(pf, p->GivName()) ) return false;
} }
if ( type.Eq( CBotTypArrayBody ) || if ( type.Eq( CBotTypArrayBody ) ||
type.Eq( CBotTypArrayPointer ) ) type.Eq( CBotTypArrayPointer ) )
{ {
if ( !WriteWord(pf, type.GivLimite()) ) return FALSE; if ( !WriteWord(pf, type.GivLimite()) ) return false;
if ( !WriteType(pf, type.GivTypElem()) ) return FALSE; if ( !WriteType(pf, type.GivTypElem()) ) return false;
} }
return TRUE; return true;
} }
BOOL ReadType(FILE* pf, CBotTypResult& type) bool ReadType(FILE* pf, CBotTypResult& type)
{ {
WORD w, ww; unsigned short w, ww;
if ( !ReadWord(pf, w) ) return FALSE; if ( !ReadWord(pf, w) ) return false;
type.SetType(w); type.SetType(w);
if ( type.Eq( CBotTypIntrinsic ) ) if ( type.Eq( CBotTypIntrinsic ) )
@ -480,7 +480,7 @@ BOOL ReadType(FILE* pf, CBotTypResult& type)
if ( type.Eq( CBotTypClass ) ) if ( type.Eq( CBotTypClass ) )
{ {
CBotString s; CBotString s;
if ( !ReadString(pf, s) ) return FALSE; if ( !ReadString(pf, s) ) return false;
type = CBotTypResult( w, s ); type = CBotTypResult( w, s );
} }
@ -488,54 +488,54 @@ BOOL ReadType(FILE* pf, CBotTypResult& type)
type.Eq( CBotTypArrayBody ) ) type.Eq( CBotTypArrayBody ) )
{ {
CBotTypResult r; CBotTypResult r;
if ( !ReadWord(pf, ww) ) return FALSE; if ( !ReadWord(pf, ww) ) return false;
if ( !ReadType(pf, r) ) return FALSE; if ( !ReadType(pf, r) ) return false;
type = CBotTypResult( w, r ); type = CBotTypResult( w, r );
type.SetLimite((short)ww); type.SetLimite((short)ww);
} }
return TRUE; return true;
} }
BOOL CBotProgram::DefineNum(const char* name, long val) bool CBotProgram::DefineNum(const char* name, long val)
{ {
return CBotToken::DefineNum(name, val); return CBotToken::DefineNum(name, val);
} }
BOOL CBotProgram::SaveState(FILE* pf) bool CBotProgram::SaveState(FILE* pf)
{ {
if (!WriteWord( pf, CBOTVERSION)) return FALSE; if (!WriteWord( pf, CBOTVERSION)) return false;
if ( m_pStack != NULL ) if ( m_pStack != NULL )
{ {
if (!WriteWord( pf, 1)) return FALSE; if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, m_pRun->GivName() )) return FALSE; if (!WriteString( pf, m_pRun->GivName() )) return false;
if (!m_pStack->SaveState(pf)) return FALSE; if (!m_pStack->SaveState(pf)) return false;
} }
else else
{ {
if (!WriteWord( pf, 0)) return FALSE; if (!WriteWord( pf, 0)) return false;
} }
return TRUE; return true;
} }
BOOL CBotProgram::RestoreState(FILE* pf) bool CBotProgram::RestoreState(FILE* pf)
{ {
WORD w; unsigned short w;
CBotString s; CBotString s;
Stop(); Stop();
if (!ReadWord( pf, w )) return FALSE; if (!ReadWord( pf, w )) return false;
if ( w != CBOTVERSION ) return FALSE; if ( w != CBOTVERSION ) return false;
if (!ReadWord( pf, w )) return FALSE; if (!ReadWord( pf, w )) return false;
if ( w == 0 ) return TRUE; if ( w == 0 ) return true;
if (!ReadString( pf, s )) return FALSE; if (!ReadString( pf, s )) return false;
Start(s); // point de reprise Start(s); // point de reprise
#if STACKMEM #if STACKMEM
@ -547,12 +547,12 @@ BOOL CBotProgram::RestoreState(FILE* pf)
// récupère la pile depuis l'enregistrement // récupère la pile depuis l'enregistrement
// utilise un pointeur NULL (m_pStack) mais c'est ok comme ça // utilise un pointeur NULL (m_pStack) mais c'est ok comme ça
if (!m_pStack->RestoreState(pf, m_pStack)) return FALSE; if (!m_pStack->RestoreState(pf, m_pStack)) return false;
m_pStack->SetBotCall(this); // bases pour les routines m_pStack->SetBotCall(this); // bases pour les routines
// rétabli certains états dans la pile selon la structure // rétabli certains états dans la pile selon la structure
m_pRun->RestoreState(NULL, m_pStack, m_pInstance); m_pRun->RestoreState(NULL, m_pStack, m_pInstance);
return TRUE; return true;
} }
int CBotProgram::GivVersion() int CBotProgram::GivVersion()
@ -566,7 +566,7 @@ int CBotProgram::GivVersion()
CBotCall* CBotCall::m_ListCalls = NULL; CBotCall* CBotCall::m_ListCalls = NULL;
CBotCall::CBotCall(const char* name, CBotCall::CBotCall(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
{ {
m_name = name; m_name = name;
@ -587,8 +587,8 @@ void CBotCall::Free()
delete CBotCall::m_ListCalls; delete CBotCall::m_ListCalls;
} }
BOOL CBotCall::AddFunction(const char* name, bool CBotCall::AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser)) CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
{ {
CBotCall* p = m_ListCalls; CBotCall* p = m_ListCalls;
@ -616,18 +616,18 @@ BOOL CBotCall::AddFunction(const char* name,
if (p) p->m_next = pp; if (p) p->m_next = pp;
else m_ListCalls = pp; else m_ListCalls = pp;
return TRUE; return true;
} }
// transforme le tableau de pointeurs aux variables // transforme le tableau de pointeurs aux variables
// en une liste de variables chaînées // en une liste de variables chaînées
CBotVar* MakeListVars(CBotVar** ppVars, BOOL bSetVal=FALSE) CBotVar* MakeListVars(CBotVar** ppVars, bool bSetVal=false)
{ {
int i = 0; int i = 0;
CBotVar* pVar = NULL; CBotVar* pVar = NULL;
while( TRUE ) while( true )
{ {
ppVars[i]; ppVars[i];
if ( ppVars[i] == NULL ) break; if ( ppVars[i] == NULL ) break;
@ -686,16 +686,16 @@ void CBotCall::SetPUser(void* pUser)
m_pUser = pUser; m_pUser = pUser;
} }
int CBotCall::CheckCall(const char* name) bool CBotCall::CheckCall(const char* name)
{ {
CBotCall* p = m_ListCalls; CBotCall* p = m_ListCalls;
while ( p != NULL ) while ( p != NULL )
{ {
if ( name == p->GivName() ) return TRUE; if ( name == p->GivName() ) return true;
p = p->m_next; p = p->m_next;
} }
return FALSE; return false;
} }
@ -746,7 +746,7 @@ fund:
#if !STACKRUN #if !STACKRUN
// fait la liste des paramètres selon le contenu de la pile (pStackVar) // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVar, TRUE); CBotVar* pVar = MakeListVars(ppVar, true);
CBotVar* pVarToDelete = pVar; CBotVar* pVarToDelete = pVar;
// crée une variable pour le résultat // crée une variable pour le résultat
@ -759,14 +759,14 @@ fund:
if ( pResult != pRes ) delete pRes; // si résultat différent rendu if ( pResult != pRes ) delete pRes; // si résultat différent rendu
delete pVarToDelete; delete pVarToDelete;
if (res == FALSE) if (res == false)
{ {
if (Exception!=0) if (Exception!=0)
{ {
pStack->SetError(Exception, token); pStack->SetError(Exception, token);
} }
delete pResult; delete pResult;
return FALSE; return false;
} }
pStack->SetVar(pResult); pStack->SetVar(pResult);
@ -775,16 +775,16 @@ fund:
pStack->SetError(TX_NORETVAL, token); pStack->SetError(TX_NORETVAL, token);
} }
nIdent = pt->m_nFuncIdent; nIdent = pt->m_nFuncIdent;
return TRUE; return true;
#else #else
CBotStack* pile = pStack->AddStackEOX(pt); CBotStack* pile = pStack->AddStackEOX(pt);
if ( pile == EOX ) return TRUE; if ( pile == EOX ) return true;
// fait la liste des paramètres selon le contenu de la pile (pStackVar) // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVar, TRUE); CBotVar* pVar = MakeListVars(ppVar, true);
CBotVar* pVarToDelete = pVar; CBotVar* pVarToDelete = pVar;
// crée une variable pour le résultat // crée une variable pour le résultat
@ -804,7 +804,7 @@ fund:
#if STACKRUN #if STACKRUN
BOOL CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack) bool CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack)
{ {
CBotCall* pt = m_ListCalls; CBotCall* pt = m_ListCalls;
@ -817,22 +817,22 @@ BOOL CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBot
nIdent = pt->m_nFuncIdent; nIdent = pt->m_nFuncIdent;
CBotStack* pile = pStack->RestoreStackEOX(pt); CBotStack* pile = pStack->RestoreStackEOX(pt);
if ( pile == NULL ) return TRUE; if ( pile == NULL ) return true;
CBotStack* pile2 = pile->RestoreStack(); CBotStack* pile2 = pile->RestoreStack();
return TRUE; return true;
} }
pt = pt->m_next; pt = pt->m_next;
} }
} }
return FALSE; return false;
} }
BOOL CBotCall::Run(CBotStack* pStack) bool CBotCall::Run(CBotStack* pStack)
{ {
CBotStack* pile = pStack->AddStackEOX(this); CBotStack* pile = pStack->AddStackEOX(this);
if ( pile == EOX ) return TRUE; if ( pile == EOX ) return true;
CBotVar* pVar = pile->GivVar(); CBotVar* pVar = pile->GivVar();
CBotStack* pile2 = pile->AddStack(); CBotStack* pile2 = pile->AddStack();
@ -842,20 +842,20 @@ BOOL CBotCall::Run(CBotStack* pStack)
int Exception = 0; int Exception = 0;
int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser()); int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser());
if (res == FALSE) if (res == false)
{ {
if (Exception!=0) if (Exception!=0)
{ {
pStack->SetError(Exception); pStack->SetError(Exception);
} }
if ( pResult != pRes ) delete pResult; // si résultat différent rendu if ( pResult != pRes ) delete pResult; // si résultat différent rendu
return FALSE; return false;
} }
if ( pResult != NULL ) pStack->SetCopyVar( pResult ); if ( pResult != NULL ) pStack->SetCopyVar( pResult );
if ( pResult != pRes ) delete pResult; // si résultat différent rendu if ( pResult != pRes ) delete pResult; // si résultat différent rendu
return TRUE; return true;
} }
#endif #endif
@ -863,7 +863,7 @@ BOOL CBotCall::Run(CBotStack* pStack)
/////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////
CBotCallMethode::CBotCallMethode(const char* name, CBotCallMethode::CBotCallMethode(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar)) CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))
{ {
m_name = name; m_name = name;
@ -893,7 +893,7 @@ CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis,
{ {
if ( pt->m_name == name ) if ( pt->m_name == name )
{ {
CBotVar* pVar = MakeListVars(ppVar, TRUE); CBotVar* pVar = MakeListVars(ppVar, true);
CBotVar* pVar2 = pVar; CBotVar* pVar2 = pVar;
CBotTypResult r = pt->m_rComp(pThis, pVar2); CBotTypResult r = pt->m_rComp(pThis, pVar2);
int ret = r.GivType(); int ret = r.GivType();
@ -942,7 +942,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
{ {
// fait la liste des paramètres selon le contenu de la pile (pStackVar) // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVars, TRUE); CBotVar* pVar = MakeListVars(ppVars, true);
CBotVar* pVarToDelete = pVar; CBotVar* pVarToDelete = pVar;
// puis appelle la routine externe au module // puis appelle la routine externe au module
@ -951,7 +951,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
int res = pt->m_rExec(pThis, pVar, pResult, Exception); int res = pt->m_rExec(pThis, pVar, pResult, Exception);
pStack->SetVar(pResult); pStack->SetVar(pResult);
if (res == FALSE) if (res == false)
{ {
if (Exception!=0) if (Exception!=0)
{ {
@ -959,10 +959,10 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
pStack->SetError(Exception, pToken); pStack->SetError(Exception, pToken);
} }
delete pVarToDelete; delete pVarToDelete;
return FALSE; return false;
} }
delete pVarToDelete; delete pVarToDelete;
return TRUE; return true;
} }
pt = pt->m_next; pt = pt->m_next;
} }
@ -975,14 +975,14 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
{ {
// fait la liste des paramètres selon le contenu de la pile (pStackVar) // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVars, TRUE); CBotVar* pVar = MakeListVars(ppVars, true);
CBotVar* pVarToDelete = pVar; CBotVar* pVarToDelete = pVar;
int Exception = 0; int Exception = 0;
int res = pt->m_rExec(pThis, pVar, pResult, Exception); int res = pt->m_rExec(pThis, pVar, pResult, Exception);
pStack->SetVar(pResult); pStack->SetVar(pResult);
if (res == FALSE) if (res == false)
{ {
if (Exception!=0) if (Exception!=0)
{ {
@ -990,11 +990,11 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
pStack->SetError(Exception, pToken); pStack->SetError(Exception, pToken);
} }
delete pVarToDelete; delete pVarToDelete;
return FALSE; return false;
} }
delete pVarToDelete; delete pVarToDelete;
nIdent = pt->m_nFuncIdent; nIdent = pt->m_nFuncIdent;
return TRUE; return true;
} }
pt = pt->m_next; pt = pt->m_next;
} }
@ -1002,7 +1002,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
return -1; return -1;
} }
BOOL rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
if ( pVar == NULL ) return TX_LOWPARAM; if ( pVar == NULL ) return TX_LOWPARAM;
@ -1016,7 +1016,7 @@ BOOL rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
} }
pResult->SetValInt(i); pResult->SetValInt(i);
return TRUE; return true;
} }
CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser ) CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser )
@ -1030,11 +1030,11 @@ CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser )
CBotString CBotProgram::m_DebugVarStr = ""; CBotString CBotProgram::m_DebugVarStr = "";
BOOL rCBotDebug( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) 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 ) CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser )
@ -1103,7 +1103,8 @@ void CBotProgram::Init()
// une fonction juste pour les debug divers // une fonction juste pour les debug divers
CBotProgram::AddFunction("CBOTDEBUGDD", rCBotDebug, cCBotDebug); CBotProgram::AddFunction("CBOTDEBUGDD", rCBotDebug, cCBotDebug);
DeleteFile("CbotDebug.txt"); //TODO implement this deletion
// DeleteFile("CbotDebug.txt");
} }

288
src/CBot/CBotStack.cpp
View File

@ -16,6 +16,8 @@
// gestion de la pile (stack) // gestion de la pile (stack)
#include "CBot.h" #include "CBot.h"
#include <cstdlib>
#include <cstring>
#define ITIMER 100 #define ITIMER 100
@ -24,14 +26,14 @@
// gestion de la pile d'exécution // gestion de la pile d'exécution
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
int CBotStack::m_initimer = ITIMER; // init la variable statique int CBotStack::m_initimer = ITIMER;
int CBotStack::m_timer = 0; // init la variable statique int CBotStack::m_timer = 0;
CBotVar* CBotStack::m_retvar = NULL; // init la variable statique CBotVar* CBotStack::m_retvar = NULL;
int CBotStack::m_error = 0; // init la variable statique int CBotStack::m_error = 0;
int CBotStack::m_start = 0; // init la variable statique int CBotStack::m_start = 0;
int CBotStack::m_end = 0; // init la variable statique int CBotStack::m_end = 0;
CBotString CBotStack::m_labelBreak=""; // init la variable statique CBotString CBotStack::m_labelBreak="";
void* CBotStack::m_pUser = NULL; void* CBotStack::m_pUser = NULL;
#if STACKMEM #if STACKMEM
@ -48,7 +50,7 @@ CBotStack* CBotStack::FirstStack()
// la vide totalement // la vide totalement
memset(p, 0, size); memset(p, 0, size);
p-> m_bBlock = TRUE; p-> m_bBlock = true;
m_timer = m_initimer; // met le timer au début m_timer = m_initimer; // met le timer au début
CBotStack* pp = p; CBotStack* pp = p;
@ -56,7 +58,7 @@ CBotStack* CBotStack::FirstStack()
int i; int i;
for ( i = 0 ; i< 10 ; i++ ) for ( i = 0 ; i< 10 ; i++ )
{ {
pp->m_bOver = TRUE; pp->m_bOver = true;
pp ++; pp ++;
} }
#ifdef _DEBUG #ifdef _DEBUG
@ -75,8 +77,8 @@ CBotStack* CBotStack::FirstStack()
CBotStack::CBotStack(CBotStack* ppapa) CBotStack::CBotStack(CBotStack* ppapa)
{ {
// constructeur doit exister, sinon le destructeur n'est jamais appelé ! // constructor must exist or the destructor is never called!
ASM_TRAP(); ASM_TRAP();
} }
CBotStack::~CBotStack() CBotStack::~CBotStack()
@ -104,7 +106,7 @@ void CBotStack::Delete()
delete m_listVar; delete m_listVar;
CBotStack* p = m_prev; CBotStack* p = m_prev;
BOOL bOver = m_bOver; bool bOver = m_bOver;
#ifdef _DEBUG #ifdef _DEBUG
int n = m_index; int n = m_index;
#endif #endif
@ -122,7 +124,7 @@ void CBotStack::Delete()
// routine optimisée // routine optimisée
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock) CBotStack* CBotStack::AddStack(CBotInstr* instr, bool bBlock)
{ {
if (m_next != NULL) if (m_next != NULL)
{ {
@ -150,11 +152,11 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
p->m_prev = this; p->m_prev = this;
p->m_state = 0; p->m_state = 0;
p->m_call = NULL; p->m_call = NULL;
p->m_bFunc = FALSE; p->m_bFunc = false;
return p; return p;
} }
CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock) CBotStack* CBotStack::AddStackEOX(CBotCall* instr, bool bBlock)
{ {
if (m_next != NULL) if (m_next != NULL)
{ {
@ -171,7 +173,7 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)
return p; return p;
} }
CBotStack* CBotStack::AddStack2(BOOL bBlock) CBotStack* CBotStack::AddStack2(bool bBlock)
{ {
if (m_next2 != NULL) if (m_next2 != NULL)
{ {
@ -194,14 +196,14 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock)
return p; return p;
} }
BOOL CBotStack::GivBlock() bool CBotStack::GivBlock()
{ {
return m_bBlock; return m_bBlock;
} }
BOOL CBotStack::Return(CBotStack* pfils) bool CBotStack::Return(CBotStack* pfils)
{ {
if ( pfils == this ) return TRUE; // spécial if ( pfils == this ) return true; // spécial
if (m_var != NULL) delete m_var; // valeur remplacée ? if (m_var != NULL) delete m_var; // valeur remplacée ?
m_var = pfils->m_var; // résultat transmis m_var = pfils->m_var; // résultat transmis
@ -213,9 +215,9 @@ BOOL CBotStack::Return(CBotStack* pfils)
return (m_error == 0); // interrompu si erreur return (m_error == 0); // interrompu si erreur
} }
BOOL CBotStack::ReturnKeep(CBotStack* pfils) bool CBotStack::ReturnKeep(CBotStack* pfils)
{ {
if ( pfils == this ) return TRUE; // spécial if ( pfils == this ) return true; // spécial
if (m_var != NULL) delete m_var; // valeur remplacée ? if (m_var != NULL) delete m_var; // valeur remplacée ?
m_var = pfils->m_var; // résultat transmis m_var = pfils->m_var; // résultat transmis
@ -224,11 +226,11 @@ BOOL CBotStack::ReturnKeep(CBotStack* pfils)
return (m_error == 0); // interrompu si erreur return (m_error == 0); // interrompu si erreur
} }
BOOL CBotStack::StackOver() bool CBotStack::StackOver()
{ {
if (!m_bOver) return FALSE; if (!m_bOver) return false;
m_error = TX_STACKOVER; m_error = TX_STACKOVER;
return TRUE; return true;
} }
#else #else
@ -239,7 +241,7 @@ CBotStack::CBotStack(CBotStack* ppapa)
m_next2 = NULL; m_next2 = NULL;
m_prev = ppapa; m_prev = ppapa;
m_bBlock = (ppapa == NULL) ? TRUE : FALSE; m_bBlock = (ppapa == NULL) ? true : false;
m_state = 0; m_state = 0;
m_step = 1; m_step = 1;
@ -247,13 +249,13 @@ CBotStack::CBotStack(CBotStack* ppapa)
if (ppapa == NULL) m_timer = m_initimer; // met le timer au début if (ppapa == NULL) m_timer = m_initimer; // met le timer au début
m_listVar = NULL; m_listVar = NULL;
m_bDontDelete = FALSE; m_bDontDelete = false;
m_var = NULL; m_var = NULL;
m_prog = NULL; m_prog = NULL;
m_instr = NULL; m_instr = NULL;
m_call = NULL; m_call = NULL;
m_bFunc = FALSE; m_bFunc = false;
} }
// destructeur // destructeur
@ -269,7 +271,7 @@ CBotStack::~CBotStack()
} }
// routine à optimiser // routine à optimiser
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock) CBotStack* CBotStack::AddStack(CBotInstr* instr, bool bBlock)
{ {
if (m_next != NULL) if (m_next != NULL)
{ {
@ -284,7 +286,7 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
return p; return p;
} }
CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock) CBotStack* CBotStack::AddStackEOX(CBotCall* instr, bool bBlock)
{ {
if (m_next != NULL) if (m_next != NULL)
{ {
@ -305,7 +307,7 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)
return p; return p;
} }
CBotStack* CBotStack::AddStack2(BOOL bBlock) CBotStack* CBotStack::AddStack2(bool bBlock)
{ {
if (m_next2 != NULL) if (m_next2 != NULL)
{ {
@ -322,9 +324,9 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock)
return p; return p;
} }
BOOL CBotStack::Return(CBotStack* pfils) bool CBotStack::Return(CBotStack* pfils)
{ {
if ( pfils == this ) return TRUE; // spécial if ( pfils == this ) return true; // spécial
if (m_var != NULL) delete m_var; // valeur remplacée ? if (m_var != NULL) delete m_var; // valeur remplacée ?
m_var = pfils->m_var; // résultat transmis m_var = pfils->m_var; // résultat transmis
@ -336,9 +338,9 @@ BOOL CBotStack::Return(CBotStack* pfils)
return (m_error == 0); // interrompu si erreur return (m_error == 0); // interrompu si erreur
} }
BOOL CBotStack::StackOver() bool CBotStack::StackOver()
{ {
return FALSE; // pas de test de débordement dans cette version return false; // pas de test de débordement dans cette version
} }
#endif #endif
@ -377,38 +379,38 @@ CBotStack* CBotStack::RestoreStackEOX(CBotCall* instr)
// routine pour l'exécution pas à pas // routine pour l'exécution pas à pas
BOOL CBotStack::IfStep() bool CBotStack::IfStep()
{ {
if ( m_initimer > 0 || m_step++ > 0 ) return FALSE; if ( m_initimer > 0 || m_step++ > 0 ) return false;
return TRUE; return true;
} }
BOOL CBotStack::BreakReturn(CBotStack* pfils, const char* name) bool CBotStack::BreakReturn(CBotStack* pfils, const char* name)
{ {
if ( m_error>=0 ) return FALSE; // sortie normale if ( m_error>=0 ) return false; // sortie normale
if ( m_error==-3 ) return FALSE; // sortie normale (return en cours) if ( m_error==-3 ) return false; // sortie normale (return en cours)
if (!m_labelBreak.IsEmpty() && (name[0] == 0 || m_labelBreak != name)) if (!m_labelBreak.IsEmpty() && (name[0] == 0 || m_labelBreak != name))
return FALSE; // c'est pas pour moi return false; // c'est pas pour moi
m_error = 0; m_error = 0;
m_labelBreak.Empty(); m_labelBreak.Empty();
return Return(pfils); return Return(pfils);
} }
BOOL CBotStack::IfContinue(int state, const char* name) bool CBotStack::IfContinue(int state, const char* name)
{ {
if ( m_error != -2 ) return FALSE; if ( m_error != -2 ) return false;
if (!m_labelBreak.IsEmpty() && (name == NULL || m_labelBreak != name)) if (!m_labelBreak.IsEmpty() && (name == NULL || m_labelBreak != name))
return FALSE; // c'est pas pour moi return false; // c'est pas pour moi
m_state = state; // où reprendre ? m_state = state; // où reprendre ?
m_error = 0; m_error = 0;
m_labelBreak.Empty(); m_labelBreak.Empty();
if ( m_next != EOX ) m_next->Delete(); // purge la pile au dessus if ( m_next != EOX ) m_next->Delete(); // purge la pile au dessus
return TRUE; return true;
} }
void CBotStack::SetBreak(int val, const char* name) void CBotStack::SetBreak(int val, const char* name)
@ -424,7 +426,7 @@ void CBotStack::SetBreak(int val, const char* name)
// remet sur la pile la valeur calculée par le dernier CBotReturn // remet sur la pile la valeur calculée par le dernier CBotReturn
BOOL CBotStack::GivRetVar(BOOL bRet) bool CBotStack::GivRetVar(bool bRet)
{ {
if (m_error == -3) if (m_error == -3)
{ {
@ -432,7 +434,7 @@ BOOL CBotStack::GivRetVar(BOOL bRet)
m_var = m_retvar; m_var = m_retvar;
m_retvar = NULL; m_retvar = NULL;
m_error = 0; m_error = 0;
return TRUE; return true;
} }
return bRet; // interrompu par autre chose que return return bRet; // interrompu par autre chose que return
} }
@ -469,7 +471,7 @@ void CBotStack::SetType(CBotTypResult& type)
// trouve une variable par son token // trouve une variable par son token
// ce peut être une variable composée avec un point // ce peut être une variable composée avec un point
CBotVar* CBotStack::FindVar(CBotToken* &pToken, BOOL bUpdate, BOOL bModif) CBotVar* CBotStack::FindVar(CBotToken* &pToken, bool bUpdate, bool bModif)
{ {
CBotStack* p = this; CBotStack* p = this;
CBotString name = pToken->GivString(); CBotString name = pToken->GivString();
@ -482,7 +484,7 @@ CBotVar* CBotStack::FindVar(CBotToken* &pToken, BOOL bUpdate, BOOL bModif)
if (pp->GivName() == name) if (pp->GivName() == name)
{ {
if ( bUpdate ) if ( bUpdate )
pp->Maj(m_pUser, FALSE); pp->Maj(m_pUser, false);
return pp; return pp;
} }
@ -515,7 +517,7 @@ CBotVar* CBotStack::FindVar(const char* name)
// retrouve une variable sur la pile selon son numéro d'identification // retrouve une variable sur la pile selon son numéro d'identification
// ce qui va plus vite que de comparer les noms. // ce qui va plus vite que de comparer les noms.
CBotVar* CBotStack::FindVar(long ident, BOOL bUpdate, BOOL bModif) CBotVar* CBotStack::FindVar(long ident, bool bUpdate, bool bModif)
{ {
CBotStack* p = this; CBotStack* p = this;
while (p != NULL) while (p != NULL)
@ -526,7 +528,7 @@ CBotVar* CBotStack::FindVar(long ident, BOOL bUpdate, BOOL bModif)
if (pp->GivUniqNum() == ident) if (pp->GivUniqNum() == ident)
{ {
if ( bUpdate ) if ( bUpdate )
pp->Maj(m_pUser, FALSE); pp->Maj(m_pUser, false);
return pp; return pp;
} }
@ -538,14 +540,14 @@ CBotVar* CBotStack::FindVar(long ident, BOOL bUpdate, BOOL bModif)
} }
CBotVar* CBotStack::FindVar(CBotToken& Token, BOOL bUpdate, BOOL bModif) CBotVar* CBotStack::FindVar(CBotToken& Token, bool bUpdate, bool bModif)
{ {
CBotToken* pt = &Token; CBotToken* pt = &Token;
return FindVar(pt, bUpdate, bModif); return FindVar(pt, bUpdate, bModif);
} }
CBotVar* CBotStack::CopyVar(CBotToken& Token, BOOL bUpdate) CBotVar* CBotStack::CopyVar(CBotToken& Token, bool bUpdate)
{ {
CBotVar* pVar = FindVar( Token, bUpdate ); CBotVar* pVar = FindVar( Token, bUpdate );
@ -557,7 +559,7 @@ CBotVar* CBotStack::CopyVar(CBotToken& Token, BOOL bUpdate)
} }
BOOL CBotStack::SetState(int n, int limite) bool CBotStack::SetState(int n, int limite)
{ {
m_state = n; m_state = n;
@ -565,7 +567,7 @@ BOOL CBotStack::SetState(int n, int limite)
return ( m_timer > limite ); // interrompu si timer passé return ( m_timer > limite ); // interrompu si timer passé
} }
BOOL CBotStack::IncState(int limite) bool CBotStack::IncState(int limite)
{ {
m_state++; m_state++;
@ -603,7 +605,7 @@ void CBotStack::SetTimer(int n)
m_initimer = n; m_initimer = n;
} }
BOOL CBotStack::Execute() bool CBotStack::Execute()
{ {
CBotCall* instr = NULL; // instruction la plus élevée CBotCall* instr = NULL; // instruction la plus élevée
CBotStack* pile; CBotStack* pile;
@ -621,9 +623,9 @@ BOOL CBotStack::Execute()
p = p->m_next; p = p->m_next;
} }
if ( instr == NULL ) return TRUE; // exécution normale demandée if ( instr == NULL ) return true; // exécution normale demandée
if (!instr->Run(pile)) return FALSE; // exécution à partir de là if (!instr->Run(pile)) return false; // exécution à partir de là
#if STACKMEM #if STACKMEM
pile->m_next->Delete(); pile->m_next->Delete();
@ -632,7 +634,7 @@ BOOL CBotStack::Execute()
#endif #endif
pile->m_next = EOX; // spécial pour reprise pile->m_next = EOX; // spécial pour reprise
return TRUE; return true;
} }
// met sur le stack le pointeur à une variable // met sur le stack le pointeur à une variable
@ -711,10 +713,10 @@ void CBotStack::AddVar(CBotVar* pVar)
void CBotStack::SetBotCall(CBotProgram* p) void CBotStack::SetBotCall(CBotProgram* p)
{ {
m_prog = p; m_prog = p;
m_bFunc = TRUE; m_bFunc = true;
} }
CBotProgram* CBotStack::GivBotCall(BOOL bFirst) CBotProgram* CBotStack::GivBotCall(bool bFirst)
{ {
if ( ! bFirst ) return m_prog; if ( ! bFirst ) return m_prog;
CBotStack* p = this; CBotStack* p = this;
@ -728,7 +730,7 @@ void* CBotStack::GivPUser()
} }
BOOL CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype) bool CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype)
{ {
CBotTypResult res; CBotTypResult res;
@ -750,7 +752,7 @@ BOOL CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBo
if (res.GivType() >= 0) return res.GivType(); if (res.GivType() >= 0) return res.GivType();
SetError(TX_NOCALL, token); SetError(TX_NOCALL, token);
return TRUE; return true;
} }
void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar) void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)
@ -762,17 +764,17 @@ void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)
} }
BOOL SaveVar(FILE* pf, CBotVar* pVar) bool SaveVar(FILE* pf, CBotVar* pVar)
{ {
while ( TRUE ) while ( true )
{ {
if ( pVar == NULL ) if ( pVar == NULL )
{ {
return WriteWord(pf, 0); // met un terminateur return WriteWord(pf, 0); // met un terminateur
} }
if ( !pVar->Save0State(pf)) return FALSE; // entête commune if ( !pVar->Save0State(pf)) return false; // entête commune
if ( !pVar->Save1State(pf) ) return FALSE; // sauve selon la classe fille if ( !pVar->Save1State(pf) ) return false; // sauve selon la classe fille
pVar = pVar->GivNext(); pVar = pVar->GivNext();
} }
@ -856,7 +858,7 @@ CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level)
return p->m_listVar; return p->m_listVar;
} }
BOOL CBotStack::SaveState(FILE* pf) bool CBotStack::SaveState(FILE* pf)
{ {
if ( this == NULL ) // fin de l'arbre ? if ( this == NULL ) // fin de l'arbre ?
{ {
@ -865,33 +867,33 @@ BOOL CBotStack::SaveState(FILE* pf)
if ( m_next2 != NULL ) if ( m_next2 != NULL )
{ {
if (!WriteWord(pf, 2)) return FALSE; // une marque de poursuite if (!WriteWord(pf, 2)) return false; // une marque de poursuite
if (!m_next2->SaveState(pf)) return FALSE; if (!m_next2->SaveState(pf)) return false;
} }
else else
{ {
if (!WriteWord(pf, 1)) return FALSE; // une marque de poursuite if (!WriteWord(pf, 1)) return false; // une marque de poursuite
} }
if (!WriteWord(pf, m_bBlock)) return FALSE; // est-ce un bloc local if (!WriteWord(pf, m_bBlock)) return false; // est-ce un bloc local
if (!WriteWord(pf, m_state)) return FALSE; // dans quel état if (!WriteWord(pf, m_state)) return false; // dans quel état
if (!WriteWord(pf, 0)) return FALSE; // par compatibilité m_bDontDelete if (!WriteWord(pf, 0)) return false; // par compatibilité m_bDontDelete
if (!WriteWord(pf, m_step)) return FALSE; // dans quel état if (!WriteWord(pf, m_step)) return false; // dans quel état
if (!SaveVar(pf, m_var)) return FALSE; // le résultat courant if (!SaveVar(pf, m_var)) return false; // le résultat courant
if (!SaveVar(pf, m_listVar)) return FALSE; // les variables locales if (!SaveVar(pf, m_listVar)) return false; // les variables locales
return m_next->SaveState(pf); // enregistre la suite return m_next->SaveState(pf); // enregistre la suite
} }
BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack) bool CBotStack::RestoreState(FILE* pf, CBotStack* &pStack)
{ {
WORD w; unsigned short w;
pStack = NULL; pStack = NULL;
if (!ReadWord(pf, w)) return FALSE; if (!ReadWord(pf, w)) return false;
if ( w == 0 ) return TRUE; if ( w == 0 ) return true;
#if STACKMEM #if STACKMEM
if ( this == NULL ) pStack = FirstStack(); if ( this == NULL ) pStack = FirstStack();
@ -902,81 +904,81 @@ BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack)
if ( w == 2 ) if ( w == 2 )
{ {
if (!pStack->RestoreState(pf, pStack->m_next2)) return FALSE; if (!pStack->RestoreState(pf, pStack->m_next2)) return false;
} }
if (!ReadWord(pf, w)) return FALSE; // est-ce un bloc local if (!ReadWord(pf, w)) return false; // est-ce un bloc local
pStack->m_bBlock = w; pStack->m_bBlock = w;
if (!ReadWord(pf, w)) return FALSE; // dans quel état j'ère ? if (!ReadWord(pf, w)) return false; // dans quel état j'ère ?
pStack->SetState((short)w); // dans le bon état pStack->SetState((short)w); // dans le bon état
if (!ReadWord(pf, w)) return FALSE; // dont delete ? if (!ReadWord(pf, w)) return false; // dont delete ?
// plus utilisé // plus utilisé
if (!ReadWord(pf, w)) return FALSE; // pas à pas if (!ReadWord(pf, w)) return false; // pas à pas
pStack->m_step = w; pStack->m_step = w;
if (!CBotVar::RestoreState(pf, pStack->m_var)) return FALSE; // la variable temp if (!CBotVar::RestoreState(pf, pStack->m_var)) return false; // la variable temp
if (!CBotVar::RestoreState(pf, pStack->m_listVar)) return FALSE;// les variables locales if (!CBotVar::RestoreState(pf, pStack->m_listVar)) return false;// les variables locales
return pStack->RestoreState(pf, pStack->m_next); return pStack->RestoreState(pf, pStack->m_next);
} }
BOOL CBotVar::Save0State(FILE* pf) bool CBotVar::Save0State(FILE* pf)
{ {
if (!WriteWord(pf, 100+m_mPrivate))return FALSE; // variable privée ? if (!WriteWord(pf, 100+m_mPrivate))return false; // variable privée ?
if (!WriteWord(pf, m_bStatic))return FALSE; // variable static ? if (!WriteWord(pf, m_bStatic))return false; // variable static ?
if (!WriteWord(pf, m_type.GivType()))return FALSE; // enregiste le type (toujours non nul) if (!WriteWord(pf, m_type.GivType()))return false; // enregiste le type (toujours non nul)
if (!WriteWord(pf, m_binit))return FALSE; // variable définie ? if (!WriteWord(pf, m_binit))return false; // variable définie ?
return WriteString(pf, m_token->GivString()); // et le nom de la variable return WriteString(pf, m_token->GivString()); // et le nom de la variable
} }
BOOL CBotVarInt::Save0State(FILE* pf) bool CBotVarInt::Save0State(FILE* pf)
{ {
if ( !m_defnum.IsEmpty() ) if ( !m_defnum.IsEmpty() )
{ {
if(!WriteWord(pf, 200 )) return FALSE; // marqueur spécial if(!WriteWord(pf, 200 )) return false; // marqueur spécial
if(!WriteString(pf, m_defnum)) return FALSE; // nom de la valeur if(!WriteString(pf, m_defnum)) return false; // nom de la valeur
} }
return CBotVar::Save0State(pf); return CBotVar::Save0State(pf);
} }
BOOL CBotVarInt::Save1State(FILE* pf) bool CBotVarInt::Save1State(FILE* pf)
{ {
return WriteWord(pf, m_val); // la valeur de la variable return WriteWord(pf, m_val); // la valeur de la variable
} }
BOOL CBotVarBoolean::Save1State(FILE* pf) bool CBotVarBoolean::Save1State(FILE* pf)
{ {
return WriteWord(pf, m_val); // la valeur de la variable return WriteWord(pf, m_val); // la valeur de la variable
} }
BOOL CBotVarFloat::Save1State(FILE* pf) bool CBotVarFloat::Save1State(FILE* pf)
{ {
return WriteFloat(pf, m_val); // la valeur de la variable return WriteFloat(pf, m_val); // la valeur de la variable
} }
BOOL CBotVarString::Save1State(FILE* pf) bool CBotVarString::Save1State(FILE* pf)
{ {
return WriteString(pf, m_val); // la valeur de la variable return WriteString(pf, m_val); // la valeur de la variable
} }
BOOL CBotVarClass::Save1State(FILE* pf) bool CBotVarClass::Save1State(FILE* pf)
{ {
if ( !WriteType(pf, m_type) ) return FALSE; if ( !WriteType(pf, m_type) ) return false;
if ( !WriteLong(pf, m_ItemIdent) ) return FALSE; if ( !WriteLong(pf, m_ItemIdent) ) return false;
return SaveVar(pf, m_pVar); // contenu de l'objet return SaveVar(pf, m_pVar); // contenu de l'objet
} }
BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) bool CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
{ {
WORD w, wi, prv, st; unsigned short w, wi, prv, st;
float ww; float ww;
CBotString name, s; CBotString name, s;
@ -986,31 +988,31 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
CBotVar* pNew = NULL; CBotVar* pNew = NULL;
CBotVar* pPrev = NULL; CBotVar* pPrev = NULL;
while ( TRUE ) // recupère toute une liste while ( true ) // recupère toute une liste
{ {
if (!ReadWord(pf, w)) return FALSE; // privé ou type ? if (!ReadWord(pf, w)) return false; // privé ou type ?
if ( w == 0 ) return TRUE; if ( w == 0 ) return true;
CBotString defnum; CBotString defnum;
if ( w == 200 ) if ( w == 200 )
{ {
if (!ReadString(pf, defnum)) return FALSE; // nombre avec un identifiant if (!ReadString(pf, defnum)) return false; // nombre avec un identifiant
if (!ReadWord(pf, w)) return FALSE; // type if (!ReadWord(pf, w)) return false; // type
} }
prv = 100; st = 0; prv = 100; st = 0;
if ( w >= 100 ) if ( w >= 100 )
{ {
prv = w; prv = w;
if (!ReadWord(pf, st)) return FALSE; // statique if (!ReadWord(pf, st)) return false; // statique
if (!ReadWord(pf, w)) return FALSE; // type if (!ReadWord(pf, w)) return false; // type
} }
if ( w == CBotTypClass ) w = CBotTypIntrinsic; // forcément intrinsèque if ( w == CBotTypClass ) w = CBotTypIntrinsic; // forcément intrinsèque
if (!ReadWord(pf, wi)) return FALSE; // init ? if (!ReadWord(pf, wi)) return false; // init ?
if (!ReadString(pf, name)) return FALSE; // nom de la variable if (!ReadString(pf, name)) return false; // nom de la variable
CBotToken token(name, CBotString()); CBotToken token(name, CBotString());
@ -1019,17 +1021,17 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
case CBotTypInt: case CBotTypInt:
case CBotTypBoolean: case CBotTypBoolean:
pNew = CBotVar::Create(&token, w); // crée une variable pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadWord(pf, w)) return FALSE; if (!ReadWord(pf, w)) return false;
pNew->SetValInt((short)w, defnum); pNew->SetValInt((short)w, defnum);
break; break;
case CBotTypFloat: case CBotTypFloat:
pNew = CBotVar::Create(&token, w); // crée une variable pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadFloat(pf, ww)) return FALSE; if (!ReadFloat(pf, ww)) return false;
pNew->SetValFloat(ww); pNew->SetValFloat(ww);
break; break;
case CBotTypString: case CBotTypString:
pNew = CBotVar::Create(&token, w); // crée une variable pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadString(pf, s)) return FALSE; if (!ReadString(pf, s)) return false;
pNew->SetValString(s); pNew->SetValString(s);
break; break;
@ -1039,17 +1041,17 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
{ {
CBotTypResult r; CBotTypResult r;
long id; long id;
if (!ReadType(pf, r)) return FALSE; // type complet if (!ReadType(pf, r)) return false; // type complet
if (!ReadLong(pf, id) ) return FALSE; if (!ReadLong(pf, id) ) return false;
// if (!ReadString(pf, s)) return FALSE; // if (!ReadString(pf, s)) return false;
{ {
CBotVar* p = NULL; CBotVar* p = NULL;
if ( id ) p = CBotVarClass::Find(id) ; if ( id ) p = CBotVarClass::Find(id) ;
pNew = new CBotVarClass(&token, r); // crée directement une instance pNew = new CBotVarClass(&token, r); // crée directement une instance
// attention cptuse = 0 // attention cptuse = 0
if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return FALSE; if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return false;
pNew->SetIdent(id); pNew->SetIdent(id);
if ( p != NULL ) if ( p != NULL )
@ -1063,7 +1065,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
case CBotTypPointer: case CBotTypPointer:
case CBotTypNullPointer: case CBotTypNullPointer:
if (!ReadString(pf, s)) return FALSE; if (!ReadString(pf, s)) return false;
{ {
pNew = CBotVar::Create(&token, CBotTypResult(w, s));// crée une variable pNew = CBotVar::Create(&token, CBotTypResult(w, s));// crée une variable
CBotVarClass* p = NULL; CBotVarClass* p = NULL;
@ -1073,7 +1075,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
// restitue une copie de l'instance d'origine // restitue une copie de l'instance d'origine
CBotVar* pInstance = NULL; CBotVar* pInstance = NULL;
if ( !CBotVar::RestoreState( pf, pInstance ) ) return FALSE; if ( !CBotVar::RestoreState( pf, pInstance ) ) return false;
((CBotVarPointer*)pNew)->SetPointer( pInstance ); // et pointe dessus ((CBotVarPointer*)pNew)->SetPointer( pInstance ); // et pointe dessus
// if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p ); // plutôt celui-ci ! // if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p ); // plutôt celui-ci !
@ -1084,13 +1086,13 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
case CBotTypArrayPointer: case CBotTypArrayPointer:
{ {
CBotTypResult r; CBotTypResult r;
if (!ReadType(pf, r)) return FALSE; if (!ReadType(pf, r)) return false;
pNew = CBotVar::Create(&token, r); // crée une variable pNew = CBotVar::Create(&token, r); // crée une variable
// restitue une copie de l'instance d'origine // restitue une copie de l'instance d'origine
CBotVar* pInstance = NULL; CBotVar* pInstance = NULL;
if ( !CBotVar::RestoreState( pf, pInstance ) ) return FALSE; if ( !CBotVar::RestoreState( pf, pInstance ) ) return false;
((CBotVarPointer*)pNew)->SetPointer( pInstance ); // et pointe dessus ((CBotVarPointer*)pNew)->SetPointer( pInstance ); // et pointe dessus
} }
break; break;
@ -1106,7 +1108,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
pNew->SetPrivate(prv-100); pNew->SetPrivate(prv-100);
pPrev = pNew; pPrev = pNew;
} }
return TRUE; return true;
} }
@ -1133,12 +1135,12 @@ CBotCStack::CBotCStack(CBotCStack* ppapa)
m_error = 0; m_error = 0;
m_start = 0; m_start = 0;
m_end = 0; m_end = 0;
m_bBlock = TRUE; m_bBlock = true;
} }
else else
{ {
m_start = ppapa->m_start; m_start = ppapa->m_start;
m_bBlock = FALSE; m_bBlock = false;
} }
m_listVar = NULL; m_listVar = NULL;
@ -1156,7 +1158,7 @@ CBotCStack::~CBotCStack()
} }
// utilisé uniquement à la compilation // utilisé uniquement à la compilation
CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, BOOL bBlock) CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, bool bBlock)
{ {
if (m_next != NULL) return m_next; // reprise dans une pile existante if (m_next != NULL) return m_next; // reprise dans une pile existante
@ -1291,7 +1293,7 @@ CBotVar* CBotCStack::CopyVar(CBotToken& Token)
return pCopy; return pCopy;
} }
BOOL CBotCStack::IsOk() bool CBotCStack::IsOk()
{ {
return (m_error == 0); return (m_error == 0);
} }
@ -1325,15 +1327,15 @@ void CBotCStack::ResetError(int n, int start, int end)
m_end = end; m_end = end;
} }
BOOL CBotCStack::NextToken(CBotToken* &p) bool CBotCStack::NextToken(CBotToken* &p)
{ {
CBotToken* pp = p; CBotToken* pp = p;
p = p->GivNext(); p = p->GivNext();
if (p!=NULL) return TRUE; if (p!=NULL) return true;
SetError(TX_ENDOF, pp->GivEnd()); SetError(TX_ENDOF, pp->GivEnd());
return FALSE; return false;
} }
void CBotCStack::SetBotCall(CBotProgram* p) void CBotCStack::SetBotCall(CBotProgram* p)
@ -1398,7 +1400,7 @@ void CBotCStack::AddVar(CBotVar* pVar)
// test si une variable est déjà définie localement // test si une variable est déjà définie localement
BOOL CBotCStack::CheckVarLocal(CBotToken* &pToken) bool CBotCStack::CheckVarLocal(CBotToken* &pToken)
{ {
CBotCStack* p = this; CBotCStack* p = this;
CBotString name = pToken->GivString(); CBotString name = pToken->GivString();
@ -1409,13 +1411,13 @@ BOOL CBotCStack::CheckVarLocal(CBotToken* &pToken)
while ( pp != NULL) while ( pp != NULL)
{ {
if (name == pp->GivName()) if (name == pp->GivName())
return TRUE; return true;
pp = pp->m_next; pp = pp->m_next;
} }
if ( p->m_bBlock ) return FALSE; if ( p->m_bBlock ) return false;
p = p->m_prev; p = p->m_prev;
} }
return FALSE; return false;
} }
CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent) CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent)
@ -1440,11 +1442,11 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId
// test si un nom de procédure est déjà défini quelque part // test si un nom de procédure est déjà défini quelque part
BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{ {
CBotString name = pToken->GivString(); CBotString name = pToken->GivString();
if ( CBotCall::CheckCall(name) ) return TRUE; if ( CBotCall::CheckCall(name) ) return true;
CBotFunction* pp = m_prog->GivFunctions(); CBotFunction* pp = m_prog->GivFunctions();
while ( pp != NULL ) while ( pp != NULL )
@ -1453,7 +1455,7 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{ {
// les paramètres sont-ils exactement les mêmes ? // les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) ) if ( pp->CheckParam( pParam ) )
return TRUE; return true;
} }
pp = pp->Next(); pp = pp->Next();
} }
@ -1465,11 +1467,11 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{ {
// les paramètres sont-ils exactement les mêmes ? // les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) ) if ( pp->CheckParam( pParam ) )
return TRUE; return true;
} }
pp = pp->m_nextpublic; pp = pp->m_nextpublic;
} }
return FALSE; return false;
} }

104
src/CBot/CBotString.cpp
View File

@ -19,9 +19,11 @@
#include "CBot.h" #include "CBot.h"
#include <string.h> #include <cstdlib>
#include <cstring>
HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("libCbot.dll"); // comment le récupérer autrement ?? #include <algorithm>
/// TODO need to be implemented to be able to load library
// HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("libCbot.dll"); // how to retrieve it otherwise ??
CBotString::CBotString() CBotString::CBotString()
@ -38,13 +40,13 @@ CBotString::~CBotString()
CBotString::CBotString(const char* p) CBotString::CBotString(const char* p)
{ {
m_lg = lstrlen( p ); m_lg = strlen( p );
m_ptr = NULL; m_ptr = NULL;
if (m_lg>0) if (m_lg>0)
{ {
m_ptr = (char*)malloc(m_lg+1); m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, p); strcpy(m_ptr, p);
} }
} }
@ -56,7 +58,7 @@ CBotString::CBotString(const CBotString& srcString)
if (m_lg>0) if (m_lg>0)
{ {
m_ptr = (char*)malloc(m_lg+1); m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, srcString.m_ptr); strcpy(m_ptr, srcString.m_ptr);
} }
} }
@ -66,7 +68,7 @@ CBotString::CBotString(const CBotString& srcString)
int CBotString::GivLength() int CBotString::GivLength()
{ {
if ( m_ptr == NULL ) return 0; if ( m_ptr == NULL ) return 0;
return lstrlen( m_ptr ); return strlen( m_ptr );
} }
@ -143,10 +145,10 @@ int CBotString::Find(const char c)
return -1; return -1;
} }
int CBotString::Find(LPCTSTR lpsz) int CBotString::Find(const char * lpsz)
{ {
int i, j; int i, j;
int l = lstrlen(lpsz); int l = strlen(lpsz);
for (i = 0; i <= m_lg-l; i++) for (i = 0; i <= m_lg-l; i++)
{ {
@ -170,10 +172,10 @@ int CBotString::ReverseFind(const char c)
return -1; return -1;
} }
int CBotString::ReverseFind(LPCTSTR lpsz) int CBotString::ReverseFind(const char * lpsz)
{ {
int i, j; int i, j;
int l = lstrlen(lpsz); int l = strlen(lpsz);
for (i = m_lg-l; i >= 0; i--) for (i = m_lg-l; i >= 0; i--)
{ {
@ -195,7 +197,7 @@ CBotString CBotString::Mid(int start, int lg)
if ( lg < 0 ) lg = m_lg - start; if ( lg < 0 ) lg = m_lg - start;
char* p = (char*)malloc(m_lg+1); char* p = (char*)malloc(m_lg+1);
lstrcpy(p, m_ptr+start); strcpy(p, m_ptr+start);
p[lg] = 0; p[lg] = 0;
res = p; res = p;
@ -229,11 +231,11 @@ void CBotString::MakeLower()
#define MAXSTRING 256 #define MAXSTRING 256
BOOL CBotString::LoadString(UINT id) bool CBotString::LoadString(unsigned int id)
{ {
char buffer[MAXSTRING]; char buffer[MAXSTRING];
/// \TODO implement loading strings from resources. Figure out how to do it
m_lg = ::LoadString( m_hInstance, id, buffer, MAXSTRING ); // m_lg = ::LoadString( m_hInstance, id, buffer, MAXSTRING );
if (m_ptr != NULL) free(m_ptr); if (m_ptr != NULL) free(m_ptr);
@ -241,10 +243,10 @@ BOOL CBotString::LoadString(UINT id)
if (m_lg > 0) if (m_lg > 0)
{ {
m_ptr = (char*)malloc(m_lg+1); m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, buffer); strcpy(m_ptr, buffer);
return TRUE; return true;
} }
return FALSE; return false;
} }
@ -258,13 +260,13 @@ const CBotString& CBotString::operator=(const CBotString& stringSrc)
if (m_lg > 0) if (m_lg > 0)
{ {
m_ptr = (char*)malloc(m_lg+1); m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, stringSrc.m_ptr); strcpy(m_ptr, stringSrc.m_ptr);
} }
return *this; return *this;
} }
CBotString operator+(const CBotString& string, LPCTSTR lpsz) CBotString operator+(const CBotString& string, const char * lpsz)
{ {
CBotString s ( string ); CBotString s ( string );
s += lpsz; s += lpsz;
@ -275,9 +277,9 @@ const CBotString& CBotString::operator+(const CBotString& stringSrc)
{ {
char* p = (char*)malloc(m_lg+stringSrc.m_lg+1); char* p = (char*)malloc(m_lg+stringSrc.m_lg+1);
lstrcpy(p, m_ptr); strcpy(p, m_ptr);
char* pp = p + m_lg; char* pp = p + m_lg;
lstrcpy(pp, stringSrc.m_ptr); strcpy(pp, stringSrc.m_ptr);
if (m_ptr != NULL) free(m_ptr); if (m_ptr != NULL) free(m_ptr);
m_ptr = p; m_ptr = p;
@ -306,12 +308,12 @@ const CBotString& CBotString::operator=(const char* pString)
if ( pString != NULL ) if ( pString != NULL )
{ {
m_lg = lstrlen(pString); m_lg = strlen(pString);
if (m_lg != 0) if (m_lg != 0)
{ {
m_ptr = (char*)malloc(m_lg+1); m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, pString); strcpy(m_ptr, pString);
} }
} }
@ -323,7 +325,7 @@ const CBotString& CBotString::operator+=(const char ch)
{ {
char* p = (char*)malloc(m_lg+2); char* p = (char*)malloc(m_lg+2);
if (m_ptr!=NULL) lstrcpy(p, m_ptr); if (m_ptr!=NULL) strcpy(p, m_ptr);
p[m_lg++] = ch; p[m_lg++] = ch;
p[m_lg] = 0; p[m_lg] = 0;
@ -338,9 +340,9 @@ const CBotString& CBotString::operator+=(const CBotString& str)
{ {
char* p = (char*)malloc(m_lg+str.m_lg+1); char* p = (char*)malloc(m_lg+str.m_lg+1);
lstrcpy(p, m_ptr); strcpy(p, m_ptr);
char* pp = p + m_lg; char* pp = p + m_lg;
lstrcpy(pp, str.m_ptr); strcpy(pp, str.m_ptr);
m_lg = m_lg + str.m_lg; m_lg = m_lg + str.m_lg;
@ -351,67 +353,67 @@ const CBotString& CBotString::operator+=(const CBotString& str)
return *this; return *this;
} }
BOOL CBotString::operator==(const CBotString& str) bool CBotString::operator==(const CBotString& str)
{ {
return Compare(str) == 0; return Compare(str) == 0;
} }
BOOL CBotString::operator==(const char* p) bool CBotString::operator==(const char* p)
{ {
return Compare(p) == 0; return Compare(p) == 0;
} }
BOOL CBotString::operator!=(const CBotString& str) bool CBotString::operator!=(const CBotString& str)
{ {
return Compare(str) != 0; return Compare(str) != 0;
} }
BOOL CBotString::operator!=(const char* p) bool CBotString::operator!=(const char* p)
{ {
return Compare(p) != 0; return Compare(p) != 0;
} }
BOOL CBotString::operator>(const CBotString& str) bool CBotString::operator>(const CBotString& str)
{ {
return Compare(str) > 0; return Compare(str) > 0;
} }
BOOL CBotString::operator>(const char* p) bool CBotString::operator>(const char* p)
{ {
return Compare(p) > 0; return Compare(p) > 0;
} }
BOOL CBotString::operator>=(const CBotString& str) bool CBotString::operator>=(const CBotString& str)
{ {
return Compare(str) >= 0; return Compare(str) >= 0;
} }
BOOL CBotString::operator>=(const char* p) bool CBotString::operator>=(const char* p)
{ {
return Compare(p) >= 0; return Compare(p) >= 0;
} }
BOOL CBotString::operator<(const CBotString& str) bool CBotString::operator<(const CBotString& str)
{ {
return Compare(str) < 0; return Compare(str) < 0;
} }
BOOL CBotString::operator<(const char* p) bool CBotString::operator<(const char* p)
{ {
return Compare(p) < 0; return Compare(p) < 0;
} }
BOOL CBotString::operator<=(const CBotString& str) bool CBotString::operator<=(const CBotString& str)
{ {
return Compare(str) <= 0; return Compare(str) <= 0;
} }
BOOL CBotString::operator<=(const char* p) bool CBotString::operator<=(const char* p)
{ {
return Compare(p) <= 0; return Compare(p) <= 0;
} }
BOOL CBotString::IsEmpty() const bool CBotString::IsEmpty() const
{ {
return (m_lg == 0); return (m_lg == 0);
} }
@ -423,20 +425,20 @@ void CBotString::Empty()
m_lg = 0; m_lg = 0;
} }
static char nilstring[] = {0}; static char emptyString[] = {0};
CBotString::operator LPCTSTR() const CBotString::operator const char * () const
{ {
if (this == NULL || m_ptr == NULL) return nilstring; if (this == NULL || m_ptr == NULL) return emptyString;
return m_ptr; return m_ptr;
} }
int CBotString::Compare(LPCTSTR lpsz) const int CBotString::Compare(const char * lpsz) const
{ {
char* p = m_ptr; char* p = m_ptr;
if (lpsz == NULL) lpsz = nilstring; if (lpsz == NULL) lpsz = emptyString;
if (m_ptr == NULL) p = nilstring; if (m_ptr == NULL) p = emptyString;
return strcmp(p, lpsz); // wcscmp return strcmp(p, lpsz); // wcscmp
} }
@ -527,14 +529,14 @@ void CBotStringArray::SetSize(int nNewSize)
// shrink to nothing // shrink to nothing
DestructElements(m_pData, m_nSize); DestructElements(m_pData, m_nSize);
delete[] (BYTE*)m_pData; delete[] (unsigned char *)m_pData;
m_pData = NULL; m_pData = NULL;
m_nSize = m_nMaxSize = 0; m_nSize = m_nMaxSize = 0;
} }
else if (m_pData == NULL) else if (m_pData == NULL)
{ {
// create one with exact size // create one with exact size
m_pData = (CBotString*) new BYTE[nNewSize * sizeof(CBotString)]; m_pData = (CBotString*) new unsigned char[nNewSize * sizeof(CBotString)];
ConstructElements(m_pData, nNewSize); ConstructElements(m_pData, nNewSize);
@ -563,7 +565,7 @@ void CBotStringArray::SetSize(int nNewSize)
{ {
// heuristically determine growth when nGrowBy == 0 // heuristically determine growth when nGrowBy == 0
// (this avoids heap fragmentation in many situations) // (this avoids heap fragmentation in many situations)
nGrowBy = min(1024, max(4, m_nSize / 8)); nGrowBy = std::min(1024, std::max(4, m_nSize / 8));
} }
int nNewMax; int nNewMax;
if (nNewSize < m_nMaxSize + nGrowBy) if (nNewSize < m_nMaxSize + nGrowBy)
@ -571,7 +573,7 @@ void CBotStringArray::SetSize(int nNewSize)
else else
nNewMax = nNewSize; // no slush nNewMax = nNewSize; // no slush
CBotString* pNewData = (CBotString*) new BYTE[nNewMax * sizeof(CBotString)]; CBotString* pNewData = (CBotString*) new unsigned char[nNewMax * sizeof(CBotString)];
// copy new data from old // copy new data from old
memcpy(pNewData, m_pData, m_nSize * sizeof(CBotString)); memcpy(pNewData, m_pData, m_nSize * sizeof(CBotString));
@ -581,7 +583,7 @@ void CBotStringArray::SetSize(int nNewSize)
// Ret rid of old stuff (note: no destructors called) // Ret rid of old stuff (note: no destructors called)
delete[] (BYTE*)m_pData; delete[] (unsigned char *)m_pData;
m_pData = pNewData; m_pData = pNewData;
m_nSize = nNewSize; m_nSize = nNewSize;
m_nMaxSize = nNewMax; m_nMaxSize = nNewMax;

67
src/CBot/CBotToken.cpp
View File

@ -22,6 +22,7 @@
#include "CBot.h" #include "CBot.h"
#include <cstdarg>
CBotStringArray CBotToken::m_ListKeyWords; CBotStringArray CBotToken::m_ListKeyWords;
int CBotToken::m_ListIdKeyWords[200]; int CBotToken::m_ListIdKeyWords[200];
@ -188,27 +189,27 @@ void CBotToken::SetPos(int start, int end)
m_end = end; m_end = end;
} }
BOOL CharInList(const char c, const char* list) bool CharInList(const char c, const char* list)
{ {
int i = 0; int i = 0;
while (TRUE) while (true)
{ {
if (c == list[i++]) return TRUE; if (c == list[i++]) return true;
if (list[i] == 0) return FALSE; if (list[i] == 0) return false;
} }
} }
BOOL Char2InList(const char c, const char cc, const char* list) bool Char2InList(const char c, const char cc, const char* list)
{ {
int i = 0; int i = 0;
while (TRUE) while (true)
{ {
if (c == list[i++] && if (c == list[i++] &&
cc == list[i++]) return TRUE; cc == list[i++]) return true;
if (list[i] == 0) return FALSE; if (list[i] == 0) return false;
} }
} }
@ -224,12 +225,12 @@ static char* nch = "\"\r\n\t"; // refus
// cherche le prochain token dans une phrase // cherche le prochain token dans une phrase
// ne doit pas commencer par des séparateurs // ne doit pas commencer par des séparateurs
// qui sont pris avec le token précédent // qui sont pris avec le token précédent
CBotToken* CBotToken::NextToken(char* &program, int& error, BOOL first) CBotToken* CBotToken::NextToken(char* &program, int& error, bool first)
{ {
CBotString mot; // le mot trouvé CBotString mot; // le mot trouvé
CBotString sep; // les séparateurs qui le suivent CBotString sep; // les séparateurs qui le suivent
char c; char c;
BOOL stop = first; bool stop = first;
if (*program == 0) return NULL; if (*program == 0) return NULL;
@ -262,14 +263,14 @@ CBotToken* CBotToken::NextToken(char* &program, int& error, BOOL first)
mot += c; // chaîne complète mot += c; // chaîne complète
c = *(program++); // prochain caractère c = *(program++); // prochain caractère
} }
stop = TRUE; stop = true;
} }
// cas particulier pour les nombres // cas particulier pour les nombres
if ( CharInList(mot[0], num )) if ( CharInList(mot[0], num ))
{ {
BOOL bdot = FALSE; // trouvé un point ? bool bdot = false; // trouvé un point ?
BOOL bexp = FALSE; // trouvé un exposant ? bool bexp = false; // trouvé un exposant ?
char* liste = num; char* liste = num;
if (mot[0] == '0' && c == 'x') // valeur hexadécimale ? if (mot[0] == '0' && c == 'x') // valeur hexadécimale ?
@ -286,10 +287,10 @@ cc: mot += c;
} }
if ( liste == num ) // pas pour les exadécimaux if ( liste == num ) // pas pour les exadécimaux
{ {
if ( !bdot && c == '.' ) { bdot = TRUE; goto cc; } if ( !bdot && c == '.' ) { bdot = true; goto cc; }
if ( !bexp && ( c == 'e' || c == 'E' ) ) if ( !bexp && ( c == 'e' || c == 'E' ) )
{ {
bexp = TRUE; bexp = true;
mot += c; mot += c;
c = *(program++); // prochain caractère c = *(program++); // prochain caractère
if ( c == '-' || if ( c == '-' ||
@ -298,7 +299,7 @@ cc: mot += c;
} }
} }
stop = TRUE; stop = true;
} }
if (CharInList(mot[0], sep3)) // un séparateur opérationnel ? if (CharInList(mot[0], sep3)) // un séparateur opérationnel ?
@ -310,13 +311,13 @@ cc: mot += c;
c = *(program++); // prochain caractère c = *(program++); // prochain caractère
} }
stop = TRUE; stop = true;
} }
} }
while (TRUE) while (true)
{ {
if (stop || c == 0 || CharInList(c, sep1)) if (stop || c == 0 || CharInList(c, sep1))
{ {
@ -381,7 +382,7 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error)
int pos = 0; int pos = 0;
error = 0; error = 0;
prv = tokenbase = NextToken(p, error, TRUE); prv = tokenbase = NextToken(p, error, true);
if (tokenbase == NULL) return NULL; if (tokenbase == NULL) return NULL;
@ -443,7 +444,7 @@ int CBotToken::GivKeyWords(const char* w)
return -1; return -1;
} }
BOOL CBotToken::GivKeyDefNum(const char* w, CBotToken* &token) bool CBotToken::GivKeyDefNum(const char* w, CBotToken* &token)
{ {
int i; int i;
int l = m_ListKeyDefine.GivSize(); int l = m_ListKeyDefine.GivSize();
@ -454,11 +455,11 @@ BOOL CBotToken::GivKeyDefNum(const char* w, CBotToken* &token)
{ {
token->m_IdKeyWord = m_ListKeyNums[i]; token->m_IdKeyWord = m_ListKeyNums[i];
token->m_type = TokenTypDef; token->m_type = TokenTypDef;
return TRUE; return true;
} }
} }
return FALSE; return false;
} }
// reprend la liste des mots clefs dans les ressources // reprend la liste des mots clefs dans les ressources
@ -498,36 +499,36 @@ void CBotToken::LoadKeyWords()
} }
} }
BOOL CBotToken::DefineNum(const char* name, long val) bool CBotToken::DefineNum(const char* name, long val)
{ {
int i; int i;
int l = m_ListKeyDefine.GivSize(); int l = m_ListKeyDefine.GivSize();
for (i = 0; i < l; i++) for (i = 0; i < l; i++)
{ {
if (m_ListKeyDefine[i] == name) return FALSE; if (m_ListKeyDefine[i] == name) return false;
} }
if ( i == MAXDEFNUM ) return FALSE; if ( i == MAXDEFNUM ) return false;
m_ListKeyDefine.Add( name ); m_ListKeyDefine.Add( name );
m_ListKeyNums[i] = val; m_ListKeyNums[i] = val;
return TRUE; return true;
} }
BOOL IsOfType(CBotToken* &p, int type1, int type2) bool IsOfType(CBotToken* &p, int type1, int type2)
{ {
if (p->GivType() == type1 || if (p->GivType() == type1 ||
p->GivType() == type2 ) p->GivType() == type2 )
{ {
p = p->GivNext(); p = p->GivNext();
return TRUE; return true;
} }
return FALSE; return false;
} }
// idem avec un nombre indéfini d'arguments // idem avec un nombre indéfini d'arguments
// il faut mettre un zéro comme dernier argument // il faut mettre un zéro comme dernier argument
BOOL IsOfTypeList(CBotToken* &p, int type1, ...) bool IsOfTypeList(CBotToken* &p, int type1, ...)
{ {
int i = type1; int i = type1;
int max = 20; int max = 20;
@ -536,18 +537,18 @@ BOOL IsOfTypeList(CBotToken* &p, int type1, ...)
va_list marker; va_list marker;
va_start( marker, type1 ); /* Initialize variable arguments. */ va_start( marker, type1 ); /* Initialize variable arguments. */
while (TRUE) while (true)
{ {
if (type == i) if (type == i)
{ {
p = p->GivNext(); p = p->GivNext();
va_end( marker ); /* Reset variable arguments. */ va_end( marker ); /* Reset variable arguments. */
return TRUE; return true;
} }
if (--max == 0 || 0 == (i = va_arg( marker, int))) if (--max == 0 || 0 == (i = va_arg( marker, int)))
{ {
va_end( marker ); /* Reset variable arguments. */ va_end( marker ); /* Reset variable arguments. */
return FALSE; return false;
} }
} }
} }

4
src/CBot/CBotToken.h
View File

@ -33,5 +33,5 @@
// ) // )
extern BOOL IsOfType(CBotToken* &p, int type1, int type2 = -1); extern bool IsOfType(CBotToken* &p, int type1, int type2 = -1);
extern BOOL IsOfTypeList(CBotToken* &p, int type1, ...); extern bool IsOfTypeList(CBotToken* &p, int type1, ...);

58
src/CBot/CBotTwoOpExpr.cpp
View File

@ -95,19 +95,19 @@ static int ListOp[] =
0, 0,
}; };
BOOL IsInList( int val, int* list, int& typemasque ) bool IsInList( int val, int* list, int& typemasque )
{ {
while (TRUE) while (true)
{ {
if ( *list == 0 ) return FALSE; if ( *list == 0 ) return false;
typemasque = *list++; typemasque = *list++;
if ( *list++ == val ) return TRUE; if ( *list++ == val ) return true;
} }
} }
BOOL TypeOk( int type, int test ) bool TypeOk( int type, int test )
{ {
while (TRUE) while (true)
{ {
if ( type == 0 ) return (test & 1); if ( type == 0 ) return (test & 1);
type--; test /= 2; type--; test /= 2;
@ -279,43 +279,43 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
} }
BOOL IsNan(CBotVar* left, CBotVar* right, int* err = NULL) bool IsNan(CBotVar* left, CBotVar* right, int* err = NULL)
{ {
if ( left ->GivInit() > IS_DEF || right->GivInit() > IS_DEF ) if ( left ->GivInit() > IS_DEF || right->GivInit() > IS_DEF )
{ {
if ( err != NULL ) *err = TX_OPNAN ; if ( err != NULL ) *err = TX_OPNAN ;
return TRUE; return true;
} }
return FALSE; return false;
} }
// fait l'opération sur 2 opérandes // fait l'opération sur 2 opérandes
BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
{ {
CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE; // if ( pStk1 == EOX ) return true;
// selon la reprise, on peut être dans l'un des 2 états // selon la reprise, on peut être dans l'un des 2 états
if ( pStk1->GivState() == 0 ) // 1er état, évalue l'opérande de gauche if ( pStk1->GivState() == 0 ) // 1er état, évalue l'opérande de gauche
{ {
if (!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ? if (!m_leftop->Execute(pStk1) ) return false; // interrompu ici ?
// pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == FALSE ) if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == false )
{ {
CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean); CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
res->SetValInt(FALSE); res->SetValInt(false);
pStk1->SetVar(res); pStk1->SetVar(res);
return pStack->Return(pStk1); // transmet le résultat return pStack->Return(pStk1); // transmet le résultat
} }
if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == TRUE ) if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == true )
{ {
CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean); CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
res->SetValInt(TRUE); res->SetValInt(true);
pStk1->SetVar(res); pStk1->SetVar(res);
return pStack->Return(pStk1); // transmet le résultat return pStack->Return(pStk1); // transmet le résultat
} }
@ -334,7 +334,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
// 2e état, évalue l'opérande de droite // 2e état, évalue l'opérande de droite
if ( pStk2->GivState() == 0 ) if ( pStk2->GivState() == 0 )
{ {
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ? if ( !m_rightop->Execute(pStk2) ) return false; // interrompu ici ?
pStk2->IncState(); pStk2->IncState();
} }
@ -342,7 +342,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
CBotTypResult type2 = pStk2->GivTypResult(); CBotTypResult type2 = pStk2->GivTypResult();
CBotStack* pStk3 = pStk2->AddStack(this); // ajoute un élément à la pile CBotStack* pStk3 = pStk2->AddStack(this); // ajoute un élément à la pile
if ( pStk3->IfStep() ) return FALSE; // montre l'opération si step by step if ( pStk3->IfStep() ) return false; // montre l'opération si step by step
// crée une variable temporaire pour y mettre le résultat // crée une variable temporaire pour y mettre le résultat
// quel est le type du résultat ? // quel est le type du résultat ?
@ -475,7 +475,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
return pStack->Return(pStk2); // transmet le résultat return pStack->Return(pStk2); // transmet le résultat
} }
void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain) void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un élément à la pile CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un élément à la pile
@ -501,31 +501,31 @@ void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
} }
BOOL CBotLogicExpr::Execute(CBotStack* &pStack) bool CBotLogicExpr::Execute(CBotStack* &pStack)
{ {
CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE; // if ( pStk1 == EOX ) return true;
if ( pStk1->GivState() == 0 ) if ( pStk1->GivState() == 0 )
{ {
if ( !m_condition->Execute(pStk1) ) return FALSE; if ( !m_condition->Execute(pStk1) ) return false;
if (!pStk1->SetState(1)) return FALSE; if (!pStk1->SetState(1)) return false;
} }
if ( pStk1->GivVal() == TRUE ) if ( pStk1->GivVal() == true )
{ {
if ( !m_op1->Execute(pStk1) ) return FALSE; if ( !m_op1->Execute(pStk1) ) return false;
} }
else else
{ {
if ( !m_op2->Execute(pStk1) ) return FALSE; if ( !m_op2->Execute(pStk1) ) return false;
} }
return pStack->Return(pStk1); // transmet le résultat return pStack->Return(pStk1); // transmet le résultat
} }
void CBotLogicExpr::RestoreState(CBotStack* &pStack, BOOL bMain) void CBotLogicExpr::RestoreState(CBotStack* &pStack, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -538,7 +538,7 @@ void CBotLogicExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
return; return;
} }
if ( pStk1->GivVal() == TRUE ) if ( pStk1->GivVal() == true )
{ {
m_op1->RestoreState(pStk1, bMain); m_op1->RestoreState(pStk1, bMain);
} }
@ -557,7 +557,7 @@ void t()
#endif #endif
#if 01 #if 01
void t(BOOL t) void t(bool t)
{ {
int x; int x;
x = 1 + t ? 1 : 3 + 4 * 2 ; x = 1 + t ? 1 : 3 + 4 * 2 ;

278
src/CBot/CBotVar.cpp
View File

@ -33,9 +33,9 @@ CBotVar::CBotVar( )
m_InitExpr = NULL; m_InitExpr = NULL;
m_LimExpr = NULL; m_LimExpr = NULL;
m_type = -1; m_type = -1;
m_binit = FALSE; m_binit = false;
m_ident = 0; m_ident = 0;
m_bStatic = FALSE; m_bStatic = false;
m_mPrivate = 0; m_mPrivate = 0;
} }
@ -48,8 +48,8 @@ CBotVarInt::CBotVarInt( const CBotToken* name )
m_InitExpr = NULL; m_InitExpr = NULL;
m_LimExpr = NULL; m_LimExpr = NULL;
m_type = CBotTypInt; m_type = CBotTypInt;
m_binit = FALSE; m_binit = false;
m_bStatic = FALSE; m_bStatic = false;
m_mPrivate = 0; m_mPrivate = 0;
m_val = 0; m_val = 0;
@ -64,8 +64,8 @@ CBotVarFloat::CBotVarFloat( const CBotToken* name )
m_InitExpr = NULL; m_InitExpr = NULL;
m_LimExpr = NULL; m_LimExpr = NULL;
m_type = CBotTypFloat; m_type = CBotTypFloat;
m_binit = FALSE; m_binit = false;
m_bStatic = FALSE; m_bStatic = false;
m_mPrivate = 0; m_mPrivate = 0;
m_val = 0; m_val = 0;
@ -80,8 +80,8 @@ CBotVarString::CBotVarString( const CBotToken* name )
m_InitExpr = NULL; m_InitExpr = NULL;
m_LimExpr = NULL; m_LimExpr = NULL;
m_type = CBotTypString; m_type = CBotTypString;
m_binit = FALSE; m_binit = false;
m_bStatic = FALSE; m_bStatic = false;
m_mPrivate = 0; m_mPrivate = 0;
m_val.Empty(); m_val.Empty();
@ -96,8 +96,8 @@ CBotVarBoolean::CBotVarBoolean( const CBotToken* name )
m_InitExpr = NULL; m_InitExpr = NULL;
m_LimExpr = NULL; m_LimExpr = NULL;
m_type = CBotTypBoolean; m_type = CBotTypBoolean;
m_binit = FALSE; m_binit = false;
m_bStatic = FALSE; m_bStatic = false;
m_mPrivate = 0; m_mPrivate = 0;
m_val = 0; m_val = 0;
@ -139,10 +139,10 @@ void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type
m_pClass = NULL; m_pClass = NULL;
m_pParent = NULL; m_pParent = NULL;
m_binit = FALSE; m_binit = false;
m_bStatic = FALSE; m_bStatic = false;
m_mPrivate = 0; m_mPrivate = 0;
m_bConstructor = FALSE; m_bConstructor = false;
m_CptUse = 0; m_CptUse = 0;
m_ItemIdent = type.Eq(CBotTypIntrinsic) ? 0 : CBotVar::NextUniqNum(); m_ItemIdent = type.Eq(CBotTypIntrinsic) ? 0 : CBotVar::NextUniqNum();
@ -189,7 +189,7 @@ CBotVarClass::~CBotVarClass( )
void CBotVarClass::ConstructorSet() void CBotVarClass::ConstructorSet()
{ {
m_bConstructor = TRUE; m_bConstructor = true;
} }
@ -201,9 +201,9 @@ CBotVar::~CBotVar( )
void CBotVar::debug() void CBotVar::debug()
{ {
const char* p = (LPCTSTR) m_token->GivString(); const char* p = (const char*) m_token->GivString();
CBotString s = (LPCTSTR) GivValString(); CBotString s = (const char*) GivValString();
const char* v = (LPCTSTR) s; const char* v = (const char*) s;
if ( m_type.Eq(CBotTypClass) ) if ( m_type.Eq(CBotTypClass) )
{ {
@ -260,19 +260,19 @@ void* CBotVar::GivUserPtr()
return m_pUserPtr; return m_pUserPtr;
} }
BOOL CBotVar::Save1State(FILE* pf) bool CBotVar::Save1State(FILE* pf)
{ {
// cette routine "virtual" ne doit jamais être appellée, // cette routine "virtual" ne doit jamais être appellée,
// il doit y avoir une routine pour chaque classe fille (CBotVarInt, CBotVarFloat, etc) // il doit y avoir une routine pour chaque classe fille (CBotVarInt, CBotVarFloat, etc)
// ( voir le type dans m_type ) // ( voir le type dans m_type )
ASM_TRAP(); ASM_TRAP();
return FALSE; return false;
} }
void CBotVar::Maj(void* pUser, BOOL bContinu) void CBotVar::Maj(void* pUser, bool bContinu)
{ {
/* if (!bContinu && m_pMyThis != NULL) /* if (!bContinu && m_pMyThis != NULL)
m_pMyThis->Maj(pUser, TRUE);*/ m_pMyThis->Maj(pUser, true);*/
} }
@ -326,7 +326,7 @@ CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type)
while (type.Eq(CBotTypArrayBody)) while (type.Eq(CBotTypArrayBody))
{ {
type = type.GivTypElem(); type = type.GivTypElem();
pv = ((CBotVarArray*)pv)->GivItem(0, TRUE); // crée au moins l'élément [0] pv = ((CBotVarArray*)pv)->GivItem(0, true); // crée au moins l'élément [0]
} }
return array; return array;
@ -397,7 +397,7 @@ CBotVar* CBotVar::Create( const char* n, CBotTypResult type)
while (type.Eq(CBotTypArrayBody)) while (type.Eq(CBotTypArrayBody))
{ {
type = type.GivTypElem(); type = type.GivTypElem();
pv = ((CBotVarArray*)pv)->GivItem(0, TRUE); // crée au moins l'élément [0] pv = ((CBotVarArray*)pv)->GivItem(0, true); // crée au moins l'élément [0]
} }
return array; return array;
@ -471,7 +471,7 @@ int CBotVar::GivInit()
return m_binit; return m_binit;
} }
void CBotVar::SetInit(BOOL bInit) void CBotVar::SetInit(int bInit)
{ {
m_binit = bInit; m_binit = bInit;
if ( bInit == 2 ) m_binit = IS_DEF; // cas spécial if ( bInit == 2 ) m_binit = IS_DEF; // cas spécial
@ -533,14 +533,14 @@ CBotVar* CBotVar::GivItemList()
return NULL; return NULL;
} }
CBotVar* CBotVar::GivItem(int row, BOOL bGrow) CBotVar* CBotVar::GivItem(int row, bool bGrow)
{ {
ASM_TRAP(); ASM_TRAP();
return NULL; return NULL;
} }
// dit si une variable appartient à une classe donnée // dit si une variable appartient à une classe donnée
BOOL CBotVar::IsElemOfClass(const char* name) bool CBotVar::IsElemOfClass(const char* name)
{ {
CBotClass* pc = NULL; CBotClass* pc = NULL;
@ -555,11 +555,11 @@ BOOL CBotVar::IsElemOfClass(const char* name)
while ( pc != NULL ) while ( pc != NULL )
{ {
if ( pc->GivName() == name ) return TRUE; if ( pc->GivName() == name ) return true;
pc = pc->GivParent(); pc = pc->GivParent();
} }
return FALSE; return false;
} }
@ -611,7 +611,7 @@ void CBotVar::SetVal(CBotVar* var)
{ {
delete ((CBotVarClass*)this)->m_pVar; delete ((CBotVarClass*)this)->m_pVar;
((CBotVarClass*)this)->m_pVar = NULL; ((CBotVarClass*)this)->m_pVar = NULL;
Copy(var, FALSE); Copy(var, false);
} }
break; break;
default: default:
@ -621,7 +621,7 @@ void CBotVar::SetVal(CBotVar* var)
m_binit = var->m_binit; // copie l'état nan s'il y a m_binit = var->m_binit; // copie l'état nan s'il y a
} }
void CBotVar::SetStatic(BOOL bStatic) void CBotVar::SetStatic(bool bStatic)
{ {
m_bStatic = bStatic; m_bStatic = bStatic;
} }
@ -631,12 +631,12 @@ void CBotVar::SetPrivate(int mPrivate)
m_mPrivate = mPrivate; m_mPrivate = mPrivate;
} }
BOOL CBotVar::IsStatic() bool CBotVar::IsStatic()
{ {
return m_bStatic; return m_bStatic;
} }
BOOL CBotVar::IsPrivate(int mode) bool CBotVar::IsPrivate(int mode)
{ {
return m_mPrivate >= mode; return m_mPrivate >= mode;
} }
@ -715,40 +715,40 @@ void CBotVar::Sub(CBotVar* left, CBotVar* right)
ASM_TRAP(); ASM_TRAP();
} }
BOOL CBotVar::Lo(CBotVar* left, CBotVar* right) bool CBotVar::Lo(CBotVar* left, CBotVar* right)
{ {
ASM_TRAP(); ASM_TRAP();
return FALSE; return false;
} }
BOOL CBotVar::Hi(CBotVar* left, CBotVar* right) bool CBotVar::Hi(CBotVar* left, CBotVar* right)
{ {
ASM_TRAP(); ASM_TRAP();
return FALSE; return false;
} }
BOOL CBotVar::Ls(CBotVar* left, CBotVar* right) bool CBotVar::Ls(CBotVar* left, CBotVar* right)
{ {
ASM_TRAP(); ASM_TRAP();
return FALSE; return false;
} }
BOOL CBotVar::Hs(CBotVar* left, CBotVar* right) bool CBotVar::Hs(CBotVar* left, CBotVar* right)
{ {
ASM_TRAP(); ASM_TRAP();
return FALSE; return false;
} }
BOOL CBotVar::Eq(CBotVar* left, CBotVar* right) bool CBotVar::Eq(CBotVar* left, CBotVar* right)
{ {
ASM_TRAP(); ASM_TRAP();
return FALSE; return false;
} }
BOOL CBotVar::Ne(CBotVar* left, CBotVar* right) bool CBotVar::Ne(CBotVar* left, CBotVar* right)
{ {
ASM_TRAP(); ASM_TRAP();
return FALSE; return false;
} }
void CBotVar::And(CBotVar* left, CBotVar* right) void CBotVar::And(CBotVar* left, CBotVar* right)
@ -800,7 +800,7 @@ void CBotVar::Dec()
ASM_TRAP(); ASM_TRAP();
} }
void CBotVar::Copy(CBotVar* pSrc, BOOL bName) void CBotVar::Copy(CBotVar* pSrc, bool bName)
{ {
ASM_TRAP(); ASM_TRAP();
} }
@ -837,7 +837,7 @@ void CBotVar::SetIndirection(CBotVar* pVar)
////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////
// copie une variable dans une autre // copie une variable dans une autre
void CBotVarInt::Copy(CBotVar* pSrc, BOOL bName) void CBotVarInt::Copy(CBotVar* pSrc, bool bName)
{ {
CBotVarInt* p = (CBotVarInt*)pSrc; CBotVarInt* p = (CBotVarInt*)pSrc;
@ -860,7 +860,7 @@ void CBotVarInt::Copy(CBotVar* pSrc, BOOL bName)
void CBotVarInt::SetValInt(int val, const char* defnum) void CBotVarInt::SetValInt(int val, const char* defnum)
{ {
m_val = val; m_val = val;
m_binit = TRUE; m_binit = true;
m_defnum = defnum; m_defnum = defnum;
} }
@ -869,7 +869,7 @@ void CBotVarInt::SetValInt(int val, const char* defnum)
void CBotVarInt::SetValFloat(float val) void CBotVarInt::SetValFloat(float val)
{ {
m_val = (int)val; m_val = (int)val;
m_binit = TRUE; m_binit = true;
} }
int CBotVarInt::GivValInt() int CBotVarInt::GivValInt()
@ -910,13 +910,13 @@ CBotString CBotVarInt::GivValString()
void CBotVarInt::Mul(CBotVar* left, CBotVar* right) void CBotVarInt::Mul(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() * right->GivValInt(); m_val = left->GivValInt() * right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::Power(CBotVar* left, CBotVar* right) void CBotVarInt::Power(CBotVar* left, CBotVar* right)
{ {
m_val = (int) pow( (double) left->GivValInt() , (double) right->GivValInt() ); m_val = (int) pow( (double) left->GivValInt() , (double) right->GivValInt() );
m_binit = TRUE; m_binit = true;
} }
int CBotVarInt::Div(CBotVar* left, CBotVar* right) int CBotVarInt::Div(CBotVar* left, CBotVar* right)
@ -925,7 +925,7 @@ int CBotVarInt::Div(CBotVar* left, CBotVar* right)
if ( r != 0 ) if ( r != 0 )
{ {
m_val = left->GivValInt() / r; m_val = left->GivValInt() / r;
m_binit = TRUE; m_binit = true;
} }
return ( r == 0 ? TX_DIVZERO : 0 ); return ( r == 0 ? TX_DIVZERO : 0 );
} }
@ -936,7 +936,7 @@ int CBotVarInt::Modulo(CBotVar* left, CBotVar* right)
if ( r != 0 ) if ( r != 0 )
{ {
m_val = left->GivValInt() % r; m_val = left->GivValInt() % r;
m_binit = TRUE; m_binit = true;
} }
return ( r == 0 ? TX_DIVZERO : 0 ); return ( r == 0 ? TX_DIVZERO : 0 );
} }
@ -944,43 +944,43 @@ int CBotVarInt::Modulo(CBotVar* left, CBotVar* right)
void CBotVarInt::Add(CBotVar* left, CBotVar* right) void CBotVarInt::Add(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() + right->GivValInt(); m_val = left->GivValInt() + right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::Sub(CBotVar* left, CBotVar* right) void CBotVarInt::Sub(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() - right->GivValInt(); m_val = left->GivValInt() - right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::XOr(CBotVar* left, CBotVar* right) void CBotVarInt::XOr(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() ^ right->GivValInt(); m_val = left->GivValInt() ^ right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::And(CBotVar* left, CBotVar* right) void CBotVarInt::And(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() & right->GivValInt(); m_val = left->GivValInt() & right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::Or(CBotVar* left, CBotVar* right) void CBotVarInt::Or(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() | right->GivValInt(); m_val = left->GivValInt() | right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::SL(CBotVar* left, CBotVar* right) void CBotVarInt::SL(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() << right->GivValInt(); m_val = left->GivValInt() << right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::ASR(CBotVar* left, CBotVar* right) void CBotVarInt::ASR(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() >> right->GivValInt(); m_val = left->GivValInt() >> right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::SR(CBotVar* left, CBotVar* right) void CBotVarInt::SR(CBotVar* left, CBotVar* right)
@ -989,7 +989,7 @@ void CBotVarInt::SR(CBotVar* left, CBotVar* right)
int shift = right->GivValInt(); int shift = right->GivValInt();
if (shift>=1) source &= 0x7fffffff; if (shift>=1) source &= 0x7fffffff;
m_val = source >> shift; m_val = source >> shift;
m_binit = TRUE; m_binit = true;
} }
void CBotVarInt::Neg() void CBotVarInt::Neg()
@ -1014,32 +1014,32 @@ void CBotVarInt::Dec()
m_defnum.Empty(); m_defnum.Empty();
} }
BOOL CBotVarInt::Lo(CBotVar* left, CBotVar* right) bool CBotVarInt::Lo(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() < right->GivValInt(); return left->GivValInt() < right->GivValInt();
} }
BOOL CBotVarInt::Hi(CBotVar* left, CBotVar* right) bool CBotVarInt::Hi(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() > right->GivValInt(); return left->GivValInt() > right->GivValInt();
} }
BOOL CBotVarInt::Ls(CBotVar* left, CBotVar* right) bool CBotVarInt::Ls(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() <= right->GivValInt(); return left->GivValInt() <= right->GivValInt();
} }
BOOL CBotVarInt::Hs(CBotVar* left, CBotVar* right) bool CBotVarInt::Hs(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() >= right->GivValInt(); return left->GivValInt() >= right->GivValInt();
} }
BOOL CBotVarInt::Eq(CBotVar* left, CBotVar* right) bool CBotVarInt::Eq(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() == right->GivValInt(); return left->GivValInt() == right->GivValInt();
} }
BOOL CBotVarInt::Ne(CBotVar* left, CBotVar* right) bool CBotVarInt::Ne(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() != right->GivValInt(); return left->GivValInt() != right->GivValInt();
} }
@ -1048,7 +1048,7 @@ BOOL CBotVarInt::Ne(CBotVar* left, CBotVar* right)
////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////
// copie une variable dans une autre // copie une variable dans une autre
void CBotVarFloat::Copy(CBotVar* pSrc, BOOL bName) void CBotVarFloat::Copy(CBotVar* pSrc, bool bName)
{ {
CBotVarFloat* p = (CBotVarFloat*)pSrc; CBotVarFloat* p = (CBotVarFloat*)pSrc;
@ -1071,13 +1071,13 @@ void CBotVarFloat::Copy(CBotVar* pSrc, BOOL bName)
void CBotVarFloat::SetValInt(int val, const char* s) void CBotVarFloat::SetValInt(int val, const char* s)
{ {
m_val = (float)val; m_val = (float)val;
m_binit = TRUE; m_binit = true;
} }
void CBotVarFloat::SetValFloat(float val) void CBotVarFloat::SetValFloat(float val)
{ {
m_val = val; m_val = val;
m_binit = TRUE; m_binit = true;
} }
int CBotVarFloat::GivValInt() int CBotVarFloat::GivValInt()
@ -1116,13 +1116,13 @@ CBotString CBotVarFloat::GivValString()
void CBotVarFloat::Mul(CBotVar* left, CBotVar* right) void CBotVarFloat::Mul(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValFloat() * right->GivValFloat(); m_val = left->GivValFloat() * right->GivValFloat();
m_binit = TRUE; m_binit = true;
} }
void CBotVarFloat::Power(CBotVar* left, CBotVar* right) void CBotVarFloat::Power(CBotVar* left, CBotVar* right)
{ {
m_val = (float)pow( left->GivValFloat() , right->GivValFloat() ); m_val = (float)pow( left->GivValFloat() , right->GivValFloat() );
m_binit = TRUE; m_binit = true;
} }
int CBotVarFloat::Div(CBotVar* left, CBotVar* right) int CBotVarFloat::Div(CBotVar* left, CBotVar* right)
@ -1131,7 +1131,7 @@ int CBotVarFloat::Div(CBotVar* left, CBotVar* right)
if ( r != 0 ) if ( r != 0 )
{ {
m_val = left->GivValFloat() / r; m_val = left->GivValFloat() / r;
m_binit = TRUE; m_binit = true;
} }
return ( r == 0 ? TX_DIVZERO : 0 ); return ( r == 0 ? TX_DIVZERO : 0 );
} }
@ -1142,7 +1142,7 @@ int CBotVarFloat::Modulo(CBotVar* left, CBotVar* right)
if ( r != 0 ) if ( r != 0 )
{ {
m_val = (float)fmod( left->GivValFloat() , r ); m_val = (float)fmod( left->GivValFloat() , r );
m_binit = TRUE; m_binit = true;
} }
return ( r == 0 ? TX_DIVZERO : 0 ); return ( r == 0 ? TX_DIVZERO : 0 );
} }
@ -1150,13 +1150,13 @@ int CBotVarFloat::Modulo(CBotVar* left, CBotVar* right)
void CBotVarFloat::Add(CBotVar* left, CBotVar* right) void CBotVarFloat::Add(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValFloat() + right->GivValFloat(); m_val = left->GivValFloat() + right->GivValFloat();
m_binit = TRUE; m_binit = true;
} }
void CBotVarFloat::Sub(CBotVar* left, CBotVar* right) void CBotVarFloat::Sub(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValFloat() - right->GivValFloat(); m_val = left->GivValFloat() - right->GivValFloat();
m_binit = TRUE; m_binit = true;
} }
void CBotVarFloat::Neg() void CBotVarFloat::Neg()
@ -1175,32 +1175,32 @@ void CBotVarFloat::Dec()
} }
BOOL CBotVarFloat::Lo(CBotVar* left, CBotVar* right) bool CBotVarFloat::Lo(CBotVar* left, CBotVar* right)
{ {
return left->GivValFloat() < right->GivValFloat(); return left->GivValFloat() < right->GivValFloat();
} }
BOOL CBotVarFloat::Hi(CBotVar* left, CBotVar* right) bool CBotVarFloat::Hi(CBotVar* left, CBotVar* right)
{ {
return left->GivValFloat() > right->GivValFloat(); return left->GivValFloat() > right->GivValFloat();
} }
BOOL CBotVarFloat::Ls(CBotVar* left, CBotVar* right) bool CBotVarFloat::Ls(CBotVar* left, CBotVar* right)
{ {
return left->GivValFloat() <= right->GivValFloat(); return left->GivValFloat() <= right->GivValFloat();
} }
BOOL CBotVarFloat::Hs(CBotVar* left, CBotVar* right) bool CBotVarFloat::Hs(CBotVar* left, CBotVar* right)
{ {
return left->GivValFloat() >= right->GivValFloat(); return left->GivValFloat() >= right->GivValFloat();
} }
BOOL CBotVarFloat::Eq(CBotVar* left, CBotVar* right) bool CBotVarFloat::Eq(CBotVar* left, CBotVar* right)
{ {
return left->GivValFloat() == right->GivValFloat(); return left->GivValFloat() == right->GivValFloat();
} }
BOOL CBotVarFloat::Ne(CBotVar* left, CBotVar* right) bool CBotVarFloat::Ne(CBotVar* left, CBotVar* right)
{ {
return left->GivValFloat() != right->GivValFloat(); return left->GivValFloat() != right->GivValFloat();
} }
@ -1209,7 +1209,7 @@ BOOL CBotVarFloat::Ne(CBotVar* left, CBotVar* right)
////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////
// copie une variable dans une autre // copie une variable dans une autre
void CBotVarBoolean::Copy(CBotVar* pSrc, BOOL bName) void CBotVarBoolean::Copy(CBotVar* pSrc, bool bName)
{ {
CBotVarBoolean* p = (CBotVarBoolean*)pSrc; CBotVarBoolean* p = (CBotVarBoolean*)pSrc;
@ -1231,14 +1231,14 @@ void CBotVarBoolean::Copy(CBotVar* pSrc, BOOL bName)
void CBotVarBoolean::SetValInt(int val, const char* s) void CBotVarBoolean::SetValInt(int val, const char* s)
{ {
m_val = (BOOL)val; m_val = (bool)val;
m_binit = TRUE; m_binit = true;
} }
void CBotVarBoolean::SetValFloat(float val) void CBotVarBoolean::SetValFloat(float val)
{ {
m_val = (BOOL)val; m_val = (bool)val;
m_binit = TRUE; m_binit = true;
} }
int CBotVarBoolean::GivValInt() int CBotVarBoolean::GivValInt()
@ -1275,31 +1275,31 @@ CBotString CBotVarBoolean::GivValString()
void CBotVarBoolean::And(CBotVar* left, CBotVar* right) void CBotVarBoolean::And(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() && right->GivValInt(); m_val = left->GivValInt() && right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarBoolean::Or(CBotVar* left, CBotVar* right) void CBotVarBoolean::Or(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() || right->GivValInt(); m_val = left->GivValInt() || right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarBoolean::XOr(CBotVar* left, CBotVar* right) void CBotVarBoolean::XOr(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValInt() ^ right->GivValInt(); m_val = left->GivValInt() ^ right->GivValInt();
m_binit = TRUE; m_binit = true;
} }
void CBotVarBoolean::Not() void CBotVarBoolean::Not()
{ {
m_val = m_val ? FALSE : TRUE ; m_val = m_val ? false : true ;
} }
BOOL CBotVarBoolean::Eq(CBotVar* left, CBotVar* right) bool CBotVarBoolean::Eq(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() == right->GivValInt(); return left->GivValInt() == right->GivValInt();
} }
BOOL CBotVarBoolean::Ne(CBotVar* left, CBotVar* right) bool CBotVarBoolean::Ne(CBotVar* left, CBotVar* right)
{ {
return left->GivValInt() != right->GivValInt(); return left->GivValInt() != right->GivValInt();
} }
@ -1307,7 +1307,7 @@ BOOL CBotVarBoolean::Ne(CBotVar* left, CBotVar* right)
////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////
// copie une variable dans une autre // copie une variable dans une autre
void CBotVarString::Copy(CBotVar* pSrc, BOOL bName) void CBotVarString::Copy(CBotVar* pSrc, bool bName)
{ {
CBotVarString* p = (CBotVarString*)pSrc; CBotVarString* p = (CBotVarString*)pSrc;
@ -1328,7 +1328,7 @@ void CBotVarString::Copy(CBotVar* pSrc, BOOL bName)
void CBotVarString::SetValString(const char* p) void CBotVarString::SetValString(const char* p)
{ {
m_val = p; m_val = p;
m_binit = TRUE; m_binit = true;
} }
CBotString CBotVarString::GivValString() CBotString CBotVarString::GivValString()
@ -1353,36 +1353,36 @@ CBotString CBotVarString::GivValString()
void CBotVarString::Add(CBotVar* left, CBotVar* right) void CBotVarString::Add(CBotVar* left, CBotVar* right)
{ {
m_val = left->GivValString() + right->GivValString(); m_val = left->GivValString() + right->GivValString();
m_binit = TRUE; m_binit = true;
} }
BOOL CBotVarString::Eq(CBotVar* left, CBotVar* right) bool CBotVarString::Eq(CBotVar* left, CBotVar* right)
{ {
return (left->GivValString() == right->GivValString()); return (left->GivValString() == right->GivValString());
} }
BOOL CBotVarString::Ne(CBotVar* left, CBotVar* right) bool CBotVarString::Ne(CBotVar* left, CBotVar* right)
{ {
return (left->GivValString() != right->GivValString()); return (left->GivValString() != right->GivValString());
} }
BOOL CBotVarString::Lo(CBotVar* left, CBotVar* right) bool CBotVarString::Lo(CBotVar* left, CBotVar* right)
{ {
return (left->GivValString() == right->GivValString()); return (left->GivValString() == right->GivValString());
} }
BOOL CBotVarString::Hi(CBotVar* left, CBotVar* right) bool CBotVarString::Hi(CBotVar* left, CBotVar* right)
{ {
return (left->GivValString() == right->GivValString()); return (left->GivValString() == right->GivValString());
} }
BOOL CBotVarString::Ls(CBotVar* left, CBotVar* right) bool CBotVarString::Ls(CBotVar* left, CBotVar* right)
{ {
return (left->GivValString() == right->GivValString()); return (left->GivValString() == right->GivValString());
} }
BOOL CBotVarString::Hs(CBotVar* left, CBotVar* right) bool CBotVarString::Hs(CBotVar* left, CBotVar* right)
{ {
return (left->GivValString() == right->GivValString()); return (left->GivValString() == right->GivValString());
} }
@ -1391,7 +1391,7 @@ BOOL CBotVarString::Hs(CBotVar* left, CBotVar* right)
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// copie une variable dans une autre // copie une variable dans une autre
void CBotVarClass::Copy(CBotVar* pSrc, BOOL bName) void CBotVarClass::Copy(CBotVar* pSrc, bool bName)
{ {
pSrc = pSrc->GivPointer(); // si source donné par un pointeur pSrc = pSrc->GivPointer(); // si source donné par un pointeur
@ -1520,10 +1520,10 @@ CBotClass* CBotVarClass::GivClass()
} }
void CBotVarClass::Maj(void* pUser, BOOL bContinu) void CBotVarClass::Maj(void* pUser, bool bContinu)
{ {
/* if (!bContinu && m_pMyThis != NULL) /* if (!bContinu && m_pMyThis != NULL)
m_pMyThis->Maj(pUser, TRUE);*/ m_pMyThis->Maj(pUser, true);*/
// une routine de mise à jour existe-elle ? // une routine de mise à jour existe-elle ?
@ -1569,7 +1569,7 @@ CBotVar* CBotVarClass::GivItemRef(int nIdent)
// pour la gestion d'un tableau // pour la gestion d'un tableau
// bExtend permet d'agrandir le tableau, mais pas au dela de la taille fixée par SetArray() // bExtend permet d'agrandir le tableau, mais pas au dela de la taille fixée par SetArray()
CBotVar* CBotVarClass::GivItem(int n, BOOL bExtend) CBotVar* CBotVarClass::GivItem(int n, bool bExtend)
{ {
CBotVar* p = m_pVar; CBotVar* p = m_pVar;
@ -1728,14 +1728,14 @@ CBotVarClass* CBotVarClass::Find(long id)
return NULL; return NULL;
} }
BOOL CBotVarClass::Eq(CBotVar* left, CBotVar* right) bool CBotVarClass::Eq(CBotVar* left, CBotVar* right)
{ {
CBotVar* l = left->GivItemList(); CBotVar* l = left->GivItemList();
CBotVar* r = right->GivItemList(); CBotVar* r = right->GivItemList();
while ( l != NULL && r != NULL ) while ( l != NULL && r != NULL )
{ {
if ( l->Ne(l, r) ) return FALSE; if ( l->Ne(l, r) ) return false;
l = l->GivNext(); l = l->GivNext();
r = r->GivNext(); r = r->GivNext();
} }
@ -1744,14 +1744,14 @@ BOOL CBotVarClass::Eq(CBotVar* left, CBotVar* right)
return l == r; return l == r;
} }
BOOL CBotVarClass::Ne(CBotVar* left, CBotVar* right) bool CBotVarClass::Ne(CBotVar* left, CBotVar* right)
{ {
CBotVar* l = left->GivItemList(); CBotVar* l = left->GivItemList();
CBotVar* r = right->GivItemList(); CBotVar* r = right->GivItemList();
while ( l != NULL && r != NULL ) while ( l != NULL && r != NULL )
{ {
if ( l->Ne(l, r) ) return TRUE; if ( l->Ne(l, r) ) return true;
l = l->GivNext(); l = l->GivNext();
r = r->GivNext(); r = r->GivNext();
} }
@ -1775,7 +1775,7 @@ CBotVarArray::CBotVarArray(const CBotToken* name, CBotTypResult& type )
m_type = type; m_type = type;
m_type.SetType(CBotTypArrayPointer); m_type.SetType(CBotTypArrayPointer);
m_binit = FALSE; m_binit = false;
m_pInstance = NULL; // la liste des éléments du tableau m_pInstance = NULL; // la liste des éléments du tableau
} }
@ -1786,7 +1786,7 @@ CBotVarArray::~CBotVarArray()
} }
// copie une variable dans une autre // copie une variable dans une autre
void CBotVarArray::Copy(CBotVar* pSrc, BOOL bName) void CBotVarArray::Copy(CBotVar* pSrc, bool bName)
{ {
if ( pSrc->GivType() != CBotTypArrayPointer ) if ( pSrc->GivType() != CBotTypArrayPointer )
ASM_TRAP(); ASM_TRAP();
@ -1811,7 +1811,7 @@ void CBotVarArray::Copy(CBotVar* pSrc, BOOL bName)
void CBotVarArray::SetPointer(CBotVar* pVarClass) void CBotVarArray::SetPointer(CBotVar* pVarClass)
{ {
m_binit = TRUE; // init, même sur un pointeur null m_binit = true; // init, même sur un pointeur null
if ( m_pInstance == pVarClass) return; // spécial, ne pas décrémenter et réincrémenter if ( m_pInstance == pVarClass) return; // spécial, ne pas décrémenter et réincrémenter
// car le décrément peut détruire l'object // car le décrément peut détruire l'object
@ -1839,7 +1839,7 @@ CBotVarClass* CBotVarArray::GivPointer()
return m_pInstance->GivPointer(); return m_pInstance->GivPointer();
} }
CBotVar* CBotVarArray::GivItem(int n, BOOL bExtend) CBotVar* CBotVarArray::GivItem(int n, bool bExtend)
{ {
if ( m_pInstance == NULL ) if ( m_pInstance == NULL )
{ {
@ -1864,9 +1864,9 @@ CBotString CBotVarArray::GivValString()
return m_pInstance->GivValString(); return m_pInstance->GivValString();
} }
BOOL CBotVarArray::Save1State(FILE* pf) bool CBotVarArray::Save1State(FILE* pf)
{ {
if ( !WriteType(pf, m_type) ) return FALSE; if ( !WriteType(pf, m_type) ) return false;
return SaveVar(pf, m_pInstance); // sauve l'instance qui gère le tableau return SaveVar(pf, m_pInstance); // sauve l'instance qui gère le tableau
} }
@ -1889,7 +1889,7 @@ CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type )
m_type = type; m_type = type;
if ( !type.Eq(CBotTypNullPointer) ) if ( !type.Eq(CBotTypNullPointer) )
m_type.SetType(CBotTypPointer); // quoi qu'il en soit, c'est un pointeur m_type.SetType(CBotTypPointer); // quoi qu'il en soit, c'est un pointeur
m_binit = FALSE; m_binit = false;
m_pClass = NULL; m_pClass = NULL;
m_pVarClass = NULL; // sera défini par un SetPointer() m_pVarClass = NULL; // sera défini par un SetPointer()
@ -1902,12 +1902,12 @@ CBotVarPointer::~CBotVarPointer()
} }
void CBotVarPointer::Maj(void* pUser, BOOL bContinu) void CBotVarPointer::Maj(void* pUser, bool bContinu)
{ {
/* if ( !bContinu && m_pMyThis != NULL ) /* if ( !bContinu && m_pMyThis != NULL )
m_pMyThis->Maj(pUser, FALSE);*/ m_pMyThis->Maj(pUser, false);*/
if ( m_pVarClass != NULL) m_pVarClass->Maj(pUser, FALSE); if ( m_pVarClass != NULL) m_pVarClass->Maj(pUser, false);
} }
CBotVar* CBotVarPointer::GivItem(const char* name) CBotVar* CBotVarPointer::GivItem(const char* name)
@ -1950,7 +1950,7 @@ void CBotVarPointer::ConstructorSet()
void CBotVarPointer::SetPointer(CBotVar* pVarClass) void CBotVarPointer::SetPointer(CBotVar* pVarClass)
{ {
m_binit = TRUE; // init, même sur un pointeur null m_binit = true; // init, même sur un pointeur null
if ( m_pVarClass == pVarClass) return; // spécial, ne pas décrémenter et réincrémenter if ( m_pVarClass == pVarClass) return; // spécial, ne pas décrémenter et réincrémenter
// car le décrément peut détruire l'object // car le décrément peut détruire l'object
@ -2009,25 +2009,25 @@ CBotClass* CBotVarPointer::GivClass()
} }
BOOL CBotVarPointer::Save1State(FILE* pf) bool CBotVarPointer::Save1State(FILE* pf)
{ {
if ( m_pClass ) if ( m_pClass )
{ {
if (!WriteString(pf, m_pClass->GivName())) return FALSE; // nom de la classe if (!WriteString(pf, m_pClass->GivName())) return false; // nom de la classe
} }
else else
{ {
if (!WriteString(pf, "")) return FALSE; if (!WriteString(pf, "")) return false;
} }
if (!WriteLong(pf, GivIdent())) return FALSE; // la référence unique if (!WriteLong(pf, GivIdent())) return false; // la référence unique
// sauve aussi une copie de l'instance // sauve aussi une copie de l'instance
return SaveVar(pf, GivPointer()); return SaveVar(pf, GivPointer());
} }
// copie une variable dans une autre // copie une variable dans une autre
void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName) void CBotVarPointer::Copy(CBotVar* pSrc, bool bName)
{ {
if ( pSrc->GivType() != CBotTypPointer && if ( pSrc->GivType() != CBotTypPointer &&
pSrc->GivType() != CBotTypNullPointer) pSrc->GivType() != CBotTypNullPointer)
@ -2054,26 +2054,26 @@ void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName)
if (m_ident == 0 ) m_ident = p->m_ident; if (m_ident == 0 ) m_ident = p->m_ident;
} }
BOOL CBotVarPointer::Eq(CBotVar* left, CBotVar* right) bool CBotVarPointer::Eq(CBotVar* left, CBotVar* right)
{ {
CBotVarClass* l = left->GivPointer(); CBotVarClass* l = left->GivPointer();
CBotVarClass* r = right->GivPointer(); CBotVarClass* r = right->GivPointer();
if ( l == r ) return TRUE; if ( l == r ) return true;
if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return TRUE; if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return true;
if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return TRUE; if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return true;
return FALSE; return false;
} }
BOOL CBotVarPointer::Ne(CBotVar* left, CBotVar* right) bool CBotVarPointer::Ne(CBotVar* left, CBotVar* right)
{ {
CBotVarClass* l = left->GivPointer(); CBotVarClass* l = left->GivPointer();
CBotVarClass* r = right->GivPointer(); CBotVarClass* r = right->GivPointer();
if ( l == r ) return FALSE; if ( l == r ) return false;
if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return FALSE; if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return false;
if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return FALSE; if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return false;
return TRUE; return true;
} }
@ -2207,9 +2207,9 @@ void CBotTypResult::SetArray( int* max )
BOOL CBotTypResult::Compare(const CBotTypResult& typ) const bool CBotTypResult::Compare(const CBotTypResult& typ) const
{ {
if ( m_type != typ.m_type ) return FALSE; if ( m_type != typ.m_type ) return false;
if ( m_type == CBotTypArrayPointer ) return m_pNext->Compare(*typ.m_pNext); if ( m_type == CBotTypArrayPointer ) return m_pNext->Compare(*typ.m_pNext);
@ -2220,10 +2220,10 @@ BOOL CBotTypResult::Compare(const CBotTypResult& typ) const
return m_pClass == typ.m_pClass; return m_pClass == typ.m_pClass;
} }
return TRUE; return true;
} }
BOOL CBotTypResult::Eq(int type) const bool CBotTypResult::Eq(int type) const
{ {
return m_type == type; return m_type == type;
} }

216
src/CBot/CBotWhile.cpp
View File

@ -66,7 +66,7 @@ CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
// la condition existe // la condition existe
IncLvl(inst->m_label); IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl(); DecLvl();
if ( pStk->IsOk() ) if ( pStk->IsOk() )
@ -83,31 +83,31 @@ CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute une instruction "while" // exécute une instruction "while"
BOOL CBotWhile :: Execute(CBotStack* &pj) bool CBotWhile :: Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
while( TRUE ) switch( pile->GivState() ) // exécute la boucle while( true ) switch( pile->GivState() ) // exécute la boucle
{ // il y a 2 états possibles (selon reprise) { // il y a 2 états possibles (selon reprise)
case 0: case 0:
// évalue la condition // évalue la condition
if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ? if ( !m_Condition->Execute(pile) ) return false; // interrompu ici ?
// le résultat de la condition est sur la pile // le résultat de la condition est sur la pile
// termine s'il y a une erreur ou si la condition est fausse // termine s'il y a une erreur ou si la condition est fausse
if ( !pile->IsOk() || pile->GivVal() != TRUE ) if ( !pile->IsOk() || pile->GivVal() != true )
{ {
return pj->Return(pile); // transmet le résultat et libère la pile return pj->Return(pile); // transmet le résultat et libère la pile
} }
// la condition est vrai, passe dans le second mode // la condition est vrai, passe dans le second mode
if (!pile->SetState(1)) return FALSE; // prêt pour la suite if (!pile->SetState(1)) return false; // prêt pour la suite
case 1: case 1:
// évalue le bloc d'instruction associé // évalue le bloc d'instruction associé
@ -125,12 +125,12 @@ BOOL CBotWhile :: Execute(CBotStack* &pj)
} }
// repasse au test pour recommencer // repasse au test pour recommencer
if (!pile->SetState(0, 0)) return FALSE; if (!pile->SetState(0, 0)) return false;
continue; continue;
} }
} }
void CBotWhile :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotWhile :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile
@ -196,7 +196,7 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
{ {
IncLvl(inst->m_label); IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl(); DecLvl();
if ( pStk->IsOk() ) if ( pStk->IsOk() )
@ -221,19 +221,19 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute une instruction "repeat" // exécute une instruction "repeat"
BOOL CBotRepeat :: Execute(CBotStack* &pj) bool CBotRepeat :: Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
while( TRUE ) switch( pile->GivState() ) // exécute la boucle while( true ) switch( pile->GivState() ) // exécute la boucle
{ // il y a 2 états possibles (selon reprise) { // il y a 2 états possibles (selon reprise)
case 0: case 0:
// évalue le nombre d'itération // évalue le nombre d'itération
if ( !m_NbIter->Execute(pile) ) return FALSE; // interrompu ici ? if ( !m_NbIter->Execute(pile) ) return false; // interrompu ici ?
// le résultat de la condition est sur la pile // le résultat de la condition est sur la pile
@ -246,7 +246,7 @@ BOOL CBotRepeat :: Execute(CBotStack* &pj)
// met le nombre d'itération +1 dans le "state" // met le nombre d'itération +1 dans le "state"
if (!pile->SetState(n+1)) return FALSE; // prêt pour la suite if (!pile->SetState(n+1)) return false; // prêt pour la suite
continue; // passe à la suite continue; // passe à la suite
case 1: case 1:
@ -269,12 +269,12 @@ BOOL CBotRepeat :: Execute(CBotStack* &pj)
} }
// repasse au test pour recommencer // repasse au test pour recommencer
if (!pile->SetState(pile->GivState()-1, 0)) return FALSE; if (!pile->SetState(pile->GivState()-1, 0)) return false;
continue; continue;
} }
} }
void CBotRepeat :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotRepeat :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile
@ -332,7 +332,7 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)
// cherche un bloc d'instruction après le do // cherche un bloc d'instruction après le do
IncLvl(inst->m_label); IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl(); DecLvl();
if ( pStk->IsOk() ) if ( pStk->IsOk() )
@ -358,15 +358,15 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute une instruction "do" // exécute une instruction "do"
BOOL CBotDo :: Execute(CBotStack* &pj) bool CBotDo :: Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
while( TRUE ) switch( pile->GivState() ) // exécute la boucle while( true ) switch( pile->GivState() ) // exécute la boucle
{ // il y a 2 états possibles (selon reprise) { // il y a 2 états possibles (selon reprise)
case 0: case 0:
// évalue le bloc d'instruction associé // évalue le bloc d'instruction associé
@ -383,27 +383,27 @@ BOOL CBotDo :: Execute(CBotStack* &pj)
return pj->Return(pile); // transmet le résultat et libère la pile return pj->Return(pile); // transmet le résultat et libère la pile
} }
if (!pile->SetState(1)) return FALSE; // prêt pour la suite if (!pile->SetState(1)) return false; // prêt pour la suite
case 1: case 1:
// évalue la condition // évalue la condition
if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ? if ( !m_Condition->Execute(pile) ) return false; // interrompu ici ?
// le résultat de la condition est sur la pile // le résultat de la condition est sur la pile
// termine s'il y a une erreur ou si la condition est fausse // termine s'il y a une erreur ou si la condition est fausse
if ( !pile->IsOk() || pile->GivVal() != TRUE ) if ( !pile->IsOk() || pile->GivVal() != true )
{ {
return pj->Return(pile); // transmet le résultat et libère la pile return pj->Return(pile); // transmet le résultat et libère la pile
} }
// repasse au bloc d'instruction pour recommencer // repasse au bloc d'instruction pour recommencer
if (!pile->SetState(0, 0)) return FALSE; if (!pile->SetState(0, 0)) return false;
continue; continue;
} }
} }
void CBotDo :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotDo :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -467,7 +467,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
return NULL; return NULL;
} }
CBotCStack* pStk = pStack->TokenStack(pp, TRUE); // un petit bout de pile svp CBotCStack* pStk = pStack->TokenStack(pp, true); // un petit bout de pile svp
// compile les instructions pour initialisation // compile les instructions pour initialisation
inst->m_Init = CBotListExpression::Compile( p, pStk ); inst->m_Init = CBotListExpression::Compile( p, pStk );
@ -494,7 +494,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
if ( IsOfType(p, ID_CLOSEPAR)) // manque la parenthèse ? if ( IsOfType(p, ID_CLOSEPAR)) // manque la parenthèse ?
{ {
IncLvl(inst->m_label); IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl(); DecLvl();
if ( pStk->IsOk() ) if ( pStk->IsOk() )
return pStack->Return(inst, pStk);; return pStack->Return(inst, pStk);;
@ -510,39 +510,39 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute l'instruction "for" // exécute l'instruction "for"
BOOL CBotFor :: Execute(CBotStack* &pj) bool CBotFor :: Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this, TRUE); // ajoute un élément à la pile (variables locales) CBotStack* pile = pj->AddStack(this, true); // ajoute un élément à la pile (variables locales)
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
while( TRUE ) switch( pile->GivState() ) // exécute la boucle while( true ) switch( pile->GivState() ) // exécute la boucle
{ // il y a 4 états possibles (selon reprise) { // il y a 4 états possibles (selon reprise)
case 0: case 0:
// évalue l'initialisation // évalue l'initialisation
if ( m_Init != NULL && if ( m_Init != NULL &&
!m_Init->Execute(pile) ) return FALSE; // interrompu ici ? !m_Init->Execute(pile) ) return false; // interrompu ici ?
if (!pile->SetState(1)) return FALSE; // prêt pour la suite if (!pile->SetState(1)) return false; // prêt pour la suite
case 1: case 1:
// évalue la condition // évalue la condition
if ( m_Test != NULL ) // pas de condition ? -> vrai ! if ( m_Test != NULL ) // pas de condition ? -> vrai !
{ {
if (!m_Test->Execute(pile) ) return FALSE; // interrompu ici ? if (!m_Test->Execute(pile) ) return false; // interrompu ici ?
// le résultat de la condition est sur la pile // le résultat de la condition est sur la pile
// termine s'il y a une erreur ou si la condition est fausse // termine s'il y a une erreur ou si la condition est fausse
if ( !pile->IsOk() || pile->GivVal() != TRUE ) if ( !pile->IsOk() || pile->GivVal() != true )
{ {
return pj->Return(pile); // transmet le résultat et libère la pile return pj->Return(pile); // transmet le résultat et libère la pile
} }
} }
// la condition est vrai, passe à la suite // la condition est vrai, passe à la suite
if (!pile->SetState(2)) return FALSE; // prêt pour la suite if (!pile->SetState(2)) return false; // prêt pour la suite
case 2: case 2:
// évalue le bloc d'instruction associé // évalue le bloc d'instruction associé
@ -559,20 +559,20 @@ BOOL CBotFor :: Execute(CBotStack* &pj)
return pj->Return(pile); // transmet le résultat et libère la pile return pj->Return(pile); // transmet le résultat et libère la pile
} }
if (!pile->SetState(3)) return FALSE; // prêt pour la suite if (!pile->SetState(3)) return false; // prêt pour la suite
case 3: case 3:
// évalue l'incrémentation // évalue l'incrémentation
if ( m_Incr != NULL && if ( m_Incr != NULL &&
!m_Incr->Execute(pile) ) return FALSE; // interrompu ici ? !m_Incr->Execute(pile) ) return false; // interrompu ici ?
// repasse au test pour recommencer // repasse au test pour recommencer
if (!pile->SetState(1, 0)) return FALSE; // revient au test if (!pile->SetState(1, 0)) return false; // revient au test
continue; continue;
} }
} }
void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotFor :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -583,28 +583,28 @@ void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain)
{ // il y a 4 états possibles (selon reprise) { // il y a 4 états possibles (selon reprise)
case 0: case 0:
// évalue l'initialisation // évalue l'initialisation
if ( m_Init != NULL ) m_Init->RestoreState(pile, TRUE); // interrompu ici ! if ( m_Init != NULL ) m_Init->RestoreState(pile, true); // interrompu ici !
return; return;
case 1: case 1:
if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // définitions variables if ( m_Init != NULL ) m_Init->RestoreState(pile, false); // définitions variables
// évalue la condition // évalue la condition
if ( m_Test != NULL ) m_Test->RestoreState(pile, TRUE); // interrompu ici ! if ( m_Test != NULL ) m_Test->RestoreState(pile, true); // interrompu ici !
return; return;
case 2: case 2:
if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // définitions variables if ( m_Init != NULL ) m_Init->RestoreState(pile, false); // définitions variables
// évalue le bloc d'instruction associé // évalue le bloc d'instruction associé
if ( m_Block != NULL ) m_Block->RestoreState(pile, TRUE); if ( m_Block != NULL ) m_Block->RestoreState(pile, true);
return; return;
case 3: case 3:
if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // définitions variables if ( m_Init != NULL ) m_Init->RestoreState(pile, false); // définitions variables
// évalue l'incrémentation // évalue l'incrémentation
if ( m_Incr != NULL ) m_Incr->RestoreState(pile, TRUE); // interrompu ici ! if ( m_Incr != NULL ) m_Incr->RestoreState(pile, true); // interrompu ici !
return; return;
} }
} }
@ -629,10 +629,10 @@ CBotListExpression::~CBotListExpression()
static CBotInstr* CompileInstrOrDefVar(CBotToken* &p, CBotCStack* pStack) static CBotInstr* CompileInstrOrDefVar(CBotToken* &p, CBotCStack* pStack)
{ {
CBotInstr* i = CBotInt::Compile( p, pStack, FALSE, TRUE ); // est-ce une déclaration d'un entier ? CBotInstr* i = CBotInt::Compile( p, pStack, false, true ); // est-ce une déclaration d'un entier ?
if ( i== NULL ) i = CBotFloat::Compile( p, pStack, FALSE, TRUE ); // ou d'un nombre réel ? if ( i== NULL ) i = CBotFloat::Compile( p, pStack, false, true ); // ou d'un nombre réel ?
if ( i== NULL ) i = CBotBoolean::Compile( p, pStack, FALSE, TRUE ); // ou d'un booléen ? if ( i== NULL ) i = CBotBoolean::Compile( p, pStack, false, true ); // ou d'un booléen ?
if ( i== NULL ) i = CBotIString::Compile( p, pStack, FALSE, TRUE ); // ou d'une chaîne ? if ( i== NULL ) i = CBotIString::Compile( p, pStack, false, true ); // ou d'une chaîne ?
if ( i== NULL ) i = CBotExpression::Compile( p, pStack ); // compile une expression if ( i== NULL ) i = CBotExpression::Compile( p, pStack ); // compile une expression
return i; return i;
} }
@ -660,7 +660,7 @@ CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack)
return NULL; return NULL;
} }
BOOL CBotListExpression::Execute(CBotStack* &pj) bool CBotListExpression::Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack();// indispensable CBotStack* pile = pj->AddStack();// indispensable
CBotInstr* p = m_Expr; // la première expression CBotInstr* p = m_Expr; // la première expression
@ -668,17 +668,17 @@ BOOL CBotListExpression::Execute(CBotStack* &pj)
int state = pile->GivState(); int state = pile->GivState();
while (state-->0) p = p->GivNext(); // revient sur l'opération interrompue while (state-->0) p = p->GivNext(); // revient sur l'opération interrompue
if ( p != NULL ) while (TRUE) if ( p != NULL ) while (true)
{ {
if ( !p->Execute(pile) ) return FALSE; if ( !p->Execute(pile) ) return false;
p = p->GivNext(); p = p->GivNext();
if ( p == NULL ) break; if ( p == NULL ) break;
if (!pile->IncState()) return FALSE; // prêt pour la suivante if (!pile->IncState()) return false; // prêt pour la suivante
} }
return pj->Return(pile); return pj->Return(pile);
} }
void CBotListExpression::RestoreState(CBotStack* &pj, BOOL bMain) void CBotListExpression::RestoreState(CBotStack* &pj, bool bMain)
{ {
CBotStack* pile = pj; CBotStack* pile = pj;
int state = 0x7000; int state = 0x7000;
@ -694,7 +694,7 @@ void CBotListExpression::RestoreState(CBotStack* &pj, BOOL bMain)
while (p != NULL && state-->0) while (p != NULL && state-->0)
{ {
p->RestoreState(pile, FALSE); p->RestoreState(pile, false);
p = p->GivNext(); // revient sur l'opération interrompue p = p->GivNext(); // revient sur l'opération interrompue
} }
@ -770,7 +770,7 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
return pStack->Return(NULL, pStk); return pStack->Return(NULL, pStk);
} }
CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk, true );
if ( !pStk->IsOk() ) if ( !pStk->IsOk() )
{ {
delete inst; delete inst;
@ -811,21 +811,21 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute une instruction "switch" // exécute une instruction "switch"
BOOL CBotSwitch :: Execute(CBotStack* &pj) bool CBotSwitch :: Execute(CBotStack* &pj)
{ {
CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile
// if ( pile1 == EOX ) return TRUE; // if ( pile1 == EOX ) return true;
CBotInstr* p = m_Block; // la première expression CBotInstr* p = m_Block; // la première expression
int state = pile1->GivState(); int state = pile1->GivState();
if (state == 0) if (state == 0)
{ {
if ( !m_Value->Execute(pile1) ) return FALSE; if ( !m_Value->Execute(pile1) ) return false;
pile1->SetState(state = -1); pile1->SetState(state = -1);
} }
if ( pile1->IfStep() ) return FALSE; if ( pile1->IfStep() ) return false;
if ( state == -1 ) if ( state == -1 )
{ {
@ -843,7 +843,7 @@ BOOL CBotSwitch :: Execute(CBotStack* &pj)
if ( p == NULL ) return pj->Return(pile1); // terminé si plus rien if ( p == NULL ) return pj->Return(pile1); // terminé si plus rien
if ( !pile1->SetState(state) ) return FALSE; if ( !pile1->SetState(state) ) return false;
} }
p = m_Block; // revient au début p = m_Block; // revient au début
@ -852,13 +852,13 @@ BOOL CBotSwitch :: Execute(CBotStack* &pj)
while( p != NULL ) while( p != NULL )
{ {
if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1); if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1);
if ( !pile1->IncState() ) return FALSE; if ( !pile1->IncState() ) return false;
p = p->GivNext(); p = p->GivNext();
} }
return pj->Return(pile1); return pj->Return(pile1);
} }
void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotSwitch :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -882,13 +882,13 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain)
// p = m_Block; // revient au début // p = m_Block; // revient au début
while ( p != NULL && state-- > 0 ) while ( p != NULL && state-- > 0 )
{ {
p->RestoreState(pile1, FALSE); p->RestoreState(pile1, false);
p = p->GivNext(); // avance dans la liste p = p->GivNext(); // avance dans la liste
} }
if( p != NULL ) if( p != NULL )
{ {
p->RestoreState(pile1, TRUE); p->RestoreState(pile1, true);
return; return;
} }
} }
@ -942,21 +942,21 @@ CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)
// exécution de l'instruction "case" // exécution de l'instruction "case"
BOOL CBotCase::Execute(CBotStack* &pj) bool CBotCase::Execute(CBotStack* &pj)
{ {
return TRUE; // l'instruction "case" ne fait rien ! return true; // l'instruction "case" ne fait rien !
} }
void CBotCase::RestoreState(CBotStack* &pj, BOOL bMain) void CBotCase::RestoreState(CBotStack* &pj, bool bMain)
{ {
} }
// routine permettant de trouver le point d'entrée "case" // routine permettant de trouver le point d'entrée "case"
// correspondant à la valeur cherchée // correspondant à la valeur cherchée
BOOL CBotCase::CompCase(CBotStack* &pile, int val) bool CBotCase::CompCase(CBotStack* &pile, int val)
{ {
if ( m_Value == NULL ) return TRUE; // cas pour "default" if ( m_Value == NULL ) return true; // cas pour "default"
while (!m_Value->Execute(pile)); // met sur la pile la valeur correpondant (sans interruption) while (!m_Value->Execute(pile)); // met sur la pile la valeur correpondant (sans interruption)
return (pile->GivVal() == val); // compare avec la valeur cherchée return (pile->GivVal() == val); // compare avec la valeur cherchée
@ -1016,18 +1016,18 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)
// exécution l'instructino "break" ou "continu" // exécution l'instructino "break" ou "continu"
BOOL CBotBreak :: Execute(CBotStack* &pj) bool CBotBreak :: Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this); CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
pile->SetBreak(m_token.GivType()==ID_BREAK ? 1 : 2, m_label); pile->SetBreak(m_token.GivType()==ID_BREAK ? 1 : 2, m_label);
return pj->Return(pile); return pj->Return(pile);
} }
void CBotBreak :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotBreak :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( bMain ) pj->RestoreStack(this); if ( bMain ) pj->RestoreStack(this);
} }
@ -1092,14 +1092,14 @@ CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack)
// les arrêts par suspension // les arrêts par suspension
// et les "finaly" // et les "finaly"
BOOL CBotTry :: Execute(CBotStack* &pj) bool CBotTry :: Execute(CBotStack* &pj)
{ {
int val; int val;
CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile
// if ( pile1 == EOX ) return TRUE; // if ( pile1 == EOX ) return true;
if ( pile1->IfStep() ) return FALSE; if ( pile1->IfStep() ) return false;
// ou le retrouve en cas de reprise // ou le retrouve en cas de reprise
CBotStack* pile0 = pj->AddStack2(); // ajoute un élément à la pile secondaire CBotStack* pile0 = pj->AddStack2(); // ajoute un élément à la pile secondaire
CBotStack* pile2 = pile0->AddStack(); CBotStack* pile2 = pile0->AddStack();
@ -1114,14 +1114,14 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
val = pile1->GivError(); val = pile1->GivError();
if ( val == 0 && CBotStack::m_initimer == 0 ) // en mode de step ? if ( val == 0 && CBotStack::m_initimer == 0 ) // en mode de step ?
return FALSE; // ne fait pas le catch return false; // ne fait pas le catch
pile1->IncState(); pile1->IncState();
pile2->SetState(val); // mémorise le numéro de l'erreur pile2->SetState(val); // mémorise le numéro de l'erreur
pile1->SetError(0); // pour l'instant il n'y a plus d'erreur ! pile1->SetError(0); // pour l'instant il n'y a plus d'erreur !
if ( val == 0 && CBotStack::m_initimer < 0 ) // en mode de step ? if ( val == 0 && CBotStack::m_initimer < 0 ) // en mode de step ?
return FALSE; // ne fait pas le catch return false; // ne fait pas le catch
} }
// il y a eu une interruption // il y a eu une interruption
@ -1137,16 +1137,16 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
if ( --state <= 0 ) if ( --state <= 0 )
{ {
// demande au bloc catch s'il se sent concerné // demande au bloc catch s'il se sent concerné
if ( !pc->TestCatch(pile2, val) ) return FALSE; // suspendu ! if ( !pc->TestCatch(pile2, val) ) return false; // suspendu !
pile1->IncState(); pile1->IncState();
} }
if ( --state <= 0 ) if ( --state <= 0 )
{ {
if ( pile2->GivVal() == TRUE ) if ( pile2->GivVal() == true )
{ {
// pile0->SetState(1); // pile0->SetState(1);
if ( !pc->Execute(pile2) ) return FALSE; // exécute l'opération if ( !pc->Execute(pile2) ) return false; // exécute l'opération
if ( m_FinalInst == NULL ) if ( m_FinalInst == NULL )
return pj->Return(pile2); // termine le try return pj->Return(pile2); // termine le try
@ -1164,7 +1164,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
{ {
// pile0->SetState(1); // pile0->SetState(1);
if (!m_FinalInst->Execute(pile2) && pile2->IsOk()) return FALSE; if (!m_FinalInst->Execute(pile2) && pile2->IsOk()) return false;
if (!pile2->IsOk()) return pj->Return(pile2); // garde cette exception if (!pile2->IsOk()) return pj->Return(pile2); // garde cette exception
pile2->SetError(pile1->GivState()==-1 ? val : 0); // remet l'erreur initiale pile2->SetError(pile1->GivState()==-1 ? val : 0); // remet l'erreur initiale
return pj->Return(pile2); return pj->Return(pile2);
@ -1176,11 +1176,11 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
return pj->Return(pile2); // termine le try sans exception aucune return pj->Return(pile2); // termine le try sans exception aucune
pile1->SetError(val); // remet l'erreur pile1->SetError(val); // remet l'erreur
return FALSE; // ce n'est pas pour nous return false; // ce n'est pas pour nous
} }
void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotTry :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -1217,7 +1217,7 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain)
} }
if ( --state <= 0 ) if ( --state <= 0 )
{ {
if ( pile2->GivVal() == TRUE ) if ( pile2->GivVal() == true )
{ {
pc->RestoreState(pile2, bMain); // exécute l'opération pc->RestoreState(pile2, bMain); // exécute l'opération
return; return;
@ -1285,27 +1285,27 @@ CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
// exécution de "catch" // exécution de "catch"
BOOL CBotCatch :: Execute(CBotStack* &pj) bool CBotCatch :: Execute(CBotStack* &pj)
{ {
if ( m_Block == NULL ) return TRUE; if ( m_Block == NULL ) return true;
return m_Block->Execute(pj); // exécute le bloc associé return m_Block->Execute(pj); // exécute le bloc associé
} }
void CBotCatch :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotCatch :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( bMain && m_Block != NULL ) m_Block->RestoreState(pj, bMain); if ( bMain && m_Block != NULL ) m_Block->RestoreState(pj, bMain);
} }
void CBotCatch :: RestoreCondState(CBotStack* &pj, BOOL bMain) void CBotCatch :: RestoreCondState(CBotStack* &pj, bool bMain)
{ {
m_Cond->RestoreState(pj, bMain); m_Cond->RestoreState(pj, bMain);
} }
// routine pour savoir si le catch est à faire ou non // routine pour savoir si le catch est à faire ou non
BOOL CBotCatch :: TestCatch(CBotStack* &pile, int val) bool CBotCatch :: TestCatch(CBotStack* &pile, int val)
{ {
if ( !m_Cond->Execute(pile) ) return FALSE; if ( !m_Cond->Execute(pile) ) return false;
if ( val > 0 || pile->GivType() != CBotTypBoolean ) if ( val > 0 || pile->GivType() != CBotTypBoolean )
{ {
@ -1314,7 +1314,7 @@ BOOL CBotCatch :: TestCatch(CBotStack* &pile, int val)
pile->SetVar(var); // remet sur la pile pile->SetVar(var); // remet sur la pile
} }
return TRUE; return true;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
@ -1359,18 +1359,18 @@ CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute l'instruction "throw" // exécute l'instruction "throw"
BOOL CBotThrow :: Execute(CBotStack* &pj) bool CBotThrow :: Execute(CBotStack* &pj)
{ {
CBotStack* pile = pj->AddStack(this); CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return TRUE; // if ( pile == EOX ) return true;
if ( pile->GivState() == 0 ) if ( pile->GivState() == 0 )
{ {
if ( !m_Value->Execute(pile) ) return FALSE; if ( !m_Value->Execute(pile) ) return false;
pile->IncState(); pile->IncState();
} }
if ( pile->IfStep() ) return FALSE; if ( pile->IfStep() ) return false;
int val = pile->GivVal(); int val = pile->GivVal();
if ( val < 0 ) val = TX_BADTHROW; if ( val < 0 ) val = TX_BADTHROW;
@ -1378,7 +1378,7 @@ BOOL CBotThrow :: Execute(CBotStack* &pj)
return pj->Return( pile ); return pj->Return( pile );
} }
void CBotThrow :: RestoreState(CBotStack* &pj, BOOL bMain) void CBotThrow :: RestoreState(CBotStack* &pj, bool bMain)
{ {
if ( !bMain ) return; if ( !bMain ) return;
@ -1417,11 +1417,11 @@ CBotInstr* CBotStartDebugDD::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute l'instruction "throw" // exécute l'instruction "throw"
BOOL CBotStartDebugDD :: Execute(CBotStack* &pj) bool CBotStartDebugDD :: Execute(CBotStack* &pj)
{ {
CBotProgram* p = pj->GivBotCall(); CBotProgram* p = pj->GivBotCall();
p->m_bDebugDD = TRUE; p->m_bDebugDD = true;
return TRUE; return true;
} }

14
src/CBot/ClassFILE.cpp
View File

@ -58,7 +58,7 @@ void PrepareFilename(CBotString &filename) //DD!
// reçois le nom du fichier en paramètre // reçois le nom du fichier en paramètre
// exécution // exécution
BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) bool rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
CBotString mode; CBotString mode;
@ -132,7 +132,7 @@ CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
// destructeur de la classe // destructeur de la classe
// exécution // exécution
BOOL rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) bool rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
// récupère l'élément "handle" // récupère l'élément "handle"
pVar = pThis->GivItem("handle"); pVar = pThis->GivItem("handle");
@ -154,7 +154,7 @@ BOOL rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception
// reçois le mode r/w en paramètre // reçois le mode r/w en paramètre
// exécution // exécution
BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) bool rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
// il doit y avoir un paramètre // il doit y avoir un paramètre
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; } if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
@ -243,7 +243,7 @@ CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)
// méthode FILE :: close // méthode FILE :: close
// exécution // exécution
BOOL rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) bool rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
// il ne doit pas y avoir de paramètre // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) return CBotErrOverParam; if ( pVar != NULL ) return CBotErrOverParam;
@ -275,7 +275,7 @@ CBotTypResult cfclose (CBotVar* pThis, CBotVar* &pVar)
// méthode FILE :: writeln // méthode FILE :: writeln
// exécution // exécution
BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) bool rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
// il doit y avoir un paramètre // il doit y avoir un paramètre
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; } if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
@ -319,7 +319,7 @@ CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)
// méthode FILE :: readln // méthode FILE :: readln
// exécution // exécution
BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) bool rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
// il ne doit pas y avoir de paramètre // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; } if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }
@ -360,7 +360,7 @@ CBotTypResult cfread (CBotVar* pThis, CBotVar* &pVar)
// exécution // exécution
BOOL rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) bool rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{ {
// il ne doit pas y avoir de paramètre // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; } if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }

98
src/CBot/StringFunctions.cpp
View File

@ -18,23 +18,23 @@
// donne la longueur d'une chaîne // donne la longueur d'une chaîne
// exécution // exécution
BOOL rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// pas de second paramètre // pas de second paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// met la longueur sur la pile // met la longueur sur la pile
pResult->SetValInt( s.GivLength() ); pResult->SetValInt( s.GivLength() );
return TRUE; return true;
} }
// int xxx ( string ) // int xxx ( string )
@ -60,36 +60,36 @@ CBotTypResult cIntStr( CBotVar* &pVar, void* pUser )
// donne la partie gauche d'une chaîne // donne la partie gauche d'une chaîne
// exécution // exécution
BOOL rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// il faut un second paramètre // il faut un second paramètre
pVar = pVar->GivNext(); pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être un nombre // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; } if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// récupère ce nombre // récupère ce nombre
int n = pVar->GivValInt(); int n = pVar->GivValInt();
// pas de 3e paramètre // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// prend la partie intéressante // prend la partie intéressante
s = s.Left( n ); s = s.Left( n );
// la met sur la pile // la met sur la pile
pResult->SetValString( s ); pResult->SetValString( s );
return TRUE; return true;
} }
// string xxx ( string, int ) // string xxx ( string, int )
@ -122,58 +122,58 @@ CBotTypResult cStrStrInt( CBotVar* &pVar, void* pUser )
// donne la partie droite d'une chaîne // donne la partie droite d'une chaîne
// exécution // exécution
BOOL rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// il faut un second paramètre // il faut un second paramètre
pVar = pVar->GivNext(); pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être un nombre // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; } if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// récupère ce nombre // récupère ce nombre
int n = pVar->GivValInt(); int n = pVar->GivValInt();
// pas de 3e paramètre // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// prend la partie intéressante // prend la partie intéressante
s = s.Right( n ); s = s.Right( n );
// la met sur la pile // la met sur la pile
pResult->SetValString( s ); pResult->SetValString( s );
return TRUE; return true;
} }
// donne la partie centrale d'une chaîne // donne la partie centrale d'une chaîne
// exécution // exécution
BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// il faut un second paramètre // il faut un second paramètre
pVar = pVar->GivNext(); pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être un nombre // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; } if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// récupère ce nombre // récupère ce nombre
int n = pVar->GivValInt(); int n = pVar->GivValInt();
@ -184,13 +184,13 @@ BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
pVar = pVar->GivNext(); pVar = pVar->GivNext();
// qui doit être un nombre // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; } if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// récupère ce nombre // récupère ce nombre
int l = pVar->GivValInt(); int l = pVar->GivValInt();
// mais pas de 4e paramètre // mais pas de 4e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
// prend la partie intéressante // prend la partie intéressante
s = s.Mid( n, l ); s = s.Mid( n, l );
@ -203,7 +203,7 @@ BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
// la met sur la pile // la met sur la pile
pResult->SetValString( s ); pResult->SetValString( s );
return TRUE; return true;
} }
// donne la partie centrale d'une chaîne // donne la partie centrale d'une chaîne
@ -247,25 +247,25 @@ CBotTypResult cStrStrIntInt( CBotVar* &pVar, void* pUser )
// donne le nombre contenu dans une chaîne // donne le nombre contenu dans une chaîne
// exécution // exécution
BOOL rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// mais pas de 2e paramètre // mais pas de 2e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
float val = GivNumFloat(s); float val = GivNumFloat(s);
// la met la valeur sur la pile // la met la valeur sur la pile
pResult->SetValFloat( val ); pResult->SetValFloat( val );
return TRUE; return true;
} }
// float xxx ( string ) // float xxx ( string )
@ -291,35 +291,35 @@ CBotTypResult cFloatStr( CBotVar* &pVar, void* pUser )
// trouve une chaine dans une autre // trouve une chaine dans une autre
// exécution // exécution
BOOL rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// il faut un second paramètre // il faut un second paramètre
pVar = pVar->GivNext(); pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// récupère ce nombre // récupère ce nombre
CBotString s2 = pVar->GivValString(); CBotString s2 = pVar->GivValString();
// pas de 3e paramètre // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// met le résultat sur la pile // met le résultat sur la pile
int res = s.Find(s2); int res = s.Find(s2);
pResult->SetValInt( res ); pResult->SetValInt( res );
if ( res < 0 ) pResult->SetInit( IS_NAN ); if ( res < 0 ) pResult->SetInit( IS_NAN );
return TRUE; return true;
} }
// int xxx ( string, string ) // int xxx ( string, string )
@ -352,51 +352,51 @@ CBotTypResult cIntStrStr( CBotVar* &pVar, void* pUser )
// donne une chaine en majuscule // donne une chaine en majuscule
// exécution // exécution
BOOL rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// mais pas de 2e paramètre // mais pas de 2e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
s.MakeUpper(); s.MakeUpper();
// la met la valeur sur la pile // la met la valeur sur la pile
pResult->SetValString( s ); pResult->SetValString( s );
return TRUE; return true;
} }
// donne une chaine en minuscules // donne une chaine en minuscules
// exécution // exécution
BOOL rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) bool rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{ {
// il faut un paramètre // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; } if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// qui doit être une string // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; } if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// recupére le contenu de la string // recupére le contenu de la string
CBotString s = pVar->GivValString(); CBotString s = pVar->GivValString();
// mais pas de 2e paramètre // mais pas de 2e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; } if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
s.MakeLower(); s.MakeLower();
// la met la valeur sur la pile // la met la valeur sur la pile
pResult->SetValString( s ); pResult->SetValString( s );
return TRUE; return true;
} }
// string xxx ( string ) // string xxx ( string )

15
src/CBot/old
View File

@ -1,15 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.

5
src/CMakeLists.txt
View File

@ -1,5 +1,5 @@
# CBot shared library is built separately # CBot shared library is built separately
# add_subdirectory(CBot) -- not yet WinAPI-independent add_subdirectory(CBot)
# Configure options # Configure options
@ -25,6 +25,7 @@ configure_file(common/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/common/config.h
# Source files # Source files
# Commented out files are still dependent on DirectX or WinAPI # Commented out files are still dependent on DirectX or WinAPI
set(SOURCES set(SOURCES
app/app.cpp app/app.cpp
app/main.cpp app/main.cpp
@ -150,7 +151,7 @@ set(LIBS
${SDL_LIBRARY} ${SDL_LIBRARY}
${SDLIMAGE_LIBRARY} ${SDLIMAGE_LIBRARY}
${OPENGL_LIBRARY} ${OPENGL_LIBRARY}
#CBot -- not yet WinAPI-independent CBot
) )
include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) include_directories(. ${CMAKE_CURRENT_BINARY_DIR})