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)
# Global compile flags
set(CMAKE_CXX_FLAGS_RELEASE "-O2")
set(CMAKE_CXX_FLAGS_DEBUG "-w -g -O0")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -Wall")
set(CMAKE_CXX_FLAGS_DEBUG "-w -g -O0 -Wall")
# Subdirectory with sources
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
BOOL CBotAddExpr::Execute(CBotStack* &pStack)
bool CBotAddExpr::Execute(CBotStack* &pStack)
{
CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// 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(const char* name, CBotClass* pPapa, BOOL bIntrinsic)
CBotClass::CBotClass(const char* name, CBotClass* pPapa, bool bIntrinsic)
{
m_pParent = pPapa;
m_name = name;
@ -30,7 +30,7 @@ CBotClass::CBotClass(const char* name, CBotClass* pPapa, BOOL bIntrinsic)
m_pCalls = NULL;
m_pMethod = NULL;
m_rMaj = NULL;
m_IsDef = TRUE;
m_IsDef = true;
m_bIntrinsic= bIntrinsic;
m_cptLock = 0;
m_cptOne = 0;
@ -86,7 +86,7 @@ void CBotClass::Purge()
m_pCalls = NULL;
delete m_pMethod;
m_pMethod = NULL;
m_IsDef = FALSE;
m_IsDef = false;
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
}
BOOL CBotClass::Lock(CBotProgram* p)
bool CBotClass::Lock(CBotProgram* p)
{
int i = m_cptLock++;
@ -102,13 +102,13 @@ BOOL CBotClass::Lock(CBotProgram* p)
{
m_cptOne = 1;
m_ProgInLock[0] = p;
return TRUE;
return true;
}
if ( p == m_ProgInLock[0] )
{
m_cptOne++;
m_cptLock--; // a déjà été compté
return TRUE;
return true;
}
for ( int j = 1 ; j <= i ; j++)
@ -116,7 +116,7 @@ BOOL CBotClass::Lock(CBotProgram* p)
if ( p == m_ProgInLock[j] )
{
m_cptLock--;
return FALSE; // déjà en attente
return false; // déjà en attente
}
}
@ -127,7 +127,7 @@ BOOL CBotClass::Lock(CBotProgram* p)
else
m_cptLock--;
return FALSE;
return false;
}
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());
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);
if ( m_pVar == NULL ) m_pVar = pVar;
else m_pVar->AddNext(pVar);
return TRUE;
return true;
}
void CBotClass::AddNext(CBotClass* pClass)
@ -223,15 +223,15 @@ CBotClass* CBotClass::GivParent()
return m_pParent;
}
BOOL CBotClass::IsChildOf(CBotClass* pClass)
bool CBotClass::IsChildOf(CBotClass* pClass)
{
CBotClass* p = this;
while ( p != NULL )
{
if ( p == pClass ) return TRUE;
if ( p == pClass ) return true;
p = p->m_pParent;
}
return FALSE;
return false;
}
@ -266,7 +266,7 @@ CBotVar* CBotClass::GivItemRef(int nIdent)
return NULL;
}
BOOL CBotClass::IsIntrinsic()
bool CBotClass::IsIntrinsic()
{
return m_bIntrinsic;
}
@ -289,8 +289,8 @@ CBotClass* CBotClass::Find(const char* name)
return NULL;
}
BOOL CBotClass::AddFunction(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
bool CBotClass::AddFunction(const char* name,
bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))
{
// mémorise les pointeurs aux deux fonctions
@ -315,13 +315,13 @@ BOOL CBotClass::AddFunction(const char* name,
if (m_pCalls == NULL) m_pCalls = p;
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;
return TRUE;
return true;
}
// 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
BOOL CBotClass::ExecuteMethode(long& nIdent, const char* name,
bool CBotClass::ExecuteMethode(long& nIdent, const char* name,
CBotVar* pThis, CBotVar** ppParams,
CBotVar* &pResult, CBotStack* &pStack,
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
CBotClass* p = m_ExClass;
while ( p != NULL )
{
if (!WriteWord( pf, 1)) return FALSE;
if (!WriteWord( pf, 1)) return false;
// enregistre le nom de la classe
if (!WriteString( pf, p->GivName() )) return FALSE;
if (!WriteString( pf, p->GivName() )) return false;
CBotVar* pv = p->GivVar();
while( pv != NULL )
{
if ( pv->IsStatic() )
{
if (!WriteWord( pf, 1)) return FALSE;
if (!WriteString( pf, pv->GivName() )) return FALSE;
if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, pv->GivName() )) return false;
if ( !pv->Save0State(pf)) return FALSE; // entête commune
if ( !pv->Save1State(pf) ) return FALSE; // sauve selon la classe fille
if ( !WriteWord( pf, 0)) return FALSE;
if ( !pv->Save0State(pf)) return false; // entête commune
if ( !pv->Save1State(pf) ) return false; // sauve selon la classe fille
if ( !WriteWord( pf, 0)) return false;
}
pv = pv->GivNext();
}
if (!WriteWord( pf, 0)) return FALSE;
if (!WriteWord( pf, 0)) return false;
p = p->m_ExNext;
}
if (!WriteWord( pf, 0)) return FALSE;
return TRUE;
if (!WriteWord( pf, 0)) return false;
return true;
}
BOOL CBotClass::RestoreStaticState(FILE* pf)
bool CBotClass::RestoreStaticState(FILE* pf)
{
CBotString ClassName, VarName;
CBotClass* pClass;
WORD w;
unsigned short w;
if (!ReadWord( pf, w )) return FALSE;
if ( w != CBOTVERSION*2 ) return FALSE;
if (!ReadWord( pf, w )) return false;
if ( w != CBOTVERSION*2 ) return false;
while (TRUE)
while (true)
{
if (!ReadWord( pf, w )) return FALSE;
if ( w == 0 ) return TRUE;
if (!ReadWord( pf, w )) return false;
if ( w == 0 ) return true;
if (!ReadString( pf, ClassName )) return FALSE;
if (!ReadString( pf, ClassName )) return false;
pClass = Find(ClassName);
while (TRUE)
while (true)
{
if (!ReadWord( pf, w )) return FALSE;
if (!ReadWord( pf, w )) return false;
if ( w == 0 ) break;
CBotVar* pVar = NULL;
CBotVar* pv = NULL;
if (!ReadString( pf, VarName )) return FALSE;
if (!ReadString( pf, VarName )) return false;
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);
delete pv;
}
}
return TRUE;
return true;
}
@ -453,7 +453,7 @@ CBotClassInst::CBotClassInst()
m_var = NULL;
m_Parameters = NULL;
m_expr = NULL;
m_hasParams = FALSE;
m_hasParams = false;
m_nMethodeIdent = 0;
name = "CBotClassInst";
}
@ -484,18 +484,17 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
p = p->GivNext();
}
BOOL bIntrinsic = pClass->IsIntrinsic();
CBotTypResult
type = CBotTypResult( bIntrinsic ? CBotTypIntrinsic : CBotTypPointer,
pClass );
bool bIntrinsic = pClass->IsIntrinsic();
CBotTypResult type = CBotTypResult( bIntrinsic ? CBotTypIntrinsic : CBotTypPointer, pClass );
CBotClassInst* inst = (CBotClassInst*)CompileArray(p, pStack, type);
if ( inst != NULL || !pStack->IsOk() ) return inst;
CBotCStack* pStk = pStack->TokenStack();
inst = new CBotClassInst();
inst->SetToken(&pClass->GivName(), p->GivStart(), p->GivEnd());
/// \TODO Need to be revised and fixed after adding unit tests
CBotToken token(pClass->GivName(), CBotString(), p->GivStart(), p->GivEnd());
inst->SetToken(&token);
CBotToken* vartoken = p;
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
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)
{
@ -640,17 +639,17 @@ error:
// déclaration de l'instance d'une classe, par exemple:
// CPoint A, B;
BOOL CBotClassInst::Execute(CBotStack* &pj)
bool CBotClassInst::Execute(CBotStack* &pj)
{
CBotVar* pThis = NULL;
CBotStack* pile = pj->AddStack(this);//indispensable pour SetState()
// if ( pile == EOX ) return TRUE;
// if ( pile == EOX ) return true;
CBotToken* pt = &m_token;
CBotClass* pClass = CBotClass::Find(pt);
BOOL bIntrincic = pClass->IsIntrinsic();
bool bIntrincic = pClass->IsIntrinsic();
// crée la variable de type pointeur à l'objet
@ -682,7 +681,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
if ( m_expr != NULL )
{
// évalue l'expression pour l'assignation
if (!m_expr->Execute(pile)) return FALSE;
if (!m_expr->Execute(pile)) return false;
if ( bIntrincic )
{
@ -692,7 +691,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
pile->SetError(TX_NULLPT, &m_token);
return pj->Return(pile);
}
pThis->Copy(pile->GivVar(), FALSE);
pThis->Copy(pile->GivVar(), false);
}
else
{
@ -700,7 +699,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
pInstance = ((CBotVarPointer*)pile->GivVar())->GivPointer(); // valeur pour l'assignation
pThis->SetPointer(pInstance);
}
pThis->SetInit(TRUE);
pThis->SetInit(true);
}
else if ( m_hasParams )
@ -732,12 +731,12 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
// et place les valeurs sur la pile
// 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
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
if (!p->Execute(pile2)) return false; // interrompu ici ?
pile2->SetState(1);
}
ppVars[i++] = pile2->GivVar();
@ -751,9 +750,9 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(),
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é
pile->Return(pile2); // libère un bout de pile
@ -766,17 +765,17 @@ BOOL CBotClassInst::Execute(CBotStack* &pj)
pile->SetState(3); // fini cette partie
}
if ( pile->IfStep() ) return FALSE;
if ( pile->IfStep() ) return false;
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
}
void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain)
void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
{
CBotVar* pThis = NULL;
@ -793,7 +792,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain)
CBotToken* pt = &m_token;
CBotClass* pClass = CBotClass::Find(pt);
BOOL bIntrincic = pClass->IsIntrinsic();
bool bIntrincic = pClass->IsIntrinsic();
if ( bMain && pile->GivState()<3)
{
@ -827,7 +826,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain)
// et place les valeurs sur la pile
// 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
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
BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
bool CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
CBotString name = pToken->GivString();
if ( CBotCall::CheckCall(name) ) return TRUE;
if ( CBotCall::CheckCall(name) ) return true;
CBotFunction* pp = m_pMethod;
while ( pp != NULL )
@ -871,11 +870,11 @@ BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
// les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
return true;
}
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
BOOL CBotCompExpr::Execute(CBotStack* &pStack)
bool CBotCompExpr::Execute(CBotStack* &pStack)
{
CBotStack* pStk1 = pStack->AddStack(this);
// if ( pStk1 == EOX ) return TRUE;

466
src/CBot/CBotDll.h
View File

@ -19,10 +19,10 @@
//#include "stdafx.h"
#include <windows.h>
// #include <windows.h>
#include <stdio.h>
#define DllExport __declspec( dllexport )
// #define DllExport __declspec( dllexport )
#define CBOTVERSION 104
@ -93,62 +93,62 @@ private:
public:
// divers constructeurs selon les besoins
DllExport
//DllExport
CBotTypResult(int type);
// pour les types simples (CBotTypInt à CBotTypString)
DllExport
//DllExport
CBotTypResult(int type, const char* name);
// pour les types pointeur et classe intrinsic
DllExport
//DllExport
CBotTypResult(int type, CBotClass* pClass);
// idem à partir de l'instance d'une classe
DllExport
//DllExport
CBotTypResult(int type, CBotTypResult elem);
// pour les tableaux de variables
DllExport
//DllExport
CBotTypResult(const CBotTypResult& typ);
// pour les assignations
DllExport
//DllExport
CBotTypResult();
// pour par défaut
DllExport
//DllExport
~CBotTypResult();
DllExport
//DllExport
int GivType(int mode = 0) const;
// rend le type CBotTyp* du résultat
void SetType(int n);
// modifie le type
DllExport
//DllExport
CBotClass* GivClass() const;
// rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer)
DllExport
//DllExport
int GivLimite() const;
// rend la taille limite du tableau (CBotTypArray)
DllExport
//DllExport
void SetLimite(int n);
// fixe une limite au tableau
void SetArray(int* max );
// idem avec une liste de dimension (tableaux de tableaux)
DllExport
//DllExport
CBotTypResult& GivTypElem() const;
// rend le type des éléments du tableau (CBotTypArray)
DllExport
BOOL Compare(const CBotTypResult& typ) const;
//DllExport
bool Compare(const CBotTypResult& typ) const;
// compare si les types sont compatibles
DllExport
BOOL Eq(int type) const;
//DllExport
bool Eq(int type) const;
// compare le type
DllExport
//DllExport
CBotTypResult&
operator=(const CBotTypResult& src);
// copie un type complet dans un autre
@ -259,102 +259,102 @@ class CBotString
private:
char* m_ptr; // pointeur à la chaine
int m_lg; // longueur de la chaine
static
HINSTANCE m_hInstance;
// static
// HINSTANCE m_hInstance;
public:
DllExport
//DllExport
CBotString();
DllExport
//DllExport
CBotString(const char* p);
DllExport
//DllExport
CBotString(const CBotString& p);
DllExport
//DllExport
~CBotString();
DllExport
//DllExport
void Empty();
DllExport
BOOL IsEmpty() const;
DllExport
//DllExport
bool IsEmpty() const;
//DllExport
int GivLength();
DllExport
//DllExport
int Find(const char c);
DllExport
int Find(LPCTSTR lpsz);
DllExport
//DllExport
int Find(const char* lpsz);
//DllExport
int ReverseFind(const char c);
DllExport
int ReverseFind(LPCTSTR lpsz);
DllExport
BOOL LoadString(UINT id);
DllExport
//DllExport
int ReverseFind(const char* lpsz);
//DllExport
bool LoadString(unsigned int id);
//DllExport
CBotString Mid(int nFirst, int nCount) const;
DllExport
//DllExport
CBotString Mid(int nFirst) const;
DllExport
//DllExport
CBotString Left(int nCount) const;
DllExport
//DllExport
CBotString Right(int nCount) const;
DllExport
//DllExport
const CBotString&
operator=(const CBotString& stringSrc);
DllExport
//DllExport
const CBotString&
operator=(const char ch);
DllExport
//DllExport
const CBotString&
operator=(const char* pString);
DllExport
//DllExport
const CBotString&
operator+(const CBotString& str);
DllExport
//DllExport
friend CBotString
operator+(const CBotString& string, LPCTSTR lpsz);
operator+(const CBotString& string, const char* lpsz);
DllExport
//DllExport
const CBotString&
operator+=(const char ch);
DllExport
//DllExport
const CBotString&
operator+=(const CBotString& str);
DllExport
BOOL operator==(const CBotString& str);
DllExport
BOOL operator==(const char* p);
DllExport
BOOL operator!=(const CBotString& str);
DllExport
BOOL operator!=(const char* p);
DllExport
BOOL operator>(const CBotString& str);
DllExport
BOOL operator>(const char* p);
DllExport
BOOL operator>=(const CBotString& str);
DllExport
BOOL operator>=(const char* p);
DllExport
BOOL operator<(const CBotString& str);
DllExport
BOOL operator<(const char* p);
DllExport
BOOL operator<=(const CBotString& str);
DllExport
BOOL operator<=(const char* p);
//DllExport
bool operator==(const CBotString& str);
//DllExport
bool operator==(const char* p);
//DllExport
bool operator!=(const CBotString& str);
//DllExport
bool operator!=(const char* p);
//DllExport
bool operator>(const CBotString& str);
//DllExport
bool operator>(const char* p);
//DllExport
bool operator>=(const CBotString& str);
//DllExport
bool operator>=(const char* p);
//DllExport
bool operator<(const CBotString& str);
//DllExport
bool operator<(const char* p);
//DllExport
bool operator<=(const CBotString& str);
//DllExport
bool operator<=(const char* p);
DllExport
operator LPCTSTR() const; // as a C string
//DllExport
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);
DllExport
//DllExport
void MakeUpper();
DllExport
//DllExport
void MakeLower();
};
@ -369,20 +369,20 @@ private:
CBotString* m_pData; // ^aux données
public:
DllExport
//DllExport
CBotStringArray();
DllExport
//DllExport
~CBotStringArray();
DllExport
//DllExport
void SetSize(int nb);
DllExport
//DllExport
int GivSize();
DllExport
//DllExport
void Add(const CBotString& str);
DllExport
//DllExport
CBotString& operator[](int nIndex);
DllExport
//DllExport
CBotString& ElementAt(int nIndex);
};
@ -418,87 +418,87 @@ private:
public:
static
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:
DllExport
//DllExport
static
void Init();
// initialise le module (défini les mots clefs pour les erreurs)
// doit être fait une fois (et une seule) au tout début
DllExport
//DllExport
static
void Free();
// libère les zones mémoires statiques
DllExport
//DllExport
static
int GivVersion();
// donne la version de la librairie CBOT
DllExport
//DllExport
CBotProgram();
DllExport
//DllExport
CBotProgram(CBotVar* pInstance);
DllExport
//DllExport
~CBotProgram();
DllExport
BOOL Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
//DllExport
bool Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
// 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
// ListFonctions retourne le nom des fonctions déclarées extern
// pUser permet de passer un pointeur pour les routines définies par AddFunction
DllExport
//DllExport
void SetIdent(long n);
// associe un identificateur avec l'instance CBotProgram
DllExport
//DllExport
long GivIdent();
// redonne l'identificateur
DllExport
//DllExport
int GivError();
DllExport
BOOL GetError(int& code, int& start, int& end);
DllExport
BOOL GetError(int& code, int& start, int& end, CBotProgram* &pProg);
// si TRUE
//DllExport
bool GetError(int& code, int& start, int& end);
//DllExport
bool GetError(int& code, int& start, int& end, CBotProgram* &pProg);
// si true
// donne l'erreur trouvée à la compilation
// ou à l'exécution
// 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
DllExport
//DllExport
static
CBotString GivErrorText(int code);
DllExport
BOOL Start(const char* name);
//DllExport
bool Start(const char* name);
// 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
DllExport
BOOL Run(void* pUser = NULL, int timer = -1);
//DllExport
bool Run(void* pUser = NULL, int timer = -1);
// exécute le programme
// retourne FALSE si le programme a été suspendu
// retourne TRUE si le programme s'est terminé avec ou sans erreur
// retourne false si le programme a été suspendu
// retourne true si le programme s'est terminé avec ou sans erreur
// timer = 0 permet de faire une avance pas à pas
DllExport
BOOL GetRunPos(const char* &FunctionName, int &start, int &end);
//DllExport
bool GetRunPos(const char* &FunctionName, int &start, int &end);
// 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
// start et end la position dans le texte du token en traitement
DllExport
//DllExport
CBotVar* GivStackVars(const char* &FunctionName, int level);
// 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
@ -507,41 +507,41 @@ public:
// FunctionName donne le nom de la fonction où se trouvent ces variables
// FunctionName == NULL signifiant qu'on est plus dans le programme (selon level)
DllExport
//DllExport
void Stop();
// arrête l'exécution du programme
// quitte donc le mode "suspendu"
DllExport
//DllExport
static
void SetTimer(int n);
// 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
BOOL AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
bool AddFunction(const char* name,
bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
// cet appel permet d'ajouter de manière externe (**)
// une nouvelle fonction utilisable par le programme CBot
DllExport
//DllExport
static
BOOL DefineNum(const char* name, long val);
bool DefineNum(const char* name, long val);
DllExport
BOOL SaveState(FILE* pf);
//DllExport
bool SaveState(FILE* pf);
// sauvegarde l'état d'exécution dans le fichier
// le fichier doit avoir été ouvert avec l'appel fopen de cette dll
// sinon le système plante
DllExport
BOOL RestoreState(FILE* pf);
//DllExport
bool RestoreState(FILE* pf);
// rétablie l'état de l'exécution depuis le fichier
// le programme compilé doit évidemment être identique
DllExport
BOOL GetPosition(const char* name, int& start, int& stop,
//DllExport
bool GetPosition(const char* name, int& start, int& stop,
CBotGet modestart = GetPosExtern,
CBotGet modestop = GetPosBloc);
// donne la position d'une routine dans le texte d'origine
@ -555,13 +555,13 @@ public:
///////////////////////////////////////////////////////////////////////////////
// routines pour la gestion d'un fichier (FILE*)
DllExport
//DllExport
FILE* fOpen(const char* name, const char* mode);
DllExport
//DllExport
int fClose(FILE* filehandle);
DllExport
//DllExport
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);
@ -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;
int nb = 0;
@ -606,7 +606,7 @@ BOOL rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception)
}
pResult->SetValFloat(total/nb); // retourne la valeur moyenne
return TRUE; // opération totalement terminée
return true; // opération totalement terminée
}
#endif
@ -645,7 +645,7 @@ protected:
int m_binit; // pas initialisée ?
CBotVarClass* m_pMyThis; // ^élément this correspondant
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 ?
CBotInstr* m_InitExpr; // expression pour le contenu initial
@ -663,17 +663,17 @@ public:
virtual ~CBotVar( ); // destructeur
/* DllExport
/* //DllExport
static
CBotVar* Create( const char* name, int type, const char* ClassName = NULL);
// crée une variable selon son type,*/
DllExport
//DllExport
static
CBotVar* Create( const char* name, CBotTypResult type);
// idem à partir du type complet
DllExport
//DllExport
static
CBotVar* Create( const char* name, CBotClass* pClass);
// idem pour une instance d'une classe connue
@ -690,51 +690,51 @@ virtual ~CBotVar( ); // destructeur
CBotVar* Create( CBotVar* pVar );
DllExport
//DllExport
void SetUserPtr(void* pUser);
// associe un pointeur utilisateur à une instance
DllExport
//DllExport
virtual void SetIdent(long UniqId);
// associe un identificateur unique à une instance
// ( c'est à l'utilisateur de s'assurer que l'id est unique)
DllExport
//DllExport
void* GivUserPtr();
// rend le pointeur associé à la variable
DllExport
//DllExport
CBotString GivName(); // le nom de la variable, s'il est connu
////////////////////////////////////////////////////////////////////////////////////
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
////////////////////////////////////////////////////////////////////////////////////////
DllExport
//DllExport
CBotTypResult GivTypResult(int mode = 0); // rend le type complet de la variable
CBotToken* GivToken();
void SetType(CBotTypResult& type);
DllExport
//DllExport
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
DllExport
void SetStatic(BOOL bStatic);
DllExport
BOOL IsStatic();
//DllExport
void SetStatic(bool bStatic);
//DllExport
bool IsStatic();
DllExport
//DllExport
void SetPrivate(int mPrivate);
DllExport
BOOL IsPrivate(int mode = PR_PROTECT);
DllExport
//DllExport
bool IsPrivate(int mode = PR_PROTECT);
//DllExport
int GivPrivate();
virtual
@ -742,55 +742,55 @@ virtual ~CBotVar( ); // destructeur
void SetVal(CBotVar* var); // remprend une valeur
DllExport
//DllExport
virtual
CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
virtual
CBotVar* GivItemRef(int nIdent); // idem à partir du n° ref
DllExport
//DllExport
virtual
CBotVar* GivItem(int row, BOOL bGrow = FALSE);
CBotVar* GivItem(int row, bool bGrow = false);
DllExport
//DllExport
virtual
CBotVar* GivItemList(); // donne la liste des éléments
DllExport
//DllExport
CBotVar* GivStaticVar(); // rend le pointeur à la variable si elle est statique
DllExport
BOOL IsElemOfClass(const char* name);
//DllExport
bool IsElemOfClass(const char* 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)
////////////////////////////////////////////////////////////////////////////////////////////
void AddNext(CBotVar* pVar); // ajoute dans une liste
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);
// initialise avec une valeur entière (#)
/////////////////////////////////////////////////////////////////////////////////
DllExport
//DllExport
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 (#)
////////////////////////////////////////////////////////////////////////////////
DllExport
//DllExport
virtual int GivValInt(); // demande la valeur entière (#)
////////////////////////////////////////////////////////////////////////
DllExport
//DllExport
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 void Power(CBotVar* left, CBotVar* right); // puissance
virtual BOOL Lo(CBotVar* left, CBotVar* right);
virtual BOOL Hi(CBotVar* left, CBotVar* right);
virtual BOOL Ls(CBotVar* left, CBotVar* right);
virtual BOOL Hs(CBotVar* left, CBotVar* right);
virtual BOOL Eq(CBotVar* left, CBotVar* right);
virtual BOOL Ne(CBotVar* left, CBotVar* right);
virtual bool Lo(CBotVar* left, CBotVar* right);
virtual bool Hi(CBotVar* left, CBotVar* right);
virtual bool Ls(CBotVar* left, CBotVar* right);
virtual bool Hs(CBotVar* left, CBotVar* right);
virtual bool Eq(CBotVar* left, CBotVar* right);
virtual bool Ne(CBotVar* left, CBotVar* right);
virtual void And(CBotVar* left, CBotVar* right);
virtual void Or(CBotVar* left, CBotVar* right);
@ -834,19 +834,19 @@ virtual ~CBotVar( ); // destructeur
virtual void Dec();
virtual BOOL Save0State(FILE* pf);
virtual BOOL Save1State(FILE* pf);
static BOOL RestoreState(FILE* pf, CBotVar* &pVar);
virtual bool Save0State(FILE* pf);
virtual bool Save1State(FILE* pf);
static bool RestoreState(FILE* pf, CBotVar* &pVar);
DllExport
//DllExport
void debug();
// virtual
// CBotVar* GivMyThis();
DllExport
//DllExport
virtual
void Maj(void* pUser = NULL, BOOL bContinue = TRUE);
void Maj(void* pUser = NULL, bool bContinue = true);
void SetUniqNum(long n);
long GivUniqNum();
@ -888,7 +888,7 @@ private:
CBotString m_name; // nom de cette classe-ci
int m_nbVar; // nombre de variables dans la chaîne
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
CBotCallMethode* m_pCalls; // liste des méthodes définie en externe
CBotFunction* m_pMethod; // liste des méthodes compilées
@ -899,37 +899,37 @@ private:
CBotProgram* m_ProgInLock[5];// processus en attente pour synchro
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* pParent, BOOL bIntrinsic = FALSE ); // constructeur
CBotClass* pParent, bool bIntrinsic = false ); // constructeur
// Dès qu'une classe est créée, elle est connue
// partout dans CBot
// le mode intrinsic donne une classe qui n'est pas gérée par des pointeurs
DllExport
//DllExport
~CBotClass( ); // destructeur
DllExport
BOOL AddFunction(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
//DllExport
bool AddFunction(const char* name,
bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));
// cet appel permet d'ajouter de manière externe (**)
// une nouvelle méthode utilisable par les objets de cette classe
DllExport
BOOL AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) );
//DllExport
bool AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) );
// défini la routine qui sera appellée pour mettre à jour les élements de la classe
DllExport
BOOL AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);
//DllExport
bool AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);
// ajoute un élément à la classe
// DllExport
// BOOL AddItem(CBotString name, CBotClass* pClass);
// //DllExport
// bool AddItem(CBotString name, CBotClass* pClass);
// idem pour des éléments appartenant à pClass
DllExport
BOOL AddItem(CBotVar* pVar);
//DllExport
bool AddItem(CBotVar* pVar);
// idem en passant le pointeur à une instance d'une variable
// 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
void AddNext(CBotClass* pClass);
DllExport
//DllExport
CBotString GivName(); // rend le nom de la classe
DllExport
//DllExport
CBotClass* GivParent(); // donne la classe père (ou NULL)
// dit si une classe est dérivée (Extends) d'une autre
// rend TRUE aussi si les classes sont identiques
DllExport
BOOL IsChildOf(CBotClass* pClass);
// rend true aussi si les classes sont identiques
//DllExport
bool IsChildOf(CBotClass* pClass);
static
CBotClass* Find(CBotToken* &pToken); // trouve une classe d'après son nom
DllExport
//DllExport
static
CBotClass* Find(const char* name);
@ -962,7 +962,7 @@ public:
CBotTypResult CompileMethode(const char* name, CBotVar* pThis, CBotVar** ppParams,
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);
// compile une classe déclarée par l'utilisateur
@ -971,27 +971,27 @@ public:
static
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();
static
void Free();
DllExport
//DllExport
static
BOOL SaveStaticState(FILE* pf);
bool SaveStaticState(FILE* pf);
DllExport
//DllExport
static
BOOL RestoreStaticState(FILE* pf);
bool RestoreStaticState(FILE* pf);
BOOL Lock(CBotProgram* p);
bool Lock(CBotProgram* p);
void Unlock();
static
void FreeLock(CBotProgram* p);
BOOL CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
bool CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
};
@ -1041,7 +1041,7 @@ private:
static
int GivKeyWords(const char* w); // est-ce un mot clef ?
static
BOOL GivKeyDefNum(const char* w, CBotToken* &token);
bool GivKeyDefNum(const char* w, CBotToken* &token);
static
void LoadKeyWords(); // fait la liste des mots clefs
@ -1054,37 +1054,37 @@ public:
// constructeur
~CBotToken(); // destructeur
DllExport
//DllExport
int GivType(); // rend le type du token
DllExport
//DllExport
CBotString& GivString(); // rend la chaine correspondant à ce token
DllExport
//DllExport
CBotString& GivSep(); // rend le séparateur suivant le token
DllExport
//DllExport
int GivStart(); // position du début dans le texte
DllExport
//DllExport
int GivEnd(); // position de fin dans le texte
DllExport
//DllExport
CBotToken* GivNext(); // rend le suivant dans la liste
DllExport
//DllExport
CBotToken* GivPrev(); // rend le Précédent dans la liste
DllExport
//DllExport
static
CBotToken* CompileTokens(const char* p, int& error);
// transforme tout le programme
DllExport
//DllExport
static
void Delete(CBotToken* pToken); // libère la liste
// fonctions non utiles en export
static
BOOL DefineNum(const char* name, long val);
bool DefineNum(const char* name, long val);
void SetString(const char* name);
void SetPos(int start, int end);
@ -1092,7 +1092,7 @@ public:
void AddNext(CBotToken* p); // ajoute un token (une copie)
static
CBotToken* NextToken(char* &program, int& error, BOOL first = FALSE);
CBotToken* NextToken(char* &program, int& error, bool first = false);
// trouve le prochain token
const CBotToken&
operator=(const CBotToken& src);
@ -1163,7 +1163,7 @@ public:
// exécute le programme main
// -------------------------
while( FALSE = m_pMonRobot->Execute( "main", pStack ))
while( false = m_pMonRobot->Execute( "main", pStack ))
{
// programme suspendu
// 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 )
BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
bool rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
{
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 ?
// 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);
m_PosToGo.y = temp->GivValFloat();
return (m_CurentPos == m_PosToGo); // rend TRUE si la position est atteinte
// rend FALSE s'il faut patienter encore
return (m_CurentPos == m_PosToGo); // rend true si la position est atteinte
// 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_Block = NULL; // le bloc d'instructions
m_next = NULL; // les fonctions peuvent être chaînées
m_bPublic = FALSE; // fonction non publique
m_bExtern = FALSE; // fonction non externe
m_bPublic = false; // fonction non publique
m_bExtern = false; // fonction non externe
m_nextpublic = NULL;
m_prevpublic = NULL;
m_pProg = NULL;
// m_nThisIdent = 0;
m_nFuncIdent = 0;
m_bSynchro = FALSE;
m_bSynchro = false;
}
CBotFunction* CBotFunction::m_listPublic = NULL;
@ -62,17 +62,17 @@ CBotFunction::~CBotFunction()
}
}
BOOL CBotFunction::IsPublic()
bool CBotFunction::IsPublic()
{
return m_bPublic;
}
BOOL CBotFunction::IsExtern()
bool CBotFunction::IsExtern()
{
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();
stop = m_closeblk.GivEnd();
@ -110,7 +110,7 @@ BOOL CBotFunction::GetPosition(int& start, int& stop, CBotGet modestart, CBotGet
stop = m_closeblk.GivEnd();
}
return TRUE;
return true;
}
@ -168,7 +168,7 @@ CBotTypResult TypeParam(CBotToken* &p, CBotCStack* pile)
// compile une nouvelle fonction
// 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
CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* finput, BOOL bLocal)
CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* finput, bool bLocal)
{
CBotToken* pp;
CBotFunction* func = finput;
@ -178,19 +178,19 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
// func->m_nFuncIdent = CBotVar::NextUniqNum();
while (TRUE)
while (true)
{
if ( IsOfType(p, ID_PUBLIC) )
{
func->m_bPublic = TRUE;
func->m_bPublic = true;
continue;
}
pp = p;
if ( IsOfType(p, ID_EXTERN) )
{
func->m_extern = pp; // pour la position du mot "extern"
func->m_bExtern = TRUE;
// func->m_bPublic = TRUE; // donc aussi publique!
func->m_bExtern = true;
// func->m_bPublic = true; // donc aussi publique!
continue;
}
break;
@ -260,7 +260,7 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
// et compile le bloc d'instruction qui suit
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();
if ( pStk->IsOk() )
{
@ -286,18 +286,18 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas
CBotFunction* func = new CBotFunction();
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) )
{
// func->m_bPublic = TRUE; // sera fait en passe 2
// func->m_bPublic = true; // sera fait en passe 2
continue;
}
if ( IsOfType(p, ID_EXTERN) )
{
func->m_bExtern = TRUE;
func->m_bExtern = true;
continue;
}
break;
@ -367,16 +367,16 @@ bad:
static int xx = 0;
#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
// if ( pile == EOX ) return TRUE;
// if ( pile == EOX ) return true;
pile->SetBotCall(m_pProg); // bases pour les routines
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();
}
@ -403,14 +403,14 @@ BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
pile->IncState();
}
if ( pile->IfStep() ) return FALSE;
if ( pile->IfStep() ) return false;
if ( !m_Block->Execute(pile) )
{
if ( pile->GivError() < 0 )
pile->SetError( 0 );
else
return FALSE;
return false;
}
return pj->Return(pile);
@ -433,7 +433,7 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst
pile2->Delete();
}
m_Param->RestoreState(pile2, TRUE); // les paramètres
m_Param->RestoreState(pile2, true); // les paramètres
if ( !m_MasterClass.IsEmpty() )
{
@ -442,7 +442,7 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst
pThis->SetUniqNum(-2);
}
m_Block->RestoreState(pile2, TRUE);
m_Block->RestoreState(pile2, true);
}
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
// 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
CBotFunction* pt;
@ -632,13 +632,13 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS
if ( pt != NULL )
{
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
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
@ -680,11 +680,11 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS
if ( !pStk3->IsOk() && pt->m_pProg != m_pProg )
{
#ifdef _DEBUG
if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return FALSE;
if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return false;
#endif
pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure
}
return FALSE; // interrompu !
return false; // interrompu !
}
return pStack->Return( pStk3 );
@ -738,13 +738,13 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars,
if ( pStk1->GivState() == 0 )
{
pt->m_Param->RestoreState(pStk3, TRUE);
pt->m_Param->RestoreState(pStk3, true);
return;
}
// initialise les variables selon paramètres
pt->m_Param->RestoreState(pStk3, FALSE);
pt->m_Block->RestoreState(pStk3, TRUE);
pt->m_Param->RestoreState(pStk3, false);
pt->m_Block->RestoreState(pStk3, true);
}
}
@ -758,17 +758,17 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
CBotTypResult type;
CBotProgram* pProgCurrent = pStack->GivBotCall();
CBotFunction* pt = FindLocalOrPublic(nIdent, name, ppVars, type, FALSE);
CBotFunction* pt = FindLocalOrPublic(nIdent, name, ppVars, type, false);
if ( pt != NULL )
{
// DEBUG( "CBotFunction::DoCall" + pt->GivName(), 0, pStack);
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
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
@ -776,7 +776,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
{
// met la variable "this" sur la pile
CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer);
pthis->Copy(pThis, FALSE);
pthis->Copy(pThis, false);
pthis->SetUniqNum(-2); // valeur spéciale
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
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
pStk->AddVar(psuper);
}
@ -798,8 +798,8 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
{
if ( pt->m_bSynchro )
{
CBotProgram* pProgBase = pStk->GivBotCall(TRUE);
if ( !pClass->Lock(pProgBase) ) return FALSE; // attend de pouvoir
CBotProgram* pProgBase = pStk->GivBotCall(true);
if ( !pClass->Lock(pProgBase) ) return false; // attend de pouvoir
}
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
}
}
return FALSE; // interrompu !
return false; // interrompu !
}
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
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 ?
pt->m_bSynchro )
{
CBotProgram* pProgBase = pStk->GivBotCall(TRUE);
CBotProgram* pProgBase = pStk->GivBotCall(true);
pClass->Lock(pProgBase); // vérouille la classe
}
// 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
BOOL CBotFunction::CheckParam(CBotDefParam* pParam)
bool CBotFunction::CheckParam(CBotDefParam* pParam)
{
CBotDefParam* pp = m_Param;
while ( pp != NULL && pParam != NULL )
{
CBotTypResult type1 = pp->GivType();
CBotTypResult type2 = pParam->GivType();
if ( !type1.Compare(type2) ) return FALSE;
if ( !type1.Compare(type2) ) return false;
pp = pp->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;
CBotDefParam* p = this;
@ -1033,7 +1033,7 @@ BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
newvar->SetValInt(ppVars[i]->GivValInt());
break;
case CBotTypIntrinsic:
((CBotVarClass*)newvar)->Copy(ppVars[i], FALSE);
((CBotVarClass*)newvar)->Copy(ppVars[i], false);
break;
case CBotTypPointer:
case CBotTypArrayPointer:
@ -1051,10 +1051,10 @@ BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
i++;
}
return TRUE;
return true;
}
void CBotDefParam::RestoreState(CBotStack* &pj, BOOL bMain)
void CBotDefParam::RestoreState(CBotStack* &pj, bool bMain)
{
int i = 0;
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
}
BOOL CBotReturn::Execute(CBotStack* &pj)
bool CBotReturn::Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return TRUE;
// if ( pile == EOX ) return true;
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
pile->IncState();
}
if ( pile->IfStep() ) return FALSE;
if ( pile->IfStep() ) return false;
pile->SetBreak(3, CBotString());
return pj->Return(pile);
}
void CBotReturn::RestoreState(CBotStack* &pj, BOOL bMain)
void CBotReturn::RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
CBotStack* pile = pj->RestoreStack(this);
@ -1211,7 +1211,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
inst->SetToken(pp);
// compile la liste des paramètres
if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE)
if (!IsOfType(p, ID_CLOSEPAR)) while (true)
{
start = p->GivStart();
pile = pile->TokenStack(); // garde les résultats sur la pile
@ -1278,7 +1278,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
return NULL;
}
BOOL CBotInstrCall::Execute(CBotStack* &pj)
bool CBotInstrCall::Execute(CBotStack* &pj)
{
CBotVar* ppVars[1000];
CBotStack* pile = pj->AddStack(this);
@ -1292,12 +1292,12 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj)
// évalue les paramètres
// et place les valeurs sur la pile
// 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
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
}
ppVars[i++] = pile->GivVar();
@ -1307,14 +1307,14 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj)
ppVars[i] = NULL;
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
}
void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain)
void CBotInstrCall::RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
@ -1329,7 +1329,7 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain)
// évalue les paramètres
// et place les valeurs sur la pile
// 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
if ( pile == NULL ) return;
@ -1394,7 +1394,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
#endif
CBotClass* classe = (pOld == NULL) ? new CBotClass(name, pPapa) : pOld;
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) )
{
@ -1404,7 +1404,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )
{
classe->CompileDefItem(p, pStack, FALSE);
classe->CompileDefItem(p, pStack, false);
}
if (pStack->IsOk()) return classe;
@ -1413,24 +1413,24 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
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;
BOOL bSynchro = FALSE;
bool bSynchro = false;
while (IsOfType(p, ID_SEP)) ;
CBotTypResult type( -1 );
if ( IsOfType(p, ID_SYNCHO) ) bSynchro = TRUE;
if ( IsOfType(p, ID_SYNCHO) ) bSynchro = true;
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_PRIVATE) ) mProtect = PR_PRIVATE;
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;
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) )
{
pStack->SetError(TX_NOTYP, p);
return FALSE;
return false;
}
while (pStack->IsOk())
@ -1463,14 +1463,14 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
if (!pStack->IsOk() || !IsOfType( p, ID_CLBRK ) )
{
pStack->SetError(TX_CLBRK, p->GivStart());
return FALSE;
return false;
}
/* CBotVar* pv = pStack->GivVar();
if ( pv->GivType()>= CBotTypBoolean )
{
pStack->SetError(TX_BADTYPE, p->GivStart());
return FALSE;
return false;
}*/
if (limites == NULL) limites = i;
@ -1485,7 +1485,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
CBotFunction* f =
CBotFunction::Compile1(p, pStack, this);
if ( f == NULL ) return FALSE;
if ( f == NULL ) return false;
if (m_pMethod == NULL) m_pMethod = f;
else m_pMethod->AddNext(f);
@ -1502,8 +1502,8 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
pf = pf->Next();
}
BOOL bConstructor = (pp->GivString() == GivName());
CBotCStack* pile = pStack->TokenStack(NULL, TRUE);
bool bConstructor = (pp->GivString() == GivName());
CBotCStack* pile = pStack->TokenStack(NULL, true);
// rend "this" connu
CBotToken TokenThis(CBotString("this"), CBotString());
@ -1540,7 +1540,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
// compile une méthode
p = pBase;
CBotFunction* f =
CBotFunction::Compile(p, pile, NULL/*, FALSE*/);
CBotFunction::Compile(p, pile, NULL/*, false*/);
if ( f != NULL )
{
@ -1563,7 +1563,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
if (type.Eq(0))
{
pStack->SetError(TX_ENDOF, p);
return FALSE;
return false;
}
CBotInstr* i = NULL;
@ -1578,7 +1578,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)
// il y a une assignation à calculer
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 ) )
{
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;
}
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
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
if ( pStk->IsOk() )
{
// 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))
{
// 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())
{
// 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
BOOL CBotIf :: Execute(CBotStack* &pj)
bool CBotIf :: Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// 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
if( pile->GivState() == 0 )
{
// é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
if ( !pile->IsOk() )
@ -105,21 +105,21 @@ BOOL CBotIf :: Execute(CBotStack* &pj)
}
// 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
// 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
!m_Block->Execute(pile) ) return FALSE; // interrompu ici ?
!m_Block->Execute(pile) ) return false; // interrompu ici ?
}
else
{
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
@ -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;
@ -145,7 +145,7 @@ void CBotIf :: RestoreState(CBotStack* &pj, BOOL bMain)
// second état, évalue les instructions associées
// 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
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;
Stop();
@ -81,7 +81,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
// transforme le programme en Tokens
CBotToken* pBaseToken = CBotToken::CompileTokens(program, error);
if ( pBaseToken == NULL ) return FALSE;
if ( pBaseToken == NULL ) return false;
CBotCStack* pStack = new CBotCStack(NULL);
@ -115,7 +115,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
delete m_Prog;
m_Prog = NULL;
delete pBaseToken;
return FALSE;
return false;
}
// CBotFunction* temp = NULL;
@ -130,12 +130,12 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
if ( p->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
}
else
{
m_bCompileClass = FALSE;
m_bCompileClass = false;
CBotFunction::Compile(p, pStack, next);
if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/);
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
m_pStack->Delete();
@ -179,7 +179,7 @@ BOOL CBotProgram::Start(const char* name)
if ( m_pRun == NULL )
{
m_ErrorCode = TX_NORUN;
return FALSE;
return false;
}
#if STACKMEM
@ -190,10 +190,10 @@ BOOL CBotProgram::Start(const char* name)
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;
while (p != NULL)
@ -202,15 +202,15 @@ BOOL CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet m
p = p->m_next;
}
if ( p == NULL ) return FALSE;
if ( p == NULL ) return false;
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;
@ -253,7 +253,7 @@ BOOL CBotProgram::Run(void* pUser, int timer)
delete m_pStack;
#endif
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
@ -261,7 +261,7 @@ BOOL CBotProgram::Run(void* pUser, int timer)
error:
m_ErrorCode = TX_NORUN;
return TRUE;
return true;
}
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;
start = end = 0;
if (m_pStack == NULL) return FALSE;
if (m_pStack == NULL) return false;
m_pStack->GetRunPos(FunctionName, start, end);
return TRUE;
return true;
}
CBotVar* CBotProgram::GivStackVars(const char* &FunctionName, int level)
@ -321,7 +321,7 @@ long CBotProgram::GivIdent()
return m_Ident;
}
BOOL CBotProgram::GetError(int& code, int& start, int& end)
bool CBotProgram::GetError(int& code, int& start, int& end)
{
code = m_ErrorCode;
start = m_ErrorStart;
@ -329,7 +329,7 @@ BOOL CBotProgram::GetError(int& code, int& start, int& end)
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;
start = m_ErrorStart;
@ -358,8 +358,8 @@ CBotFunction* CBotProgram::GivFunctions()
return m_Prog;
}
BOOL CBotProgram::AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
bool CBotProgram::AddFunction(const char* name,
bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
{
// 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;
lg = fwrite(&w, sizeof( WORD ), 1, pf );
lg = fwrite(&w, sizeof( unsigned short ), 1, pf );
return (lg == 1);
}
BOOL ReadWord(FILE* pf, WORD& w)
bool ReadWord(FILE* pf, unsigned short& w)
{
size_t lg;
lg = fread(&w, sizeof( WORD ), 1, pf );
lg = fread(&w, sizeof( unsigned short ), 1, pf );
return (lg == 1);
}
BOOL WriteFloat(FILE* pf, float w)
bool WriteFloat(FILE* pf, float w)
{
size_t lg;
@ -394,7 +394,7 @@ BOOL WriteFloat(FILE* pf, float w)
return (lg == 1);
}
BOOL ReadFloat(FILE* pf, float& w)
bool ReadFloat(FILE* pf, float& w)
{
size_t lg;
@ -403,7 +403,7 @@ BOOL ReadFloat(FILE* pf, float& w)
return (lg == 1);
}
BOOL WriteLong(FILE* pf, long w)
bool WriteLong(FILE* pf, long w)
{
size_t lg;
@ -412,7 +412,7 @@ BOOL WriteLong(FILE* pf, long w)
return (lg == 1);
}
BOOL ReadLong(FILE* pf, long& w)
bool ReadLong(FILE* pf, long& w)
{
size_t lg;
@ -421,24 +421,24 @@ BOOL ReadLong(FILE* pf, long& w)
return (lg == 1);
}
BOOL WriteString(FILE* pf, CBotString s)
bool WriteString(FILE* pf, CBotString s)
{
size_t lg1, lg2;
lg1 = s.GivLength();
if (!WriteWord(pf, lg1)) return FALSE;
if (!WriteWord(pf, lg1)) return false;
lg2 = fwrite(s, 1, lg1, pf );
return (lg1 == lg2);
}
BOOL ReadString(FILE* pf, CBotString& s)
bool ReadString(FILE* pf, CBotString& s)
{
WORD w;
unsigned short w;
char buf[1000];
size_t lg1, lg2;
if (!ReadWord(pf, w)) return FALSE;
if (!ReadWord(pf, w)) return false;
lg1 = w;
lg2 = fread(buf, 1, lg1, pf );
buf[lg2] = 0;
@ -447,29 +447,29 @@ BOOL ReadString(FILE* pf, CBotString& s)
return (lg1 == lg2);
}
BOOL WriteType(FILE* pf, CBotTypResult type)
bool WriteType(FILE* pf, CBotTypResult type)
{
int typ = type.GivType();
if ( typ == CBotTypIntrinsic ) typ = CBotTypClass;
if ( !WriteWord(pf, typ) ) return FALSE;
if ( !WriteWord(pf, typ) ) return false;
if ( typ == CBotTypClass )
{
CBotClass* p = type.GivClass();
if ( !WriteString(pf, p->GivName()) ) return FALSE;
if ( !WriteString(pf, p->GivName()) ) return false;
}
if ( type.Eq( CBotTypArrayBody ) ||
type.Eq( CBotTypArrayPointer ) )
{
if ( !WriteWord(pf, type.GivLimite()) ) return FALSE;
if ( !WriteType(pf, type.GivTypElem()) ) return FALSE;
if ( !WriteWord(pf, type.GivLimite()) ) 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;
if ( !ReadWord(pf, w) ) return FALSE;
unsigned short w, ww;
if ( !ReadWord(pf, w) ) return false;
type.SetType(w);
if ( type.Eq( CBotTypIntrinsic ) )
@ -480,7 +480,7 @@ BOOL ReadType(FILE* pf, CBotTypResult& type)
if ( type.Eq( CBotTypClass ) )
{
CBotString s;
if ( !ReadString(pf, s) ) return FALSE;
if ( !ReadString(pf, s) ) return false;
type = CBotTypResult( w, s );
}
@ -488,54 +488,54 @@ BOOL ReadType(FILE* pf, CBotTypResult& type)
type.Eq( CBotTypArrayBody ) )
{
CBotTypResult r;
if ( !ReadWord(pf, ww) ) return FALSE;
if ( !ReadType(pf, r) ) return FALSE;
if ( !ReadWord(pf, ww) ) return false;
if ( !ReadType(pf, r) ) return false;
type = CBotTypResult( w, r );
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);
}
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 (!WriteWord( pf, 1)) return FALSE;
if (!WriteString( pf, m_pRun->GivName() )) return FALSE;
if (!m_pStack->SaveState(pf)) return FALSE;
if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, m_pRun->GivName() )) return false;
if (!m_pStack->SaveState(pf)) return false;
}
else
{
if (!WriteWord( pf, 0)) return FALSE;
if (!WriteWord( pf, 0)) return false;
}
return TRUE;
return true;
}
BOOL CBotProgram::RestoreState(FILE* pf)
bool CBotProgram::RestoreState(FILE* pf)
{
WORD w;
CBotString s;
unsigned short w;
CBotString s;
Stop();
if (!ReadWord( pf, w )) return FALSE;
if ( w != CBOTVERSION ) return FALSE;
if (!ReadWord( pf, w )) return false;
if ( w != CBOTVERSION ) return false;
if (!ReadWord( pf, w )) return FALSE;
if ( w == 0 ) return TRUE;
if (!ReadWord( pf, w )) return false;
if ( w == 0 ) return true;
if (!ReadString( pf, s )) return FALSE;
if (!ReadString( pf, s )) return false;
Start(s); // point de reprise
#if STACKMEM
@ -547,12 +547,12 @@ BOOL CBotProgram::RestoreState(FILE* pf)
// récupère la pile depuis l'enregistrement
// 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
// rétabli certains états dans la pile selon la structure
m_pRun->RestoreState(NULL, m_pStack, m_pInstance);
return TRUE;
return true;
}
int CBotProgram::GivVersion()
@ -566,7 +566,7 @@ int CBotProgram::GivVersion()
CBotCall* CBotCall::m_ListCalls = NULL;
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))
{
m_name = name;
@ -587,8 +587,8 @@ void CBotCall::Free()
delete CBotCall::m_ListCalls;
}
BOOL CBotCall::AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
bool CBotCall::AddFunction(const char* name,
bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
{
CBotCall* p = m_ListCalls;
@ -616,18 +616,18 @@ BOOL CBotCall::AddFunction(const char* name,
if (p) p->m_next = pp;
else m_ListCalls = pp;
return TRUE;
return true;
}
// transforme le tableau de pointeurs aux variables
// 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;
CBotVar* pVar = NULL;
while( TRUE )
while( true )
{
ppVars[i];
if ( ppVars[i] == NULL ) break;
@ -686,16 +686,16 @@ void CBotCall::SetPUser(void* pUser)
m_pUser = pUser;
}
int CBotCall::CheckCall(const char* name)
bool CBotCall::CheckCall(const char* name)
{
CBotCall* p = m_ListCalls;
while ( p != NULL )
{
if ( name == p->GivName() ) return TRUE;
if ( name == p->GivName() ) return true;
p = p->m_next;
}
return FALSE;
return false;
}
@ -746,7 +746,7 @@ fund:
#if !STACKRUN
// 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;
// crée une variable pour le résultat
@ -759,14 +759,14 @@ fund:
if ( pResult != pRes ) delete pRes; // si résultat différent rendu
delete pVarToDelete;
if (res == FALSE)
if (res == false)
{
if (Exception!=0)
{
pStack->SetError(Exception, token);
}
delete pResult;
return FALSE;
return false;
}
pStack->SetVar(pResult);
@ -775,16 +775,16 @@ fund:
pStack->SetError(TX_NORETVAL, token);
}
nIdent = pt->m_nFuncIdent;
return TRUE;
return true;
#else
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)
CBotVar* pVar = MakeListVars(ppVar, TRUE);
CBotVar* pVar = MakeListVars(ppVar, true);
CBotVar* pVarToDelete = pVar;
// crée une variable pour le résultat
@ -804,7 +804,7 @@ fund:
#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;
@ -817,22 +817,22 @@ BOOL CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBot
nIdent = pt->m_nFuncIdent;
CBotStack* pile = pStack->RestoreStackEOX(pt);
if ( pile == NULL ) return TRUE;
if ( pile == NULL ) return true;
CBotStack* pile2 = pile->RestoreStack();
return TRUE;
return true;
}
pt = pt->m_next;
}
}
return FALSE;
return false;
}
BOOL CBotCall::Run(CBotStack* pStack)
bool CBotCall::Run(CBotStack* pStack)
{
CBotStack* pile = pStack->AddStackEOX(this);
if ( pile == EOX ) return TRUE;
if ( pile == EOX ) return true;
CBotVar* pVar = pile->GivVar();
CBotStack* pile2 = pile->AddStack();
@ -842,20 +842,20 @@ BOOL CBotCall::Run(CBotStack* pStack)
int Exception = 0;
int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser());
if (res == FALSE)
if (res == false)
{
if (Exception!=0)
{
pStack->SetError(Exception);
}
if ( pResult != pRes ) delete pResult; // si résultat différent rendu
return FALSE;
return false;
}
if ( pResult != NULL ) pStack->SetCopyVar( pResult );
if ( pResult != pRes ) delete pResult; // si résultat différent rendu
return TRUE;
return true;
}
#endif
@ -863,7 +863,7 @@ BOOL CBotCall::Run(CBotStack* pStack)
///////////////////////////////////////////////////////////////////////////////////////
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))
{
m_name = name;
@ -893,7 +893,7 @@ CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis,
{
if ( pt->m_name == name )
{
CBotVar* pVar = MakeListVars(ppVar, TRUE);
CBotVar* pVar = MakeListVars(ppVar, true);
CBotVar* pVar2 = pVar;
CBotTypResult r = pt->m_rComp(pThis, pVar2);
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)
CBotVar* pVar = MakeListVars(ppVars, TRUE);
CBotVar* pVar = MakeListVars(ppVars, true);
CBotVar* pVarToDelete = pVar;
// 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);
pStack->SetVar(pResult);
if (res == FALSE)
if (res == false)
{
if (Exception!=0)
{
@ -959,10 +959,10 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
pStack->SetError(Exception, pToken);
}
delete pVarToDelete;
return FALSE;
return false;
}
delete pVarToDelete;
return TRUE;
return true;
}
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)
CBotVar* pVar = MakeListVars(ppVars, TRUE);
CBotVar* pVar = MakeListVars(ppVars, true);
CBotVar* pVarToDelete = pVar;
int Exception = 0;
int res = pt->m_rExec(pThis, pVar, pResult, Exception);
pStack->SetVar(pResult);
if (res == FALSE)
if (res == false)
{
if (Exception!=0)
{
@ -990,11 +990,11 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
pStack->SetError(Exception, pToken);
}
delete pVarToDelete;
return FALSE;
return false;
}
delete pVarToDelete;
nIdent = pt->m_nFuncIdent;
return TRUE;
return true;
}
pt = pt->m_next;
}
@ -1002,7 +1002,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
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;
@ -1016,7 +1016,7 @@ BOOL rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
}
pResult->SetValInt(i);
return TRUE;
return true;
}
CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser )
@ -1030,11 +1030,11 @@ CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser )
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 );
return TRUE;
return true;
}
CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser )
@ -1103,7 +1103,8 @@ void CBotProgram::Init()
// une fonction juste pour les debug divers
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)
#include "CBot.h"
#include <cstdlib>
#include <cstring>
#define ITIMER 100
@ -24,14 +26,14 @@
// gestion de la pile d'exécution
////////////////////////////////////////////////////////////////////////////
int CBotStack::m_initimer = ITIMER; // init la variable statique
int CBotStack::m_timer = 0; // init la variable statique
CBotVar* CBotStack::m_retvar = NULL; // init la variable statique
int CBotStack::m_error = 0; // init la variable statique
int CBotStack::m_start = 0; // init la variable statique
int CBotStack::m_end = 0; // init la variable statique
CBotString CBotStack::m_labelBreak=""; // init la variable statique
void* CBotStack::m_pUser = NULL;
int CBotStack::m_initimer = ITIMER;
int CBotStack::m_timer = 0;
CBotVar* CBotStack::m_retvar = NULL;
int CBotStack::m_error = 0;
int CBotStack::m_start = 0;
int CBotStack::m_end = 0;
CBotString CBotStack::m_labelBreak="";
void* CBotStack::m_pUser = NULL;
#if STACKMEM
@ -48,7 +50,7 @@ CBotStack* CBotStack::FirstStack()
// la vide totalement
memset(p, 0, size);
p-> m_bBlock = TRUE;
p-> m_bBlock = true;
m_timer = m_initimer; // met le timer au début
CBotStack* pp = p;
@ -56,7 +58,7 @@ CBotStack* CBotStack::FirstStack()
int i;
for ( i = 0 ; i< 10 ; i++ )
{
pp->m_bOver = TRUE;
pp->m_bOver = true;
pp ++;
}
#ifdef _DEBUG
@ -75,8 +77,8 @@ CBotStack* CBotStack::FirstStack()
CBotStack::CBotStack(CBotStack* ppapa)
{
// constructeur doit exister, sinon le destructeur n'est jamais appelé !
ASM_TRAP();
// constructor must exist or the destructor is never called!
ASM_TRAP();
}
CBotStack::~CBotStack()
@ -104,7 +106,7 @@ void CBotStack::Delete()
delete m_listVar;
CBotStack* p = m_prev;
BOOL bOver = m_bOver;
bool bOver = m_bOver;
#ifdef _DEBUG
int n = m_index;
#endif
@ -122,7 +124,7 @@ void CBotStack::Delete()
// routine optimisée
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
CBotStack* CBotStack::AddStack(CBotInstr* instr, bool bBlock)
{
if (m_next != NULL)
{
@ -150,11 +152,11 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
p->m_prev = this;
p->m_state = 0;
p->m_call = NULL;
p->m_bFunc = FALSE;
p->m_bFunc = false;
return p;
}
CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)
CBotStack* CBotStack::AddStackEOX(CBotCall* instr, bool bBlock)
{
if (m_next != NULL)
{
@ -171,7 +173,7 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)
return p;
}
CBotStack* CBotStack::AddStack2(BOOL bBlock)
CBotStack* CBotStack::AddStack2(bool bBlock)
{
if (m_next2 != NULL)
{
@ -194,14 +196,14 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock)
return p;
}
BOOL CBotStack::GivBlock()
bool CBotStack::GivBlock()
{
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 ?
m_var = pfils->m_var; // résultat transmis
@ -213,9 +215,9 @@ BOOL CBotStack::Return(CBotStack* pfils)
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 ?
m_var = pfils->m_var; // résultat transmis
@ -224,11 +226,11 @@ BOOL CBotStack::ReturnKeep(CBotStack* pfils)
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;
return TRUE;
return true;
}
#else
@ -239,7 +241,7 @@ CBotStack::CBotStack(CBotStack* ppapa)
m_next2 = NULL;
m_prev = ppapa;
m_bBlock = (ppapa == NULL) ? TRUE : FALSE;
m_bBlock = (ppapa == NULL) ? true : false;
m_state = 0;
m_step = 1;
@ -247,13 +249,13 @@ CBotStack::CBotStack(CBotStack* ppapa)
if (ppapa == NULL) m_timer = m_initimer; // met le timer au début
m_listVar = NULL;
m_bDontDelete = FALSE;
m_bDontDelete = false;
m_var = NULL;
m_prog = NULL;
m_instr = NULL;
m_call = NULL;
m_bFunc = FALSE;
m_bFunc = false;
}
// destructeur
@ -269,7 +271,7 @@ CBotStack::~CBotStack()
}
// routine à optimiser
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
CBotStack* CBotStack::AddStack(CBotInstr* instr, bool bBlock)
{
if (m_next != NULL)
{
@ -284,7 +286,7 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
return p;
}
CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)
CBotStack* CBotStack::AddStackEOX(CBotCall* instr, bool bBlock)
{
if (m_next != NULL)
{
@ -305,7 +307,7 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)
return p;
}
CBotStack* CBotStack::AddStack2(BOOL bBlock)
CBotStack* CBotStack::AddStack2(bool bBlock)
{
if (m_next2 != NULL)
{
@ -322,9 +324,9 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock)
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 ?
m_var = pfils->m_var; // résultat transmis
@ -336,9 +338,9 @@ BOOL CBotStack::Return(CBotStack* pfils)
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
@ -377,38 +379,38 @@ CBotStack* CBotStack::RestoreStackEOX(CBotCall* instr)
// routine pour l'exécution pas à pas
BOOL CBotStack::IfStep()
bool CBotStack::IfStep()
{
if ( m_initimer > 0 || m_step++ > 0 ) return FALSE;
return TRUE;
if ( m_initimer > 0 || m_step++ > 0 ) return false;
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==-3 ) return FALSE; // sortie normale (return en cours)
if ( m_error>=0 ) return false; // sortie normale
if ( m_error==-3 ) return false; // sortie normale (return en cours)
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_labelBreak.Empty();
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))
return FALSE; // c'est pas pour moi
return false; // c'est pas pour moi
m_state = state; // où reprendre ?
m_error = 0;
m_labelBreak.Empty();
if ( m_next != EOX ) m_next->Delete(); // purge la pile au dessus
return TRUE;
return true;
}
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
BOOL CBotStack::GivRetVar(BOOL bRet)
bool CBotStack::GivRetVar(bool bRet)
{
if (m_error == -3)
{
@ -432,7 +434,7 @@ BOOL CBotStack::GivRetVar(BOOL bRet)
m_var = m_retvar;
m_retvar = NULL;
m_error = 0;
return TRUE;
return true;
}
return bRet; // interrompu par autre chose que return
}
@ -469,7 +471,7 @@ void CBotStack::SetType(CBotTypResult& type)
// trouve une variable par son token
// 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;
CBotString name = pToken->GivString();
@ -482,7 +484,7 @@ CBotVar* CBotStack::FindVar(CBotToken* &pToken, BOOL bUpdate, BOOL bModif)
if (pp->GivName() == name)
{
if ( bUpdate )
pp->Maj(m_pUser, FALSE);
pp->Maj(m_pUser, false);
return pp;
}
@ -515,7 +517,7 @@ CBotVar* CBotStack::FindVar(const char* name)
// retrouve une variable sur la pile selon son numéro d'identification
// 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;
while (p != NULL)
@ -526,7 +528,7 @@ CBotVar* CBotStack::FindVar(long ident, BOOL bUpdate, BOOL bModif)
if (pp->GivUniqNum() == ident)
{
if ( bUpdate )
pp->Maj(m_pUser, FALSE);
pp->Maj(m_pUser, false);
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;
return FindVar(pt, bUpdate, bModif);
}
CBotVar* CBotStack::CopyVar(CBotToken& Token, BOOL bUpdate)
CBotVar* CBotStack::CopyVar(CBotToken& Token, bool 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;
@ -565,7 +567,7 @@ BOOL CBotStack::SetState(int n, int limite)
return ( m_timer > limite ); // interrompu si timer passé
}
BOOL CBotStack::IncState(int limite)
bool CBotStack::IncState(int limite)
{
m_state++;
@ -603,7 +605,7 @@ void CBotStack::SetTimer(int n)
m_initimer = n;
}
BOOL CBotStack::Execute()
bool CBotStack::Execute()
{
CBotCall* instr = NULL; // instruction la plus élevée
CBotStack* pile;
@ -621,9 +623,9 @@ BOOL CBotStack::Execute()
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
pile->m_next->Delete();
@ -632,7 +634,7 @@ BOOL CBotStack::Execute()
#endif
pile->m_next = EOX; // spécial pour reprise
return TRUE;
return true;
}
// met sur le stack le pointeur à une variable
@ -711,10 +713,10 @@ void CBotStack::AddVar(CBotVar* pVar)
void CBotStack::SetBotCall(CBotProgram* 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;
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;
@ -750,7 +752,7 @@ BOOL CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBo
if (res.GivType() >= 0) return res.GivType();
SetError(TX_NOCALL, token);
return TRUE;
return true;
}
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 )
{
return WriteWord(pf, 0); // met un terminateur
}
if ( !pVar->Save0State(pf)) return FALSE; // entête commune
if ( !pVar->Save1State(pf) ) return FALSE; // sauve selon la classe fille
if ( !pVar->Save0State(pf)) return false; // entête commune
if ( !pVar->Save1State(pf) ) return false; // sauve selon la classe fille
pVar = pVar->GivNext();
}
@ -856,7 +858,7 @@ CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level)
return p->m_listVar;
}
BOOL CBotStack::SaveState(FILE* pf)
bool CBotStack::SaveState(FILE* pf)
{
if ( this == NULL ) // fin de l'arbre ?
{
@ -865,33 +867,33 @@ BOOL CBotStack::SaveState(FILE* pf)
if ( m_next2 != NULL )
{
if (!WriteWord(pf, 2)) return FALSE; // une marque de poursuite
if (!m_next2->SaveState(pf)) return FALSE;
if (!WriteWord(pf, 2)) return false; // une marque de poursuite
if (!m_next2->SaveState(pf)) return false;
}
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_state)) return FALSE; // dans quel état
if (!WriteWord(pf, 0)) return FALSE; // par compatibilité m_bDontDelete
if (!WriteWord(pf, m_step)) return FALSE; // dans quel état
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, 0)) return false; // par compatibilité m_bDontDelete
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_listVar)) return FALSE; // les variables locales
if (!SaveVar(pf, m_var)) return false; // le résultat courant
if (!SaveVar(pf, m_listVar)) return false; // les variables locales
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;
if (!ReadWord(pf, w)) return FALSE;
if ( w == 0 ) return TRUE;
if (!ReadWord(pf, w)) return false;
if ( w == 0 ) return true;
#if STACKMEM
if ( this == NULL ) pStack = FirstStack();
@ -902,81 +904,81 @@ BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack)
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;
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
if (!ReadWord(pf, w)) return FALSE; // dont delete ?
if (!ReadWord(pf, w)) return false; // dont delete ?
// plus utilisé
if (!ReadWord(pf, w)) return FALSE; // pas à pas
if (!ReadWord(pf, w)) return false; // pas à pas
pStack->m_step = w;
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_var)) return false; // la variable temp
if (!CBotVar::RestoreState(pf, pStack->m_listVar)) return false;// les variables locales
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, m_bStatic))return FALSE; // variable static ?
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, 100+m_mPrivate))return false; // variable privée ?
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_binit))return false; // variable définie ?
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(!WriteWord(pf, 200 )) return FALSE; // marqueur spécial
if(!WriteString(pf, m_defnum)) return FALSE; // nom de la valeur
if(!WriteWord(pf, 200 )) return false; // marqueur spécial
if(!WriteString(pf, m_defnum)) return false; // nom de la valeur
}
return CBotVar::Save0State(pf);
}
BOOL CBotVarInt::Save1State(FILE* pf)
bool CBotVarInt::Save1State(FILE* pf)
{
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
}
BOOL CBotVarFloat::Save1State(FILE* pf)
bool CBotVarFloat::Save1State(FILE* pf)
{
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
}
BOOL CBotVarClass::Save1State(FILE* pf)
bool CBotVarClass::Save1State(FILE* pf)
{
if ( !WriteType(pf, m_type) ) return FALSE;
if ( !WriteLong(pf, m_ItemIdent) ) return FALSE;
if ( !WriteType(pf, m_type) ) return false;
if ( !WriteLong(pf, m_ItemIdent) ) return false;
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;
CBotString name, s;
@ -986,31 +988,31 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
CBotVar* pNew = 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 ( w == 0 ) return TRUE;
if (!ReadWord(pf, w)) return false; // privé ou type ?
if ( w == 0 ) return true;
CBotString defnum;
if ( w == 200 )
{
if (!ReadString(pf, defnum)) return FALSE; // nombre avec un identifiant
if (!ReadWord(pf, w)) return FALSE; // type
if (!ReadString(pf, defnum)) return false; // nombre avec un identifiant
if (!ReadWord(pf, w)) return false; // type
}
prv = 100; st = 0;
if ( w >= 100 )
{
prv = w;
if (!ReadWord(pf, st)) return FALSE; // statique
if (!ReadWord(pf, w)) return FALSE; // type
if (!ReadWord(pf, st)) return false; // statique
if (!ReadWord(pf, w)) return false; // type
}
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());
@ -1019,17 +1021,17 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
case CBotTypInt:
case CBotTypBoolean:
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);
break;
case CBotTypFloat:
pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadFloat(pf, ww)) return FALSE;
if (!ReadFloat(pf, ww)) return false;
pNew->SetValFloat(ww);
break;
case CBotTypString:
pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadString(pf, s)) return FALSE;
if (!ReadString(pf, s)) return false;
pNew->SetValString(s);
break;
@ -1039,17 +1041,17 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
{
CBotTypResult r;
long id;
if (!ReadType(pf, r)) return FALSE; // type complet
if (!ReadLong(pf, id) ) return FALSE;
if (!ReadType(pf, r)) return false; // type complet
if (!ReadLong(pf, id) ) return false;
// if (!ReadString(pf, s)) return FALSE;
// if (!ReadString(pf, s)) return false;
{
CBotVar* p = NULL;
if ( id ) p = CBotVarClass::Find(id) ;
pNew = new CBotVarClass(&token, r); // crée directement une instance
// attention cptuse = 0
if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return FALSE;
if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return false;
pNew->SetIdent(id);
if ( p != NULL )
@ -1063,7 +1065,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
case CBotTypPointer:
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
CBotVarClass* p = NULL;
@ -1073,7 +1075,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
// restitue une copie de l'instance d'origine
CBotVar* pInstance = NULL;
if ( !CBotVar::RestoreState( pf, pInstance ) ) return FALSE;
if ( !CBotVar::RestoreState( pf, pInstance ) ) return false;
((CBotVarPointer*)pNew)->SetPointer( pInstance ); // et pointe dessus
// if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p ); // plutôt celui-ci !
@ -1084,13 +1086,13 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
case CBotTypArrayPointer:
{
CBotTypResult r;
if (!ReadType(pf, r)) return FALSE;
if (!ReadType(pf, r)) return false;
pNew = CBotVar::Create(&token, r); // crée une variable
// restitue une copie de l'instance d'origine
CBotVar* pInstance = NULL;
if ( !CBotVar::RestoreState( pf, pInstance ) ) return FALSE;
if ( !CBotVar::RestoreState( pf, pInstance ) ) return false;
((CBotVarPointer*)pNew)->SetPointer( pInstance ); // et pointe dessus
}
break;
@ -1106,7 +1108,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
pNew->SetPrivate(prv-100);
pPrev = pNew;
}
return TRUE;
return true;
}
@ -1133,12 +1135,12 @@ CBotCStack::CBotCStack(CBotCStack* ppapa)
m_error = 0;
m_start = 0;
m_end = 0;
m_bBlock = TRUE;
m_bBlock = true;
}
else
{
m_start = ppapa->m_start;
m_bBlock = FALSE;
m_bBlock = false;
}
m_listVar = NULL;
@ -1156,7 +1158,7 @@ CBotCStack::~CBotCStack()
}
// 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
@ -1291,7 +1293,7 @@ CBotVar* CBotCStack::CopyVar(CBotToken& Token)
return pCopy;
}
BOOL CBotCStack::IsOk()
bool CBotCStack::IsOk()
{
return (m_error == 0);
}
@ -1325,15 +1327,15 @@ void CBotCStack::ResetError(int n, int start, int end)
m_end = end;
}
BOOL CBotCStack::NextToken(CBotToken* &p)
bool CBotCStack::NextToken(CBotToken* &p)
{
CBotToken* pp = p;
p = p->GivNext();
if (p!=NULL) return TRUE;
if (p!=NULL) return true;
SetError(TX_ENDOF, pp->GivEnd());
return FALSE;
return false;
}
void CBotCStack::SetBotCall(CBotProgram* p)
@ -1398,7 +1400,7 @@ void CBotCStack::AddVar(CBotVar* pVar)
// test si une variable est déjà définie localement
BOOL CBotCStack::CheckVarLocal(CBotToken* &pToken)
bool CBotCStack::CheckVarLocal(CBotToken* &pToken)
{
CBotCStack* p = this;
CBotString name = pToken->GivString();
@ -1409,13 +1411,13 @@ BOOL CBotCStack::CheckVarLocal(CBotToken* &pToken)
while ( pp != NULL)
{
if (name == pp->GivName())
return TRUE;
return true;
pp = pp->m_next;
}
if ( p->m_bBlock ) return FALSE;
if ( p->m_bBlock ) return false;
p = p->m_prev;
}
return FALSE;
return false;
}
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
BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
CBotString name = pToken->GivString();
if ( CBotCall::CheckCall(name) ) return TRUE;
if ( CBotCall::CheckCall(name) ) return true;
CBotFunction* pp = m_prog->GivFunctions();
while ( pp != NULL )
@ -1453,7 +1455,7 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
// les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
return true;
}
pp = pp->Next();
}
@ -1465,11 +1467,11 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
// les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
return true;
}
pp = pp->m_nextpublic;
}
return FALSE;
return false;
}

