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

Merge branch 'dev' into dev-opengl 

Pulled changes & resolved conflicts
dev-ui
Piotr Dziwinski 2012-07-27 18:09:50 +02:00
parent 4ddcd9f810 6b846aa629
commit ab8e55a651
26 changed files with 7486 additions and 7835 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -16,8 +16,8 @@ find_package(PNG REQUIRED)
set(CMAKE_BUILD_TYPE debug)
# Global compile flags
set(CMAKE_CXX_FLAGS_RELEASE "-O2")
set(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -O0")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -Wall -std=gnu++0x")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -Wall -std=gnu++0x")
# Subdirectory with sources
add_subdirectory(src bin)

1631
src/CBot/CBot.cpp
View File

File diff suppressed because it is too large Load Diff

768
src/CBot/CBot.h
View File

File diff suppressed because it is too large Load Diff

279
src/CBot/CBot.rc
View File

@ -1,279 +0,0 @@
//Microsoft Developer Studio generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// French (France) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
#ifdef _WIN32
LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
#pragma code_page(1252)
#endif //_WIN32
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE DISCARDABLE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE DISCARDABLE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
3 TEXTINCLUDE DISCARDABLE
BEGIN
"\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// String Table
//
STRINGTABLE DISCARDABLE
BEGIN
ID_IF "if"
ID_ELSE "else"
ID_WHILE "while"
ID_DO "do"
ID_FOR "for"
ID_BREAK "break"
ID_CONTINUE "continue"
ID_SWITCH "switch"
ID_CASE "case"
ID_DEFAULT "default"
ID_TRY "try"
ID_THROW "throw"
ID_CATCH "catch"
ID_FINALLY "finally"
ID_TXT_AND "and"
ID_TXT_OR "or"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_DEBUGDD "STARTDEBUGDD"
ID_INT "int"
ID_FLOAT "float"
ID_BOOLEAN "boolean"
ID_STRING "string"
ID_VOID "void"
ID_BOOL "bool"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_TXT_NOT "not"
ID_RETURN "return"
ID_CLASS "class"
ID_EXTENDS "extends"
ID_SYNCHO "synchronized"
ID_NEW "new"
ID_PUBLIC "public"
ID_EXTERN "extern"
ID_FINAL "final"
ID_STATIC "static"
ID_PROTECTED "protected"
ID_PRIVATE "private"
ID_REPEAT "repeat"
END
STRINGTABLE DISCARDABLE
BEGIN
TX_OPENPAR "Il manque une parenthèse ouvrante."
TX_CLOSEPAR "Il manque une parenthèse fermante."
TX_NOTBOOL "L'expression doit être un boolean."
TX_UNDEFVAR "Variable non déclarée."
TX_BADLEFT "Assignation impossible."
TX_ENDOF "Terminateur point-virgule non trouvé."
TX_OUTCASE "Instruction ""case"" hors d'un bloc ""switch""."
TX_NOTERM "Instructions après la fin."
END
STRINGTABLE DISCARDABLE
BEGIN
TX_CLOSEBLK "Il manque la fin du bloc."
TX_ELSEWITHOUTIF "Instruction ""else"" sans ""if"" correspondant."
TX_OPENBLK "Début d'un bloc attendu."
TX_BADTYPE "Mauvais type de résultat pour l'assignation."
TX_REDEFVAR "Redéfinition d'une variable."
TX_BAD2TYPE "Les deux opérandes ne sont pas de types compatibles."
TX_UNDEFCALL "Routine inconnue."
TX_MISDOTS "Séparateur "" : "" attendu."
TX_WHILE "Manque le mot ""while""."
TX_BREAK "Instruction ""break"" en dehors d'une boucle."
TX_LABEL "Un label ne peut se placer que devant un ""for"", un ""while"" ou un ""do""."
TX_NOLABEL "Cette étiquette n'existe pas"
TX_NOCASE "Manque une instruction ""case""."
TX_BADNUM "Un nombre est attendu."
TX_VOID "Paramètre void."
TX_NOTYP "Déclaration de type attendu."
END
STRINGTABLE DISCARDABLE
BEGIN
TX_DIVZERO "Division par zéro."
TX_NOTINIT "Variable non initialisée."
TX_BADTHROW "Valeur négative refusée pour ""throw""."
TX_NORETVAL "La fonction n'a pas retourné de résultat"
TX_NORUN "Pas de fonction en exécution"
TX_NOCALL "Appel d'une fonction inexistante"
TX_NOCLASS "Cette classe n'existe pas"
TX_NULLPT "Pointeur nul."
TX_OPNAN "Opération sur un ""nan"""
TX_OUTARRAY "Accès hors du tableau"
TX_STACKOVER "Dépassement de la pile"
TX_DELETEDPT "Pointeur à un objet détruit"
TX_FILEOPEN "Ouverture du fichier impossible"
TX_NOTOPEN "Fichier pas ouvert"
TX_ERRREAD "Erreur de lecture"
TX_ERRWRITE "Erreur d'écriture"
END
STRINGTABLE DISCARDABLE
BEGIN
TX_NOVAR "Nom d'une variable attendu."
TX_NOFONC "Nom de la fonction attendu."
TX_OVERPARAM "Trop de paramètres."
TX_REDEF "Cette fonction existe déjà."
TX_LOWPARAM "Pas assez de paramètres."
TX_BADPARAM "Aucune fonction de ce nom n'accepte ce(s) type(s) de paramètre(s)."
TX_NUMPARAM "Aucune fonction de ce nom n'accepte ce nombre de paramètres."
TX_NOITEM "Cet élément n'existe pas dans cette classe."
TX_DOT "L'objet n'est pas une instance d'une classe."
TX_NOCONST "Il n'y a pas de constructeur approprié."
TX_REDEFCLASS "Cette classe existe déjà."
TX_CLBRK """ ] "" attendu."
TX_RESERVED "Ce mot est réservé."
TX_BADNEW "Mauvais argument pour ""new""."
TX_OPBRK """ [ "" attendu."
TX_BADSTRING "Une chaîne de caractère est attendue."
END
STRINGTABLE DISCARDABLE
BEGIN
TX_BADINDEX "Mauvais type d'index"
TX_PRIVATE "Membre privé de la classe"
TX_NOPUBLIC """public"" manque"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_OPENPAR "("
ID_CLOSEPAR ")"
ID_OPBLK "{"
ID_CLBLK "}"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_SEP ";"
ID_COMMA ","
ID_DOTS ":"
ID_DOT "."
ID_OPBRK "["
ID_CLBRK "]"
ID_DBLDOTS "::"
ID_LOGIC "?"
ID_ADD "+"
ID_SUB "-"
ID_MUL "*"
ID_DIV "/"
ID_ASS "="
ID_ASSADD "+="
ID_ASSSUB "-="
ID_ASSMUL "*="
END
STRINGTABLE DISCARDABLE
BEGIN
ID_TRUE "true"
ID_FALSE "false"
ID_NULL "null"
ID_NAN "nan"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_ASSDIV "/="
ID_ASSOR "|="
ID_ASSAND "&="
ID_ASSXOR "^="
ID_ASSSL "<<="
ID_ASSSR ">>>="
ID_ASSASR ">>="
ID_SL "<<"
ID_SR ">>>"
ID_ASR ">>"
ID_INC "++"
ID_DEC "--"
ID_LO "<"
ID_HI ">"
ID_LS "<="
ID_HS ">="
END
STRINGTABLE DISCARDABLE
BEGIN
ID_EQ "=="
ID_NE "!="
ID_AND "&"
ID_XOR "^"
ID_OR "|"
ID_LOG_AND "&&"
ID_LOG_OR "||"
ID_LOG_NOT "!"
ID_NOT "~"
ID_MODULO "%"
ID_POWER "**"
ID_ASSMODULO "%="
END
STRINGTABLE DISCARDABLE
BEGIN
TX_UNDEF "undefined"
TX_NAN "not a number"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_SUPER "super"
END
#endif // French (France) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

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;

575
src/CBot/CBotDll.h
View File

@ -13,76 +13,130 @@
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////////
// Librairie pour l'interprétation du language CBOT
// pour le jeu COLOBOT
//
#ifndef _CBOTDLL_H_
#define _CBOTDLL_H_
/**
* \file CBotDll.h
* \brief Library for interpretation of CBOT language
*/
//#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include "resource.h"
#include <map>
#include <cstring>
#define DllExport __declspec( dllexport )
#define CBOTVERSION 104
////////////////////////////////////////////////////////////////////////
// quelques classes définies par ailleurs
// forward declaration of needed classes
class CBotToken; // programme transformé en "jetons"
class CBotStack; // pile pour l'exécution
class CBotClass; // classe d'object
class CBotInstr; // instruction à exécuter
class CBotFunction; // les fonctions user
class CBotVar; // les variables
class CBotVarClass; // une instance de classe
class CBotVarPointer; // pointeur à une instance de classe
class CBotCall; // les fonctions
class CBotCallMethode; // les méthodes
class CBotDefParam; // liste de paramètres
class CBotCStack;
class CBotToken; // program turned into "tokens
class CBotStack; // for the execution stack
class CBotClass; // class of object
class CBotInstr; // instruction to be executed
class CBotFunction; // user functions
class CBotVar; // variables
class CBotVarClass; // instance of class
class CBotVarPointer; // pointer to an instance of class
class CBotCall; // fonctions
class CBotCallMethode; // methods
class CBotDefParam; // parameter list
class CBotCStack; // stack
////////////////////////////////////////////////////////////////////////
// Gestion des variables
// Variables management
////////////////////////////////////////////////////////////////////////
// ces types sont calqués sur les types Java
// ne pas changer l'ordre de ces types
/** \brief CBotType Defines known types. This types are modeled on Java types. Do not change the order of elements */
enum CBotType
{
CBotTypVoid = 0, // fonction retournant void
CBotTypByte = 1, //n // nombre entier ( 8 bits)
CBotTypShort = 2, //n // nombre entier (16 bits)
CBotTypChar = 3, //n // caractère "unicode" (16 bits)
CBotTypInt = 4, // nombre entier (32 bits)
CBotTypLong = 5, //n // nombre entier (64 bits)
CBotTypFloat = 6, // nombre décimal (32 bits)
CBotTypDouble = 7, //n // nombre décimal (64 bits)
CBotTypBoolean = 8, // true ou false exclusivement
CBotTypString = 9, // chaine de caractère
CBotTypVoid = 0,
CBotTypByte = 1, //n
CBotTypShort = 2, //n
CBotTypChar = 3, //n
CBotTypInt = 4,
CBotTypLong = 5, //n
CBotTypFloat = 6,
CBotTypDouble = 7, //n
CBotTypBoolean = 8,
CBotTypString = 9,
CBotTypArrayPointer = 10, // un tableau de variables
CBotTypArrayBody = 11, // idem mais crée l'instance
CBotTypArrayPointer = 10, // array of variables
CBotTypArrayBody = 11, // same but creates an instance
CBotTypPointer = 12, // pointeur à une instance
CBotTypNullPointer = 13, // pointeur null est spécial
CBotTypClass = 15, // instance d'une classe
CBotTypIntrinsic = 16 // instance d'une classe intrinsèque
CBotTypPointer = 12, // pointer to an instance
CBotTypNullPointer = 13, // null pointer is special
CBotTypClass = 15,
CBotTypIntrinsic = 16 // instance of a class intrinsic
};
//n = non encore implémenté
//n = not implemented yet
// pour SetUserPtr lors de la suppression d'un objet
// for SetUserPtr when deleting an object
#define OBJECTDELETED ((void*)-1)
// valeur mise avant initialisation
// value set before initialization
#define OBJECTCREATED ((void*)-2)
// classe permettant de définir le type complet d'un résultat
/** \brief CBotTypResult class to define the complete type of a result*/
class CBotTypResult
{
public:
/**
* \brief CBotTypResult constructor of an object
* \param type type of created result, see CBotType
*/
CBotTypResult(int type);
/**
* \brief CBotTypResult constructor for simple types (CBotTypInt to CBotTypString)
* \param type type of created result, see CBotType
* \param name
*/
// pour les types simples (CBotTypInt à CBotTypString)
CBotTypResult(int type, const char* name);
// pour les types pointeur et classe intrinsic
CBotTypResult(int type, CBotClass* pClass);
// idem à partir de l'instance d'une classe
CBotTypResult(int type, CBotTypResult elem);
// pour les tableaux de variables
CBotTypResult(const CBotTypResult& typ);
// pour les assignations
CBotTypResult();
// pour par défaut
~CBotTypResult();
int GivType(int mode = 0) const;
// rend le type CBotTyp* du résultat
void SetType(int n);
// modifie le type
CBotClass* GivClass() const;
// rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer)
int GivLimite() const;
// rend la taille limite du tableau (CBotTypArray)
void SetLimite(int n);
// fixe une limite au tableau
void SetArray(int* max );
// idem avec une liste de dimension (tableaux de tableaux)
CBotTypResult& GivTypElem() const;
// rend le type des éléments du tableau (CBotTypArray)
bool Compare(const CBotTypResult& typ) const;
// compare si les types sont compatibles
bool Eq(int type) const;
// compare le type
CBotTypResult&
operator=(const CBotTypResult& src);
// copie un type complet dans un autre
private:
int m_type;
CBotTypResult* m_pNext; // pour les types de types
@ -90,68 +144,6 @@ private:
int m_limite; // limitation des tableaux
friend class CBotVarClass;
friend class CBotVarPointer;
public:
// divers constructeurs selon les besoins
DllExport
CBotTypResult(int type);
// pour les types simples (CBotTypInt à CBotTypString)
DllExport
CBotTypResult(int type, const char* name);
// pour les types pointeur et classe intrinsic
DllExport
CBotTypResult(int type, CBotClass* pClass);
// idem à partir de l'instance d'une classe
DllExport
CBotTypResult(int type, CBotTypResult elem);
// pour les tableaux de variables
DllExport
CBotTypResult(const CBotTypResult& typ);
// pour les assignations
DllExport
CBotTypResult();
// pour par défaut
DllExport
~CBotTypResult();
DllExport
int GivType(int mode = 0) const;
// rend le type CBotTyp* du résultat
void SetType(int n);
// modifie le type
DllExport
CBotClass* GivClass() const;
// rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer)
DllExport
int GivLimite() const;
// rend la taille limite du tableau (CBotTypArray)
DllExport
void SetLimite(int n);
// fixe une limite au tableau
void SetArray(int* max );
// idem avec une liste de dimension (tableaux de tableaux)
DllExport
CBotTypResult& GivTypElem() const;
// rend le type des éléments du tableau (CBotTypArray)
DllExport
BOOL Compare(const CBotTypResult& typ) const;
// compare si les types sont compatibles
DllExport
BOOL Eq(int type) const;
// compare le type
DllExport
CBotTypResult&
operator=(const CBotTypResult& src);
// copie un type complet dans un autre
};
/*
@ -249,113 +241,82 @@ public:
////////////////////////////////////////////////////////////////////////
// définie une classe pour l'utilisation des strings
//
// car CString fait partie de MFC pas utilisé ici.
//
// ( toutes les fonctions ne sont pas encore implémentées )
/** \brief CBotString Class used to work on strings */
class CBotString
{
private:
char* m_ptr; // pointeur à la chaine
int m_lg; // longueur de la chaine
static
HINSTANCE m_hInstance;
public:
DllExport
CBotString();
DllExport
CBotString(const char* p);
DllExport
CBotString(const CBotString& p);
DllExport
~CBotString();
DllExport
void Empty();
DllExport
BOOL IsEmpty() const;
DllExport
bool IsEmpty() const;
int GivLength();
DllExport
int Find(const char c);
DllExport
int Find(LPCTSTR lpsz);
DllExport
int Find(const char* lpsz);
int ReverseFind(const char c);
DllExport
int ReverseFind(LPCTSTR lpsz);
DllExport
BOOL LoadString(UINT id);
DllExport
int ReverseFind(const char* lpsz);
bool LoadString(unsigned int id);
CBotString Mid(int nFirst, int nCount) const;
DllExport
CBotString Mid(int nFirst) const;
DllExport
CBotString Left(int nCount) const;
DllExport
CBotString Right(int nCount) const;
DllExport
const CBotString&
operator=(const CBotString& stringSrc);
DllExport
const CBotString&
operator=(const char ch);
DllExport
const CBotString&
operator=(const char* pString);
DllExport
const CBotString&
operator+(const CBotString& str);
DllExport
friend CBotString
operator+(const CBotString& string, LPCTSTR lpsz);
DllExport
const CBotString&
operator+=(const char ch);
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
operator LPCTSTR() const; // as a C string
int Compare(LPCTSTR lpsz) const;
DllExport
CBotString Mid(int start, int lg=-1);
DllExport
CBotString Left(int nCount) const;
CBotString Right(int nCount) const;
int Compare(const char* lpsz) const;
void MakeUpper();
DllExport
void MakeLower();
/**
* \brief Overloaded oprators to work on CBotString classes
*/
const CBotString& operator=(const CBotString& stringSrc);
const CBotString& operator=(const char ch);
const CBotString& operator=(const char* pString);
const CBotString& operator+(const CBotString& str);
friend CBotString operator+(const CBotString& string, const char* lpsz);
const CBotString& operator+=(const char ch);
const CBotString& operator+=(const CBotString& str);
bool operator==(const CBotString& str);
bool operator==(const char* p);
bool operator!=(const CBotString& str);
bool operator!=(const char* p);
bool operator>(const CBotString& str);
bool operator>(const char* p);
bool operator>=(const CBotString& str);
bool operator>=(const char* p);
bool operator<(const CBotString& str);
bool operator<(const char* p);
bool operator<=(const CBotString& str);
bool operator<=(const char* p);
operator const char*() const; // as a C string
private:
/** \brief Pointer to string */
char* m_ptr;
/** \brief Length of the string */
int m_lg;
/** \brief Keeps the string corresponding to keyword ID */
static const std::map<EID, char *> s_keywordString;
/**
* \brief MapIdToString maps given ID to its string equivalent
* \param id Provided identifier
* \return string if found, else NullString
*/
static const char * MapIdToString(EID id);
};
@ -369,20 +330,13 @@ private:
CBotString* m_pData; // ^aux données
public:
DllExport
CBotStringArray();
DllExport
~CBotStringArray();
DllExport
void SetSize(int nb);
DllExport
int GivSize();
DllExport
void Add(const CBotString& str);
DllExport
CBotString& operator[](int nIndex);
DllExport
CBotString& ElementAt(int nIndex);
};
@ -418,87 +372,70 @@ 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
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
static
void Free();
// libère les zones mémoires statiques
DllExport
static
int GivVersion();
// donne la version de la librairie CBOT
DllExport
CBotProgram();
DllExport
CBotProgram(CBotVar* pInstance);
DllExport
~CBotProgram();
DllExport
BOOL Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
bool Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
// compile le programme donné en texte
// 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
void SetIdent(long n);
// associe un identificateur avec l'instance CBotProgram
DllExport
long GivIdent();
// redonne l'identificateur
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
bool GetError(int& code, int& start, int& end);
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
static
CBotString GivErrorText(int code);
DllExport
BOOL Start(const char* name);
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);
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);
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
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 +444,34 @@ 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
void Stop();
// arrête l'exécution du programme
// quitte donc le mode "suspendu"
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
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
static
BOOL DefineNum(const char* name, long val);
bool DefineNum(const char* name, long val);
DllExport
BOOL SaveState(FILE* pf);
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);
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,
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 +485,9 @@ public:
///////////////////////////////////////////////////////////////////////////////
// routines pour la gestion d'un fichier (FILE*)
DllExport
FILE* fOpen(const char* name, const char* mode);
DllExport
int fClose(FILE* filehandle);
DllExport
size_t fWrite(const void *buffer, size_t elemsize, size_t length, FILE* filehandle);
DllExport
size_t fRead(void *buffer, size_t elemsize, size_t length, FILE* filehandle);
@ -594,7 +520,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 +532,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
@ -614,7 +540,6 @@ BOOL rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception)
/////////////////////////////////////////////////////////////////////////////////
// Classe pour la gestion des variables
// les méthodes marquées DllExport
// peuvent être utile à l'exterieur du module
// ( il n'est pour l'instant pas prévu de pouvoir créer ces objets en externe )
@ -645,7 +570,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
@ -662,18 +587,10 @@ public:
CBotVar();
virtual ~CBotVar( ); // destructeur
/* DllExport
static
CBotVar* Create( const char* name, int type, const char* ClassName = NULL);
// crée une variable selon son type,*/
DllExport
static
CBotVar* Create( const char* name, CBotTypResult type);
// idem à partir du type complet
DllExport
static
CBotVar* Create( const char* name, CBotClass* pClass);
// idem pour une instance d'une classe connue
@ -690,51 +607,38 @@ virtual ~CBotVar( ); // destructeur
CBotVar* Create( CBotVar* pVar );
DllExport
void SetUserPtr(void* pUser);
// associe un pointeur utilisateur à une instance
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
void* GivUserPtr();
// rend le pointeur associé à la variable
DllExport
CBotString GivName(); // le nom de la variable, s'il est connu
////////////////////////////////////////////////////////////////////////////////////
void SetName(const char* name); // change le nom de la variable
DllExport
int GivType(int mode = 0); // rend le type de base (int) de la variable
////////////////////////////////////////////////////////////////////////////////////////
DllExport
CBotTypResult GivTypResult(int mode = 0); // rend le type complet de la variable
CBotToken* GivToken();
void SetType(CBotTypResult& type);
DllExport
void SetInit(int bInit); // met la variable dans l'état IS_UNDEF, IS_DEF, IS_NAN
DllExport
int GivInit(); // donne l'état de la variable
DllExport
void SetStatic(BOOL bStatic);
DllExport
BOOL IsStatic();
void SetStatic(bool bStatic);
bool IsStatic();
DllExport
void SetPrivate(int mPrivate);
DllExport
BOOL IsPrivate(int mode = PR_PROTECT);
DllExport
bool IsPrivate(int mode = PR_PROTECT);
int GivPrivate();
virtual
@ -742,55 +646,44 @@ virtual ~CBotVar( ); // destructeur
void SetVal(CBotVar* var); // remprend une valeur
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
virtual
CBotVar* GivItem(int row, BOOL bGrow = FALSE);
CBotVar* GivItem(int row, bool bGrow = false);
DllExport
virtual
CBotVar* GivItemList(); // donne la liste des éléments
DllExport
CBotVar* GivStaticVar(); // rend le pointeur à la variable si elle est statique
DllExport
BOOL IsElemOfClass(const char* name);
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
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
virtual void SetValInt(int val, const char* name = NULL);
// initialise avec une valeur entière (#)
/////////////////////////////////////////////////////////////////////////////////
DllExport
virtual void SetValFloat(float val); // initialise avec une valeur réelle (#)
////////////////////////////////////////////////////////////////////////////////
DllExport
virtual void SetValString(const char* p);// initialise avec une valeur chaîne (#)
////////////////////////////////////////////////////////////////////////////////
DllExport
virtual int GivValInt(); // demande la valeur entière (#)
////////////////////////////////////////////////////////////////////////
DllExport
virtual float GivValFloat(); // demande la valeur réelle (#)
///////////////////////////////////////////////////////////////////////
@ -814,12 +707,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 +727,17 @@ 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
void debug();
// virtual
// CBotVar* GivMyThis();
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 +779,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 +790,30 @@ 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
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
~CBotClass( ); // destructeur
DllExport
BOOL AddFunction(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
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 ) );
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);
bool AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);
// ajoute un élément à la classe
// DllExport
// BOOL AddItem(CBotString name, CBotClass* pClass);
// bool AddItem(CBotString name, CBotClass* pClass);
// idem pour des éléments appartenant à pClass
DllExport
BOOL AddItem(CBotVar* pVar);
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 +822,16 @@ public:
// idem en donnant un élément de type CBotVar
void AddNext(CBotClass* pClass);
DllExport
CBotString GivName(); // rend le nom de la classe
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
bool IsChildOf(CBotClass* pClass);
static
CBotClass* Find(CBotToken* &pToken); // trouve une classe d'après son nom
DllExport
static
CBotClass* Find(const char* name);
@ -962,7 +842,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 +851,25 @@ 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
static
BOOL SaveStaticState(FILE* pf);
bool SaveStaticState(FILE* pf);
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 +919,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 +932,28 @@ public:
// constructeur
~CBotToken(); // destructeur
DllExport
int GivType(); // rend le type du token
DllExport
CBotString& GivString(); // rend la chaine correspondant à ce token
DllExport
CBotString& GivSep(); // rend le séparateur suivant le token
DllExport
int GivStart(); // position du début dans le texte
DllExport
int GivEnd(); // position de fin dans le texte
DllExport
CBotToken* GivNext(); // rend le suivant dans la liste
DllExport
CBotToken* GivPrev(); // rend le Précédent dans la liste
DllExport
static
CBotToken* CompileTokens(const char* p, int& error);
// transforme tout le programme
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 +961,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 +1032,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 +1043,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 +1062,10 @@ 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 //_CBOTDLL_H_

168
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;
@ -1379,7 +1379,6 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
if (IsOfType(p, TokenTypVar))
{
CBotClass* pPapa = NULL;
#if EXTENDS
if ( IsOfType( p, ID_EXTENDS ) )
{
CBotString name = p->GivString();
@ -1391,10 +1390,9 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
return NULL;
}
}
#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 +1402,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 +1411,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 +1436,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 +1461,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 +1483,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 +1500,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 +1538,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 +1561,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 +1576,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;
}
@ -1627,20 +1625,18 @@ CBotClass* CBotClass::Compile(CBotToken* &p, CBotCStack* pStack)
// la classe à été créée par Compile1
CBotClass* pOld = CBotClass::Find(name);
#if EXTENDS
if ( IsOfType( p, ID_EXTENDS ) )
{
IsOfType(p, TokenTypVar); // forcément
}
#endif
IsOfType( p, ID_OPBLK); // forcément
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 !

209
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;
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");
}

296
src/CBot/CBotStack.cpp
View File

@ -13,9 +13,13 @@
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.//////////////////////////////////////////////////////////////////////
// gestion de la pile (stack)
//Management of the stack
#include "CBot.h"
#include <cstdlib>
#include <cstring>
#define ITIMER 100
@ -24,13 +28,13 @@
// 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
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 +52,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 +60,7 @@ CBotStack* CBotStack::FirstStack()
int i;
for ( i = 0 ; i< 10 ; i++ )
{
pp->m_bOver = TRUE;
pp->m_bOver = true;
pp ++;
}
#ifdef _DEBUG
@ -75,7 +79,7 @@ CBotStack* CBotStack::FirstStack()
CBotStack::CBotStack(CBotStack* ppapa)
{
// constructeur doit exister, sinon le destructeur n'est jamais appelé !
// constructor must exist or the destructor is never called!
ASM_TRAP();
}
@ -104,7 +108,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 +126,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 +154,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 +175,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 +198,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 +217,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 +228,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 +243,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 +251,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 +273,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 +288,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 +309,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 +326,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 +340,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 +381,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 +428,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 +436,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
}
@ -445,21 +449,18 @@ int CBotStack::GivError(int& start, int& end)
}
// type d'instruction sur la pile
int CBotStack::GivType(int mode)
{
if (m_var == NULL) return -1;
return m_var->GivType(mode);
}
// type d'instruction sur la pile
CBotTypResult CBotStack::GivTypResult(int mode)
{
if (m_var == NULL) return -1;
return m_var->GivTypResult(mode);
}
// type d'instruction sur la pile
void CBotStack::SetType(CBotTypResult& type)
{
if (m_var == NULL) return;
@ -467,9 +468,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 +481,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;
}
@ -512,10 +511,7 @@ CBotVar* CBotStack::FindVar(const char* name)
return NULL;
}
// 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 +522,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 +534,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 +553,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 +561,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 +599,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 +617,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 +628,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 +707,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 +724,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 +746,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 +758,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 +852,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 +861,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 +898,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 +982,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 +1015,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 +1035,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 +1059,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 +1069,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 +1080,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 +1102,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
pNew->SetPrivate(prv-100);
pPrev = pNew;
}
return TRUE;
return true;
}
@ -1133,12 +1129,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 +1152,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 +1287,7 @@ CBotVar* CBotCStack::CopyVar(CBotToken& Token)
return pCopy;
}
BOOL CBotCStack::IsOk()
bool CBotCStack::IsOk()
{
return (m_error == 0);
}
@ -1325,15 +1321,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 +1394,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 +1405,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 +1436,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 +1449,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 +1461,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;
}

326
src/CBot/CBotString.cpp
View File

@ -13,38 +13,132 @@
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/./////////////////////////////////////////////////////
// gestion de chaine
// basé sur le CString de MFC
// mais moins complet
//strings management
#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>
//Map is filled with id-string pars that are needed for CBot language parsing
const std::map<EID, char *> CBotString::s_keywordString =
{
{ID_IF, "if"},
{ID_ELSE, "else"},
{ID_WHILE, "while"},
{ID_DO, "do"},
{ID_FOR, "for"},
{ID_BREAK, "break"},
{ID_CONTINUE, "continue"},
{ID_SWITCH, "switch"},
{ID_CASE, "case"},
{ID_DEFAULT, "default"},
{ID_TRY, "try"},
{ID_THROW, "throw"},
{ID_CATCH, "catch"},
{ID_FINALLY, "finally"},
{ID_TXT_AND, "and"},
{ID_TXT_OR, "or"},
{ID_TXT_NOT, "not"},
{ID_RETURN, "return"},
{ID_CLASS, "class"},
{ID_EXTENDS, "extends"},
{ID_SYNCHO, "synchronized"},
{ID_NEW, "new"},
{ID_PUBLIC, "public"},
{ID_EXTERN, "extern"},
{ID_FINAL, "final"},
{ID_STATIC, "static"},
{ID_PROTECTED, "protected"},
{ID_PRIVATE, "private"},
{ID_REPEAT, "repeat"},
{ID_DEBUGDD, "STARTDEBUGDD"},
{ID_INT, "int"},
{ID_FLOAT, "float"},
{ID_BOOLEAN, "boolean"},
{ID_STRING, "string"},
{ID_VOID, "void"},
{ID_BOOL, "bool"},
{ID_TRUE, "true"},
{ID_FALSE, "false"},
{ID_NULL, "null"},
{ID_NAN, "nan"},
{ID_OPENPAR, "("},
{ID_CLOSEPAR, ")"},
{ID_OPBLK, "{"},
{ID_CLBLK, "}"},
{ID_SEP, "},"},
{ID_COMMA, ","},
{ID_DOTS, ":"},
{ID_DOT, "."},
{ID_OPBRK, "["},
{ID_CLBRK, "]"},
{ID_DBLDOTS, "::"},
{ID_LOGIC, "?"},
{ID_ADD, "+"},
{ID_SUB, "-"},
{ID_MUL, "*"},
{ID_DIV, "/"},
{ID_ASS, "="},
{ID_ASSADD, "+="},
{ID_ASSSUB, "-="},
{ID_ASSMUL, "*="},
{ID_ASSDIV, "/="},
{ID_ASSOR, "|="},
{ID_ASSAND, "&="},
{ID_ASSXOR, "^="},
{ID_ASSSL, "<<="},
{ID_ASSSR, ">>>="},
{ID_ASSASR, ">>="},
{ID_SL, "<<"},
{ID_SR, ">>"},
{ID_ASR, ">>"},
{ID_INC, "++"},
{ID_DEC, "--"},
{ID_LO, "<"},
{ID_HI, ">"},
{ID_LS, "<<"},
{ID_HS, ">="},
{ID_EQ, "=="},
{ID_NE, "!="},
{ID_AND, "&"},
{ID_XOR, "^"},
{ID_OR, "|"},
{ID_LOG_AND, "&&"},
{ID_LOG_OR, "||"},
{ID_LOG_NOT, "!"},
{ID_NOT, "~"},
{ID_MODULO, "%"},
{ID_POWER, "**"},
{ID_ASSMODULO, "%="},
{ID_SUPER, "super"},
{TX_UNDEF, "undefined"},
{TX_NAN, "not a number"}
};
CBotString::CBotString()
{
m_ptr = NULL; // chaine vide
m_ptr = NULL;
m_lg = 0;
}
CBotString::~CBotString()
{
if (m_ptr != NULL) free(m_ptr);
free(m_ptr); //we can call free on null pointer as it's save
}
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 +150,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,91 +160,87 @@ CBotString::CBotString(const CBotString& srcString)
int CBotString::GivLength()
{
if (m_ptr == NULL) return 0;
return lstrlen( m_ptr );
return strlen( m_ptr );
}
CBotString CBotString::Left(int nCount) const
{
char chaine[2000];
char chain[2000];
int i;
for (i = 0; i < m_lg && i < nCount && i < 1999; i++)
size_t i;
for (i = 0; i < m_lg && i < nCount && i < 1999; ++i)
{
chaine[i] = m_ptr[i];
chain[i] = m_ptr[i];
}
chaine[i] = 0 ;
chain[i] = 0 ;
return CBotString( chaine );
return CBotString(chain);
}
CBotString CBotString::Right(int nCount) const
{
char chaine[2000];
char chain[2000];
int i = m_lg - nCount;
if ( i < 0 ) i = 0;
int j;
for ( j = 0 ; i < m_lg && i < 1999; i++)
size_t j;
for (size_t j = 0 ; i < m_lg && i < 1999; ++i)
{
chaine[j++] = m_ptr[i];
chain[j++] = m_ptr[i];
}
chaine[j] = 0 ;
chain[j] = 0 ;
return CBotString( chaine );
return CBotString(chain);
}
CBotString CBotString::Mid(int nFirst, int nCount) const
{
char chaine[2000];
char chain[2000];
int i;
for ( i = nFirst; i < m_lg && i < 1999 && i <= nFirst + nCount; i++)
size_t i;
for (i = nFirst; i < m_lg && i < 1999 && i <= nFirst + nCount; ++i)
{
chaine[i] = m_ptr[i];
chain[i] = m_ptr[i];
}
chaine[i] = 0 ;
chain[i] = 0 ;
return CBotString( chaine );
return CBotString(chain);
}
CBotString CBotString::Mid(int nFirst) const
{
char chaine[2000];
char chain[2000];
int i;
for ( i = nFirst; i < m_lg && i < 1999 ; i++)
size_t i;
for (i = nFirst; i < m_lg && i < 1999 ; ++i)
{
chaine[i] = m_ptr[i];
chain[i] = m_ptr[i];
}
chaine[i] = 0 ;
chain[i] = 0 ;
return CBotString( chaine );
return CBotString(chain);
}
int CBotString::Find(const char c)
{
int i;
for (i = 0; i < m_lg; i++)
for (size_t i = 0; i < m_lg; ++i)
{
if (m_ptr[i] == c) return i;
}
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++)
for (size_t i = 0; i <= m_lg-l; ++i)
{
for (j = 0; j < l; j++)
for (size_t j = 0; j < l; ++j)
{
if (m_ptr[i+j] != lpsz[j]) goto bad;
}
@ -163,21 +253,21 @@ bad:;
int CBotString::ReverseFind(const char c)
{
int i;
for (i = m_lg-1; i >= 0; i--)
for (i = m_lg-1; i >= 0; --i)
{
if (m_ptr[i] == c) return i;
}
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--)
for (i = m_lg-l; i >= 0; --i)
{
for (j = 0; j < l; j++)
for (j = 0; j < l; ++j)
{
if (m_ptr[i+j] != lpsz[j]) goto bad;
}
@ -195,7 +285,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;
@ -205,9 +295,7 @@ CBotString CBotString::Mid(int start, int lg)
void CBotString::MakeUpper()
{
int i;
for ( i = 0; i < m_lg && i < 1999 ; i++)
for (size_t i = 0; i < m_lg && i < 1999 ; ++i)
{
char c = m_ptr[i];
if ( c >= 'a' && c <= 'z' ) m_ptr[i] = c - 'a' + 'A';
@ -216,55 +304,48 @@ void CBotString::MakeUpper()
void CBotString::MakeLower()
{
int i;
for ( i = 0; i < m_lg && i < 1999 ; i++)
for (size_t i = 0; i < m_lg && i < 1999 ; ++i)
{
char c = m_ptr[i];
if ( c >= 'A' && c <= 'Z' ) m_ptr[i] = c - 'A' + 'a';
}
}
#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 );
const char * str = NULL;
str = MapIdToString((EID)id);
if (m_ptr != NULL) free(m_ptr);
m_lg = strlen(str);
m_ptr = NULL;
if (m_lg > 0)
{
m_ptr = (char*)malloc(m_lg+1);
lstrcpy(m_ptr, buffer);
return TRUE;
strcpy(m_ptr, str);
return true;
}
return FALSE;
return false;
}
const CBotString& CBotString::operator=(const CBotString& stringSrc)
{
if (m_ptr != NULL) free(m_ptr);
free(m_ptr);
m_ptr = NULL;
m_lg = stringSrc.m_lg;
m_ptr = NULL;
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,11 +356,11 @@ 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);
free(m_ptr);
m_ptr = p;
m_lg += stringSrc.m_lg;
@ -288,7 +369,7 @@ const CBotString& CBotString::operator+(const CBotString& stringSrc)
const CBotString& CBotString::operator=(const char ch)
{
if (m_ptr != NULL) free(m_ptr);
free(m_ptr);
m_lg = 1;
@ -301,17 +382,17 @@ const CBotString& CBotString::operator=(const char ch)
const CBotString& CBotString::operator=(const char* pString)
{
if (m_ptr != NULL) free(m_ptr);
free(m_ptr);
m_ptr = NULL;
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,11 +404,11 @@ 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;
if (m_ptr != NULL) free(m_ptr);
free(m_ptr);
m_ptr = p;
@ -338,112 +419,122 @@ 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;
if (m_ptr != NULL) free(m_ptr);
free(m_ptr);
m_ptr = p;
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);
}
void CBotString::Empty()
{
if (m_ptr != NULL) free(m_ptr);
free(m_ptr);
m_ptr = NULL;
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
}
const char * CBotString::MapIdToString(EID id)
{
if (s_keywordString.find(id) != s_keywordString.end())
{
return s_keywordString.at(id);
}
else
{
return emptyString;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// tableaux de chaines
// arrays of strings
CBotStringArray::CBotStringArray()
{
@ -453,7 +544,7 @@ CBotStringArray::CBotStringArray()
CBotStringArray::~CBotStringArray()
{
SetSize(0); // détruit les données !
SetSize(0); // destroys data !
}
@ -469,9 +560,8 @@ void CBotStringArray::Add(const CBotString& str)
m_pData[m_nSize-1] = str;
}
///////////////////////////////////////////////////////////////////////
// routines utilitaires
// utility routines
static inline void ConstructElement(CBotString* pNewData)
{
@ -518,7 +608,7 @@ static void CopyElements(CBotString* pDest, CBotString* pSrc, int nCount)
// sélect la taille du tableau
// set the array size
void CBotStringArray::SetSize(int nNewSize)
{
@ -527,14 +617,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 +653,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 +661,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));
@ -580,8 +670,8 @@ void CBotStringArray::SetSize(int nNewSize)
ConstructElements(&pNewData[m_nSize], nNewSize-m_nSize);
// Ret rid of old stuff (note: no destructors called)
delete[] (BYTE*)m_pData;
// Get rid of old stuff (note: no destructors called)
delete[] (unsigned char *)m_pData;
m_pData = pNewData;
m_nSize = nNewSize;
m_nMaxSize = nNewMax;
@ -599,5 +689,3 @@ CBotString& CBotStringArray::ElementAt(int nIndex)
return m_pData[nIndex];
}

68
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,15 +455,16 @@ 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
/// \todo Fixme Figure out how this should work.
void CBotToken::LoadKeyWords()
{
CBotString s;
@ -498,36 +500,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 +538,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;
}

1
src/CBot/CMakeLists.txt
View File

@ -10,7 +10,6 @@ CBotToken.cpp
CBotTwoOpExpr.cpp
CBotVar.cpp
CBotWhile.cpp
CBot.rc
)
add_library(CBot SHARED ${SOURCES})

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 )

50
src/CBot/idees.txt
View File

@ -1,39 +1,41 @@
pour la gestion des instances d'une classe.
l'objet créé actuellement avec CBotVar::Create(nom, pClasse)
est a conserver tel quel, en dehors des vars sur la pile
for managing instances of a class.
il faut un autre type de variable pour garder les pointeurs
CBotTypPtClass par exemple
the object being created with CBotVar :: Create (name, pClasse)
is to keep as is, outside the vars on the stack
L'instance de la classe doit avoir un compteur d'utilisation
qui est le nombre d'objet de classe CBotTypPtClass qui y réfèrent.
Le compteur est décrémenté lorsque le pointeur est détruit,
l'objet supprimé lorsqu'il n'y a plus de pointeurs.
we need another type of variable to keep the pointers
For example CBotTypPtClass
The instance of the class must have a usage count
which is the number of class object to which they refer CBotTypPtClass.
The counter is decremented when the pointer is destroyed,
be deleted when there is more pointers.
Dans le cas des robots, Daniel crée une instance de sa classe "Object"
et peut retourner des pointeurs à cette instance par des routines genre FindRobot()
In the case of robots, Daniel creates an instance of class "Object"
and can return pointers to this proceeding by routines such FindRobot ()
Object FindRobot (int n) {}
pResult dans ce cas est un pointeur CBotTypPtClass
lorsqu'il a trouvé le robot concerné, il lui faudra faire
pResult in this case is a pointer CBotTypPtClass
when he found the robot concerned, it must make
pResult-> SetPointeur (InstanceDeLaClassObject);
cette opération incrémente le compteur des références
this operation increments the reference
--
-
lorsque le robot est détruit, l'instance de la classe Object correspondant
est détruit également.
s'il reste des pointeurs à cet objet, et l'on risque la planté
when the robot is destroyed, the instance of the Object class corresponding
is also destroyed.
if there are pointers to that object, and we planted the risk
solution 1:
garder non pas le pointeur à l'objet directement, mais
un index dans une tables de pointeurs
Solution 1:
not keep the pointer to the object directly, but
an index into a table of pointers
Solution 2:
not destroy the object when there imédiatement pointers
but marked as virtually destroyed
solution 2:
ne pas détruire l'objet imédiatement lorsqu'il reste des pointeurs
mais le marqué comme virtuellement détruit

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/.

206
src/CBot/resource.h
View File

@ -13,100 +13,105 @@
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by CBot.rc
//
#define ID_KEYWORDS 2000
#define ID_IF 2000
#define ID_ELSE 2001
#define ID_WHILE 2002
#define ID_DO 2003
#define ID_FOR 2004
#define ID_BREAK 2005
#define ID_CONTINUE 2006
#define ID_SWITCH 2007
#define ID_CASE 2008
#define ID_DEFAULT 2009
#define ID_TRY 2010
#define ID_THROW 2011
#define ID_CATCH 2012
#define ID_FINALLY 2013
#define ID_TXT_AND 2014
#define ID_TXT_OR 2015
#define ID_TXT_NOT 2016
#define ID_RETURN 2017
#define ID_CLASS 2018
#define ID_EXTENDS 2019
#define ID_SYNCHO 2020
#define ID_NEW 2021
#define ID_PUBLIC 2022
#define ID_EXTERN 2023
#define ID_FINAL 2024
#define ID_STATIC 2025
#define ID_PROTECTED 2026
#define ID_PRIVATE 2027
#define ID_REPEAT 2028
#define ID_DEBUGDD 2099
#define ID_INT 2100
#define ID_FLOAT 2101
#define ID_BOOLEAN 2102
#define ID_STRING 2103
#define ID_VOID 2104
#define ID_BOOL 2105
#define ID_TRUE 2200
#define ID_FALSE 2201
#define ID_NULL 2202
#define ID_NAN 2203
#define ID_OPENPAR 2300
#define ID_CLOSEPAR 2301
#define ID_OPBLK 2302
#define ID_CLBLK 2303
#define ID_SEP 2304
#define ID_COMMA 2305
#define ID_DOTS 2306
#define ID_DOT 2307
#define ID_OPBRK 2308
#define ID_CLBRK 2309
#define ID_DBLDOTS 2310
#define ID_LOGIC 2311
#define ID_ADD 2312
#define ID_SUB 2313
#define ID_MUL 2314
#define ID_DIV 2315
#define ID_ASS 2316
#define ID_ASSADD 2317
#define ID_ASSSUB 2318
#define ID_ASSMUL 2319
#define ID_ASSDIV 2320
#define ID_ASSOR 2321
#define ID_ASSAND 2322
#define ID_ASSXOR 2323
#define ID_ASSSL 2324
#define ID_ASSSR 2325
#define ID_ASSASR 2326
#define ID_SL 2327
#define ID_SR 2328
#define ID_ASR 2329
#define ID_INC 2330
#define ID_DEC 2331
#define ID_LO 2332
#define ID_HI 2333
#define ID_LS 2334
#define ID_HS 2335
#define ID_EQ 2336
#define ID_NE 2337
#define ID_AND 2338
#define ID_XOR 2339
#define ID_OR 2340
#define ID_LOG_AND 2341
#define ID_LOG_OR 2342
#define ID_LOG_NOT 2343
#define ID_NOT 2344
#define ID_MODULO 2345
#define ID_POWER 2346
#define ID_ASSMODULO 2347
#define TX_UNDEF 4000
#define TX_NAN 4001
#ifndef _RESOURCE_H_
#define _RESOURCE_H_
enum EID
{
ID_IF = 2000,
ID_ELSE,
ID_WHILE,
ID_DO,
ID_FOR,
ID_BREAK,
ID_CONTINUE,
ID_SWITCH,
ID_CASE,
ID_DEFAULT,
ID_TRY,
ID_THROW,
ID_CATCH,
ID_FINALLY,
ID_TXT_AND,
ID_TXT_OR,
ID_TXT_NOT,
ID_RETURN,
ID_CLASS,
ID_EXTENDS,
ID_SYNCHO,
ID_NEW,
ID_PUBLIC,
ID_EXTERN,
ID_FINAL,
ID_STATIC,
ID_PROTECTED,
ID_PRIVATE,
ID_REPEAT,
ID_DEBUGDD,
ID_INT,
ID_FLOAT,
ID_BOOLEAN,
ID_STRING,
ID_VOID,
ID_BOOL,
ID_TRUE = 2200,
ID_FALSE,
ID_NULL,
ID_NAN,
ID_OPENPAR = 2300,
ID_CLOSEPAR,
ID_OPBLK,
ID_CLBLK,
ID_SEP,
ID_COMMA,
ID_DOTS,
ID_DOT,
ID_OPBRK,
ID_CLBRK,
ID_DBLDOTS,
ID_LOGIC,
ID_ADD,
ID_SUB,
ID_MUL,
ID_DIV,
ID_ASS,
ID_ASSADD,
ID_ASSSUB,
ID_ASSMUL,
ID_ASSDIV,
ID_ASSOR,
ID_ASSAND,
ID_ASSXOR,
ID_ASSSL,
ID_ASSSR,
ID_ASSASR,
ID_SL,
ID_SR,
ID_ASR,
ID_INC,
ID_DEC,
ID_LO,
ID_HI,
ID_LS,
ID_HS,
ID_EQ,
ID_NE,
ID_AND,
ID_XOR,
ID_OR,
ID_LOG_AND,
ID_LOG_OR,
ID_LOG_NOT,
ID_NOT,
ID_MODULO,
ID_POWER,
ID_ASSMODULO,
TX_UNDEF = 4000,
TX_NAN,
ID_SUPER = 6000
};
#define TX_OPENPAR 5000
#define TX_CLOSEPAR 5001
#define TX_NOTBOOL 5002
@ -166,15 +171,6 @@
#define TX_NOTOPEN 6013
#define TX_ERRREAD 6014
#define TX_ERRWRITE 6015
#define ID_SUPER 62020
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 101
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1000
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif
#endif //_RESOURCE_H_

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
@ -29,6 +29,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
@ -155,8 +156,8 @@ ${SDL_LIBRARY}
${SDLIMAGE_LIBRARY}
${OPENGL_LIBRARY}
${PNG_LIBRARIES}
#CBot -- not yet WinAPI-independent
${PLATFORM_LIBS}
CBot
)
include_directories(. ${CMAKE_CURRENT_BINARY_DIR}

3
src/sound/sound.h
View File

@ -28,6 +28,9 @@
#include <plugins/plugin.h>
#include <string>
/*!
* Maximum possible audio volume
*/