104
src/CBot/CBotString.cpp
View File

@ -19,9 +19,11 @@
#include "CBot.h"
#include <string.h>
HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("libCbot.dll"); // comment le récupérer autrement ??
#include <cstdlib>
#include <cstring>
#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()
@ -38,13 +40,13 @@ CBotString::~CBotString()
CBotString::CBotString(const char* p)
{
m_lg = lstrlen( p );
m_lg = strlen( p );
m_ptr = NULL;
if (m_lg>0)
{
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)
{
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()
{
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;
}
int CBotString::Find(LPCTSTR lpsz)
int CBotString::Find(const char * lpsz)
{
int i, j;
int l = lstrlen(lpsz);
int l = strlen(lpsz);
for (i = 0; i <= m_lg-l; i++)
{
@ -170,10 +172,10 @@ int CBotString::ReverseFind(const char c)
return -1;
}
int CBotString::ReverseFind(LPCTSTR lpsz)
int CBotString::ReverseFind(const char * lpsz)
{
int i, j;
int l = lstrlen(lpsz);
int l = strlen(lpsz);
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;
char* p = (char*)malloc(m_lg+1);
lstrcpy(p, m_ptr+start);
strcpy(p, m_ptr+start);
p[lg] = 0;
res = p;
@ -229,11 +231,11 @@ void CBotString::MakeLower()
#define MAXSTRING 256
BOOL CBotString::LoadString(UINT id)
bool CBotString::LoadString(unsigned int id)
{
char buffer[MAXSTRING];
m_lg = ::LoadString( m_hInstance, id, buffer, MAXSTRING );
/// \TODO implement loading strings from resources. Figure out how to do it
// m_lg = ::LoadString( m_hInstance, id, buffer, MAXSTRING );
if (m_ptr != NULL) free(m_ptr);
@ -241,10 +243,10 @@ BOOL CBotString::LoadString(UINT id)
if (m_lg > 0)
{
m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, buffer);
return TRUE;
strcpy(m_ptr, buffer);
return true;
}
return FALSE;
return false;
}
@ -258,13 +260,13 @@ const CBotString& CBotString::operator=(const CBotString& stringSrc)
if (m_lg > 0)
{
m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, stringSrc.m_ptr);
strcpy(m_ptr, stringSrc.m_ptr);
}
return *this;
}
CBotString operator+(const CBotString& string, LPCTSTR lpsz)
CBotString operator+(const CBotString& string, const char * lpsz)
{
CBotString s ( string );
s += lpsz;
@ -275,9 +277,9 @@ const CBotString& CBotString::operator+(const CBotString& stringSrc)
{
char* p = (char*)malloc(m_lg+stringSrc.m_lg+1);
lstrcpy(p, m_ptr);
strcpy(p, m_ptr);
char* pp = p + m_lg;
lstrcpy(pp, stringSrc.m_ptr);
strcpy(pp, stringSrc.m_ptr);
if (m_ptr != NULL) free(m_ptr);
m_ptr = p;
@ -306,12 +308,12 @@ const CBotString& CBotString::operator=(const char* pString)
if ( pString != NULL )
{
m_lg = lstrlen(pString);
m_lg = strlen(pString);
if (m_lg != 0)
{
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);
if (m_ptr!=NULL) lstrcpy(p, m_ptr);
if (m_ptr!=NULL) strcpy(p, m_ptr);
p[m_lg++] = ch;
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);
lstrcpy(p, m_ptr);
strcpy(p, m_ptr);
char* pp = p + m_lg;
lstrcpy(pp, str.m_ptr);
strcpy(pp, str.m_ptr);
m_lg = m_lg + str.m_lg;
@ -351,67 +353,67 @@ const CBotString& CBotString::operator+=(const CBotString& str)
return *this;
}
BOOL CBotString::operator==(const CBotString& str)
bool CBotString::operator==(const CBotString& str)
{
return Compare(str) == 0;
}
BOOL CBotString::operator==(const char* p)
bool CBotString::operator==(const char* p)
{
return Compare(p) == 0;
}
BOOL CBotString::operator!=(const CBotString& str)
bool CBotString::operator!=(const CBotString& str)
{
return Compare(str) != 0;
}
BOOL CBotString::operator!=(const char* p)
bool CBotString::operator!=(const char* p)
{
return Compare(p) != 0;
}
BOOL CBotString::operator>(const CBotString& str)
bool CBotString::operator>(const CBotString& str)
{
return Compare(str) > 0;
}
BOOL CBotString::operator>(const char* p)
bool CBotString::operator>(const char* p)
{
return Compare(p) > 0;
}
BOOL CBotString::operator>=(const CBotString& str)
bool CBotString::operator>=(const CBotString& str)
{
return Compare(str) >= 0;
}
BOOL CBotString::operator>=(const char* p)
bool CBotString::operator>=(const char* p)
{
return Compare(p) >= 0;
}
BOOL CBotString::operator<(const CBotString& str)
bool CBotString::operator<(const CBotString& str)
{
return Compare(str) < 0;
}
BOOL CBotString::operator<(const char* p)
bool CBotString::operator<(const char* p)
{
return Compare(p) < 0;
}
BOOL CBotString::operator<=(const CBotString& str)
bool CBotString::operator<=(const CBotString& str)
{
return Compare(str) <= 0;
}
BOOL CBotString::operator<=(const char* p)
bool CBotString::operator<=(const char* p)
{
return Compare(p) <= 0;
}
BOOL CBotString::IsEmpty() const
bool CBotString::IsEmpty() const
{
return (m_lg == 0);
}
@ -423,20 +425,20 @@ void CBotString::Empty()
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;
}
int CBotString::Compare(LPCTSTR lpsz) const
int CBotString::Compare(const char * lpsz) const
{
char* p = m_ptr;
if (lpsz == NULL) lpsz = nilstring;
if (m_ptr == NULL) p = nilstring;
if (lpsz == NULL) lpsz = emptyString;
if (m_ptr == NULL) p = emptyString;
return strcmp(p, lpsz); // wcscmp
}
@ -527,14 +529,14 @@ void CBotStringArray::SetSize(int nNewSize)
// shrink to nothing
DestructElements(m_pData, m_nSize);
delete[] (BYTE*)m_pData;
delete[] (unsigned char *)m_pData;
m_pData = NULL;
m_nSize = m_nMaxSize = 0;
}
else if (m_pData == NULL)
{
// 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);
@ -563,7 +565,7 @@ void CBotStringArray::SetSize(int nNewSize)
{
// heuristically determine growth when nGrowBy == 0
// (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;
if (nNewSize < m_nMaxSize + nGrowBy)
@ -571,7 +573,7 @@ void CBotStringArray::SetSize(int nNewSize)
else
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
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)
delete[] (BYTE*)m_pData;
delete[] (unsigned char *)m_pData;
m_pData = pNewData;
m_nSize = nNewSize;
m_nMaxSize = nNewMax;

67
src/CBot/CBotToken.cpp
View File

@ -22,6 +22,7 @@
#include "CBot.h"
#include <cstdarg>
CBotStringArray CBotToken::m_ListKeyWords;
int CBotToken::m_ListIdKeyWords[200];
@ -188,27 +189,27 @@ void CBotToken::SetPos(int start, int end)
m_end = end;
}
BOOL CharInList(const char c, const char* list)
bool CharInList(const char c, const char* list)
{
int i = 0;
while (TRUE)
while (true)
{
if (c == list[i++]) return TRUE;
if (list[i] == 0) return FALSE;
if (c == list[i++]) return true;
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;
while (TRUE)
while (true)
{
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
// ne doit pas commencer par des séparateurs
// 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 sep; // les séparateurs qui le suivent
char c;
BOOL stop = first;
bool stop = first;
if (*program == 0) return NULL;
@ -262,14 +263,14 @@ CBotToken* CBotToken::NextToken(char* &program, int& error, BOOL first)
mot += c; // chaîne complète
c = *(program++); // prochain caractère
}
stop = TRUE;
stop = true;
}
// cas particulier pour les nombres
if ( CharInList(mot[0], num ))
{
BOOL bdot = FALSE; // trouvé un point ?
BOOL bexp = FALSE; // trouvé un exposant ?
bool bdot = false; // trouvé un point ?
bool bexp = false; // trouvé un exposant ?
char* liste = num;
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 ( !bdot && c == '.' ) { bdot = TRUE; goto cc; }
if ( !bdot && c == '.' ) { bdot = true; goto cc; }
if ( !bexp && ( c == 'e' || c == 'E' ) )
{
bexp = TRUE;
bexp = true;
mot += c;
c = *(program++); // prochain caractère
if ( c == '-' ||
@ -298,7 +299,7 @@ cc: mot += c;
}
}
stop = TRUE;
stop = true;
}
if (CharInList(mot[0], sep3)) // un séparateur opérationnel ?
@ -310,13 +311,13 @@ cc: mot += c;
c = *(program++); // prochain caractère
}
stop = TRUE;
stop = true;
}
}
while (TRUE)
while (true)
{
if (stop || c == 0 || CharInList(c, sep1))
{
@ -381,7 +382,7 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error)
int pos = 0;
error = 0;
prv = tokenbase = NextToken(p, error, TRUE);
prv = tokenbase = NextToken(p, error, true);
if (tokenbase == NULL) return NULL;
@ -443,7 +444,7 @@ int CBotToken::GivKeyWords(const char* w)
return -1;
}
BOOL CBotToken::GivKeyDefNum(const char* w, CBotToken* &token)
bool CBotToken::GivKeyDefNum(const char* w, CBotToken* &token)
{
int i;
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_type = TokenTypDef;
return TRUE;
return true;
}
}
return FALSE;
return false;
}
// 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 l = m_ListKeyDefine.GivSize();
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_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 ||
p->GivType() == type2 )
{
p = p->GivNext();
return TRUE;
return true;
}
return FALSE;
return false;
}
// idem avec un nombre indéfini d'arguments
// 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 max = 20;
@ -536,18 +537,18 @@ BOOL IsOfTypeList(CBotToken* &p, int type1, ...)
va_list marker;
va_start( marker, type1 ); /* Initialize variable arguments. */
while (TRUE)
while (true)
{
if (type == i)
{
p = p->GivNext();
va_end( marker ); /* Reset variable arguments. */
return TRUE;
return true;
}
if (--max == 0 || 0 == (i = va_arg( marker, int)))
{
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 IsOfTypeList(CBotToken* &p, int type1, ...);
extern bool IsOfType(CBotToken* &p, int type1, int type2 = -1);
extern bool IsOfTypeList(CBotToken* &p, int type1, ...);

58
src/CBot/CBotTwoOpExpr.cpp
View File

@ -95,19 +95,19 @@ static int ListOp[] =
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++;
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);
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 ( err != NULL ) *err = TX_OPNAN ;
return TRUE;
return true;
}
return FALSE;
return false;
}
// 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
// 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
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
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);
res->SetValInt(FALSE);
res->SetValInt(false);
pStk1->SetVar(res);
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);
res->SetValInt(TRUE);
res->SetValInt(true);
pStk1->SetVar(res);
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
if ( pStk2->GivState() == 0 )
{
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
if ( !m_rightop->Execute(pStk2) ) return false; // interrompu ici ?
pStk2->IncState();
}
@ -342,7 +342,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
CBotTypResult type2 = pStk2->GivTypResult();
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
// quel est le type du résultat ?
@ -475,7 +475,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
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;
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
// ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE;
// if ( pStk1 == EOX ) return true;
if ( pStk1->GivState() == 0 )
{
if ( !m_condition->Execute(pStk1) ) return FALSE;
if (!pStk1->SetState(1)) return FALSE;
if ( !m_condition->Execute(pStk1) ) 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
{
if ( !m_op2->Execute(pStk1) ) return FALSE;
if ( !m_op2->Execute(pStk1) ) return false;
}
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;
@ -538,7 +538,7 @@ void CBotLogicExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
return;
}
if ( pStk1->GivVal() == TRUE )
if ( pStk1->GivVal() == true )
{
m_op1->RestoreState(pStk1, bMain);
}
@ -557,7 +557,7 @@ void t()
#endif
#if 01
void t(BOOL t)
void t(bool t)
{
int x;
x = 1 + t ? 1 : 3 + 4 * 2 ;

278
src/CBot/CBotVar.cpp
View File

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

216
src/CBot/CBotWhile.cpp
View File

@ -66,7 +66,7 @@ CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
// la condition existe
IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl();
if ( pStk->IsOk() )
@ -83,31 +83,31 @@ CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
// 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
// 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)
case 0:
// é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
// 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
}
// 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:
// évalue le bloc d'instruction associé
@ -125,12 +125,12 @@ BOOL CBotWhile :: Execute(CBotStack* &pj)
}
// repasse au test pour recommencer
if (!pile->SetState(0, 0)) return FALSE;
if (!pile->SetState(0, 0)) return false;
continue;
}
}
void CBotWhile :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotWhile :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
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);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl();
if ( pStk->IsOk() )
@ -221,19 +221,19 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
// 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
// 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)
case 0:
// é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
@ -246,7 +246,7 @@ BOOL CBotRepeat :: Execute(CBotStack* &pj)
// 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
case 1:
@ -269,12 +269,12 @@ BOOL CBotRepeat :: Execute(CBotStack* &pj)
}
// repasse au test pour recommencer
if (!pile->SetState(pile->GivState()-1, 0)) return FALSE;
if (!pile->SetState(pile->GivState()-1, 0)) return false;
continue;
}
}
void CBotRepeat :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotRepeat :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
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
IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl();
if ( pStk->IsOk() )
@ -358,15 +358,15 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)
// 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
// 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)
case 0:
// é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
}
if (!pile->SetState(1)) return FALSE; // prêt pour la suite
if (!pile->SetState(1)) return false; // prêt pour la suite
case 1:
// é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
// 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
}
// repasse au bloc d'instruction pour recommencer
if (!pile->SetState(0, 0)) return FALSE;
if (!pile->SetState(0, 0)) return false;
continue;
}
}
void CBotDo :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotDo :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
@ -467,7 +467,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
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
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 ?
{
IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl();
if ( pStk->IsOk() )
return pStack->Return(inst, pStk);;
@ -510,39 +510,39 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
// 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
// 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)
case 0:
// évalue l'initialisation
if ( m_Init != NULL &&
!m_Init->Execute(pile) ) return FALSE; // interrompu ici ?
if (!pile->SetState(1)) return FALSE; // prêt pour la suite
!m_Init->Execute(pile) ) return false; // interrompu ici ?
if (!pile->SetState(1)) return false; // prêt pour la suite
case 1:
// évalue la condition
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
// 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
}
}
// 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:
// é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
}
if (!pile->SetState(3)) return FALSE; // prêt pour la suite
if (!pile->SetState(3)) return false; // prêt pour la suite
case 3:
// évalue l'incrémentation
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
if (!pile->SetState(1, 0)) return FALSE; // revient au test
if (!pile->SetState(1, 0)) return false; // revient au test
continue;
}
}
void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotFor :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
@ -583,28 +583,28 @@ void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain)
{ // il y a 4 états possibles (selon reprise)
case 0:
// é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;
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
if ( m_Test != NULL ) m_Test->RestoreState(pile, TRUE); // interrompu ici !
if ( m_Test != NULL ) m_Test->RestoreState(pile, true); // interrompu ici !
return;
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é
if ( m_Block != NULL ) m_Block->RestoreState(pile, TRUE);
if ( m_Block != NULL ) m_Block->RestoreState(pile, true);
return;
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
if ( m_Incr != NULL ) m_Incr->RestoreState(pile, TRUE); // interrompu ici !
if ( m_Incr != NULL ) m_Incr->RestoreState(pile, true); // interrompu ici !
return;
}
}
@ -629,10 +629,10 @@ CBotListExpression::~CBotListExpression()
static CBotInstr* CompileInstrOrDefVar(CBotToken* &p, CBotCStack* pStack)
{
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 = 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 ?
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 = 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 = CBotExpression::Compile( p, pStack ); // compile une expression
return i;
}
@ -660,7 +660,7 @@ CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack)
return NULL;
}
BOOL CBotListExpression::Execute(CBotStack* &pj)
bool CBotListExpression::Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack();// indispensable
CBotInstr* p = m_Expr; // la première expression
@ -668,17 +668,17 @@ BOOL CBotListExpression::Execute(CBotStack* &pj)
int state = pile->GivState();
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();
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);
}
void CBotListExpression::RestoreState(CBotStack* &pj, BOOL bMain)
void CBotListExpression::RestoreState(CBotStack* &pj, bool bMain)
{
CBotStack* pile = pj;
int state = 0x7000;
@ -694,7 +694,7 @@ void CBotListExpression::RestoreState(CBotStack* &pj, BOOL bMain)
while (p != NULL && state-->0)
{
p->RestoreState(pile, FALSE);
p->RestoreState(pile, false);
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);
}
CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk, true );
if ( !pStk->IsOk() )
{
delete inst;
@ -811,21 +811,21 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
// 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
// if ( pile1 == EOX ) return TRUE;
// if ( pile1 == EOX ) return true;
CBotInstr* p = m_Block; // la première expression
int state = pile1->GivState();
if (state == 0)
{
if ( !m_Value->Execute(pile1) ) return FALSE;
if ( !m_Value->Execute(pile1) ) return false;
pile1->SetState(state = -1);
}
if ( pile1->IfStep() ) return FALSE;
if ( pile1->IfStep() ) return false;
if ( state == -1 )
{
@ -843,7 +843,7 @@ BOOL CBotSwitch :: Execute(CBotStack* &pj)
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
@ -852,13 +852,13 @@ BOOL CBotSwitch :: Execute(CBotStack* &pj)
while( p != NULL )
{
if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1);
if ( !pile1->IncState() ) return FALSE;
if ( !pile1->IncState() ) return false;
p = p->GivNext();
}
return pj->Return(pile1);
}
void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotSwitch :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
@ -882,13 +882,13 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain)
// p = m_Block; // revient au début
while ( p != NULL && state-- > 0 )
{
p->RestoreState(pile1, FALSE);
p->RestoreState(pile1, false);
p = p->GivNext(); // avance dans la liste
}
if( p != NULL )
{
p->RestoreState(pile1, TRUE);
p->RestoreState(pile1, true);
return;
}
}
@ -942,21 +942,21 @@ CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)
// 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"
// 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)
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"
BOOL CBotBreak :: Execute(CBotStack* &pj)
bool CBotBreak :: Execute(CBotStack* &pj)
{
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);
return pj->Return(pile);
}
void CBotBreak :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotBreak :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( bMain ) pj->RestoreStack(this);
}
@ -1092,14 +1092,14 @@ CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack)
// les arrêts par suspension
// et les "finaly"
BOOL CBotTry :: Execute(CBotStack* &pj)
bool CBotTry :: Execute(CBotStack* &pj)
{
int val;
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
CBotStack* pile0 = pj->AddStack2(); // ajoute un élément à la pile secondaire
CBotStack* pile2 = pile0->AddStack();
@ -1114,14 +1114,14 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
val = pile1->GivError();
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();
pile2->SetState(val); // mémorise le numéro de l'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 ?
return FALSE; // ne fait pas le catch
return false; // ne fait pas le catch
}
// il y a eu une interruption
@ -1137,16 +1137,16 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
if ( --state <= 0 )
{
// 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();
}
if ( --state <= 0 )
{
if ( pile2->GivVal() == TRUE )
if ( pile2->GivVal() == true )
{
// 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 )
return pj->Return(pile2); // termine le try
@ -1164,7 +1164,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
{
// 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
pile2->SetError(pile1->GivState()==-1 ? val : 0); // remet l'erreur initiale
return pj->Return(pile2);
@ -1176,11 +1176,11 @@ BOOL CBotTry :: Execute(CBotStack* &pj)
return pj->Return(pile2); // termine le try sans exception aucune
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;
@ -1217,7 +1217,7 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain)
}
if ( --state <= 0 )
{
if ( pile2->GivVal() == TRUE )
if ( pile2->GivVal() == true )
{
pc->RestoreState(pile2, bMain); // exécute l'opération
return;
@ -1285,27 +1285,27 @@ CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
// 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é
}
void CBotCatch :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotCatch :: RestoreState(CBotStack* &pj, bool 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);
}
// 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 )
{
@ -1314,7 +1314,7 @@ BOOL CBotCatch :: TestCatch(CBotStack* &pile, int val)
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"
BOOL CBotThrow :: Execute(CBotStack* &pj)
bool CBotThrow :: Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return TRUE;
// if ( pile == EOX ) return true;
if ( pile->GivState() == 0 )
{
if ( !m_Value->Execute(pile) ) return FALSE;
if ( !m_Value->Execute(pile) ) return false;
pile->IncState();
}
if ( pile->IfStep() ) return FALSE;
if ( pile->IfStep() ) return false;
int val = pile->GivVal();
if ( val < 0 ) val = TX_BADTHROW;
@ -1378,7 +1378,7 @@ BOOL CBotThrow :: Execute(CBotStack* &pj)
return pj->Return( pile );
}
void CBotThrow :: RestoreState(CBotStack* &pj, BOOL bMain)
void CBotThrow :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
@ -1417,11 +1417,11 @@ CBotInstr* CBotStartDebugDD::Compile(CBotToken* &p, CBotCStack* pStack)
// exécute l'instruction "throw"
BOOL CBotStartDebugDD :: Execute(CBotStack* &pj)
bool CBotStartDebugDD :: Execute(CBotStack* &pj)
{
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
// exécution
BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
bool rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
CBotString mode;
@ -132,7 +132,7 @@ CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
// destructeur de la classe
// 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"
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
// 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
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
@ -243,7 +243,7 @@ CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)
// méthode FILE :: close
// 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
if ( pVar != NULL ) return CBotErrOverParam;
@ -275,7 +275,7 @@ CBotTypResult cfclose (CBotVar* pThis, CBotVar* &pVar)
// méthode FILE :: writeln
// 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
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
@ -319,7 +319,7 @@ CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)
// méthode FILE :: readln
// 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
if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }
@ -360,7 +360,7 @@ CBotTypResult cfread (CBotVar* pThis, CBotVar* &pVar)
// 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
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
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
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
CBotString s = pVar->GivValString();
// met la longueur sur la pile
pResult->SetValInt( s.GivLength() );
return TRUE;
return true;
}
// int xxx ( string )
@ -60,36 +60,36 @@ CBotTypResult cIntStr( CBotVar* &pVar, void* pUser )
// donne la partie gauche d'une chaîne
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s = pVar->GivValString();
// il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
int n = pVar->GivValInt();
// 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
s = s.Left( n );
// la met sur la pile
pResult->SetValString( s );
return TRUE;
return true;
}
// string xxx ( string, int )
@ -122,58 +122,58 @@ CBotTypResult cStrStrInt( CBotVar* &pVar, void* pUser )
// donne la partie droite d'une chaîne
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s = pVar->GivValString();
// il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
int n = pVar->GivValInt();
// 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
s = s.Right( n );
// la met sur la pile
pResult->SetValString( s );
return TRUE;
return true;
}
// donne la partie centrale d'une chaîne
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s = pVar->GivValString();
// il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
int n = pVar->GivValInt();
@ -184,13 +184,13 @@ BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
pVar = pVar->GivNext();
// 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
int l = pVar->GivValInt();
// 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
s = s.Mid( n, l );
@ -203,7 +203,7 @@ BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
// la met sur la pile
pResult->SetValString( s );
return TRUE;
return true;
}
// 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
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s = pVar->GivValString();
// 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);
// la met la valeur sur la pile
pResult->SetValFloat( val );
return TRUE;
return true;
}
// float xxx ( string )
@ -291,35 +291,35 @@ CBotTypResult cFloatStr( CBotVar* &pVar, void* pUser )
// trouve une chaine dans une autre
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s = pVar->GivValString();
// il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s2 = pVar->GivValString();
// 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
int res = s.Find(s2);
pResult->SetValInt( res );
if ( res < 0 ) pResult->SetInit( IS_NAN );
return TRUE;
return true;
}
// int xxx ( string, string )
@ -352,51 +352,51 @@ CBotTypResult cIntStrStr( CBotVar* &pVar, void* pUser )
// donne une chaine en majuscule
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s = pVar->GivValString();
// 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();
// la met la valeur sur la pile
pResult->SetValString( s );
return TRUE;
return true;
}
// donne une chaine en minuscules
// 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
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// 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
CBotString s = pVar->GivValString();
// 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();
// la met la valeur sur la pile
pResult->SetValString( s );
return TRUE;
return true;
}
// 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
# add_subdirectory(CBot) -- not yet WinAPI-independent
add_subdirectory(CBot)
# Configure options
@ -25,6 +25,7 @@ configure_file(common/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/common/config.h
# Source files
# Commented out files are still dependent on DirectX or WinAPI
set(SOURCES
app/app.cpp
app/main.cpp
@ -150,7 +151,7 @@ set(LIBS
${SDL_LIBRARY}
${SDLIMAGE_LIBRARY}
${OPENGL_LIBRARY}
#CBot -- not yet WinAPI-independent
CBot
)
include_directories(. ${CMAKE_CURRENT_BINARY_DIR})