diff options
Diffstat (limited to 'src/CBot')
62 files changed, 2499 insertions, 2241 deletions
diff --git a/src/CBot/CBot.cpp b/src/CBot/CBot.cpp index 34840ba..180113d 100644 --- a/src/CBot/CBot.cpp +++ b/src/CBot/CBot.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,12 +12,15 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////
+// compilation des diverses instructions
+// toutes les routines Compile sont statiques
+// et retournent un object selon ce qui a été trouvé comme instruction
// principe de compilation:
-// les routines Compile retournent un objet de la classe correspondant � l'op�ration trouv�e
+// les routines Compile retournent un objet de la classe correspondant à l'opération trouvée
// il s'agit toujours d'une classe fille de CBotInstr.
-// ( les objets CBotInstr ne sont jamais utilis�s directement )
+// ( les objets CBotInstr ne sont jamais utilisés directement )
// si la routine Compile retourne NULL, c'est que l'instruction est fausse
// ou incomprise.
@@ -27,7 +30,7 @@ #include "CBot.h"
// les divers constructeurs / destructeurs
-// pour lib�rer tout selon l'arbre �tabli
+// pour libérer tout selon l'arbre établi
CBotInstr::CBotInstr()
{
name = "CBotInstr";
@@ -45,8 +48,8 @@ CBotInstr::~CBotInstr() delete m_next3b;
}
-// compteur de boucles imbriqu�es,
-// pour d�termniner les break et continue valides
+// compteur de boucles imbriquées,
+// pour détermniner les break et continue valides
// et liste des labels utilisables
int CBotInstr::m_LoopLvl = 0;
@@ -69,14 +72,14 @@ void CBotInstr::IncLvl() m_LoopLvl++;
}
-// lib�re un niveau
+// libère un niveau
void CBotInstr::DecLvl()
{
m_LoopLvl--;
m_labelLvl[m_LoopLvl].Empty();
}
-// controle la validit� d'un break ou continu
+// controle la validité d'un break ou continu
BOOL CBotInstr::ChkLvl(CBotString& label, int type)
{
int i = m_LoopLvl;
@@ -98,7 +101,7 @@ BOOL CBotInstr::IsOfClass(CBotString n) ////////////////////////////////////////////////////////////////////////////
// gestion de base de la classe CBotInstr
-// d�finie le token correspondant � l'instruction
+// définie le token correspondant à l'instruction
void CBotInstr::SetToken(CBotToken* p)
{
@@ -111,21 +114,21 @@ void CBotInstr::SetToken(CBotString* name, int start, int end) }
-// rend le type du token associ� � l'instruction
+// rend le type du token associé à l'instruction
int CBotInstr::GivTokenType()
{
return m_token.GivType();
}
-// rend le token associ�
+// rend le token associé
CBotToken* CBotInstr::GivToken()
{
return &m_token;
}
-// ajoute une instruction � la suite des autres
+// ajoute une instruction à la suite des autres
void CBotInstr::AddNext(CBotInstr* n)
{
@@ -166,10 +169,10 @@ CBotInstr* CBotInstr::GivNext3b() }
///////////////////////////////////////////////////////////////////////////
-// compile une instruction, qui peut �tre
+// compile une instruction, qui peut être
// while, do, try, throw, if, for, switch, break, continu, return
// int, float, boolean, string,
-// d�claration d'une instance d'une classe
+// déclaration d'une instance d'une classe
// expression quelconque
CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack)
@@ -193,7 +196,7 @@ CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack) }
}
- // appel la routine de compilation correspondant au token trouv�
+ // appel la routine de compilation correspondant au token trouvé
switch (type)
{
case ID_WHILE:
@@ -256,25 +259,25 @@ CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack) pStack->SetStartError(p->GivStart());
- // ne doit pas �tre un mot r�serv� par DefineNum
+ // ne doit pas être un mot réservé par DefineNum
if ( p->GivType() == TokenTypDef )
{
pStack->SetError(TX_RESERVED, p);
return NULL;
}
- // ce peut �tre une d�finition d'instance de class
+ // ce peut être une définition d'instance de class
CBotToken* ppp = p;
if ( IsOfType( ppp, TokenTypVar ) /* && IsOfType( ppp, TokenTypVar )*/ )
{
if ( CBotClass::Find(p) != NULL )
{
- // oui, compile la d�claration de l'instance
+ // oui, compile la déclaration de l'instance
return CBotClassInst::Compile(p, pStack);
}
}
- // ce peut �tre une instruction arithm�tique
+ // ce peut être une instruction arithmétique
CBotInstr* inst = CBotExpression::Compile(p, pStack);
if (IsOfType(p, ID_SEP))
{
@@ -325,9 +328,9 @@ void CBotInstr::RestoreStateVar(CBotStack* &pile, BOOL bMain) __asm int 3; // papa sait pas faire, voir les filles
}
-// cette routine n'est d�finie que pour la classe fille CBotCase
+// cette routine n'est définie que pour la classe fille CBotCase
// cela permet de faire l'appel CompCase sur toutes les instructions
-// pour savoir s'il s'agit d'un case pour la valeur d�sir�e.
+// pour savoir s'il s'agit d'un case pour la valeur désirée.
BOOL CBotInstr::CompCase(CBotStack* &pj, int val)
{
@@ -341,7 +344,7 @@ BOOL CBotInstr::CompCase(CBotStack* &pj, int val) // compile un bloc d'instruction " { i ; i ; } "
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourn� par Compile est g�n�ralement de type CBotListInstr
+// l'objet retourné par Compile est généralement de type CBotListInstr
CBotInstr* CBotBlock::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal)
@@ -357,7 +360,7 @@ CBotInstr* CBotBlock::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal) return inst;
}
- pStack->SetError(TX_CLOSEBLK, p->GivStart()); // manque la parenth�se
+ pStack->SetError(TX_CLOSEBLK, p->GivStart()); // manque la parenthèse
delete inst;
return NULL;
}
@@ -371,9 +374,9 @@ CBotInstr* CBotBlock::CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, BOOL b // est-ce un nouveau bloc ?
if ( p->GivType() == ID_OPBLK ) return CBotBlock::Compile(p, pStack);
- // sinon, cherche une instruction unique � la place
+ // sinon, cherche une instruction unique à la place
- // pour g�rer les cas avec d�finition local � l'instructin (*)
+ // pour gérer les cas avec définition local à l'instructin (*)
CBotCStack* pStk = pStack->TokenStack(p, bLocal);
return pStack->Return( CBotInstr::Compile(p, pStk), // une instruction unique
@@ -382,14 +385,14 @@ CBotInstr* CBotBlock::CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, BOOL b // (*) c'est le cas dans l'instruction suivante
// if ( 1 == 1 ) int x = 0;
-// o� la variable x n'est connue que dans le bloc qui suit le if.
+// où la variable x n'est connue que dans le bloc qui suit le if.
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// compile une liste d'instruction, s�par�s par des points-virgules
+// compile une liste d'instruction, séparés par des points-virgules
CBotListInstr::CBotListInstr()
{
@@ -412,8 +415,8 @@ CBotInstr* CBotListInstr::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal {
if ( p == NULL ) break;
- if (IsOfType(p, ID_SEP)) continue; // instruction vide ignor�e
- if ( p->GivType() == ID_CLBLK ) break; // d�ja plus d'instruction
+ if (IsOfType(p, ID_SEP)) continue; // instruction vide ignorée
+ if ( p->GivType() == ID_CLBLK ) break; // déja plus d'instruction
if (IsOfType(p, 0))
{
@@ -431,12 +434,12 @@ CBotInstr* CBotListInstr::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal }
if ( inst->m_Instr == NULL ) inst->m_Instr = i;
- else inst->m_Instr->AddNext(i); // ajoute � la suite
+ else inst->m_Instr->AddNext(i); // ajoute à la suite
}
return pStack->Return(inst, pStk);
}
-// ex�cute une liste d'instructions
+// exécute une liste d'instructions
BOOL CBotListInstr::Execute(CBotStack* &pj)
{
@@ -445,10 +448,10 @@ BOOL CBotListInstr::Execute(CBotStack* &pj) if ( pile->StackOver() ) return pj->Return( pile );
- CBotInstr* p = m_Instr; // la premi�re expression
+ CBotInstr* p = m_Instr; // la première expression
int state = pile->GivState();
- while (state-->0) p = p->GivNext(); // revient sur l'op�ration interrompue
+ while (state-->0) p = p->GivNext(); // revient sur l'opération interrompue
if ( p != NULL ) while (TRUE)
{
@@ -457,7 +460,7 @@ BOOL CBotListInstr::Execute(CBotStack* &pj) 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 ); // transmet en dessous
@@ -470,13 +473,13 @@ void CBotListInstr::RestoreState(CBotStack* &pj, BOOL bMain) CBotStack* pile = pj->RestoreStack(this);
if ( pile == NULL ) return;
- CBotInstr* p = m_Instr; // la premi�re expression
+ CBotInstr* p = m_Instr; // la première expression
int state = pile->GivState();
while ( p != NULL && state-- > 0)
{
p->RestoreState(pile, FALSE);
- p = p->GivNext(); // revient sur l'op�ration interrompue
+ p = p->GivNext(); // revient sur l'opération interrompue
}
if ( p != NULL ) p->RestoreState(pile, TRUE);
@@ -485,7 +488,7 @@ void CBotListInstr::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// compilation d'un �l�ment se trouvant � gauche d'une assignation
+// compilation d'un élément se trouvant à gauche d'une assignation
CBotLeftExprVar::CBotLeftExprVar()
{
@@ -500,7 +503,7 @@ CBotLeftExprVar::~CBotLeftExprVar() CBotInstr* CBotLeftExprVar::Compile(CBotToken* &p, CBotCStack* pStack)
{
- // v�rifie que le token est un nom de variable
+ // vérifie que le token est un nom de variable
if (p->GivType() != TokenTypVar)
{
pStack->SetError( TX_NOVAR, p->GivStart());
@@ -514,7 +517,7 @@ CBotInstr* CBotLeftExprVar::Compile(CBotToken* &p, CBotCStack* pStack) return inst;
}
-// cr�e une variable et lui assigne le r�sultat de la pile
+// crée une variable et lui assigne le résultat de la pile
BOOL CBotLeftExprVar::Execute(CBotStack* &pj)
{
CBotVar* var1;
@@ -527,7 +530,7 @@ BOOL CBotLeftExprVar::Execute(CBotStack* &pj) var2 = pj->GivVar(); // resultat sur la pile
if ( var2 ) var1->SetVal(var2); // fait l'assignation
- return TRUE; // op�ration faite
+ return TRUE; // opération faite
}
void CBotLeftExprVar::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -545,7 +548,7 @@ void CBotLeftExprVar::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// d�finition d'un tableau de n'importe quel type
+// définition d'un tableau de n'importe quel type
// int a[12];
// point x[];
@@ -567,15 +570,15 @@ CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu {
CBotCStack* pStk = pStack->TokenStack(p);
- CBotInstArray* inst = new CBotInstArray(); // cr�e l'objet
+ CBotInstArray* inst = new CBotInstArray(); // crée l'objet
CBotToken* vartoken = p;
inst->SetToken(vartoken);
- // d�termine l'expression valable pour l'�l�ment gauche
+ // détermine l'expression valable pour l'élément gauche
if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
- if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable ?
+ if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable ?
{
pStk->SetError(TX_REDEFVAR, vartoken);
goto error;
@@ -587,7 +590,7 @@ CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu if ( p->GivType() != ID_CLBRK )
i = CBotExpression::Compile( p, pStk ); // expression pour la valeur
else
- i = new CBotEmpty(); // sp�cial si pas de formule
+ i = new CBotEmpty(); // spécial si pas de formule
inst->AddNext3b(i); // construit une liste
type = CBotTypResult(CBotTypArrayPointer, type);
@@ -599,12 +602,12 @@ CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu }
}
- CBotVar* var = CBotVar::Create(vartoken, type); // cr�e avec une instance
+ CBotVar* var = CBotVar::Create(vartoken, type); // crée avec une instance
inst->m_typevar = type;
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un num�ro unique
+ // lui attribut un numéro unique
pStack->AddVar(var); // la place sur la pile
if ( IsOfType(p, ID_ASS) ) // avec une assignation
@@ -621,7 +624,7 @@ error: }
-// ex�cute la d�finition d'un tableau
+// exécute la définition d'un tableau
BOOL CBotInstArray::Execute(CBotStack* &pj)
{
@@ -633,7 +636,7 @@ BOOL CBotInstArray::Execute(CBotStack* &pj) if ( pile1->GivState() == 0 )
{
// cherche les dimensions max du tableau
- CBotInstr* p = GivNext3b(); // les diff�rentes formules
+ CBotInstr* p = GivNext3b(); // les différentes formules
int nb = 0;
while (p != NULL)
@@ -655,8 +658,8 @@ BOOL CBotInstArray::Execute(CBotStack* &pj) while (p != NULL)
{
- pile = pile->AddStack(); // r�cup�re la m�me petite place
- CBotVar* v = pile->GivVar(); // r�sultat
+ pile = pile->AddStack(); // récupère la même petite place
+ CBotVar* v = pile->GivVar(); // résultat
max[n] = v->GivValInt(); // valeur
if (max[n]>MAXARRAYSIZE)
{
@@ -668,9 +671,9 @@ BOOL CBotInstArray::Execute(CBotStack* &pj) }
while (n<100) max[n++] = 0;
- m_typevar.SetArray( max ); // m�morise les limitations
+ m_typevar.SetArray( max ); // mémorise les limitations
- // cr�e simplement un pointeur null
+ // crée simplement un pointeur null
CBotVar* var = CBotVar::Create(m_var->GivToken(), m_typevar);
var->SetPointer(NULL);
var->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);
@@ -719,7 +722,7 @@ void CBotInstArray::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile1->GivState() == 0 )
{
// cherche les dimensions max du tableau
- CBotInstr* p = GivNext3b(); // les diff�rentes formules
+ CBotInstr* p = GivNext3b(); // les différentes formules
while (p != NULL)
{
@@ -758,7 +761,7 @@ void CBotEmpty :: RestoreState(CBotStack* &pj, BOOL bMain) }
//////////////////////////////////////////////////////////////////////////////////////
-// d�finition d'une liste d'initialisation pour un tableau
+// définition d'une liste d'initialisation pour un tableau
// int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;
@@ -786,14 +789,14 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu inst->SetToken( pp );
// CBotVar* var = CBotVar::Create("", CBotTypNullPointer);
// pStk->SetVar(var);
- return pStack->Return(inst, pStk); // ok avec �l�ment vide
+ return pStack->Return(inst, pStk); // ok avec élément vide
}
- CBotListArray* inst = new CBotListArray(); // cr�e l'objet
+ CBotListArray* inst = new CBotListArray(); // crée l'objet
if ( IsOfType( p, ID_OPENPAR ) )
{
- // prend chaque �l�ment l'un apr�s l'autre
+ // prend chaque élément l'un après l'autre
if ( type.Eq( CBotTypArrayPointer ) )
{
type = type.GivTypElem();
@@ -804,7 +807,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu goto error;
}
- while ( IsOfType( p, ID_COMMA ) ) // d'autres �l�ments ?
+ while ( IsOfType( p, ID_COMMA ) ) // d'autres éléments ?
{
pStk->SetStartError(p->GivStart());
@@ -824,7 +827,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu {
goto error;
}
- CBotVar* pv = pStk->GivVar(); // le r�sultat de l'expression
+ CBotVar* pv = pStk->GivVar(); // le résultat de l'expression
if ( pv == NULL || !TypesCompatibles( type, pv->GivTypResult() )) // type compatible ?
{
@@ -832,7 +835,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu goto error;
}
- while ( IsOfType( p, ID_COMMA ) ) // d'autres �l�ments ?
+ while ( IsOfType( p, ID_COMMA ) ) // d'autres éléments ?
{
pStk->SetStartError(p->GivStart());
@@ -842,7 +845,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu goto error;
}
- CBotVar* pv = pStk->GivVar(); // le r�sultat de l'expression
+ CBotVar* pv = pStk->GivVar(); // le résultat de l'expression
if ( pv == NULL || !TypesCompatibles( type, pv->GivTypResult() )) // type compatible ?
{
@@ -868,7 +871,7 @@ error: }
-// ex�cute la d�finition d'un tableau
+// exécute la définition d'un tableau
BOOL CBotListArray::Execute(CBotStack* &pj, CBotVar* pVar)
{
@@ -886,7 +889,7 @@ BOOL CBotListArray::Execute(CBotStack* &pj, CBotVar* pVar) pVar2 = pVar->GivItem(n, TRUE);
- if ( !p->Execute(pile1, pVar2) ) return FALSE; // �value l'expression
+ if ( !p->Execute(pile1, pVar2) ) return FALSE; // évalue l'expression
pile1->IncState();
}
@@ -914,12 +917,12 @@ void CBotListArray::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// d�finition d'une variable enti�re
+// définition d'une variable entière
// int a, b = 12;
CBotInt::CBotInt()
{
- m_next = NULL; // pour les d�finitions multiples
+ m_next = NULL; // pour les définitions multiples
m_var =
m_expr = NULL;
name = "CBotInt";
@@ -946,13 +949,13 @@ CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypRes if ( inst != NULL || !pStack->IsOk() ) return inst;
}
- // compile une d�claration de tableau
+ // compile une déclaration de tableau
if (first) return NULL ;
CBotInstr* inst = CBotInstArray::Compile( p, pStack, type );
if ( inst == NULL ) return NULL;
- if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
+ if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
{
if ( NULL != ( inst->m_next2b = CBotInstArray::CompileArray(p, pStack, type, FALSE) )) // compile la suivante
{
@@ -962,7 +965,7 @@ CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypRes return NULL;
}
- if (IsOfType(p, ID_SEP)) // instruction termin�e
+ if (IsOfType(p, ID_SEP)) // instruction terminée
{
return inst;
}
@@ -974,7 +977,7 @@ CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypRes CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL noskip)
{
- CBotToken* pp = cont ? NULL : p; // pas de r�p�tition du token "int"
+ CBotToken* pp = cont ? NULL : p; // pas de répétition du token "int"
if (!cont && !IsOfType(p, ID_INT)) return NULL;
@@ -983,18 +986,18 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n CBotCStack* pStk = pStack->TokenStack(pp);
- inst = new CBotInt(); // cr�e l'objet
+ inst = new CBotInt(); // crée l'objet
inst->m_expr = NULL;
CBotToken* vartoken = p;
inst->SetToken( vartoken );
- // d�termine l'expression valable pour l'�l�ment gauche
+ // détermine l'expression valable pour l'élément gauche
if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypInt;
- if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
{
pStk->SetError(TX_REDEFVAR, vartoken);
goto error;
@@ -1005,7 +1008,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une d�claration de tableau
+ // compile une déclaration de tableau
CBotInstr* inst2 = CBotInstArray::Compile( p, pStk, CBotTypInt );
@@ -1015,7 +1018,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n goto error;
}
- if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
+ if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
{
if ( NULL != ( inst2->m_next2b = CBotInt::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1023,7 +1026,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n }
}
inst = (CBotInt*)inst2;
- goto suite; // pas d'assignation, variable d�j� cr��e
+ goto suite; // pas d'assignation, variable déjà créée
}
if (IsOfType(p, ID_ASS)) // avec une assignation ?
@@ -1040,15 +1043,15 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n }
{
- CBotVar* var = CBotVar::Create(vartoken, CBotTypInt);// cr�e la variable (apr�s l'assignation �valu�e)
- var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
+ CBotVar* var = CBotVar::Create(vartoken, CBotTypInt);// crée la variable (après l'assignation évaluée)
+ var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un num�ro unique
+ // lui attribut un numéro unique
pStack->AddVar(var); // la place sur la pile
}
- if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
+ if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
{
if ( NULL != ( inst->m_next2b = CBotInt::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1056,7 +1059,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n }
}
suite:
- if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
+ if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
{
return pStack->Return(inst, pStk);
}
@@ -1069,7 +1072,7 @@ error: return pStack->Return(NULL, pStk);
}
-// ex�cute la d�finition de la variable enti�re
+// exécute la définition de la variable entière
BOOL CBotInt::Execute(CBotStack* &pj)
{
@@ -1079,7 +1082,7 @@ BOOL CBotInt::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
+ m_var->Execute( pile ); // crée et fait l'assigation du résultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1087,7 +1090,7 @@ BOOL CBotInt::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !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
}
@@ -1109,14 +1112,14 @@ void CBotInt::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState(pile, bMain);
- if ( m_next2b ) m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
+ if ( m_next2b ) m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// d�finition d'une variable bool�en
+// définition d'une variable booléen
// int a, b = false;
CBotBoolean::CBotBoolean()
@@ -1154,7 +1157,7 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypBoolean;
- if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
{
pStk->SetError(TX_REDEFVAR, vartoken);
goto error;
@@ -1165,7 +1168,7 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une d�claration de tableau
+ // compile une déclaration de tableau
inst = (CBotBoolean*)CBotInstArray::Compile( p, pStk, CBotTypBoolean );
@@ -1174,7 +1177,7 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO pStk->SetError(TX_CLBRK, p->GivStart());
goto error;
}
- goto suite; // pas d'assignation, variable d�j� cr��e
+ goto suite; // pas d'assignation, variable déjà créée
}
if (IsOfType(p, ID_ASS)) // avec une assignation ?
@@ -1190,14 +1193,14 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO }
}
- var = CBotVar::Create(vartoken, CBotTypBoolean);// cr�e la variable (apr�s l'assignation �valu�e)
- var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
+ var = CBotVar::Create(vartoken, CBotTypBoolean);// crée la variable (après l'assignation évaluée)
+ var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un num�ro unique
+ // lui attribut un numéro unique
pStack->AddVar(var); // la place sur la pile
suite:
- if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
+ if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
{
if ( NULL != ( inst->m_next2b = CBotBoolean::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1205,7 +1208,7 @@ suite: }
}
- if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
+ if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
{
return pStack->Return(inst, pStk);
}
@@ -1218,7 +1221,7 @@ error: return pStack->Return(NULL, pStk);
}
-// ex�cute une d�finition de variable bool�enne
+// exécute une définition de variable booléenne
BOOL CBotBoolean::Execute(CBotStack* &pj)
{
@@ -1228,7 +1231,7 @@ BOOL CBotBoolean::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
+ m_var->Execute( pile ); // crée et fait l'assigation du résultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1236,7 +1239,7 @@ BOOL CBotBoolean::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !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
}
@@ -1259,14 +1262,14 @@ void CBotBoolean::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState( pile, bMain ); //
if ( m_next2b )
- m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// d�finition d'une variable r�elle
+// définition d'une variable réelle
// int a, b = 12.4;
CBotFloat::CBotFloat()
@@ -1304,7 +1307,7 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypFloat;
- if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
{
pStk->SetStartError(vartoken->GivStart());
pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
@@ -1316,7 +1319,7 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une d�claration de tableau
+ // compile une déclaration de tableau
inst = (CBotFloat*)CBotInstArray::Compile( p, pStk, CBotTypFloat );
@@ -1325,7 +1328,7 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL pStk->SetError(TX_CLBRK, p->GivStart());
goto error;
}
- goto suite; // pas d'assignation, variable d�j� cr��e
+ goto suite; // pas d'assignation, variable déjà créée
}
if (IsOfType(p, ID_ASS)) // avec une assignation ?
@@ -1341,14 +1344,14 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL }
}
- var = CBotVar::Create(vartoken, CBotTypFloat); // cr�e la variable (apr�s l'assignation �valu�e)
- var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
+ var = CBotVar::Create(vartoken, CBotTypFloat); // crée la variable (après l'assignation évaluée)
+ var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un num�ro unique
+ // lui attribut un numéro unique
pStack->AddVar(var); // la place sur la pile
suite:
- if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
+ if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
{
if ( NULL != ( inst->m_next2b = CBotFloat::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1356,7 +1359,7 @@ suite: }
}
- if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
+ if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
{
return pStack->Return(inst, pStk);
}
@@ -1369,7 +1372,7 @@ error: return pStack->Return(NULL, pStk);
}
-// ex�cute la d�fintion de la variable r�elle
+// exécute la défintion de la variable réelle
BOOL CBotFloat::Execute(CBotStack* &pj)
{
@@ -1379,7 +1382,7 @@ BOOL CBotFloat::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
+ m_var->Execute( pile ); // crée et fait l'assigation du résultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1387,7 +1390,7 @@ BOOL CBotFloat::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !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
}
@@ -1410,14 +1413,14 @@ void CBotFloat::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState( pile, bMain ); //
if ( m_next2b )
- m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// d�finition d'une variable cha�ne de caract�res
+// définition d'une variable chaîne de caractères
// int a, b = "salut";
CBotIString::CBotIString()
@@ -1454,7 +1457,7 @@ CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypString;
- if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
{
pStk->SetStartError(vartoken->GivStart());
pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
@@ -1474,14 +1477,14 @@ CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO }*/
}
- CBotVar* var = CBotVar::Create(vartoken, CBotTypString); // cr�e la variable (apr�s l'assignation �valu�e)
- var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
+ CBotVar* var = CBotVar::Create(vartoken, CBotTypString); // crée la variable (après l'assignation évaluée)
+ var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un num�ro unique
+ // lui attribut un numéro unique
pStack->AddVar(var); // la place sur la pile
- if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
+ if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
{
if ( NULL != ( inst->m_next2b = CBotIString::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1489,7 +1492,7 @@ CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO }
}
- if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
+ if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
{
return pStack->Return(inst, pStk);
}
@@ -1502,7 +1505,7 @@ error: return pStack->Return(NULL, pStk);
}
-// ex�cute la d�finition de la variable string
+// exécute la définition de la variable string
BOOL CBotIString::Execute(CBotStack* &pj)
{
@@ -1512,7 +1515,7 @@ BOOL CBotIString::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
+ m_var->Execute( pile ); // crée et fait l'assigation du résultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1520,7 +1523,7 @@ BOOL CBotIString::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !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
}
@@ -1544,7 +1547,7 @@ void CBotIString::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState( pile, bMain ); //
if ( m_next2b )
- m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -1600,7 +1603,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) CBotTypResult type1 = pStack->GivTypResult();
- // r�cup�re la variable pour la marquer assign�e
+ // récupère la variable pour la marquer assignée
CBotVar* var = NULL;
inst->m_leftop->ExecuteVar(var, pStack);
if ( var == NULL )
@@ -1628,7 +1631,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) {
/* CBotClass* c1 = type1.GivClass();
CBotClass* c2 = type2.GivClass();
- if ( !c1->IsChildOf(c2) ) type2.SetType(-1); // pas la m�me classe
+ if ( !c1->IsChildOf(c2) ) type2.SetType(-1); // pas la même classe
//- if ( !type1.Eq(CBotTypClass) ) var->SetPointer(pStack->GivVar()->GivPointer());*/
var->SetInit(2);
}
@@ -1662,7 +1665,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) // p = p->GivNext();
int start, end, error = pStack->GivError(start, end);
- p = pp; // revient au d�but
+ p = pp; // revient au début
pStack->SetError(0,0); // oublie l'erreur
// return CBotTwoOpExpr::Compile(p, pStack); // essaie sans assignation
@@ -1672,7 +1675,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) return i;
}
-// ex�cute une expression avec assignation
+// exécute une expression avec assignation
BOOL CBotExpression::Execute(CBotStack* &pj)
{
@@ -1687,8 +1690,8 @@ BOOL CBotExpression::Execute(CBotStack* &pj) BOOL IsInit = TRUE;
CBotVar* result = NULL;
- // doit �tre fait avant pour les indices �ventuels (pile peut �tre chang�e)
- if ( !m_leftop->ExecuteVar(pVar, pile, NULL, FALSE) ) return FALSE; // variable avant �valuation de la valeur droite
+ // doit être fait avant pour les indices éventuels (pile peut être changée)
+ if ( !m_leftop->ExecuteVar(pVar, pile, NULL, FALSE) ) return FALSE; // variable avant évaluation de la valeur droite
// DEBUG( "CBotExpression::Execute", -1, pj);
if ( pile1->GivState()==0)
@@ -1711,7 +1714,7 @@ BOOL CBotExpression::Execute(CBotStack* &pj) // DEBUG( "CBotExpression::Execute", -3, pj);
if ( m_token.GivType() != ID_ASS )
{
- pVar = pile1->GivVar(); // r�cup�re si interrompu
+ pVar = pile1->GivVar(); // récupére si interrompu
IsInit = pVar->GivInit();
if ( IsInit == IS_NAN )
{
@@ -1727,51 +1730,51 @@ BOOL CBotExpression::Execute(CBotStack* &pj) break;
case ID_ASSADD:
result->Add(pile1->GivVar(), pile2->GivVar()); // additionne
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSSUB:
result->Sub(pile1->GivVar(), pile2->GivVar()); // soustrait
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSMUL:
result->Mul(pile1->GivVar(), pile2->GivVar()); // multiplie
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSDIV:
if (IsInit &&
result->Div(pile1->GivVar(), pile2->GivVar())) // divise
pile2->SetError(TX_DIVZERO, &m_token);
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSMODULO:
if (IsInit &&
result->Modulo(pile1->GivVar(), pile2->GivVar())) // reste de la division
pile2->SetError(TX_DIVZERO, &m_token);
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSAND:
result->And(pile1->GivVar(), pile2->GivVar()); // multiplie
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSXOR:
result->XOr(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSOR:
result->Or(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSSL:
result->SL(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSSR:
result->SR(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
case ID_ASSASR:
result->ASR(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le r�sultat
+ pile2->SetVar(result); // re-place le résultat
break;
default:
__asm int 3;
@@ -1784,7 +1787,7 @@ BOOL CBotExpression::Execute(CBotStack* &pj) // DEBUG( "CBotExpression::Execute", -4, pj);
if ( !m_leftop->Execute( pile2, pile1 ) )
- return FALSE; // cr�e et fait l'assigation du r�sultat
+ return FALSE; // crée et fait l'assigation du résultat
return pj->Return( pile2 ); // transmet en dessous
}
@@ -1805,11 +1808,11 @@ void CBotExpression::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile1->GivState()==0)
{
- m_leftop->RestoreStateVar(pile, TRUE); // variable avant �valuation de la valeur droite
+ m_leftop->RestoreStateVar(pile, TRUE); // variable avant évaluation de la valeur droite
return;
}
- m_leftop->RestoreStateVar(pile, FALSE); // variable avant �valuation de la valeur droite
+ m_leftop->RestoreStateVar(pile, FALSE); // variable avant évaluation de la valeur droite
CBotStack* pile2 = pile->RestoreStack(); // attention pile et surtout pas pile1
if ( pile2 == NULL ) return;
@@ -1827,10 +1830,10 @@ void CBotExpression::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
// compile une instruction de type " ( condition ) "
-// la condition doit �tre de type bool�en
+// la condition doit être de type booléen
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourn� par Compile est g�n�ralement de type CBotExpression
+// l'objet retourné par Compile est généralement de type CBotExpression
CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack)
{
@@ -1844,12 +1847,12 @@ CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack) {
return inst;
}
- pStack->SetError(TX_CLOSEPAR, p->GivStart()); // manque la parenth�se
+ pStack->SetError(TX_CLOSEPAR, p->GivStart()); // manque la parenthèse
}
delete inst;
}
- pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenth�se
+ pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenthèse
return NULL;
}
@@ -1857,10 +1860,10 @@ CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack) //////////////////////////////////////////////////////////////////////////////////////
// compile une instruction de type " condition "
-// la condition doit �tre de type bool�en
+// la condition doit être de type booléen
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourn� par Compile est g�n�ralement de type CBotExpression
+// l'objet retourné par Compile est généralement de type CBotExpression
CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack)
{
@@ -1874,7 +1877,7 @@ CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
return inst;
}
- pStack->SetError(TX_NOTBOOL, p->GivStart()); // n'est pas un bool�an
+ pStack->SetError(TX_NOTBOOL, p->GivStart()); // n'est pas un booléan
}
delete inst;
@@ -1886,17 +1889,17 @@ CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack) //////////////////////////////////////////////////////////////////////////////////////
// compile soit :
-// une instruction entre parenth�ses (...)
-// une expression unaire (n�gatif, not)
+// une instruction entre parenthèses (...)
+// une expression unaire (négatif, not)
// nom de variable
-// les variables pr� et post incr�ment�es ou d�cr�ment�es
-// un nombre donn� par DefineNum
+// les variables prè et post incrémentées ou décrémentées
+// un nombre donné par DefineNum
// une constante
-// un appel de proc�dure
+// un appel de procédure
// l'instruction new
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourn� par Compile est de la classe correspondant � l'instruction
+// l'objet retourné par Compile est de la classe correspondant à l'instruction
CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack)
{
@@ -1904,7 +1907,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) pStk->SetStartError(p->GivStart());
- // est-ce une expression entre parenth�se ?
+ // est-ce une expression entre parenthèse ?
if (IsOfType(p, ID_OPENPAR))
{
CBotInstr* inst = CBotExpression::Compile( p, pStk );
@@ -1921,7 +1924,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk);
}
- // est-ce une op�ration unaire ?
+ // est-ce une opération unaire ?
CBotInstr* inst = CBotExprUnaire::Compile(p, pStk);
if (inst != NULL || !pStk->IsOk())
return pStack->Return(inst, pStk);
@@ -1929,12 +1932,12 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) // est-ce un nom de variable ?
if (p->GivType() == TokenTypVar)
{
- // c'est peut-�tre un appel de m�thode sans le "this." devant
+ // c'est peut-être un appel de méthode sans le "this." devant
inst = CBotExprVar::CompileMethode(p, pStk);
if ( inst != NULL ) return pStack->Return(inst, pStk);
- // est-ce un appel de proc�dure ?
+ // est-ce un appel de procédure ?
inst = CBotInstrCall::Compile(p, pStk);
if ( inst != NULL || !pStk->IsOk() )
return pStack->Return(inst, pStk);
@@ -1945,7 +1948,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) inst = CBotExprVar::Compile(p, pStk);
CBotToken* pp = p;
- // post incr�ment� ou d�cr�ment� ?
+ // post incrémenté ou décrémenté ?
if (IsOfType(p, ID_INC, ID_DEC))
{
if ( pStk->GivType() >= CBotTypBoolean )
@@ -1963,13 +1966,13 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) CBotPostIncExpr* i = new CBotPostIncExpr();
i->SetToken(pp);
- i->m_Instr = inst; // instruction associ�e
+ i->m_Instr = inst; // instruction associée
return pStack->Return(i, pStk);
}
return pStack->Return(inst, pStk);
}
- // est-ce une variable pr�incr�ment�e ou pr�d�cr�ment�e ?
+ // est-ce une variable préincrémentée ou prédécrémentée ?
CBotToken* pp = p;
if (IsOfType(p, ID_INC, ID_DEC))
{
@@ -2008,7 +2011,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
- // est un �l�ment "true" ou "false"
+ // est un élément "true" ou "false"
if (p->GivType() == ID_TRUE ||
p->GivType() == ID_FALSE )
{
@@ -2016,7 +2019,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
- // est un objet � cr�er avec new
+ // est un objet à créer avec new
if (p->GivType() == ID_NEW)
{
CBotInstr* inst = CBotNew::Compile( p, pStk );
@@ -2051,9 +2054,9 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) //////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// gestion du post et pr�- incr�ment/d�cr�ment
+// gestion du post et pré- incrément/décrément
-// il n'y a pas de routine Compile, l'objet est cr�� directement
+// il n'y a pas de routine Compile, l'objet est créé directement
// dans CBotParExpr::Compile
CBotPostIncExpr::CBotPostIncExpr()
@@ -2085,10 +2088,10 @@ BOOL CBotPostIncExpr::Execute(CBotStack* &pj) CBotVar* var1 = NULL;
- if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // r�cup�re la variable selon champs et index
+ if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // récupère la variable selon champs et index
pile1->SetState(1);
- pile1->SetCopyVar(var1); // place le r�sultat (avant incr�mentation);
+ pile1->SetCopyVar(var1); // place le résultat (avant incrémentation);
CBotStack* pile3 = pile2->AddStack(this);
if ( pile3->IfStep() ) return FALSE;
@@ -2106,7 +2109,7 @@ BOOL CBotPostIncExpr::Execute(CBotStack* &pj) if (GivTokenType() == ID_INC) var1->Inc();
else var1->Dec();
- return pj->Return(pile1); // op�ration faite, r�sultat sur pile2
+ return pj->Return(pile1); // opération faite, résultat sur pile2
}
void CBotPostIncExpr::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -2133,19 +2136,19 @@ BOOL CBotPreIncExpr::Execute(CBotStack* &pj) if ( pile->GivState() == 0 )
{
CBotStack* pile2 = pile;
- if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // r�cup�re la variable selon champs et index
- // pile2 est modifi� en retour
+ if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // récupère la variable selon champs et index
+ // pile2 est modifié en retour
if ( var1->GivInit() == IS_NAN )
{
pile->SetError( TX_OPNAN, &m_token );
- return pj->Return(pile); // op�ration faite
+ return pj->Return(pile); // opération faite
}
if ( var1->GivInit() != IS_DEF )
{
pile->SetError( TX_NOTINIT, &m_token );
- return pj->Return(pile); // op�ration faite
+ return pj->Return(pile); // opération faite
}
if (GivTokenType() == ID_INC) var1->Inc();
@@ -2155,7 +2158,7 @@ BOOL CBotPreIncExpr::Execute(CBotStack* &pj) }
if ( !m_Instr->Execute(pile) ) return FALSE;
- return pj->Return(pile); // op�ration faite
+ return pj->Return(pile); // opération faite
}
@@ -2213,9 +2216,9 @@ CBotInstr* CBotExprUnaire::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
if ( op == ID_NOT && pStk->GivType() < CBotTypFloat ) // seulement avec des entiers
return pStack->Return(inst, pStk);
- if ( op == ID_LOG_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des bool�ens
+ if ( op == ID_LOG_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des booléens
return pStack->Return(inst, pStk);
- if ( op == ID_TXT_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des bool�ens
+ if ( op == ID_TXT_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des booléens
return pStack->Return(inst, pStk);
pStk->SetError(TX_BADTYPE, &inst->m_token);
@@ -2224,7 +2227,7 @@ CBotInstr* CBotExprUnaire::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk);
}
-// ex�cute l'expresson unaire
+// exécute l'expresson unaire
BOOL CBotExprUnaire::Execute(CBotStack* &pj)
{
@@ -2240,7 +2243,7 @@ BOOL CBotExprUnaire::Execute(CBotStack* &pj) CBotStack* pile2 = pile->AddStack();
if ( pile2->IfStep() ) return FALSE;
- CBotVar* var = pile->GivVar(); // r�cup�re le r�sultat sur la pile
+ CBotVar* var = pile->GivVar(); // récupère le résultat sur la pile
switch (GivTokenType())
{
@@ -2290,14 +2293,14 @@ CBotIndexExpr::~CBotIndexExpr() delete m_expr;
}
-// trouve un champ � partir de l'instance � la compilation
+// trouve un champ à partir de l'instance à la compilation
BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
{
if ( pVar->GivType(1) != CBotTypArrayPointer )
__asm int 3;
- pVar = ((CBotVarArray*)pVar)->GivItem(0, FALSE); // � la compilation rend l'�l�ment [0]
+ pVar = ((CBotVarArray*)pVar)->GivItem(0, FALSE); // à la compilation rend l'élément [0]
if ( pVar == NULL )
{
pile->SetError(TX_OUTARRAY, m_token.GivEnd());
@@ -2307,9 +2310,9 @@ BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile) return TRUE;
}
-// idem � l'ex�cution
-// attention, modifie le pointeur � la pile volontairement
-// place les index calcul�s sur la pile suppl�mentaire
+// idem à l'exécution
+// attention, modifie le pointeur à la pile volontairement
+// place les index calculés sur la pile supplémentaire
BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend)
{
@@ -2329,7 +2332,7 @@ BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev }
// traite les tableaux
- CBotVar* p = pile->GivVar(); // r�sultat sur la pile
+ CBotVar* p = pile->GivVar(); // résultat sur la pile
if ( p == NULL || p->GivType() > CBotTypDouble )
{
@@ -2356,8 +2359,8 @@ BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev !m_next3->ExecuteVar(pVar, pile, prevToken, bStep, bExtend) ) return FALSE;
// DEBUG( "CBotIndexExpr::ExecuteVar", -4 , pj);
- return TRUE; // ne lib�re pas la pile
- // pour �viter de recalculer les index deux fois le cas �ch�ant
+ return TRUE; // ne libère pas la pile
+ // pour éviter de recalculer les index deux fois le cas échéant
}
void CBotIndexExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain)
@@ -2378,7 +2381,7 @@ void CBotIndexExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// gestion des champs dans une instance (op�rateur point)
+// gestion des champs dans une instance (opérateur point)
// toto.x
@@ -2398,7 +2401,7 @@ void CBotFieldExpr::SetUniqNum(int num) }
-// trouve un champ � partir de l'instance � la compilation
+// trouve un champ à partir de l'instance à la compilation
BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
{
@@ -2419,7 +2422,7 @@ BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile) return TRUE;
}
-// idem � l'ex�cution
+// idem à l'exécution
BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend)
{
@@ -2457,20 +2460,20 @@ BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev if ( pVar->IsStatic() )
{
// DEBUG( "IsStatic", 0, pj) ;
- // pour une variable statique, la prend dans la classe elle-m�me
+ // pour une variable statique, la prend dans la classe elle-même
CBotClass* pClass = pItem->GivClass();
pVar = pClass->GivItem(m_token.GivString());
// DEBUG( "done "+pVar->GivName(), 0, pj) ;
}
- // demande la mise � jour de l'�l�ment, s'il y a lieu
+ // demande la mise à jour de l'élément, s'il y a lieu
pVar->Maj(pile->GivPUser(), TRUE);
if ( m_next3 != NULL &&
!m_next3->ExecuteVar(pVar, pile, &m_token, bStep, bExtend) ) return FALSE;
- return TRUE; // ne lib�re pas la pile
- // pour conserver l'�tat SetState() correspondant � l'�tape
+ return TRUE; // ne libère pas la pile
+ // pour conserver l'état SetState() correspondant à l'étape
}
void CBotFieldExpr::RestoreStateVar(CBotStack* &pj, BOOL bMain)
@@ -2485,7 +2488,7 @@ void CBotFieldExpr::RestoreStateVar(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// compile un op�rande gauche pour une assignation
+// compile un opérande gauche pour une assignation
CBotLeftExpr::CBotLeftExpr()
{
@@ -2497,8 +2500,8 @@ CBotLeftExpr::~CBotLeftExpr() {
}
-// compile une expression pour un left-op�rande ( � gauche d'une assignation)
-// cela peut �tre
+// compile une expression pour un left-opérande ( à gauche d'une assignation)
+// cela peut être
// toto
// toto[ 3 ]
// toto.x
@@ -2516,7 +2519,7 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) // est-ce un nom de variable ?
if (p->GivType() == TokenTypVar)
{
- CBotLeftExpr* inst = new CBotLeftExpr(); // cr�e l'objet
+ CBotLeftExpr* inst = new CBotLeftExpr(); // crée l'objet
inst->SetToken(p);
@@ -2533,15 +2536,15 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) pStk->SetError( TX_PRIVATE, p );
goto err;
}
- // il s'agit d'un �lement de la classe courante
- // ajoute l'�quivalent d'un this. devant
+ // il s'agit d'un élement de la classe courante
+ // ajoute l'équivalent d'un this. devant
CBotToken pthis("this");
inst->SetToken(&pthis);
inst->m_nIdent = -2; // ident pour this
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
i->SetToken( p ); // garde le nom du token
- inst->AddNext3(i); // ajoute � la suite
+ inst->AddNext3(i); // ajoute à la suite
var = pStk->FindVar(pthis);
var = var->GivItem(p->GivString());
@@ -2557,7 +2560,7 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotIndexExpr* i = new CBotIndexExpr();
i->m_expr = CBotExpression::Compile(p, pStk); // compile la formule
- inst->AddNext3(i); // ajoute � la chaine
+ inst->AddNext3(i); // ajoute à la chaine
var = ((CBotVarArray*)var)->GivItem(0,TRUE); // donne le composant [0]
@@ -2582,13 +2585,13 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotToken* pp = p;
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
i->SetToken( pp ); // garde le nom du token
- inst->AddNext3(i); // ajoute � la suite
+ inst->AddNext3(i); // ajoute à la suite
- if ( p->GivType() == TokenTypVar ) // doit �tre un nom
+ if ( p->GivType() == TokenTypVar ) // doit être un nom
{
- var = var->GivItem(p->GivString()); // r�cup�re l'item correpondant
+ var = var->GivItem(p->GivString()); // récupère l'item correpondant
if ( var != NULL )
{
if ( var->IsPrivate(PR_READ) &&
@@ -2623,7 +2626,7 @@ err: return (CBotLeftExpr*) pStack->Return(NULL, pStk);
}
-// ex�cute, trouve une variable et lui assigne le r�sultat de la pile
+// exécute, trouve une variable et lui assigne le résultat de la pile
BOOL CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array)
{
@@ -2642,7 +2645,7 @@ BOOL CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array) if ( var1 )
{
- var2 = pj->GivVar(); // resultat sur la pile d'entr�e
+ var2 = pj->GivVar(); // resultat sur la pile d'entrée
if ( var2 )
{
CBotTypResult t1 = var1->GivTypResult();
@@ -2655,16 +2658,16 @@ BOOL CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array) {
CBotToken* pt = &m_token;
pile->SetError(TX_BADTYPE, pt);
- return pj->Return(pile); // op�ration faite
+ return pj->Return(pile); // opération faite
}
}
var1->SetVal(var2); // fait l'assignation
}
- pile->SetCopyVar( var1 ); // remplace sur la pile par une copie de la variable elle-m�me
+ pile->SetCopyVar( var1 ); // remplace sur la pile par une copie de la variable elle-même
// (pour avoir le nom)
}
- return pj->Return(pile); // op�ration faite
+ return pj->Return(pile); // opération faite
}
// retrouve une variable pendant la compilation
@@ -2680,11 +2683,11 @@ BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile) return TRUE;
}
-// retrouve une variable � l'ex�cution
+// retrouve une variable à l'exécution
BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep)
{
- pile = pile->AddStack( this ); // d�place la pile
+ pile = pile->AddStack( this ); // déplace la pile
pVar = pile->FindVar(m_nIdent);
if ( pVar == NULL )
@@ -2706,7 +2709,7 @@ BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevT void CBotLeftExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain)
{
- pile = pile->RestoreStack( this ); // d�place la pile
+ pile = pile->RestoreStack( this ); // déplace la pile
if ( pile == NULL ) return;
if ( m_next3 != NULL )
@@ -2715,8 +2718,8 @@ void CBotLeftExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// transforme une cha�ne en nombre entier
-// peut �tre de la forme 0xabc123
+// transforme une chaîne en nombre entier
+// peut être de la forme 0xabc123
long GivNumInt( const char* p )
{
@@ -2751,7 +2754,7 @@ long GivNumInt( const char* p ) return num;
}
-// transforme une cha�ne en un nombre r�el
+// transforme une chaîne en un nombre réel
extern float GivNumFloat( const char* p )
{
@@ -2816,7 +2819,7 @@ extern float GivNumFloat( const char* p ) //////////////////////////////////////////////////////////////////////////////////////
-// compile un token repr�sentant un nombre
+// compile un token représentant un nombre
CBotExprNum::CBotExprNum()
{
@@ -2865,7 +2868,7 @@ CBotInstr* CBotExprNum::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk);
}
-// ex�cute, retourne le nombre correspondant
+// exécute, retourne le nombre correspondant
BOOL CBotExprNum::Execute(CBotStack* &pj)
{
@@ -2906,7 +2909,7 @@ void CBotExprNum::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
-// compile un token repr�sentant une chaine de caract�res
+// compile un token représentant une chaine de caractères
CBotExprAlpha::CBotExprAlpha()
{
@@ -2932,7 +2935,7 @@ CBotInstr* CBotExprAlpha::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
-// ex�cute, retourne la cha�ne correspondante
+// exécute, retourne la chaîne correspondante
BOOL CBotExprAlpha::Execute(CBotStack* &pj)
{
@@ -2944,7 +2947,7 @@ BOOL CBotExprAlpha::Execute(CBotStack* &pj) CBotVar* var = CBotVar::Create((CBotToken*)NULL, CBotTypString);
CBotString chaine = m_token.GivString();
- chaine = chaine.Mid(1, chaine.GivLength()-2); // enl�ve les guillemets
+ chaine = chaine.Mid(1, chaine.GivLength()-2); // enlève les guillemets
var->SetValString( chaine ); // valeur du nombre
@@ -2962,7 +2965,7 @@ void CBotExprAlpha::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
-// compile un token repr�sentant true ou false
+// compile un token représentant true ou false
CBotExprBool::CBotExprBool()
{
@@ -2982,7 +2985,7 @@ CBotInstr* CBotExprBool::Compile(CBotToken* &p, CBotCStack* pStack) p->GivType() == ID_FALSE )
{
inst = new CBotExprBool();
- inst->SetToken(p); // m�morise l'op�ration false ou true
+ inst->SetToken(p); // mémorise l'opération false ou true
p = p->GivNext();
CBotVar* var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);
@@ -2992,7 +2995,7 @@ CBotInstr* CBotExprBool::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
-// ex�cute, retourne true ou false
+// exécute, retourne true ou false
BOOL CBotExprBool::Execute(CBotStack* &pj)
{
@@ -3017,7 +3020,7 @@ void CBotExprBool::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// gestion de l'op�rande "null"
+// gestion de l'opérande "null"
CBotExprNull::CBotExprNull()
{
@@ -3028,7 +3031,7 @@ CBotExprNull::~CBotExprNull() {
}
-// ex�cute, retourne un pointeur vide
+// exécute, retourne un pointeur vide
BOOL CBotExprNull::Execute(CBotStack* &pj)
{
@@ -3050,7 +3053,7 @@ void CBotExprNull::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// gestion de l'op�rande "nan"
+// gestion de l'opérande "nan"
CBotExprNan::CBotExprNan()
{
@@ -3061,7 +3064,7 @@ CBotExprNan::~CBotExprNan() {
}
-// ex�cute, retourne un pointeur vide
+// exécute, retourne un pointeur vide
BOOL CBotExprNan::Execute(CBotStack* &pj)
{
@@ -3083,8 +3086,8 @@ void CBotExprNan::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
// compile un nom de variable
-// v�rifie qu'elle est connue sur la pile
-// et qu'elle a �t� initialis�e
+// vérifie qu'elle est connue sur la pile
+// et qu'elle a été initialisée
CBotExprVar::CBotExprVar()
{
@@ -3106,7 +3109,7 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) // est-ce un nom de variable ?
if (p->GivType() == TokenTypVar)
{
- CBotInstr* inst = new CBotExprVar(); // cr�e l'objet
+ CBotInstr* inst = new CBotExprVar(); // crée l'objet
inst->SetToken(p);
@@ -3115,7 +3118,7 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) if ( NULL != (var = pStk->FindVar(p)) ) // cherche si variable connue
{
int ident = var->GivUniqNum();
- ((CBotExprVar*)inst)->m_nIdent = ident; // l'identifie par son num�ro
+ ((CBotExprVar*)inst)->m_nIdent = ident; // l'identifie par son numéro
if (ident > 0 && ident < 9000)
{
@@ -3126,15 +3129,15 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) goto err;
}
- // il s'agit d'un �lement de la classe courante
- // ajoute l'�quivalent d'un this. devant
+ // il s'agit d'un élement de la classe courante
+ // ajoute l'équivalent d'un this. devant
inst->SetToken(&CBotToken("this"));
((CBotExprVar*)inst)->m_nIdent = -2; // ident pour this
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
i->SetToken( p ); // garde le nom du token
i->SetUniqNum(ident);
- inst->AddNext3(i); // ajoute � la suite
+ inst->AddNext3(i); // ajoute à la suite
}
p = p->GivNext(); // token suivant
@@ -3147,7 +3150,7 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) {
CBotIndexExpr* i = new CBotIndexExpr();
i->m_expr = CBotExpression::Compile(p, pStk); // compile la formule
- inst->AddNext3(i); // ajoute � la chaine
+ inst->AddNext3(i); // ajoute à la chaine
var = ((CBotVarArray*)var)->GivItem(0,TRUE); // donne le composant [0]
@@ -3171,21 +3174,21 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) {
CBotToken* pp = p;
- if ( p->GivType() == TokenTypVar ) // doit �tre un nom
+ if ( p->GivType() == TokenTypVar ) // doit être un nom
{
- if ( p->GivNext()->GivType() == ID_OPENPAR )// un appel de m�thode ?
+ if ( p->GivNext()->GivType() == ID_OPENPAR )// un appel de méthode ?
{
CBotInstr* i = CBotInstrMethode::Compile(p, pStk, var);
if ( !pStk->IsOk() ) goto err;
- inst->AddNext3(i); // ajoute � la suite
+ inst->AddNext3(i); // ajoute à la suite
return pStack->Return(inst, pStk);
}
else
{
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
i->SetToken( pp ); // garde le nom du token
- inst->AddNext3(i); // ajoute � la suite
- var = var->GivItem(p->GivString()); // r�cup�re l'item correpondant
+ inst->AddNext3(i); // ajoute à la suite
+ var = var->GivItem(p->GivString()); // récupère l'item correpondant
if ( var != NULL )
{
i->SetUniqNum(var->GivUniqNum());
@@ -3241,27 +3244,27 @@ CBotInstr* CBotExprVar::CompileMethode(CBotToken* &p, CBotCStack* pStack) CBotVar* var = pStk->FindVar(pthis);
if ( var == 0 ) return pStack->Return(NULL, pStk);
- CBotInstr* inst = new CBotExprVar(); // cr�e l'objet
+ CBotInstr* inst = new CBotExprVar(); // crée l'objet
- // il s'agit d'un �lement de la classe courante
- // ajoute l'�quivalent d'un this. devant
+ // il s'agit d'un élement de la classe courante
+ // ajoute l'équivalent d'un this. devant
inst->SetToken(&pthis);
((CBotExprVar*)inst)->m_nIdent = -2; // ident pour this
CBotToken* pp = p;
- if ( pp->GivType() == TokenTypVar ) // doit �tre un nom
+ if ( pp->GivType() == TokenTypVar ) // doit être un nom
{
- if ( pp->GivNext()->GivType() == ID_OPENPAR ) // un appel de m�thode ?
+ if ( pp->GivNext()->GivType() == ID_OPENPAR ) // un appel de méthode ?
{
CBotInstr* i = CBotInstrMethode::Compile(pp, pStk, var);
if ( pStk->IsOk() )
{
- inst->AddNext3(i); // ajoute � la suite
- p = pp; // instructions pass�es
+ inst->AddNext3(i); // ajoute à la suite
+ p = pp; // instructions passées
return pStack->Return(inst, pStk);
}
- pStk->SetError(0,0); // l'erreur n'est pas trait�e ici
+ pStk->SetError(0,0); // l'erreur n'est pas traitée ici
}
}
delete inst;
@@ -3270,7 +3273,7 @@ CBotInstr* CBotExprVar::CompileMethode(CBotToken* &p, CBotCStack* pStack) }
-// ex�cute, rend la valeur d'une variable
+// exécute, rend la valeur d'une variable
BOOL CBotExprVar::Execute(CBotStack* &pj)
{
@@ -3284,19 +3287,19 @@ BOOL CBotExprVar::Execute(CBotStack* &pj) if ( pile1->GivState() == 0 )
{
- if ( !ExecuteVar(pVar, pile, NULL, TRUE) ) return FALSE; // r�cup�re la variable selon champs et index
+ if ( !ExecuteVar(pVar, pile, NULL, TRUE) ) return FALSE; // récupère la variable selon champs et index
// DEBUG("CBotExprVar::Execute", 1 , pj);
if ( pVar ) pile1->SetCopyVar(pVar); // la place une copie sur la pile
else
{
-//-- pile1->SetVar(NULL); // la pile contient d�j� le resultat (m�thode)
+//-- pile1->SetVar(NULL); // la pile contient déjà le resultat (méthode)
return pj->Return(pile1);
}
pile1->IncState();
}
- pVar = pile1->GivVar(); // r�cup�re si interrompu
+ pVar = pile1->GivVar(); // récupère si interrompu
if ( pVar == NULL )
{
@@ -3311,7 +3314,7 @@ BOOL CBotExprVar::Execute(CBotStack* &pj) pile1->SetError(TX_NOTINIT, pt);
return pj->Return(pile1);
}
- return pj->Return(pile1); // op�ration faite
+ return pj->Return(pile1); // opération faite
}
void CBotExprVar::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -3325,12 +3328,12 @@ void CBotExprVar::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile1->GivState() == 0 )
{
- RestoreStateVar(pile, bMain); // r�cup�re la variable selon champs et index
+ RestoreStateVar(pile, bMain); // récupère la variable selon champs et index
return;
}
}
-// retrouve une variable � l'ex�cution
+// retrouve une variable à l'exécution
BOOL CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep)
{
@@ -3339,7 +3342,7 @@ BOOL CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToke if ( bStep && m_nIdent>0 && pj->IfStep() ) return FALSE;
- pVar = pj->FindVar(m_nIdent, TRUE); // cherche la variable avec mise � jour si n�cessaire
+ pVar = pj->FindVar(m_nIdent, TRUE); // cherche la variable avec mise à jour si nécessaire
if ( pVar == NULL )
{
#ifdef _DEBUG
@@ -3350,13 +3353,13 @@ BOOL CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToke }
if ( m_next3 != NULL &&
!m_next3->ExecuteVar(pVar, pj, &m_token, bStep, FALSE) )
- return FALSE; // Champs d'une instance, tableau, m�thode ?
+ return FALSE; // Champs d'une instance, tableau, méthode ?
- return pile->ReturnKeep( pj ); // ne rend pas la pile mais r�cup�re le r�sultat si une m�thode a �t� appel�e
+ return pile->ReturnKeep( pj ); // ne rend pas la pile mais récupère le résultat si une méthode a été appelée
}
-// retrouve une variable � l'ex�cution
+// retrouve une variable à l'exécution
void CBotExprVar::RestoreStateVar(CBotStack* &pj, BOOL bMain)
{
@@ -3369,12 +3372,12 @@ void CBotExprVar::RestoreStateVar(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// compile une liste de param�tres
+// compile une liste de paramètres
CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars)
{
BOOL first = TRUE;
- CBotInstr* ret = NULL; // pour la liste � retourner
+ CBotInstr* ret = NULL; // pour la liste à retourner
// pStack->SetStartError(p->GivStart());
CBotCStack* pile = pStack;
@@ -3386,7 +3389,7 @@ CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars) if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE)
{
start = p->GivStart();
- pile = pile->TokenStack(); // garde les r�sultats sur la pile
+ pile = pile->TokenStack(); // garde les résultats sur la pile
if ( first ) pStack->SetStartError(start);
first = FALSE;
@@ -3431,7 +3434,7 @@ CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars) //////////////////////////////////////////////////////////////////////////////////////
-// compile un appel d'une m�thode
+// compile un appel d'une méthode
CBotInstrMethode::CBotInstrMethode()
{
@@ -3462,17 +3465,17 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* {
inst->m_NomMethod = pp->GivString();
- // compile la liste des param�tres
+ // compile la liste des paramètres
CBotVar* ppVars[1000];
inst->m_Parameters = CompileParams(p, pStack, ppVars);
if ( pStack->IsOk() )
{
- CBotClass* pClass = var->GivClass(); // pointeur � la classe
+ CBotClass* pClass = var->GivClass(); // pointeur à la classe
inst->m_ClassName = pClass->GivName(); // le nom de la classe
CBotTypResult r = pClass->CompileMethode(inst->m_NomMethod, var, ppVars,
pStack, inst->m_MethodeIdent);
- delete pStack->TokenStack(); // lib�res les param�tres encore sur la pile
+ delete pStack->TokenStack(); // libères les paramètres encore sur la pile
inst->m_typRes = r;
if (inst->m_typRes.GivType() > 20)
@@ -3481,7 +3484,7 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* delete inst;
return NULL;
}
- // met un r�sultat sur la pile pour avoir quelque chose
+ // met un résultat sur la pile pour avoir quelque chose
if (inst->m_typRes.GivType() > 0)
{
CBotVar* pResult = CBotVar::Create("", inst->m_typRes);
@@ -3503,7 +3506,7 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* return NULL;
}
-// ex�cute l'appel de m�thode
+// exécute l'appel de méthode
BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep, BOOL bExtend)
{
@@ -3520,13 +3523,13 @@ BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* pre if ( pile1->IfStep() ) return FALSE;
- CBotStack* pile2 = pile1->AddStack(); // et pour les param�tres � venir
+ CBotStack* pile2 = pile1->AddStack(); // et pour les paramètres à venir
if ( pile1->GivState() == 0)
{
CBotVar* pThis = CBotVar::Create(pVar);
pThis->Copy(pVar);
- // la valeur de This doit �tre prise avant l'�valuation des param�tres
+ // la valeur de This doit être prise avant l'évaluation des paramètres
// Test.Action( Test = Autre );
// Action doit agir sur la valeur avant Test = Autre !!
pThis->SetName("this");
@@ -3538,18 +3541,18 @@ BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* pre int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
- if (!pile2->SetState(1)) return FALSE; // marque sp�ciale pour reconna�re les param�tres
+ if (!pile2->SetState(1)) return FALSE; // marque spéciale pour reconnaîre les paramètres
}
ppVars[i++] = pile2->GivVar(); // construit la liste des pointeurs
- pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
p = p->GivNext();
if ( p == NULL) break;
}
@@ -3572,7 +3575,7 @@ BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* pre if (pRes != pResult) delete pRes;
pVar = NULL; // ne retourne pas une valeur par cela
- return pj->Return(pile2); // lib�re toute la pile
+ return pj->Return(pile2); // libère toute la pile
}
void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, BOOL bMain)
@@ -3583,7 +3586,7 @@ void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, BOOL bMain) CBotStack* pile1 = pile->RestoreStack(this); // une place pour la copie de This
if ( pile1 == NULL ) return;
- CBotStack* pile2 = pile1->RestoreStack(); // et pour les param�tres � venir
+ CBotStack* pile2 = pile1->RestoreStack(); // et pour les paramètres à venir
if ( pile2 == NULL ) return;
CBotVar* pThis = pile1->FindVar("this");
@@ -3593,9 +3596,9 @@ void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, BOOL bMain) int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
if ( pile2->GivState() == 0 )
@@ -3630,12 +3633,12 @@ BOOL CBotInstrMethode::Execute(CBotStack* &pj) if ( pile1->IfStep() ) return FALSE;
- CBotStack* pile2 = pile1->AddStack(); // et pour les param�tres � venir
+ CBotStack* pile2 = pile1->AddStack(); // et pour les paramètres à venir
if ( pile1->GivState() == 0)
{
CBotVar* pThis = pile1->CopyVar(m_token);
- // la valeur de This doit �tre prise avant l'�valuation des param�tres
+ // la valeur de This doit être prise avant l'évaluation des paramètres
// Test.Action( Test = Autre );
// Action doit agir sur la valeur avant Test = Autre !!
pThis->SetName("this");
@@ -3645,18 +3648,18 @@ BOOL CBotInstrMethode::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
- if (!pile2->SetState(1)) return FALSE; // marque sp�ciale pour reconna�re les param�tres
+ if (!pile2->SetState(1)) return FALSE; // marque spéciale pour reconnaîre les paramètres
}
ppVars[i++] = pile2->GivVar(); // construit la liste des pointeurs
- pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
p = p->GivNext();
if ( p == NULL) break;
}
@@ -3677,13 +3680,13 @@ BOOL CBotInstrMethode::Execute(CBotStack* &pj) pThis, ppVars,
pResult, pile2, GivToken())) return FALSE; // interrompu
- // met la nouvelle valeur de this � la place de l'ancienne variable
+ // met la nouvelle valeur de this à la place de l'ancienne variable
CBotVar* old = pile1->FindVar(m_token);
old->Copy(pThis, FALSE);
if (pRes != pResult) delete pRes;
- return pj->Return(pile2); // lib�re toute la pile
+ return pj->Return(pile2); // libère toute la pile
}
///////////////////////////////////////////////////////////////////////////
@@ -3708,7 +3711,7 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) CBotToken* pp = p;
if ( !IsOfType(p, ID_NEW) ) return NULL;
- // v�rifie que le token est un nom de classe
+ // vérifie que le token est un nom de classe
if (p->GivType() != TokenTypVar) return NULL;
CBotClass* pClass = CBotClass::Find(p);
@@ -3729,15 +3732,15 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_vartoken = p;
p = p->GivNext();
- // cr�e l'objet sur le "tas"
+ // crée l'objet sur le "tas"
// avec un pointeur sur cet objet
CBotVar* pVar = CBotVar::Create("", pClass);
// inst->m_nThisIdent = CBotVar::NextUniqNum();
- // fait l'appel du cr�ateur
+ // fait l'appel du créateur
CBotCStack* pStk = pStack->TokenStack();
{
- // regarde s'il y a des param�tres
+ // regarde s'il y a des paramètres
CBotVar* ppVars[1000];
inst->m_Parameters = CompileParams(p, pStk, ppVars);
if ( !pStk->IsOk() ) goto error;
@@ -3745,10 +3748,10 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) // le constructeur existe-il ?
// CBotString noname;
CBotTypResult r = pClass->CompileMethode(pClass->GivName(), pVar, ppVars, pStk, inst->m_nMethodeIdent);
- delete pStk->TokenStack(); // lib�re le suppl�ment de pile
+ delete pStk->TokenStack(); // libère le supplément de pile
int typ = r.GivType();
- // s'il n'y a pas de constructeur, et pas de param�tres non plus, c'est ok
+ // s'il n'y a pas de constructeur, et pas de paramètres non plus, c'est ok
if ( typ == TX_UNDEFCALL && inst->m_Parameters == NULL ) typ = 0;
pVar->SetInit(TRUE); // marque l'instance comme init
@@ -3758,14 +3761,14 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) goto error;
}
- // si le constructeur n'existe pas, mais qu'il y a des param�tres
+ // si le constructeur n'existe pas, mais qu'il y a des paramètres
if (typ<0 && inst->m_Parameters != NULL)
{
pStk->SetError(TX_NOCONST, &inst->m_vartoken);
goto error;
}
- // rend le pointeur � l'objet sur la pile
+ // rend le pointeur à l'objet sur la pile
pStk->SetVar(pVar);
return pStack->Return(inst, pStk);
}
@@ -3774,7 +3777,7 @@ error: return pStack->Return(NULL, pStk);
}
-// ex�cute une instruction "new"
+// exécute une instruction "new"
BOOL CBotNew::Execute(CBotStack* &pj)
{
@@ -3790,12 +3793,12 @@ BOOL CBotNew::Execute(CBotStack* &pj) CBotToken* pt = &m_vartoken;
CBotClass* pClass = CBotClass::Find(pt);
- // cr�e la variable "this" de type pointeur � l'objet
+ // crée la variable "this" de type pointeur à l'objet
if ( pile->GivState()==0)
{
- // cr�e une instance de la classe demand�e
- // et initialise le pointeur � cet objet
+ // crée une instance de la classe demandée
+ // et initialise le pointeur à cet objet
pThis = CBotVar::Create("this", pClass);
// pThis->SetUniqNum( m_nThisIdent ) ;
@@ -3805,16 +3808,16 @@ BOOL CBotNew::Execute(CBotStack* &pj) pile->IncState();
}
- // retrouve le pointeur this si on a �t� interrompu
+ // retrouve le pointeur this si on a été interrompu
if ( pThis == NULL)
{
pThis = pile1->GivVar(); // retrouve le pointeur
}
- // y a-t-il une assignation ou des param�tres (constructeur)
+ // y a-t-il une assignation ou des paramètres (constructeur)
if ( pile->GivState()==1)
{
- // �value le constructeur de l'instance
+ // évalue le constructeur de l'instance
CBotVar* ppVars[1000];
CBotStack* pile2 = pile;
@@ -3822,13 +3825,13 @@ BOOL CBotNew::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
@@ -3840,15 +3843,15 @@ BOOL CBotNew::Execute(CBotStack* &pj) }
ppVars[i] = NULL;
- // cr�e une variable pour le r�sultat
+ // crée une variable pour le résultat
CBotVar* pResult = NULL; // constructeurs toujours void
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(),
pThis, ppVars,
pResult, pile2, GivToken())) return FALSE; // interrompu
- pThis->ConstructorSet(); // signale que le constructeur a �t� appel�
-// pile->Return(pile2); // lib�re un bout de pile
+ pThis->ConstructorSet(); // signale que le constructeur a été appelé
+// pile->Return(pile2); // libère un bout de pile
// pile->IncState();
}
@@ -3868,7 +3871,7 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) CBotToken* pt = &m_vartoken;
CBotClass* pClass = CBotClass::Find(pt);
- // cr�e la variable "this" de type pointeur � l'objet
+ // crée la variable "this" de type pointeur à l'objet
if ( pile->GivState()==0)
{
@@ -3879,10 +3882,10 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) // pThis->SetUniqNum( m_nThisIdent );
pThis->SetUniqNum( -2 );
- // y a-t-il une assignation ou des param�tres (constructeur)
+ // y a-t-il une assignation ou des paramètres (constructeur)
if ( pile->GivState()==1)
{
- // �value le constructeur de l'instance
+ // évalue le constructeur de l'instance
CBotVar* ppVars[1000];
CBotStack* pile2 = pile;
@@ -3890,13 +3893,13 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->RestoreStack(); // de la place sur la pile pour les r�sultats
+ pile2 = pile2->RestoreStack(); // de la place sur la pile pour les résultats
if ( pile2 == NULL ) return;
if ( pile2->GivState() == 0 )
@@ -3916,7 +3919,7 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) }
/////////////////////////////////////////////////////////////
-// regarde si deux r�sultats sont compatibles pour faire une op�ration
+// regarde si deux résultats sont compatibles pour faire une opération
BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op )
{
@@ -3925,9 +3928,9 @@ BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op ) int max = (t1 > t2) ? t1 : t2;
- if ( max == 99 ) return FALSE; // un r�sultat est void ?
+ if ( max == 99 ) return FALSE; // un résultat est void ?
- // cas particulier pour les concat�nation de cha�nes
+ // cas particulier pour les concaténation de chaînes
if (op == ID_ADD && max >= CBotTypString) return TRUE;
if (op == ID_ASSADD && max >= CBotTypString) return TRUE;
if (op == ID_ASS && t1 == CBotTypString) return TRUE;
@@ -3952,8 +3955,8 @@ BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op ) CBotClass* c2 = type2.GivClass();
return c1->IsChildOf(c2) || c2->IsChildOf(c1);
- // accepte le caste � l'envers,
- // l'op�ration sera refus�e � l'ex�cution si le pointeur n'est pas compatible
+ // accepte le caste à l'envers,
+ // l'opération sera refusée à l'exécution si le pointeur n'est pas compatible
}
return TRUE;
@@ -3964,7 +3967,7 @@ BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op ) return TRUE;
}
-// regarde si deux variables sont compatible pour un passage de param�tre
+// regarde si deux variables sont compatible pour un passage de paramètre
BOOL TypesCompatibles( CBotTypResult& type1, CBotTypResult& type2 )
{
@@ -3976,7 +3979,7 @@ BOOL TypesCompatibles( CBotTypResult& type1, CBotTypResult& type2 ) int max = (t1 > t2) ? t1 : t2;
- if ( max == 99 ) return FALSE; // un r�sultat est void ?
+ if ( max == 99 ) return FALSE; // un résultat est void ?
if ( max >= CBotTypBoolean )
{
@@ -3997,7 +4000,7 @@ BOOL TypesCompatibles( CBotTypResult& type1, CBotTypResult& type2 ) /////////////////////////////////////////////////////////////////////////////////////
// Gestion des fichiers
-// n�cessaire car il n'est pas possible de faire le fopen dans le programme principal
+// nécessaire car il n'est pas possible de faire le fopen dans le programme principal
// et les fwrite ou fread dans une dll en utilisant le FILE* rendu.
FILE* fOpen(const char* name, const char* mode)
diff --git a/src/CBot/CBot.h b/src/CBot/CBot.h index c1a7de9..ae2284a 100644 --- a/src/CBot/CBot.h +++ b/src/CBot/CBot.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,31 +12,32 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////
+// interpréteur pour le language CBot du jeu COLOBOT
-// derni�re r�vision : 03/10/2002 DD
+// dernière révision : 03/10/2002 DD
#define EXTENDS TRUE
#include "resource.h"
-#include "CBotDll.h" // d�finitions publiques
+#include "CBotDll.h" // définitions publiques
#include "CBotToken.h" // gestion des tokens
-#define STACKRUN TRUE // reprise de l'ex�cution direct sur une routine suspendue
-#define STACKMEM TRUE // pr�r�serve la m�moire pour la pile d'ex�cution
-#define MAXSTACK 990 // taille du stack r�serv�
+#define STACKRUN TRUE // reprise de l'exécution direct sur une routine suspendue
+#define STACKMEM TRUE // préréserve la mémoire pour la pile d'exécution
+#define MAXSTACK 990 // taille du stack réservé
-#define EOX (CBotStack*)-1 // marqueur condition sp�ciale
+#define EOX (CBotStack*)-1 // marqueur condition spéciale
/////////////////////////////////////////////////////////////////////
-// r�sum� des classes utilis�es, d�finies ci-apr�s
+// résumé des classes utilisées, définies ci-après
class CBotCompExpr; // une expression telle que
// () <= ()
class CBotAddExpr; // une expression telle que
// () + ()
-class CBotParExpr; // un �l�ment de base ou entre parenth�se
+class CBotParExpr; // un élément de base ou entre parenthèse
// Toto.truc
// 12.5
// "chaine"
@@ -46,17 +47,17 @@ class CBotExprVar; // un nom de variable tel que // chose.truc.machin
class CBotWhile; // while (...) {...};
class CBotIf; // if (...) {...} else {...}
-class CBotDefParam; // liste de param�tres d'une fonction
+class CBotDefParam; // liste de paramètres d'une fonction
class CBotRepeat; // repeat (nb) {...}
////////////////////////////////////////////////////////////////////////
-// Gestion de la pile d'ex�cution
+// Gestion de la pile d'exécution
////////////////////////////////////////////////////////////////////////
// en fait, en externe, la seule chose qu'il est possible de faire
-// c'est de cr�er une instance d'une pile
+// c'est de créer une instance d'une pile
// pour l'utiliser pour la routine CBotProgram::Execute(CBotStack)
class CBotStack
@@ -76,15 +77,15 @@ private: static int m_start;
static int m_end;
static
- CBotVar* m_retvar; // r�sultat d'un return
+ CBotVar* m_retvar; // résultat d'un return
- CBotVar* m_var; // r�sultat des op�rations
- CBotVar* m_listVar; // les variables d�clar�es � ce niveau
+ CBotVar* m_var; // résultat des opérations
+ CBotVar* m_listVar; // les variables déclarées à ce niveau
- BOOL m_bBlock; // fait partie d'un bloc (variables sont locales � ce bloc)
+ BOOL m_bBlock; // fait partie d'un bloc (variables sont locales à ce bloc)
BOOL m_bOver; // limites de la pile ?
-// BOOL m_bDontDelete; // sp�cial, ne pas d�truire les variables au delete
- CBotProgram* m_prog; // les fonctions d�finies par user
+// BOOL m_bDontDelete; // spécial, ne pas détruire les variables au delete
+ CBotProgram* m_prog; // les fonctions définies par user
static
int m_initimer;
@@ -96,7 +97,7 @@ private: void* m_pUser;
CBotInstr* m_instr; // l'instruction correspondante
- BOOL m_bFunc; // une entr�e d'une fonction ?
+ BOOL m_bFunc; // une entrée d'une fonction ?
CBotCall* m_call; // point de reprise dans un call extern
friend class CBotTry;
@@ -111,10 +112,10 @@ public: BOOL StackOver();
int GivError(int& start, int& end);
- int GivError(); // rend le num�ro d'erreur retourn�
+ int GivError(); // rend le numéro d'erreur retourné
- void Reset(void* pUser); // plus d'erreur, timer au d�but
- void SetType(CBotTypResult& type); // d�termine le type
+ void Reset(void* pUser); // plus d'erreur, timer au début
+ void SetType(CBotTypResult& type); // détermine le type
int GivType(int mode = 0); // donne le type de valeur sur le stack
CBotTypResult GivTypResult(int mode = 0); // donne le type complet de valeur sur le stack
@@ -133,25 +134,25 @@ public: CBotVar* CopyVar(CBotToken& Token, BOOL bUpdate = FALSE); // trouve et rend une copie
- CBotStack* AddStack(CBotInstr* instr = NULL, BOOL bBlock = FALSE); // �tend le stack
- CBotStack* AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE); // �tend le stack
+ CBotStack* AddStack(CBotInstr* instr = NULL, BOOL bBlock = FALSE); // étend le stack
+ CBotStack* AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE); // étend le stack
CBotStack* RestoreStack(CBotInstr* instr = NULL);
CBotStack* RestoreStackEOX(CBotCall* instr = NULL);
- CBotStack* AddStack2(BOOL bBlock = FALSE); // �tend le stack
- BOOL Return(CBotStack* pFils); // transmet le r�sultat au dessus
- BOOL ReturnKeep(CBotStack* pFils); // transmet le r�sultat sans r�duire la pile
+ CBotStack* AddStack2(BOOL bBlock = FALSE); // étend le stack
+ BOOL Return(CBotStack* pFils); // transmet le résultat au dessus
+ BOOL ReturnKeep(CBotStack* pFils); // transmet le résultat sans réduire la pile
BOOL BreakReturn(CBotStack* pfils, const char* name = NULL);
- // en cas de break �ventuel
+ // en cas de break éventuel
BOOL IfContinue(int state, const char* name);
// ou de "continue"
BOOL IsOk();
- BOOL SetState(int n, int lim = -10); // s�lectionne un �tat
- int GivState(); // dans quel �tat j'�re ?
- BOOL IncState(int lim = -10); // passe � l'�tat suivant
- BOOL IfStep(); // faire du pas � pas ?
+ BOOL SetState(int n, int lim = -10); // sélectionne un état
+ int GivState(); // dans quel état j'ère ?
+ BOOL IncState(int lim = -10); // passe à l'état suivant
+ BOOL IfStep(); // faire du pas à pas ?
BOOL Execute();
void SetVar( CBotVar* var );
@@ -190,7 +191,7 @@ public: int m_temp;
};
-// les routines inline doivent �tre d�clar�es dans le fichier .h
+// les routines inline doivent être déclarées dans le fichier .h
inline BOOL CBotStack::IsOk()
{
@@ -224,13 +225,13 @@ private: int m_end;
int m_start;
- CBotVar* m_var; // r�sultat des op�rations
+ CBotVar* m_var; // résultat des opérations
- BOOL m_bBlock; // fait partie d'un bloc (variables sont locales � ce bloc)
+ BOOL m_bBlock; // fait partie d'un bloc (variables sont locales à ce bloc)
CBotVar* m_listVar;
static
- CBotProgram* m_prog; // liste des fonctions compil�es
+ CBotProgram* m_prog; // liste des fonctions compilées
static
CBotTypResult m_retTyp;
// static
@@ -243,9 +244,9 @@ public: BOOL IsOk();
int GivError();
int GivError(int& start, int& end);
- // rend le num�ro d'erreur retourn�
+ // rend le numéro d'erreur retourné
- void SetType(CBotTypResult& type);// d�termine le type
+ void SetType(CBotTypResult& type);// détermine le type
CBotTypResult GivTypResult(int mode = 0); // donne le type de valeur sur le stack
int GivType(int mode = 0); // donne le type de valeur sur le stack
CBotClass* GivClass(); // donne la classe de la valeur sur le stack
@@ -257,8 +258,8 @@ public: CBotVar* CopyVar(CBotToken& Token); // trouve et rend une copie
CBotCStack* TokenStack(CBotToken* pToken = NULL, BOOL bBlock = FALSE);
- CBotInstr* Return(CBotInstr* p, CBotCStack* pParent); // transmet le r�sultat au dessus
- CBotFunction* ReturnFunc(CBotFunction* p, CBotCStack* pParent); // transmet le r�sultat au dessus
+ CBotInstr* Return(CBotInstr* p, CBotCStack* pParent); // transmet le résultat au dessus
+ CBotFunction* ReturnFunc(CBotFunction* p, CBotCStack* pParent); // transmet le résultat au dessus
void SetVar( CBotVar* var );
void SetCopyVar( CBotVar* var );
@@ -286,7 +287,7 @@ extern BOOL SaveVar(FILE* pf, CBotVar* pVar); /////////////////////////////////////////////////////////////////////
-// classes d�finissant une instruction
+// classes définissant une instruction
class CBotInstr
{
private:
@@ -296,15 +297,15 @@ private: protected:
CBotToken m_token; // conserve le token
CBotString name; // debug
- CBotInstr* m_next; // instructions cha�n�es
- CBotInstr* m_next2b; // seconde liste pour d�finition en cha�ne
- CBotInstr* m_next3; // troisi�me liste pour les indices et champs
- CBotInstr* m_next3b; // n�cessaire pour la d�claration des tableaux
+ CBotInstr* m_next; // instructions chaînées
+ CBotInstr* m_next2b; // seconde liste pour définition en chaîne
+ CBotInstr* m_next3; // troisième liste pour les indices et champs
+ CBotInstr* m_next3b; // nécessaire pour la déclaration des tableaux
/*
par exemple, le programme suivant
int x[]; x[1] = 4;
int y[x[1]][10], z;
- va g�n�r�
+ va généré
CBotInstrArray
m_next3b-> CBotEmpty
m_next->
@@ -381,7 +382,7 @@ class CBotWhile : public CBotInstr private:
CBotInstr* m_Condition; // la condition
CBotInstr* m_Block; // les instructions
- CBotString m_label; // une �tiquette s'il y a
+ CBotString m_label; // une étiquette s'il y a
public:
CBotWhile();
@@ -395,9 +396,9 @@ public: class CBotRepeat : public CBotInstr
{
private:
- CBotInstr* m_NbIter; // le nombre d'it�ration
+ CBotInstr* m_NbIter; // le nombre d'itération
CBotInstr* m_Block; // les instructions
- CBotString m_label; // une �tiquette s'il y a
+ CBotString m_label; // une étiquette s'il y a
public:
CBotRepeat();
@@ -413,7 +414,7 @@ class CBotDo : public CBotInstr private:
CBotInstr* m_Block; // les instructions
CBotInstr* m_Condition; // la condition
- CBotString m_label; // une �tiquette s'il y a
+ CBotString m_label; // une étiquette s'il y a
public:
CBotDo();
@@ -429,9 +430,9 @@ class CBotFor : public CBotInstr private:
CBotInstr* m_Init; // intruction initiale
CBotInstr* m_Test; // la condition de test
- CBotInstr* m_Incr; // instruction pour l'incr�ment
+ CBotInstr* m_Incr; // instruction pour l'incrément
CBotInstr* m_Block; // les instructions
- CBotString m_label; // une �tiquette s'il y a
+ CBotString m_label; // une étiquette s'il y a
public:
CBotFor();
@@ -445,7 +446,7 @@ public: class CBotBreak : public CBotInstr
{
private:
- CBotString m_label; // une �tiquette s'il y a
+ CBotString m_label; // une étiquette s'il y a
public:
CBotBreak();
@@ -459,7 +460,7 @@ public: class CBotReturn : public CBotInstr
{
private:
- CBotInstr* m_Instr; // le param�tre � retourner
+ CBotInstr* m_Instr; // le paramètre à retourner
public:
CBotReturn();
@@ -474,7 +475,7 @@ public: class CBotSwitch : public CBotInstr
{
private:
- CBotInstr* m_Value; // value � chercher
+ CBotInstr* m_Value; // value à chercher
CBotInstr* m_Block; // les instructions
public:
@@ -490,7 +491,7 @@ public: class CBotCase : public CBotInstr
{
private:
- CBotInstr* m_Value; // valeur � comparer
+ CBotInstr* m_Value; // valeur à comparer
public:
CBotCase();
@@ -540,7 +541,7 @@ public: class CBotThrow : public CBotInstr
{
private:
- CBotInstr* m_Value; // la valeur � envoyer
+ CBotInstr* m_Value; // la valeur à envoyer
public:
CBotThrow();
@@ -582,14 +583,14 @@ public: };
-// d�finition d'un nombre entier
+// définition d'un nombre entier
class CBotInt : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable � initialiser
- CBotInstr* m_expr; // la valeur � mettre, s'il y a
-/// CBotInstr* m_next; // plusieurs d�finitions encha�n�es
+ CBotInstr* m_var; // la variable à initialiser
+ CBotInstr* m_expr; // la valeur à mettre, s'il y a
+/// CBotInstr* m_next; // plusieurs définitions enchaînées
public:
CBotInt();
@@ -600,15 +601,15 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// d�finition d'un tableau
+// définition d'un tableau
class CBotInstArray : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable � initialiser
+ CBotInstr* m_var; // la variable à initialiser
CBotInstr* m_listass; // liste d'assignations pour le tableau
CBotTypResult
- m_typevar; // type d'�l�ments
+ m_typevar; // type d'éléments
// CBotString m_ClassName;
public:
@@ -621,14 +622,14 @@ public: };
-// d�finition d'une liste d'assignation pour un tableau
+// définition d'une liste d'assignation pour un tableau
// int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;
class CBotListArray : public CBotInstr
{
private:
- CBotInstr* m_expr; // expression pour un �l�ment
- // les autres sont cha�n�s avec CBotInstr::m_next3;
+ CBotInstr* m_expr; // expression pour un élément
+ // les autres sont chaînés avec CBotInstr::m_next3;
public:
CBotListArray();
~CBotListArray();
@@ -645,13 +646,13 @@ class CBotEmpty : public CBotInstr void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// d�finition d'un bool�en
+// définition d'un booléen
class CBotBoolean : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable � initialiser
- CBotInstr* m_expr; // la valeur � mettre, s'il y a
+ CBotInstr* m_var; // la variable à initialiser
+ CBotInstr* m_expr; // la valeur à mettre, s'il y a
public:
CBotBoolean();
@@ -663,13 +664,13 @@ public: };
-// d�finition d'un nombre r�el
+// définition d'un nombre réel
class CBotFloat : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable � initialiser
- CBotInstr* m_expr; // la valeur � mettre, s'il y a
+ CBotInstr* m_var; // la variable à initialiser
+ CBotInstr* m_expr; // la valeur à mettre, s'il y a
public:
CBotFloat();
@@ -680,13 +681,13 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// d�finition d'un el�ment string
+// définition d'un elément string
class CBotIString : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable � initialiser
- CBotInstr* m_expr; // la valeur � mettre, s'il y a
+ CBotInstr* m_var; // la variable à initialiser
+ CBotInstr* m_expr; // la valeur à mettre, s'il y a
public:
CBotIString();
@@ -697,16 +698,16 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// d�finition d'un el�ment dans une classe quelconque
+// définition d'un elément dans une classe quelconque
class CBotClassInst : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable � initialiser
- CBotClass* m_pClass; // r�f�rence � la classe
- CBotInstr* m_Parameters; // les param�tres � �valuer pour le constructeur
- CBotInstr* m_expr; // la valeur � mettre, s'il y a
- BOOL m_hasParams; // il y a des param�tres ?
+ CBotInstr* m_var; // la variable à initialiser
+ CBotClass* m_pClass; // référence à la classe
+ CBotInstr* m_Parameters; // les paramètres à évaluer pour le constructeur
+ CBotInstr* m_expr; // la valeur à mettre, s'il y a
+ BOOL m_hasParams; // il y a des paramètres ?
long m_nMethodeIdent;
public:
@@ -729,8 +730,8 @@ public: };
-// left op�rande
-// n'accepte que les expressions pouvant �tre � gauche d'une assignation
+// left opérande
+// n'accepte que les expressions pouvant être à gauche d'une assignation
class CBotLeftExpr : public CBotInstr
{
@@ -795,8 +796,8 @@ public: class CBotExpression : public CBotInstr
{
private:
- CBotLeftExpr* m_leftop; // �l�ment de gauche
- CBotInstr* m_rightop; // �l�ment de droite
+ CBotLeftExpr* m_leftop; // élément de gauche
+ CBotInstr* m_rightop; // élément de droite
public:
CBotExpression();
@@ -810,7 +811,7 @@ public: class CBotListExpression : public CBotInstr
{
private:
- CBotInstr* m_Expr; // la 1�re expression � �valuer
+ CBotInstr* m_Expr; // la 1ère expression à évaluer
public:
CBotListExpression();
@@ -824,9 +825,9 @@ public: class CBotLogicExpr : public CBotInstr
{
private:
- CBotInstr* m_condition; // test � �valuer
- CBotInstr* m_op1; // �l�ment de gauche
- CBotInstr* m_op2; // �l�ment de droite
+ CBotInstr* m_condition; // test à évaluer
+ CBotInstr* m_op1; // élément de gauche
+ CBotInstr* m_op2; // élément de droite
friend class CBotTwoOpExpr;
public:
@@ -851,9 +852,9 @@ public: -// une expression �ventuellement entre parenth�ses ( ... )
+// une expression éventuellement entre parenthèses ( ... )
// il n'y a jamais d'instance de cette classe
-// l'objet retourn� �tant le contenu de la parenth�se
+// l'objet retourné étant le contenu de la parenthése
class CBotParExpr : public CBotInstr
{
private:
@@ -867,7 +868,7 @@ public: class CBotExprUnaire : public CBotInstr
{
private:
- CBotInstr* m_Expr; // l'expression � �valuer
+ CBotInstr* m_Expr; // l'expression à évaluer
public:
CBotExprUnaire();
~CBotExprUnaire();
@@ -877,13 +878,13 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// toutes les op�rations � 2 op�randes
+// toutes les opérations à 2 opérandes
class CBotTwoOpExpr : public CBotInstr
{
private:
- CBotInstr* m_leftop; // �l�ment de gauche
- CBotInstr* m_rightop; // �l�ment de droite
+ CBotInstr* m_leftop; // élément de gauche
+ CBotInstr* m_rightop; // élément de droite
public:
CBotTwoOpExpr();
~CBotTwoOpExpr();
@@ -913,7 +914,7 @@ public: class CBotListInstr : public CBotInstr
{
private:
- CBotInstr* m_Instr; // les instructions � faire
+ CBotInstr* m_Instr; // les instructions à faire
public:
CBotListInstr();
@@ -928,11 +929,11 @@ public: class CBotInstrCall : public CBotInstr
{
private:
- CBotInstr* m_Parameters; // les param�tres � �valuer
-// int m_typeRes; // type du r�sultat
-// CBotString m_RetClassName; // class du r�sultat
+ CBotInstr* m_Parameters; // les paramètres à évaluer
+// int m_typeRes; // type du résultat
+// CBotString m_RetClassName; // class du résultat
CBotTypResult
- m_typRes; // type complet du r�sultat
+ m_typRes; // type complet du résultat
long m_nFuncIdent; // id de la fonction
public:
@@ -944,19 +945,19 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// un appel d'une m�thode
+// un appel d'une méthode
class CBotInstrMethode : public CBotInstr
{
private:
- CBotInstr* m_Parameters; // les param�tres � �valuer
-// int m_typeRes; // type du r�sultat
-// CBotString m_RetClassName; // class du r�sultat
+ CBotInstr* m_Parameters; // les paramètres à évaluer
+// int m_typeRes; // type du résultat
+// CBotString m_RetClassName; // class du résultat
CBotTypResult
- m_typRes; // type complet du r�sultat
+ m_typRes; // type complet du résultat
- CBotString m_NomMethod; // nom de la m�thode
- long m_MethodeIdent; // identificateur de la m�thode
+ CBotString m_NomMethod; // nom de la méthode
+ long m_MethodeIdent; // identificateur de la méthode
// long m_nThisIdent; // identificateur pour "this"
CBotString m_ClassName; // nom de la classe
@@ -1030,7 +1031,7 @@ class CBotLeftExprVar : public CBotInstr private:
public:
CBotTypResult
- m_typevar; // type de variable d�clar�e
+ m_typevar; // type de variable déclarée
long m_nIdent; // identificateur unique pour cette variable
public:
@@ -1085,7 +1086,7 @@ public: class CBotNew : public CBotInstr
{
private:
- CBotInstr* m_Parameters; // les param�tres � �valuer
+ CBotInstr* m_Parameters; // les paramètres à évaluer
long m_nMethodeIdent;
// long m_nThisIdent;
CBotToken m_vartoken;
@@ -1100,7 +1101,7 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// expression repr�sentant un nombre
+// expression représentant un nombre
class CBotExprNum : public CBotInstr
{
@@ -1120,7 +1121,7 @@ public: -// expression repr�sentant une chaine de caract�res
+// expression représentant une chaine de caractères
class CBotExprAlpha : public CBotInstr
{
@@ -1144,7 +1145,7 @@ class CBotVarInt : public CBotVar {
private:
int m_val; // la valeur
- CBotString m_defnum; // le nom si donn� par DefineNum
+ CBotString m_defnum; // le nom si donné par DefineNum
friend class CBotVar;
public:
@@ -1192,7 +1193,7 @@ public: };
-// classe pour la gestion des nombres r�els (float)
+// classe pour la gestion des nombres réels (float)
class CBotVarFloat : CBotVar
{
private:
@@ -1233,7 +1234,7 @@ public: };
-// classe pour la gestion des cha�nes (String)
+// classe pour la gestion des chaînes (String)
class CBotVarString : CBotVar
{
private:
@@ -1294,19 +1295,19 @@ class CBotVarClass : public CBotVar {
private:
static
- CBotVarClass* m_ExClass; // liste des instances existantes � un moment donn�
- CBotVarClass* m_ExNext; // pour cette liste g�n�rale
- CBotVarClass* m_ExPrev; // pour cette liste g�n�rale
+ CBotVarClass* m_ExClass; // liste des instances existantes à un moment donné
+ CBotVarClass* m_ExNext; // pour cette liste générale
+ CBotVarClass* m_ExPrev; // pour cette liste générale
private:
- CBotClass* m_pClass; // la d�finition de la classe
+ CBotClass* m_pClass; // la définition de la classe
CBotVarClass* m_pParent; // l'instance dans la classe parent
CBotVar* m_pVar; // contenu
friend class CBotVar; // mon papa est un copain
friend class CBotVarPointer; // et le pointeur aussi
int m_CptUse; // compteur d'utilisation
long m_ItemIdent; // identificateur (unique) de l'instance
- BOOL m_bConstructor; // set si un constructeur a �t� appel�
+ BOOL m_bConstructor; // set si un constructeur a été appelé
public:
CBotVarClass( const CBotToken* name, CBotTypResult& type );
@@ -1317,7 +1318,7 @@ public: void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void SetClass(CBotClass* pClass); //, int &nIdent);
CBotClass* GivClass();
- CBotVar* GivItem(const char* name); // rend un �l�ment d'une classe selon son nom (*)
+ CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
CBotVar* GivItemRef(int nIdent);
CBotVar* GivItem(int n, BOOL bExtend);
@@ -1328,8 +1329,8 @@ public: BOOL Save1State(FILE* pf);
void Maj(void* pUser, BOOL bContinue);
- void IncrementUse(); // une r�f�rence en plus
- void DecrementUse(); // une r�f�rence en moins
+ void IncrementUse(); // une référence en plus
+ void DecrementUse(); // une référence en moins
CBotVarClass*
GivPointer();
@@ -1351,13 +1352,13 @@ public: };
-// classe pour la gestion des pointeurs � une instances de classe
+// classe pour la gestion des pointeurs à une instances de classe
class CBotVarPointer : public CBotVar
{
private:
CBotVarClass*
m_pVarClass; // contenu
- CBotClass* m_pClass; // la classe pr�vue pour ce pointeur
+ CBotClass* m_pClass; // la classe prévue pour ce pointeur
friend class CBotVar; // mon papa est un copain
public:
@@ -1367,7 +1368,7 @@ public: void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void SetClass(CBotClass* pClass);
CBotClass* GivClass();
- CBotVar* GivItem(const char* name); // rend un �l�ment d'une classe selon son nom (*)
+ CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
CBotVar* GivItemRef(int nIdent);
CBotVar* GivItemList();
@@ -1376,8 +1377,8 @@ public: CBotVarClass*
GivPointer();
- void SetIdent(long n); // associe un num�ro d'identification (unique)
- long GivIdent(); // donne le num�ro d'identification associ�
+ void SetIdent(long n); // associe un numéro d'identification (unique)
+ long GivIdent(); // donne le numéro d'identification associé
void ConstructorSet();
BOOL Save1State(FILE* pf);
@@ -1396,7 +1397,7 @@ class CBotVarArray : public CBotVar {
private:
CBotVarClass*
- m_pInstance; // instance g�rant le tableau
+ m_pInstance; // instance gérant le tableau
friend class CBotVar; // papa est un copain
@@ -1409,12 +1410,12 @@ public: GivPointer();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
- CBotVar* GivItem(int n, BOOL bGrow=FALSE); // rend un �l�ment selon son index num�rique
- // agrandi le tableau si n�cessaire si bExtend
-// CBotVar* GivItem(const char* name); // rend un �l�ment selon son index lit�ral
- CBotVar* GivItemList(); // donne le premier �l�ment de la liste
+ CBotVar* GivItem(int n, BOOL bGrow=FALSE); // rend un élément selon son index numérique
+ // agrandi le tableau si nécessaire si bExtend
+// CBotVar* GivItem(const char* name); // rend un élément selon son index litéral
+ CBotVar* GivItemList(); // donne le premier élément de la liste
- CBotString GivValString(); // donne le contenu du tableau dans une cha�ne
+ CBotString GivValString(); // donne le contenu du tableau dans une chaîne
BOOL Save1State(FILE* pf);
};
@@ -1495,7 +1496,7 @@ public: static void Free();
};
-// classe g�rant les m�thodes d�clar�es par AddFunction sur une classe
+// classe gérant les méthodes déclarées par AddFunction sur une classe
class CBotCallMethode
{
@@ -1527,15 +1528,15 @@ public: };
-// une liste de param�tres
+// une liste de paramètres
class CBotDefParam
{
private:
- CBotToken m_token; // nom du param�tre
+ CBotToken m_token; // nom du paramètre
CBotString m_typename; // nom du type
- CBotTypResult m_type; // type de param�tre
- CBotDefParam* m_next; // param�tre suivant
+ CBotTypResult m_type; // type de paramètre
+ CBotDefParam* m_next; // paramètre suivant
long m_nIdent;
public:
@@ -1555,7 +1556,7 @@ public: };
-// une d�claration de fonction
+// une déclaration de fonction
class CBotFunction : CBotInstr
{
@@ -1568,18 +1569,18 @@ private: friend class CBotCStack;
// long m_nThisIdent;
long m_nFuncIdent;
- BOOL m_bSynchro; // m�thode synchronis�e ?
+ BOOL m_bSynchro; // méthode synchronisée ?
private:
- CBotDefParam* m_Param; // liste des param�tres
+ CBotDefParam* m_Param; // liste des paramètres
CBotInstr* m_Block; // le bloc d'instructions
CBotFunction* m_next;
CBotToken m_retToken; // si retourne un CBotTypClass
- CBotTypResult m_retTyp; // type complet du r�sultat
+ CBotTypResult m_retTyp; // type complet du résultat
BOOL m_bPublic; // fonction publique
BOOL m_bExtern; // fonction extern
- CBotString m_MasterClass; // nom de la classe qu'on d�rive
+ CBotString m_MasterClass; // nom de la classe qu'on dérive
CBotProgram* m_pProg;
friend class CBotProgram;
friend class CBotClass;
diff --git a/src/CBot/CBotAddExpr.cpp b/src/CBot/CBotAddExpr.cpp index c6ed82d..ad87880 100644 --- a/src/CBot/CBotAddExpr.cpp +++ b/src/CBot/CBotAddExpr.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////
+// expression du genre Opérande1 + Opérande2
+// Opérande1 - Opérande2
#include "CBot.h"
@@ -38,9 +40,9 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack) {
CBotStack* pStk = pStack->TokenStack(); // un bout de pile svp
- // cherche des instructions qui peuvent convenir � gauche de l'op�ration + ou -
+ // cherche des instructions qui peuvent convenir à gauche de l'opération + ou -
- CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B � gauche
+ CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B à gauche
if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
// est-ce qu'on a le token + ou - ensuite ?
@@ -48,80 +50,80 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack) if ( p->GetType() == ID_ADD ||
p->GetType() == ID_SUB) // plus ou moins
{
- CBotAddExpr* inst = new CBotAddExpr(); // �l�ment pour op�ration
- inst->SetToken(p); // m�morise l'op�ration
+ CBotAddExpr* inst = new CBotAddExpr(); // élément pour opération
+ inst->SetToken(p); // mémorise l'opération
int type1, type2;
- type1 = pStack->GetType(); // de quel type le premier op�rande ?
+ type1 = pStack->GetType(); // de quel type le premier opérande ?
- p = p->Next(); // saute le token de l'op�ration
+ p = p->Next(); // saute le token de l'opération
- // cherche des instructions qui peuvent convenir � droite
+ // cherche des instructions qui peuvent convenir à droite
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) � droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) à droite
{
- // il y a un second op�rande acceptable
+ // il y a un second opérande acceptable
- type2 = pStack->GetType(); // de quel type le r�sultat ?
+ type2 = pStack->GetType(); // de quel type le résultat ?
- if ( type1 == type2 ) // les r�sultats sont-ils compatibles
+ if ( type1 == type2 ) // les résultats sont-ils compatibles
{
- // si ok, enregistre l'op�rande dans l'objet
+ // si ok, enregistre l'opérande dans l'objet
inst->m_leftop = left;
- // et rend l'object � qui l'a demand�
+ // et rend l'object à qui l'a demandé
return pStack->Return(inst, pStk);
}
}
- // en cas d'erreur, lib�re les �l�ments
+ // en cas d'erreur, libère les éléments
delete left;
delete inst;
// et transmet l'erreur qui se trouve sur la pile
return pStack->Return(NULL, pStk);
}
- // si on n'a pas affaire � une op�ration + ou -
- // rend � qui l'a demand�, l'op�rande (de gauche) trouv�
- // � la place de l'objet "addition"
+ // si on n'a pas affaire à une opération + ou -
+ // rend à qui l'a demandé, l'opérande (de gauche) trouvé
+ // à la place de l'objet "addition"
return pStack->Return(left, pStk);
}
-// fait l'op�ration d'addition ou de soustraction
+// fait l'opération d'addition ou de soustraction
BOOL CBotAddExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pSk1 == EOX ) return TRUE;
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
- if ( pStk1->GetState() == 0 && // 1er �tat, �value l'op�rande de gauche
+ if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- // passe � l'�tape suivante
- pStk1->SetState(1); // pr�t pour la suite
+ // passe à l'étape suivante
+ pStk1->SetState(1); // prêt pour la suite
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
+ // demande un peu plus de stack pour ne pas toucher le résultat de gauche
// qui se trouve sur la pile, justement.
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
- // 2e �tat, �value l'op�rande de droite
+ // 2e état, évalue l'opérande de droite
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
- int type1 = pStk1->GetType(); // de quels types les r�sultats ?
+ int type1 = pStk1->GetType(); // de quels types les résultats ?
int type2 = pStk2->GetType();
- // cr�e une variable temporaire pour y mettre le r�sultat
+ // crée une variable temporaire pour y mettre le résultat
CBotVar* result = new CBotVar( NULL, MAX(type1, type2));
- // fait l'op�ration selon la demande
+ // fait l'opération selon la demande
switch (GetTokenType())
{
case ID_ADD:
@@ -131,10 +133,10 @@ BOOL CBotAddExpr::Execute(CBotStack* &pStack) result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
break;
}
- pStk2->SetVar(result); // met le r�sultat sur la pile
+ pStk2->SetVar(result); // met le résultat sur la pile
- pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk1); // transmet le r�sultat
+ pStk1->Return(pStk2); // libère la pile
+ return pStack->Return(pStk1); // transmet le résultat
}
diff --git a/src/CBot/CBotClass.cpp b/src/CBot/CBotClass.cpp index a70449d..7c097af 100644 --- a/src/CBot/CBotClass.cpp +++ b/src/CBot/CBotClass.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////
+// Gestion des variables de type classe
+//
#include "CBot.h"
@@ -62,7 +64,7 @@ CBotClass::~CBotClass() delete m_pCalls;
delete m_pMethod;
- delete m_next; // lib�re toutes celle de ce niveau
+ delete m_next; // libère toutes celle de ce niveau
}
@@ -89,7 +91,7 @@ void CBotClass::Purge() m_nbVar = m_pParent == NULL ? 0 : m_pParent->m_nbVar;
m_next->Purge();
- m_next = NULL; // n'appartient plus � cette cha�ne
+ m_next = NULL; // n'appartient plus à cette chaîne
}
BOOL CBotClass::Lock(CBotProgram* p)
@@ -105,7 +107,7 @@ BOOL CBotClass::Lock(CBotProgram* p) if ( p == m_ProgInLock[0] )
{
m_cptOne++;
- m_cptLock--; // a d�j� �t� compt�
+ m_cptLock--; // a déjà été compté
return TRUE;
}
@@ -114,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
}
}
@@ -291,7 +293,7 @@ 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
+ // mémorise les pointeurs aux deux fonctions
CBotCallMethode* p = m_pCalls;
CBotCallMethode* pp = NULL;
@@ -311,7 +313,7 @@ BOOL CBotClass::AddFunction(const char* name, p = new CBotCallMethode(name, rExec, rCompile);
if (m_pCalls == NULL) m_pCalls = p;
- else m_pCalls->AddNext(p); // ajoute � la liste
+ else m_pCalls->AddNext(p); // ajoute à la liste
return TRUE;
}
@@ -322,21 +324,21 @@ BOOL CBotClass::AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) ) return TRUE;
}
-// compile une m�thode associ�e � une instance de classe
-// la m�thode peut �tre d�clar�e par AddFunction ou par l'utilisateur
+// compile une méthode associée à une instance de classe
+// la méthode peut être déclarée par AddFunction ou par l'utilisateur
CBotTypResult CBotClass::CompileMethode(const char* name,
CBotVar* pThis, CBotVar** ppParams,
CBotCStack* pStack, long& nIdent)
{
- nIdent = 0; // oublie le pr�c�dent s'il y a lieu
+ nIdent = 0; // oublie le précédent s'il y a lieu
- // recherche dans les m�thodes d�clar�es par AddFunction
+ // recherche dans les méthodes déclarées par AddFunction
CBotTypResult r = m_pCalls->CompileCall(name, pThis, ppParams, pStack, nIdent);
if ( r.GivType() >= 0) return r;
- // recherche dans les m�thodes d�clar�es par l'utilisateur
+ // recherche dans les méthodes déclarées par l'utilisateur
r = m_pMethod->CompileCall(name, ppParams, nIdent);
if ( r.Eq(TX_UNDEFCALL) && m_pParent != NULL )
@@ -344,7 +346,7 @@ CBotTypResult CBotClass::CompileMethode(const char* name, return r;
}
-// ex�cute une m�thode
+// exécute une méthode
BOOL CBotClass::ExecuteMethode(long& nIdent, const char* name,
CBotVar* pThis, CBotVar** ppParams,
@@ -358,7 +360,7 @@ BOOL CBotClass::ExecuteMethode(long& nIdent, const char* name, return ret;
}
-// r�tabli la pile d'ex�cution
+// rétabli la pile d'exécution
void CBotClass::RestoreMethode(long& nIdent, const char* name, CBotVar* pThis,
CBotVar** ppParams, CBotStack* &pStack)
@@ -373,7 +375,7 @@ BOOL CBotClass::SaveStaticState(FILE* pf) {
if (!WriteWord( pf, CBOTVERSION*2)) return FALSE;
- // sauve l'�tat des variables statiques dans les classes
+ // sauve l'état des variables statiques dans les classes
CBotClass* p = m_ExClass;
while ( p != NULL )
@@ -390,7 +392,7 @@ BOOL CBotClass::SaveStaticState(FILE* pf) if (!WriteWord( pf, 1)) return FALSE;
if (!WriteString( pf, pv->GivName() )) return FALSE;
- if ( !pv->Save0State(pf)) return FALSE; // ent�te commune
+ if ( !pv->Save0State(pf)) return FALSE; // entête commune
if ( !pv->Save1State(pf) ) return FALSE; // sauve selon la classe fille
if ( !WriteWord( pf, 0)) return FALSE;
}
@@ -462,7 +464,7 @@ CBotClassInst::~CBotClassInst() // delete m_next; // fait par le destructeur de la classe de base ~CBotInstr()
}
-// d�finition de pointeur(s) � un objet
+// définition de pointeur(s) à un objet
// du style
// CPoint A, B ;
@@ -475,7 +477,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass = CBotClass::Find(p);
if ( pClass == NULL )
{
- // pas trouv� ? c'est bizare
+ // pas trouvé ? c'est bizare
pStack->SetError(TX_NOCLASS, p);
return NULL;
}
@@ -499,7 +501,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = type;
- if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
{
pStk->SetStartError(vartoken->GivStart());
pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
@@ -511,7 +513,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une d�claration de tableau
+ // compile une déclaration de tableau
inst = (CBotClassInst*)CBotInstArray::Compile( p, pStk, type );
@@ -520,27 +522,27 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pStk->SetError(TX_CLBRK, p->GivStart());
goto error;
}
- goto suite; // pas d'assignation, variable d�j� cr��e
+ goto suite; // pas d'assignation, variable déjà créée
}
CBotVar* var;
- var = CBotVar::Create(vartoken->GivString(), type); // cr�e l'instance
+ var = CBotVar::Create(vartoken->GivString(), type); // crée l'instance
// var->SetClass(pClass);
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un num�ro unique
+ // lui attribut un numéro unique
pStack->AddVar(var); // la place sur la pile
- // regarde s'il y a des param�tres
+ // regarde s'il y a des paramètres
inst->m_hasParams = (p->GivType() == ID_OPENPAR);
CBotVar* ppVars[1000];
inst->m_Parameters = CompileParams(p, pStk, ppVars);
if ( !pStk->IsOk() ) goto error;
- // s'il y a des param�tres, fait l'�quivalent de l'instruction new
- // CPoint A ( 0, 0 ) est �quivalent �
+ // s'il y a des paramètres, fait l'équivalent de l'instruction new
+ // CPoint A ( 0, 0 ) est équivalent à
// CPoint A = new CPoint( 0, 0 )
// if ( NULL != inst->m_Parameters )
@@ -549,13 +551,13 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* // le constructeur existe-il ?
// CBotString noname;
CBotTypResult r = pClass->CompileMethode(pClass->GivName(), var, ppVars, pStk, inst->m_nMethodeIdent);
- delete pStk->TokenStack(); // lib�re le suppl�ment de pile
+ delete pStk->TokenStack(); // libère le supplément de pile
int typ = r.GivType();
if (typ == TX_UNDEFCALL)
{
// si le constructeur n'existe pas
- if (inst->m_Parameters != NULL) // avec des param�tres
+ if (inst->m_Parameters != NULL) // avec des paramètres
{
pStk->SetError(TX_NOCONST, vartoken);
goto error;
@@ -594,27 +596,27 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* // if ( !bIntrinsic ) var->SetPointer(pStk->GivVar()->GivPointer());
if ( !bIntrinsic )
{
- // n'utilise pas le r�sultat sur la pile, pour imposer la classe
+ // n'utilise pas le résultat sur la pile, pour imposer la classe
CBotVar* pvar = CBotVar::Create("", pClass);
- var->SetPointer( pvar ); // var d�j� d�clar�e pointe l'instance
+ var->SetPointer( pvar ); // var déjà déclarée pointe l'instance
delete pvar; // supprime le second pointeur
}
var->SetInit(TRUE); // marque le pointeur comme init
}
else if (inst->m_hasParams)
{
- // cr�e l'objet sur le "tas"
+ // crée l'objet sur le "tas"
// avec un pointeur sur cet objet
if ( !bIntrinsic )
{
CBotVar* pvar = CBotVar::Create("", pClass);
- var->SetPointer( pvar ); // var d�j� d�clar�e pointe l'instance
+ var->SetPointer( pvar ); // var déjà déclarée pointe l'instance
delete pvar; // supprime le second pointeur
}
var->SetInit(2); // marque le pointeur comme init
}
suite:
- if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
+ if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
{
if ( NULL != ( inst->m_next = CBotClassInst::Compile(p, pStk, pClass) )) // compile la suivante
{
@@ -622,7 +624,7 @@ suite: }
}
- if (IsOfType(p, ID_SEP)) // instruction termin�e
+ if (IsOfType(p, ID_SEP)) // instruction terminée
{
return pStack->Return(inst, pStk);
}
@@ -635,7 +637,7 @@ error: return pStack->Return(NULL, pStk);
}
-// d�claration de l'instance d'une classe, par exemple:
+// déclaration de l'instance d'une classe, par exemple:
// CPoint A, B;
BOOL CBotClassInst::Execute(CBotStack* &pj)
@@ -650,7 +652,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) BOOL bIntrincic = pClass->IsIntrinsic();
- // cr�e la variable de type pointeur � l'objet
+ // crée la variable de type pointeur à l'objet
if ( pile->GivState()==0)
{
@@ -664,7 +666,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) pThis = CBotVar::Create(name, CBotTypResult( CBotTypPointer, pClass ));
}
- pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un num�ro unique
+ pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un numéro unique
pile->AddVar(pThis); // la place sur la pile
pile->IncState();
}
@@ -673,13 +675,13 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) if ( pile->GivState()<3)
{
- // y a-t-il une assignation ou des param�tres (constructeur)
+ // y a-t-il une assignation ou des paramètres (constructeur)
// CBotVarClass* pInstance = NULL;
if ( m_expr != NULL )
{
- // �value l'expression pour l'assignation
+ // évalue l'expression pour l'assignation
if (!m_expr->Execute(pile)) return FALSE;
if ( bIntrincic )
@@ -703,14 +705,14 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) else if ( m_hasParams )
{
- // �value le constructeur d'une instance
+ // évalue le constructeur d'une instance
if ( !bIntrincic && pile->GivState() == 1)
{
CBotToken* pt = &m_token;
CBotClass* pClass = CBotClass::Find(pt);
- // cr�e une instance de la classe demand�e
+ // crée une instance de la classe demandée
CBotVarClass* pInstance;
pInstance = (CBotVarClass*)CBotVar::Create("", pClass);
@@ -726,13 +728,13 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
@@ -744,7 +746,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) }
ppVars[i] = NULL;
- // cr�e une variable pour le r�sultat
+ // crée une variable pour le résultat
CBotVar* pResult = NULL; // constructeurs toujours void
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(),
@@ -752,8 +754,8 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) pResult, pile2, GivToken())) return FALSE; // interrompu
pThis->SetInit(TRUE);
- pThis->ConstructorSet(); // signale que le constructeur a �t� appel�
- pile->Return(pile2); // lib�re un bout de pile
+ pThis->ConstructorSet(); // signale que le constructeur a été appelé
+ pile->Return(pile2); // libère un bout de pile
// pInstance = pThis->GivPointer();
@@ -767,7 +769,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) 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
}
@@ -782,11 +784,11 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) if ( bMain ) pile = pj->RestoreStack(this);
if ( pile == NULL ) return;
- // cr�e la variable de type pointeur � l'objet
+ // crée la variable de type pointeur à l'objet
{
CBotString name = m_var->m_token.GivString();
pThis = pile->FindVar(name);
- pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un num�ro unique
+ pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un numéro unique
}
CBotToken* pt = &m_token;
@@ -795,20 +797,20 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) if ( bMain && pile->GivState()<3)
{
- // y a-t-il une assignation ou des param�tres (constructeur)
+ // y a-t-il une assignation ou des paramètres (constructeur)
// CBotVarClass* pInstance = NULL;
if ( m_expr != NULL )
{
- // �value l'expression pour l'assignation
+ // évalue l'expression pour l'assignation
m_expr->RestoreState(pile, bMain);
return;
}
else if ( m_hasParams )
{
- // �value le constructeur d'une instance
+ // évalue le constructeur d'une instance
if ( !bIntrincic && pile->GivState() == 1)
{
@@ -821,13 +823,13 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->RestoreStack(); // de la place sur la pile pour les r�sultats
+ pile2 = pile2->RestoreStack(); // de la place sur la pile pour les résultats
if ( pile2 == NULL ) return;
if ( pile2->GivState() == 0 )
@@ -841,7 +843,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) }
ppVars[i] = NULL;
- // cr�e une variable pour le r�sultat
+ // crée une variable pour le résultat
CBotVar* pResult = NULL; // constructeurs toujours void
pClass->RestoreMethode(m_nMethodeIdent, pClass->GivName(), pThis, ppVars, pile2);
@@ -850,11 +852,11 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) }
if ( m_next2b != NULL )
- m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
}
-// test si un nom de proc�dure est d�j� d�fini quelque part
+// test si un nom de procédure est déjà défini quelque part
BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
@@ -867,7 +869,7 @@ BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) {
if ( pToken->GivString() == pp->GivName() )
{
- // les param�tres sont-ils exactement les m�mes ?
+ // les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
}
diff --git a/src/CBot/CBotCompExpr.cpp b/src/CBot/CBotCompExpr.cpp index dada30e..41e7e05 100644 --- a/src/CBot/CBotCompExpr.cpp +++ b/src/CBot/CBotCompExpr.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,10 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////
+// expression du genre Opérande1 > Opérande2
+// Opérande1 != Opérande2
+// etc.
#include "CBot.h"
@@ -39,7 +42,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotCStack* pStk = pStack->AddStack();
- CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B � gauche
+ CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B à gauche
if (left == NULL) return pStack->Return(NULL, pStk); // erreur
if ( p->GetType() == ID_HI ||
@@ -49,22 +52,22 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) p->GetType() == ID_EQ ||
p->GetType() == ID_NE) // les diverses comparaisons
{
- CBotCompExpr* inst = new CBotCompExpr(); // �l�ment pour op�ration
- inst->SetToken(p); // m�morise l'op�ration
+ CBotCompExpr* inst = new CBotCompExpr(); // élément pour opération
+ inst->SetToken(p); // mémorise l'opération
int type1, type2;
type1 = pStack->GetType();
p = p->Next();
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B � droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B à droite
{
type2 = pStack->GetType();
- // les r�sultats sont-ils compatibles
+ // les résultats sont-ils compatibles
if ( type1 == type2 )
{
inst->m_leftop = left;
pStk->SetVar(new CBotVar(NULL, CBotTypBoolean));
- // le r�sultat est un boolean
+ // le résultat est un boolean
return pStack->Return(inst, pStk);
}
}
@@ -78,7 +81,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) }
-// fait l'op�ration
+// fait l'opération
BOOL CBotCompExpr::Execute(CBotStack* &pStack)
{
@@ -87,9 +90,9 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) if ( pStk1->GetState() == 0 && !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- pStk1->SetState(1); // op�ration termin�e
+ pStk1->SetState(1); // opération terminée
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
+ // demande un peu plus de stack pour ne pas toucher le résultat de gauche
CBotStack* pStk2 = pStk1->AddStack();
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
@@ -102,27 +105,27 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) switch (GetTokenType())
{
case ID_LO:
- result->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
+ result->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
break;
case ID_HI:
- result->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
+ result->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
break;
case ID_LS:
- result->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
+ result->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
break;
case ID_HS:
- result->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
+ result->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
break;
case ID_EQ:
- result->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
+ result->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
break;
case ID_NE:
- result->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
+ result->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
break;
}
- pStk2->SetVar(result); // met le r�sultat sur la pile
+ pStk2->SetVar(result); // met le résultat sur la pile
- pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk1); // transmet le r�sultat
+ pStk1->Return(pStk2); // libère la pile
+ return pStack->Return(pStk1); // transmet le résultat
}
diff --git a/src/CBot/CBotDll.h b/src/CBot/CBotDll.h index afb9c1c..ea67f2c 100644 --- a/src/CBot/CBotDll.h +++ b/src/CBot/CBotDll.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,10 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////////
+// Librairie pour l'interprétation du language CBOT
+// pour le jeu COLOBOT
+//
//#include "stdafx.h"
@@ -24,26 +27,26 @@ #define CBOTVERSION 104
////////////////////////////////////////////////////////////////////////
-// quelques classes d�finies par ailleurs
+// quelques classes définies par ailleurs
-class CBotToken; // programme transform� en "jetons"
-class CBotStack; // pile pour l'ex�cution
+class CBotToken; // programme transformé en "jetons"
+class CBotStack; // pile pour l'exécution
class CBotClass; // classe d'object
-class CBotInstr; // instruction � ex�cuter
+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 CBotVarPointer; // pointeur à une instance de classe
class CBotCall; // les fonctions
-class CBotCallMethode; // les m�thodes
-class CBotDefParam; // liste de param�tres
+class CBotCallMethode; // les méthodes
+class CBotDefParam; // liste de paramètres
////////////////////////////////////////////////////////////////////////
// Gestion des variables
////////////////////////////////////////////////////////////////////////
-// ces types sont calqu�s sur les types Java
+// ces types sont calqués sur les types Java
// ne pas changer l'ordre de ces types
enum CBotType
@@ -51,24 +54,24 @@ 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)
+ 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)
+ 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
+ CBotTypString = 9, // chaine de caractère
CBotTypArrayPointer = 10, // un tableau de variables
- CBotTypArrayBody = 11, // idem mais cr�e l'instance
+ CBotTypArrayBody = 11, // idem mais crée l'instance
- CBotTypPointer = 12, // pointeur � une instance
- CBotTypNullPointer = 13, // pointeur null est sp�cial
+ 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
+ CBotTypIntrinsic = 16 // instance d'une classe intrinsèque
};
- //n = non encore impl�ment�
+ //n = non encore implémenté
// pour SetUserPtr lors de la suppression d'un objet
#define OBJECTDELETED ((void*)-1)
@@ -76,13 +79,13 @@ enum CBotType #define OBJECTCREATED ((void*)-2)
-// classe permettant de d�finir le type complet d'un r�sultat
+// classe permettant de définir le type complet d'un résultat
class CBotTypResult
{
private:
int m_type;
CBotTypResult* m_pNext; // pour les types de types
- CBotClass* m_pClass; // pour les d�riv�s de classe
+ CBotClass* m_pClass; // pour les dérivés de classe
int m_limite; // limitation des tableaux
friend class CBotVarClass;
friend class CBotVarPointer;
@@ -91,13 +94,13 @@ public: // divers constructeurs selon les besoins
DllExport
CBotTypResult(int type);
- // pour les types simples (CBotTypInt � CBotTypString)
+ // 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
+ // idem à partir de l'instance d'une classe
DllExport
CBotTypResult(int type, CBotTypResult elem);
// pour les tableaux de variables
@@ -107,20 +110,20 @@ public: // pour les assignations
DllExport
CBotTypResult();
- // pour par d�faut
+ // pour par défaut
DllExport
~CBotTypResult();
DllExport
int GivType(int mode = 0);
- // rend le type CBotTyp* du r�sultat
+ // rend le type CBotTyp* du résultat
void SetType(int n);
// modifie le type
DllExport
CBotClass* GivClass();
- // rend le pointeur � la classe (pour les CBotTypClass, CBotTypPointer)
+ // rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer)
DllExport
int GivLimite();
@@ -135,7 +138,7 @@ public: DllExport
CBotTypResult& GivTypElem();
- // rend le type des �l�ments du tableau (CBotTypArray)
+ // rend le type des éléments du tableau (CBotTypArray)
DllExport
BOOL Compare(CBotTypResult& typ);
@@ -151,7 +154,7 @@ public: };
/*
-// pour d�finir un r�sultat en sortie, utiliser par exemple
+// pour définir un résultat en sortie, utiliser par exemple
// pour rendre un simple Float
return CBotTypResult( CBotTypFloat );
@@ -168,16 +171,16 @@ public: ////////////////////////////////////////////////////////////////////////
-// Gestion des erreurs compilation et ex�cution
+// Gestion des erreurs compilation et exécution
////////////////////////////////////////////////////////////////////////
-// voici la liste des erreurs pouvant �tre retourn�es par le module
+// voici la liste des erreurs pouvant être retournées par le module
// pour la compilation
-#define CBotErrOpenPar 5000 // manque la parenth�se ouvrante
-#define CBotErrClosePar 5001 // manque la parenth�se fermante
-#define CBotErrNotBoolean 5002 // l'expression doit �tre un boolean
-#define CBotErrUndefVar 5003 // variable non d�clar�e
+#define CBotErrOpenPar 5000 // manque la parenthèse ouvrante
+#define CBotErrClosePar 5001 // manque la parenthèse fermante
+#define CBotErrNotBoolean 5002 // l'expression doit être un boolean
+#define CBotErrUndefVar 5003 // variable non déclarée
#define CBotErrBadLeft 5004 // assignation impossible ( 5 = ... )
#define CBotErrNoTerminator 5005 // point-virgule attendu
#define CBotErrCaseOut 5006 // case en dehors d'un switch
@@ -186,8 +189,8 @@ public: #define CBotErrElseWhitoutIf 5009 // else sans if correspondant
#define CBotErrOpenBlock 5010 // manque " { "
#define CBotErrBadType1 5011 // mauvais type pour l'assignation
-#define CBotErrRedefVar 5012 // red�finition de la variable
-#define CBotErrBadType2 5013 // 2 op�randes de type incompatibles
+#define CBotErrRedefVar 5012 // redéfinition de la variable
+#define CBotErrBadType2 5013 // 2 opérandes de type incompatibles
#define CBotErrUndefCall 5014 // routine inconnue
#define CBotErrNoDoubleDots 5015 // " : " attendu
// CBotErrWhile 5016, plus utile
@@ -197,63 +200,63 @@ public: #define CBotErrNoCase 5020 // manque " case "
#define CBotErrBadNum 5021 // nombre attendu
#define CBotErrVoid 5022 // " void " pas possible ici
-#define CBotErrNoType 5023 // d�claration de type attendue
+#define CBotErrNoType 5023 // déclaration de type attendue
#define CBotErrNoVar 5024 // nom de variable attendu
#define CBotErrNoFunc 5025 // nom de fonction attendu
-#define CBotErrOverParam 5026 // trop de param�tres
-#define CBotErrRedefFunc 5027 // cette fonction existe d�j�
-#define CBotErrLowParam 5028 // pas assez de param�tres
-#define CBotErrBadParam 5029 // mauvais types de param�tres
-#define CBotErrNbParam 5030 // mauvais nombre de param�tres
-#define CBotErrUndefItem 5031 // �l�ment n'existe pas dans la classe
+#define CBotErrOverParam 5026 // trop de paramètres
+#define CBotErrRedefFunc 5027 // cette fonction existe déjà
+#define CBotErrLowParam 5028 // pas assez de paramètres
+#define CBotErrBadParam 5029 // mauvais types de paramètres
+#define CBotErrNbParam 5030 // mauvais nombre de paramètres
+#define CBotErrUndefItem 5031 // élément n'existe pas dans la classe
#define CBotErrUndefClass 5032 // variable n'est pas une classe
-#define CBotErrNoConstruct 5033 // pas de constructeur appropri�
-#define CBotErrRedefClass 5034 // classe existe d�j�
+#define CBotErrNoConstruct 5033 // pas de constructeur approprié
+#define CBotErrRedefClass 5034 // classe existe déjà
#define CBotErrCloseIndex 5035 // " ] " attendu
-#define CBotErrReserved 5036 // mot r�serv� (par un DefineNum)
-#define CBotErrBadNew 5037 // mauvais param�tre pour new
+#define CBotErrReserved 5036 // mot réservé (par un DefineNum)
+#define CBotErrBadNew 5037 // mauvais paramètre pour new
#define CBotErrOpenIndex 5038 // " [ " attendu
-#define CBotErrBadString 5039 // cha�ne de caract�re attendue
+#define CBotErrBadString 5039 // chaîne de caractère attendue
#define CBotErrBadIndex 5040 // mauvais type d'index "[ false ]"
-#define CBotErrPrivate 5041 // �l�ment prot�g�
+#define CBotErrPrivate 5041 // élément protégé
#define CBotErrNoPublic 5042 // manque le mot "public"
-// voici la liste des erreurs pouvant �tre retourn�es par le module
-// pour l'ex�cution
+// voici la liste des erreurs pouvant être retournées par le module
+// pour l'exécution
-#define CBotErrZeroDiv 6000 // division par z�ro
-#define CBotErrNotInit 6001 // variable non initialis�e
-#define CBotErrBadThrow 6002 // throw d'une valeur n�gative
-#define CBotErrNoRetVal 6003 // fonction n'a pas retourn� de r�sultat
+#define CBotErrZeroDiv 6000 // division par zéro
+#define CBotErrNotInit 6001 // variable non initialisée
+#define CBotErrBadThrow 6002 // throw d'une valeur négative
+#define CBotErrNoRetVal 6003 // fonction n'a pas retourné de résultat
#define CBotErrNoRun 6004 // Run() sans fonction active
#define CBotErrUndefFunc 6005 // appel d'une fonction qui n'existe plus
#define CBotErrNotClass 6006 // cette classe n'existe pas
#define CBotErrNull 6007 // pointeur null
#define CBotErrNan 6008 // calcul avec un NAN
#define CBotErrOutArray 6009 // index hors du tableau
-#define CBotErrStackOver 6010 // d�passement de la pile
-#define CBotErrDeletedPtr 6011 // pointeur � un objet d�truit
+#define CBotErrStackOver 6010 // dépassement de la pile
+#define CBotErrDeletedPtr 6011 // pointeur à un objet détruit
#define CBotErrFileOpen 6012 // ouverture du fichier impossible
#define CBotErrNotOpen 6013 // canal pas ouvert
-#define CBotErrRead 6014 // erreur � la lecture
-#define CBotErrWrite 6015 // erreur � l'�criture
+#define CBotErrRead 6014 // erreur à la lecture
+#define CBotErrWrite 6015 // erreur à l'écriture
-// d'autres valeurs peuvent �tre rendues
+// d'autres valeurs peuvent être rendues
// par exemple les exceptions rendues par les routines externes
// et les " throw " avec un nombre quelconque.
////////////////////////////////////////////////////////////////////////
-// d�finie une classe pour l'utilisation des strings
-// car CString fait partie de MFC pas utilis� ici.
+// 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 )
+// ( toutes les fonctions ne sont pas encore implémentées )
class CBotString
{
private:
- char* m_ptr; // pointeur � la chaine
+ char* m_ptr; // pointeur à la chaine
int m_lg; // longueur de la chaine
static
HINSTANCE m_hInstance;
@@ -360,9 +363,9 @@ public: class CBotStringArray : public CBotString
{
private:
- int m_nSize; // nombre d'�l�ments
- int m_nMaxSize; // taille r�serv�e
- CBotString* m_pData; // ^aux donn�es
+ int m_nSize; // nombre d'éléments
+ int m_nMaxSize; // taille réservée
+ CBotString* m_pData; // ^aux données
public:
DllExport
@@ -382,7 +385,7 @@ public: CBotString& ElementAt(int nIndex);
};
-// diff�rents mode pour GetPosition
+// différents mode pour GetPosition
enum CBotGet
{
GetPosExtern = 1,
@@ -392,16 +395,16 @@ enum CBotGet };
////////////////////////////////////////////////////////////////////
-// classe principale g�rant un programme CBot
+// classe principale gérant un programme CBot
//
class CBotProgram
{
private:
- CBotFunction* m_Prog; // les fonctions d�finies par l'utilisateur
- CBotFunction* m_pRun; // la fonction de base pour l'ex�cution
- CBotClass* m_pClass; // les classes d�finies dans cette partie
- CBotStack* m_pStack; // la pile d'ex�cution
+ CBotFunction* m_Prog; // les fonctions définies par l'utilisateur
+ CBotFunction* m_pRun; // la fonction de base pour l'exécution
+ CBotClass* m_pClass; // les classes définies dans cette partie
+ CBotStack* m_pStack; // la pile d'exécution
CBotVar* m_pInstance; // instance de la classe parent
friend class CBotFunction;
@@ -409,12 +412,12 @@ private: int m_ErrorStart;
int m_ErrorEnd;
- long m_Ident; // identificateur associ�
+ long m_Ident; // identificateur associé
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;
@@ -422,12 +425,12 @@ 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
+ // 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
+ // libère les zones mémoires statiques
DllExport
static
@@ -444,11 +447,11 @@ public: DllExport
BOOL Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
- // compile le programme donn� en texte
- // retourne FALSE s'il y a une erreur � la compilation
- // 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
+ // compile le programme donné en texte
+ // 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);
@@ -465,10 +468,10 @@ public: DllExport
BOOL GetError(int& code, int& start, int& end, CBotProgram* &pProg);
// si TRUE
- // donne l'erreur trouv�e � la compilation
- // ou � l'ex�cution
- // start et end d�limite le bloc o� se trouve l'erreur
- // pProg permet de savoir dans quel "module" s'est produite l'erreur d'ex�cution
+ // 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);
@@ -476,42 +479,42 @@ public: DllExport
BOOL Start(const char* name);
- // d�finie quelle fonction doit �tre ex�cut�e
- // retourne FALSE si la fontion name n'est pas trouv�e
+ // définie quelle fonction doit être exécuté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);
- // ex�cute le programme
- // 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
+ // exécute le programme
+ // 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);
- // donne la position dans le programme en ex�cution
- // retourne FALSE si on n'est pas en ex�cution (programme termin�)
+ // donne la position dans le programme en exécution
+ // 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
- // la valeur retourn�e (CBotVar*) est une liste de variable (ou NULL)
- // qui peut �tre trait� que la liste des param�tres re�u par une routine
- // FunctionName donne le nom de la fonction o� se trouvent ces variables
+ // 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
+ // la valeur retournée (CBotVar*) est une liste de variable (ou NULL)
+ // qui peut être traité que la liste des paramètres reçu par une routine
+ // 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
+ // 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
+ // défini le nombre de pas (parties d'instructions) à faire
// dans Run() avant de rendre la main "FALSE"
DllExport
@@ -519,7 +522,7 @@ public: 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 (**)
+ // cet appel permet d'ajouter de manière externe (**)
// une nouvelle fonction utilisable par le programme CBot
DllExport
@@ -528,20 +531,20 @@ public: DllExport
BOOL SaveState(FILE* pf);
- // sauvegarde l'�tat d'ex�cution dans le fichier
- // le fichier doit avoir �t� ouvert avec l'appel fopen de cette dll
- // sinon le syst�me plante
+ // 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);
- // r�tablie l'�tat de l'ex�cution depuis le fichier
- // le programme compil� doit �videmment �tre identique
+ // 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,
CBotGet modestart = GetPosExtern,
CBotGet modestop = GetPosBloc);
// donne la position d'une routine dans le texte d'origine
- // le mode permet de choisir l'�l�ment � trouver pour le d�but et la fin
+ // le mode permet de choisir l'élément à trouver pour le début et la fin
// voir les modes ci-dessus dans CBotGet
@@ -564,21 +567,21 @@ public: #if 0
/*
(**) Note:
- Pour d�finir une fonction externe, il faut proc�der ainsi:
+ Pour définir une fonction externe, il faut procéder ainsi:
- a) d�finir une routine pour la compilation
- cette routine re�ois la liste des param�tres (sans valeurs)
- et retourne soit un type de r�sultat (CBotTyp... ou 0 = void)
- soit un num�ro d'erreur
- b) d�finir une routine pour l'ex�cution
- cette rourine reCoit la liste des param�tres (avec valeurs),
- une variable pour stocker le r�sultat (selon le type donn� � la compilation)
+ a) définir une routine pour la compilation
+ cette routine reçois la liste des paramètres (sans valeurs)
+ et retourne soit un type de résultat (CBotTyp... ou 0 = void)
+ soit un numéro d'erreur
+ b) définir une routine pour l'exécution
+ cette rourine reCoit la liste des paramètres (avec valeurs),
+ une variable pour stocker le résultat (selon le type donné à la compilation)
- Par exemple, une routine qui calcule la moyenne d'une liste de param�tres */
+ Par exemple, une routine qui calcule la moyenne d'une liste de paramètres */
int cMoyenne(CBotVar* &pVar, CBotString& ClassName)
{
- if ( pVar == NULL ) return 6001; // il n'y a aucun param�tre !
+ if ( pVar == NULL ) return 6001; // il n'y a aucun paramètre !
while ( pVar != NULL )
{
@@ -586,7 +589,7 @@ int cMoyenne(CBotVar* &pVar, CBotString& ClassName) pVar = pVar -> GivNext();
}
- return CBotTypFloat; // le type du r�sultat pourrait d�pendre des param�tres !
+ return CBotTypFloat; // le type du résultat pourrait dépendre des paramètres !
}
@@ -602,7 +605,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
@@ -610,20 +613,20 @@ 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 )
+// 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 )
-// r�sultats pour GivInit()
-#define IS_UNDEF 0 // variable ind�finie
-#define IS_DEF 1 // variable d�finie
-#define IS_NAN 999 // variable d�finie comme �tant not a number
+// résultats pour GivInit()
+#define IS_UNDEF 0 // variable indéfinie
+#define IS_DEF 1 // variable définie
+#define IS_NAN 999 // variable définie comme étant not a number
// type de variable SetPrivate / IsPrivate
#define PR_PUBLIC 0 // variable publique
#define PR_READ 1 // read only
-#define PR_PROTECT 2 // protected (h�ritage)
-#define PR_PRIVATE 3 // strictement priv�e
+#define PR_PROTECT 2 // protected (héritage)
+#define PR_PRIVATE 3 // strictement privée
class CBotVar
{
@@ -638,11 +641,11 @@ protected: CBotTypResult m_type; // type de valeur
- 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)
- int m_mPrivate; // �l�ment public, protected ou private ?
+ 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)
+ int m_mPrivate; // élément public, protected ou private ?
CBotInstr* m_InitExpr; // expression pour le contenu initial
CBotInstr* m_LimExpr; // liste des limites pour un tableau
@@ -662,12 +665,12 @@ virtual ~CBotVar( ); // destructeur /* DllExport
static
CBotVar* Create( const char* name, int type, const char* ClassName = NULL);
- // cr�e une variable selon son type,*/
+ // crée une variable selon son type,*/
DllExport
static
CBotVar* Create( const char* name, CBotTypResult type);
- // idem � partir du type complet
+ // idem à partir du type complet
DllExport
static
@@ -688,16 +691,16 @@ virtual ~CBotVar( ); // destructeur DllExport
void SetUserPtr(void* pUser);
- // associe un pointeur utilisateur � une instance
+ // 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)
+ // 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
+ // rend le pointeur associé à la variable
DllExport
CBotString GivName(); // le nom de la variable, s'il est connu
@@ -716,10 +719,10 @@ virtual ~CBotVar( ); // destructeur void SetType(CBotTypResult& type);
DllExport
- void SetInit(int bInit); // met la variable dans l'�tat IS_UNDEF, IS_DEF, IS_NAN
+ void SetInit(int bInit); // met la variable dans l'état IS_UNDEF, IS_DEF, IS_NAN
DllExport
- int GivInit(); // donne l'�tat de la variable
+ int GivInit(); // donne l'état de la variable
DllExport
void SetStatic(BOOL bStatic);
@@ -740,9 +743,9 @@ virtual ~CBotVar( ); // destructeur DllExport
virtual
- CBotVar* GivItem(const char* name); // rend un �l�ment d'une classe selon son nom (*)
+ CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
virtual
- CBotVar* GivItemRef(int nIdent); // idem � partir du n� ref
+ CBotVar* GivItemRef(int nIdent); // idem à partir du n° ref
DllExport
virtual
@@ -750,18 +753,18 @@ virtual ~CBotVar( ); // destructeur DllExport
virtual
- CBotVar* GivItemList(); // donne la liste des �l�ments
+ CBotVar* GivItemList(); // donne la liste des éléments
DllExport
- CBotVar* GivStaticVar(); // rend le pointeur � la variable si elle est statique
+ CBotVar* GivStaticVar(); // rend le pointeur à la variable si elle est statique
DllExport
BOOL IsElemOfClass(const char* name);
- // dit si l'�l�ment appartient � la classe "name"
+ // dit si l'élément appartient à la classe "name"
// rend TRUE si l'objet est d'une classe fille
DllExport
- CBotVar* GivNext(); // prochaine variable dans la liste (param�tres)
+ CBotVar* GivNext(); // prochaine variable dans la liste (paramètres)
////////////////////////////////////////////////////////////////////////////////////////////
void AddNext(CBotVar* pVar); // ajoute dans une liste
@@ -771,27 +774,27 @@ virtual ~CBotVar( ); // destructeur DllExport
virtual void SetValInt(int val, const char* name = NULL);
- // initialise avec une valeur enti�re (#)
+ // initialise avec une valeur entière (#)
/////////////////////////////////////////////////////////////////////////////////
DllExport
- virtual void SetValFloat(float val); // initialise avec une valeur r�elle (#)
+ virtual void SetValFloat(float val); // initialise avec une valeur réelle (#)
////////////////////////////////////////////////////////////////////////////////
DllExport
- virtual void SetValString(const char* p);// initialise avec une valeur cha�ne (#)
+ virtual void SetValString(const char* p);// initialise avec une valeur chaîne (#)
////////////////////////////////////////////////////////////////////////////////
DllExport
- virtual int GivValInt(); // demande la valeur enti�re (#)
+ virtual int GivValInt(); // demande la valeur entière (#)
////////////////////////////////////////////////////////////////////////
DllExport
- virtual float GivValFloat(); // demande la valeur r�elle (#)
+ virtual float GivValFloat(); // demande la valeur réelle (#)
///////////////////////////////////////////////////////////////////////
virtual
- CBotString GivValString(); // demande la valeur cha�ne (#)
+ CBotString GivValString(); // demande la valeur chaîne (#)
///////////////////////////////////////////////////////////////////////
virtual void SetClass(CBotClass* pClass);
@@ -850,16 +853,16 @@ virtual ~CBotVar( ); // destructeur };
/* NOTE (#)
- les m�thodes SetValInt() SetValFloat() et SetValString()
- ne peuvent �tes appell�es qu'avec des objets respectivement entier, r�elle ou cha�ne
- toujours s'assurer du type de la variable avant d'appeller ces m�thodes
+ les méthodes SetValInt() SetValFloat() et SetValString()
+ ne peuvent êtes appellées qu'avec des objets respectivement entier, réelle ou chaîne
+ toujours s'assurer du type de la variable avant d'appeller ces méthodes
if ( pVar->GivType() == CBotInt() ) pVar->SetValFloat( 3.3 ); // plante !!
- les m�thodes GivValInt(), GivValFloat() et GivValString()
+ les méthodes GivValInt(), GivValFloat() et GivValString()
font des conversions de valeur,
- GivValString() fonctionne sur des nombres (rend la cha�ne correspondante)
- par contre il ne faut pas faire de GivValInt() avec une variable de type cha�ne !
+ GivValString() fonctionne sur des nombres (rend la chaîne correspondante)
+ par contre il ne faut pas faire de GivValInt() avec une variable de type chaîne !
*/
@@ -868,41 +871,41 @@ virtual ~CBotVar( ); // destructeur // Gestion des classes
////////////////////////////////////////////////////////////////////////
-// classe pour d�finir de nouvelle classes dans le language CBOT
-// par exemple pour d�finir la classe CPoint (x,y)
+// classe pour définir de nouvelle classes dans le language CBOT
+// par exemple pour définir la classe CPoint (x,y)
class CBotClass
{
private:
static
- CBotClass* m_ExClass; // liste des classes existante � un moment donn�
- CBotClass* m_ExNext; // pour cette liste g�n�rale
- CBotClass* m_ExPrev; // pour cette liste g�n�rale
+ CBotClass* m_ExClass; // liste des classes existante à un moment donné
+ CBotClass* m_ExNext; // pour cette liste générale
+ CBotClass* m_ExPrev; // pour cette liste générale
private:
CBotClass* m_pParent; // classe parent
CBotString m_name; // nom de cette classe-ci
- int m_nbVar; // nombre de variables dans la cha�ne
+ int m_nbVar; // nombre de variables dans la chaîne
CBotVar* m_pVar; // contenu de la classe
- 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
+ CBotCallMethode* m_pCalls; // liste des méthodes définie en externe
+ CBotFunction* m_pMethod; // liste des méthodes compilées
void (*m_rMaj) ( CBotVar* pThis, void* pUser );
friend class CBotVarClass;
int m_cptLock; // pour Lock / UnLock
- int m_cptOne; // pour r�entrance Lock
+ int m_cptOne; // pour réentrance Lock
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
- // D�s qu'une classe est cr��e, elle est connue
+ // Dès qu'une classe est créée, elle est connue
// partout dans CBot
- // le mode intrinsic donne une classe qui n'est pas g�r�e par des pointeurs
+ // le mode intrinsic donne une classe qui n'est pas gérée par des pointeurs
DllExport
~CBotClass( ); // destructeur
@@ -911,41 +914,41 @@ public: 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
+ // 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 ) );
- // d�fini la routine qui sera appell�e pour mettre � jour les �lements de la classe
+ // défini la routine qui sera appellée pour mettre à jour les élements de la classe
DllExport
BOOL AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);
- // ajoute un �l�ment � la classe
+ // ajoute un élément à la classe
// DllExport
// BOOL AddItem(CBotString name, CBotClass* pClass);
- // idem pour des �l�ments appartenant � pClass
+ // idem pour des éléments appartenant à pClass
DllExport
BOOL AddItem(CBotVar* pVar);
- // idem en passant le pointeur � une instance d'une variable
- // l'objet est pris tel quel, il ne faut donc pas le d�truire
+ // idem en passant le pointeur à une instance d'une variable
+ // l'objet est pris tel quel, il ne faut donc pas le détruire
- // idem en donnant un �l�ment de type CBotVar
+ // 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)
+ CBotClass* GivParent(); // donne la classe père (ou NULL)
- // dit si une classe est d�riv�e (Extends) d'une autre
+ // dit si une classe est dérivée (Extends) d'une autre
// rend TRUE aussi si les classes sont identiques
DllExport
BOOL IsChildOf(CBotClass* pClass);
static
- CBotClass* Find(CBotToken* &pToken); // trouve une classe d'apr�s son nom
+ CBotClass* Find(CBotToken* &pToken); // trouve une classe d'après son nom
DllExport
static
@@ -961,7 +964,7 @@ public: 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
+ // compile une classe déclarée par l'utilisateur
static
CBotClass* Compile(CBotToken* &p, CBotCStack* pStack);
static
@@ -1003,9 +1006,9 @@ public: #define TokenTypDef 5 // une valeur selon DefineNum
#define TokenKeyWord 2000 // les mots clefs du langage
-#define TokenKeyDeclare 2100 // mots clefs pour d�clarations (int, float,..)
-#define TokenKeyVal 2200 // les mots repr�sentant une "valeur" (true, false, null, nan)
-#define TokenKeyOp 2300 // les op�rateurs
+#define TokenKeyDeclare 2100 // mots clefs pour déclarations (int, float,..)
+#define TokenKeyVal 2200 // les mots représentant une "valeur" (true, false, null, nan)
+#define TokenKeyOp 2300 // les opérateurs
class CBotToken
@@ -1017,19 +1020,19 @@ private: int m_ListIdKeyWords[200]; // les codes correspondants
static
- CBotStringArray m_ListKeyDefine; // les noms d�finis par un DefineNum
+ CBotStringArray m_ListKeyDefine; // les noms définis par un DefineNum
static
- long m_ListKeyNums[MAXDEFNUM]; // les valeurs associ�es
+ long m_ListKeyNums[MAXDEFNUM]; // les valeurs associées
private:
CBotToken* m_next; // suivant dans la liste
CBotToken* m_prev;
int m_type; // type de Token
- long m_IdKeyWord; // num�ro du mot clef si c'en est un
+ long m_IdKeyWord; // numéro du mot clef si c'en est un
// ou valeur du "define"
- CBotString m_Text; // mot trouv� comme token
- CBotString m_Sep; // s�parateurs qui suivent
+ CBotString m_Text; // mot trouvé comme token
+ CBotString m_Sep; // séparateurs qui suivent
int m_start; // position dans le texte d'origine (programme)
int m_end; // itou pour la fin du token
@@ -1054,20 +1057,20 @@ public: int GivType(); // rend le type du token
DllExport
- CBotString& GivString(); // rend la chaine correspondant � ce token
+ CBotString& GivString(); // rend la chaine correspondant à ce token
DllExport
- CBotString& GivSep(); // rend le s�parateur suivant le token
+ CBotString& GivSep(); // rend le séparateur suivant le token
DllExport
- int GivStart(); // position du d�but dans le texte
+ 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
+ CBotToken* GivPrev(); // rend le Précédent dans la liste
DllExport
static
@@ -1075,7 +1078,7 @@ public: // transforme tout le programme
DllExport
static
- void Delete(CBotToken* pToken); // lib�re la liste
+ void Delete(CBotToken* pToken); // libère la liste
// fonctions non utiles en export
@@ -1102,10 +1105,10 @@ public: #if 0
////////////////////////////////////////////////////////////////////////
// Exemples d'utilisation
-// D�finition de classes et de fonctions
+// Définition de classes et de fonctions
-// d�finie la classe globale CPoint
+// définie la classe globale CPoint
// --------------------------------
m_pClassPoint = new CBotClass("CPoint", NULL);
// ajoute le composant ".x"
@@ -1115,17 +1118,17 @@ public: // le joueur peut alors utiliser les instructions
// CPoint position; position.x = 12; position.y = -13.6
-// d�finie la classe CColobotObject
+// définie la classe CColobotObject
// --------------------------------
-// cette classe g�re tous les objets dans le monde de COLOBOT
-// le programme utilisateur "main" appartient � cette classe
+// cette classe gère tous les objets dans le monde de COLOBOT
+// le programme utilisateur "main" appartient à cette classe
m_pClassObject = new CBotClass("CColobotObject", m_pClassBase);
// ajoute le composant ".position"
m_pClassObject->AddItem("position", m_pClassPoint);
// ajoute le composant ".type"
m_pClassObject->AddItem("type", CBotTypResult(CBotTypShort));
- // ajoute une d�finition de constante
- m_pClassObject->AddConst("ROBOT", CBotTypShort, 1); // ROBOT �quivalent � la valeur 1
+ // ajoute une définition de constante
+ m_pClassObject->AddConst("ROBOT", CBotTypShort, 1); // ROBOT équivalent à la valeur 1
// ajoute la routine FIND
m_pClassObject->AddFunction( rCompFind, rDoFind );
// le joueur peut maintenant utiliser les instructions
@@ -1133,9 +1136,9 @@ public: -// d�finie la classe CColobotRobot d�riv�e de CColobotObject
+// définie la classe CColobotRobot dérivée de CColobotObject
// ---------------------------------------------------------
-// les programmes "main" associ�s aux robots font partie de cette classe
+// les programmes "main" associés aux robots font partie de cette classe
m_pClassRobot = new CBotClass("CColobotRobot", m_pClassObject);
// ajoute la routine GOTO
m_pClassRobot->AddFunction( rCompGoto, rDoGoto );
@@ -1143,49 +1146,49 @@ public: // GOTO( FIND ( ROBOT ) );
-// cr�e une instance de la classe Robot
+// crée une instance de la classe Robot
// ------------------------------------
-// par exemple un nouveau robot qui vient d'�tre fabriqu�
+// par exemple un nouveau robot qui vient d'être fabriqué
CBotVar* m_pMonRobot = new CBotVar("MonRobot", m_pClassRobot);
-// compile le programme main pour ce robot-l�
+// compile le programme main pour ce robot-là
// ------------------------------------------
CString LeProgramme( "void main() {GOTO(0, 0); return 0;}" );
if ( !m_pMonRobot->Compile( LeProgramme ) ) {gestion d'erreur...};
-// construit une pile pour l'interpr�teur
+// construit une pile pour l'interpréteur
// --------------------------------------
CBotStack* pStack = new CBotStack(NULL);
-// ex�cute le programme main
+// exécute le programme main
// -------------------------
while( FALSE = m_pMonRobot->Execute( "main", pStack ))
{
// programme suspendu
- // on pourrait passer la main � un autre (en sauvegardant pStack pour ce robot-l�)
+ // on pourrait passer la main à un autre (en sauvegardant pStack pour ce robot-là)
};
- // programme "main" termin� !
+ // programme "main" terminé !
-// routine impl�mentant l'instruction GOTO( CPoint pos )
+// routine implémentant l'instruction GOTO( CPoint pos )
BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
{
if (pVar->GivType() != CBotTypeClass ||
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
+ // 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
- m_PosToGo.Copy( pVar ); // garde la position � atteindre (object type CBotVar)
+ m_PosToGo.Copy( pVar ); // garde la position à atteindre (object type CBotVar)
// ou alors
CBotVar* temp;
- temp = pVar->GivItem("x"); // trouve forc�ment pour un object de type "CPoint"
+ temp = pVar->GivItem("x"); // trouve forcément pour un object de type "CPoint"
ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
m_PosToGo.x = temp->GivValFloat();
- temp = pVar->GivItem("y"); // trouve forc�ment pour un object de type "CPoint"
+ temp = pVar->GivItem("y"); // trouve forcément pour un object de type "CPoint"
ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
m_PosToGo.y = temp->GivValFloat();
@@ -1193,4 +1196,4 @@ BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception ) // rend FALSE s'il faut patienter encore
}
-#endif
+#endif
\ No newline at end of file diff --git a/src/CBot/CBotFunction.cpp b/src/CBot/CBotFunction.cpp index ce61f44..a7fbadc 100644 --- a/src/CBot/CBotFunction.cpp +++ b/src/CBot/CBotFunction.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,17 +12,19 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////
+// compilation des diverses fonctions déclarées par l'utilisateur
+//
#include "CBot.h"
// les divers constructeurs / destructeurs
-// pour lib�rer tout selon l'arbre �tabli
+// pour libérer tout selon l'arbre établi
CBotFunction::CBotFunction()
{
- m_Param = NULL; // liste des param�tres vide
+ m_Param = NULL; // liste des paramètres vide
m_Block = NULL; // le bloc d'instructions
- m_next = NULL; // les fonctions peuvent �tre cha�n�es
+ m_next = NULL; // les fonctions peuvent être chaînées
m_bPublic = FALSE; // fonction non publique
m_bExtern = FALSE; // fonction non externe
m_nextpublic = NULL;
@@ -37,11 +39,11 @@ CBotFunction* CBotFunction::m_listPublic = NULL; CBotFunction::~CBotFunction()
{
- delete m_Param; // liste des param�tres vide
+ delete m_Param; // liste des paramètres vide
delete m_Block; // le bloc d'instructions
delete m_next;
- // enl�ve de la liste publique s'il y a lieu
+ // enlève de la liste publique s'il y a lieu
if ( m_bPublic )
{
if ( m_nextpublic != NULL )
@@ -54,7 +56,7 @@ CBotFunction::~CBotFunction() }
else
{
- // si prev = next = null peut ne pas �tre dans la liste !
+ // si prev = next = null peut ne pas être dans la liste !
if ( m_listPublic == this ) m_listPublic = m_nextpublic;
}
}
@@ -164,8 +166,8 @@ 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
+// 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)
{
CBotToken* pp;
@@ -196,7 +198,7 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct func->m_retToken = *p;
// CBotClass* pClass;
- func->m_retTyp = TypeParam(p, pStk); // type du r�sultat
+ func->m_retTyp = TypeParam(p, pStk); // type du résultat
if (func->m_retTyp.GivType() >= 0)
{
@@ -209,10 +211,10 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct func->m_token = d;
}
- // un nom de fonction est-il l� ?
+ // un nom de fonction est-il là ?
if (IsOfType(p, TokenTypVar))
{
- if ( IsOfType( p, ID_DBLDOTS ) ) // m�thode pour une classe
+ if ( IsOfType( p, ID_DBLDOTS ) ) // méthode pour une classe
{
func->m_MasterClass = pp->GivString();
CBotClass* pClass = CBotClass::Find(pp);
@@ -240,8 +242,8 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct pStk->AddVar(pThis);
// initialise les variables selon This
- // n'enregistre que le pointeur � la premi�re,
- // le reste est chain�
+ // n'enregistre que le pointeur à la première,
+ // le reste est chainé
CBotVar* pv = pThis->GivItemList();
// int num = 1;
while (pv != NULL)
@@ -278,7 +280,7 @@ bad: return pStack->ReturnFunc(NULL, pStk);
}
-// pr�-compile une nouvelle fonction
+// pré-compile une nouvelle fonction
CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass)
{
CBotFunction* func = new CBotFunction();
@@ -302,16 +304,16 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas }
func->m_retToken = *p;
- func->m_retTyp = TypeParam(p, pStack); // type du r�sultat
+ func->m_retTyp = TypeParam(p, pStack); // type du résultat
if (func->m_retTyp.GivType() >= 0)
{
CBotToken* pp = p;
func->m_token = *p;
- // un nom de fonction est-il l� ?
+ // un nom de fonction est-il là ?
if (IsOfType(p, TokenTypVar))
{
- if ( IsOfType( p, ID_DBLDOTS ) ) // m�thode pour une classe
+ if ( IsOfType( p, ID_DBLDOTS ) ) // méthode pour une classe
{
func->m_MasterClass = pp->GivString();
CBotClass* pClass = CBotClass::Find(pp);
@@ -367,14 +369,14 @@ static int xx = 0; BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
{
- CBotStack* pile = pj->AddStack(this, 2); // un bout de pile local � cette fonction
+ CBotStack* pile = pj->AddStack(this, 2); // un bout de pile local à cette fonction
// if ( pile == EOX ) return TRUE;
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();
}
@@ -417,7 +419,7 @@ BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance) void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
{
- CBotStack* pile = pj->RestoreStack(this); // un bout de pile local � cette fonction
+ CBotStack* pile = pj->RestoreStack(this); // un bout de pile local à cette fonction
if ( pile == NULL ) return;
CBotStack* pile2 = pile;
@@ -425,13 +427,13 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst if ( pile->GivBlock() < 2 )
{
- CBotStack* pile2 = pile->RestoreStack(NULL); // un bout de pile local � cette fonction
+ CBotStack* pile2 = pile->RestoreStack(NULL); // un bout de pile local à cette fonction
if ( pile2 == NULL ) return;
pile->SetState(pile->GivState() + pile2->GivState());
pile2->Delete();
}
- m_Param->RestoreState(pile2, TRUE); // les param�tres
+ m_Param->RestoreState(pile2, TRUE); // les paramètres
if ( !m_MasterClass.IsEmpty() )
{
@@ -463,7 +465,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
+// 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)
{
@@ -496,7 +498,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( name == NULL ) return NULL;
int delta = 99999; // cherche la signature la plus faible
- CBotFunction* pFunc = NULL; // la meilleure fonction trouv�e
+ CBotFunction* pFunc = NULL; // la meilleure fonction trouvée
if ( this != NULL )
{
@@ -505,10 +507,10 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pt->m_token.GivString() == name )
{
int i = 0;
- int alpha = 0; // signature des param�tres
- // les param�tres sont-ils compatibles ?
- CBotDefParam* pv = pt->m_Param; // liste des param�tres attendus
- CBotVar* pw = ppVars[i++]; // liste des param�tres fournis
+ int alpha = 0; // signature des paramètres
+ // les paramètres sont-ils compatibles ?
+ CBotDefParam* pv = pt->m_Param; // liste des paramètres attendus
+ CBotVar* pw = ppVars[i++]; // liste des paramètres fournis
while ( pv != NULL && pw != NULL)
{
if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
@@ -517,7 +519,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB break;
}
int d = pv->GivType() - pw->GivType(2);
- alpha += d>0 ? d : -10*d; // perte de qualit�, 10 fois plus cher !!
+ alpha += d>0 ? d : -10*d; // perte de qualité, 10 fois plus cher !!
pv = pv->GivNext();
pw = ppVars[i++];
@@ -527,14 +529,14 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);
- continue; // trop de param�tres
+ continue; // trop de paramètres
}
if ( pv != NULL )
{
if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);
- continue; // pas assez de param�tres
+ continue; // pas assez de paramètres
}
if (alpha == 0) // signature parfaite
@@ -560,10 +562,10 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pt->m_token.GivString() == name )
{
int i = 0;
- int alpha = 0; // signature des param�tres
- // les param�tres sont-ils compatibles ?
- CBotDefParam* pv = pt->m_Param; // liste des param�tres attendus
- CBotVar* pw = ppVars[i++]; // liste des param�tres fournis
+ int alpha = 0; // signature des paramètres
+ // les paramètres sont-ils compatibles ?
+ CBotDefParam* pv = pt->m_Param; // liste des paramètres attendus
+ CBotVar* pw = ppVars[i++]; // liste des paramètres fournis
while ( pv != NULL && pw != NULL)
{
if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
@@ -572,7 +574,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB break;
}
int d = pv->GivType() - pw->GivType(2);
- alpha += d>0 ? d : -10*d; // perte de qualit�, 10 fois plus cher !!
+ alpha += d>0 ? d : -10*d; // perte de qualité, 10 fois plus cher !!
pv = pv->GivNext();
pw = ppVars[i++];
@@ -582,14 +584,14 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);
- continue; // trop de param�tres
+ continue; // trop de paramètres
}
if ( pv != NULL )
{
if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);
- continue; // pas assez de param�tres
+ continue; // pas assez de paramètres
}
if (alpha == 0) // signature parfaite
@@ -618,7 +620,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB }
-// fait un appel � une fonction
+// fait un appel à une fonction
int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken)
{
@@ -632,13 +634,13 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS CBotStack* pStk1 = pStack->AddStack(pt, 2); // pour mettre "this"
// if ( pStk1 == EOX ) return TRUE;
- pStk1->SetBotCall(pt->m_pProg); // on a peut-�tre chang� de module
+ pStk1->SetBotCall(pt->m_pProg); // on a peut-être changé de module
if ( pStk1->IfStep() ) return FALSE;
- CBotStack* pStk3 = pStk1->AddStack(NULL, TRUE); // param�tres
+ CBotStack* pStk3 = pStk1->AddStack(NULL, TRUE); // paramètres
- // pr�pare les param�tres sur la pile
+ // prépare les paramètres sur la pile
if ( pStk1->GivState() == 0 )
{
@@ -664,15 +666,15 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS }
- // initialise les variables selon param�tres
- pt->m_Param->Execute(ppVars, pStk3); // ne peut pas �tre interrompu
+ // initialise les variables selon paramètres
+ pt->m_Param->Execute(ppVars, pStk3); // ne peut pas être interrompu
pStk1->IncState();
}
- // finalement ex�cute la fonction trouv�e
+ // finalement exécute la fonction trouvée
- if ( !pStk3->GivRetVar( // remet le r�sultat sur la pile
+ if ( !pStk3->GivRetVar( // remet le résultat sur la pile
pt->m_Block->Execute(pStk3) )) // GivRetVar dit si c'est interrompu
{
if ( !pStk3->IsOk() && pt->m_pProg != m_pProg )
@@ -680,7 +682,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS #ifdef _DEBUG
if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return FALSE;
#endif
- pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de proc�dure
+ pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure
}
return FALSE; // interrompu !
}
@@ -706,11 +708,11 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, pStk1 = pStack->RestoreStack(pt);
if ( pStk1 == NULL ) return;
- pStk1->SetBotCall(pt->m_pProg); // on a peut-�tre chang� de module
+ pStk1->SetBotCall(pt->m_pProg); // on a peut-être changé de module
if ( pStk1->GivBlock() < 2 )
{
- CBotStack* pStk2 = pStk1->RestoreStack(NULL); // plus utilis�
+ CBotStack* pStk2 = pStk1->RestoreStack(NULL); // plus utilisé
if ( pStk2 == NULL ) return;
pStk3 = pStk2->RestoreStack(NULL);
if ( pStk3 == NULL ) return;
@@ -721,7 +723,7 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, if ( pStk3 == NULL ) return;
}
- // pr�pare les param�tres sur la pile
+ // prépare les paramètres sur la pile
{
if ( !pt->m_MasterClass.IsEmpty() )
@@ -740,7 +742,7 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, return;
}
- // initialise les variables selon param�tres
+ // initialise les variables selon paramètres
pt->m_Param->RestoreState(pStk3, FALSE);
pt->m_Block->RestoreState(pStk3, TRUE);
}
@@ -748,8 +750,8 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, -// fait un appel d'une m�thode
-// note : this est d�j� sur la pile, le pointeur pThis est juste l� pour simplifier
+// fait un appel d'une méthode
+// note : this est déjà sur la pile, le pointeur pThis est juste là pour simplifier
int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass)
{
@@ -765,17 +767,17 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar CBotStack* pStk = pStack->AddStack(pt, 2);
// 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
+ 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
- // pr�pare les param�tres sur la pile
+ // prépare les paramètres sur la pile
if ( pStk->GivState() == 0 )
{
// met la variable "this" sur la pile
CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer);
pthis->Copy(pThis, FALSE);
- pthis->SetUniqNum(-2); // valeur sp�ciale
+ pthis->SetUniqNum(-2); // valeur spéciale
pStk->AddVar(pthis);
CBotClass* pClass = pThis->GivClass()->GivParent();
@@ -783,12 +785,12 @@ 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->SetUniqNum(-3); // valeur sp�ciale
+ psuper->Copy(pThis, FALSE); // en fait identique à "this"
+ psuper->SetUniqNum(-3); // valeur spéciale
pStk->AddVar(psuper);
}
- // initialise les variables selon param�tres
- pt->m_Param->Execute(ppVars, pStk3); // ne peut pas �tre interrompu
+ // initialise les variables selon paramètres
+ pt->m_Param->Execute(ppVars, pStk3); // ne peut pas être interrompu
pStk->IncState();
}
@@ -801,21 +803,21 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar }
pStk->IncState();
}
- // finalement appelle la fonction trouv�e
+ // finalement appelle la fonction trouvée
- if ( !pStk3->GivRetVar( // remet le r�sultat sur la pile
+ if ( !pStk3->GivRetVar( // remet le résultat sur la pile
pt->m_Block->Execute(pStk3) )) // GivRetVar dit si c'est interrompu
{
if ( !pStk3->IsOk() )
{
if ( pt->m_bSynchro )
{
- pClass->Unlock(); // lib�re la fonction
+ pClass->Unlock(); // libère la fonction
}
if ( pt->m_pProg != pProgCurrent )
{
- pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de proc�dure
+ pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure
}
}
return FALSE; // interrompu !
@@ -823,7 +825,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar if ( pt->m_bSynchro )
{
- pClass->Unlock(); // lib�re la fonction
+ pClass->Unlock(); // libère la fonction
}
return pStack->Return( pStk3 );
@@ -840,30 +842,30 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar* pThis, C {
CBotStack* pStk = pStack->RestoreStack(pt);
if ( pStk == NULL ) return;
- pStk->SetBotCall(pt->m_pProg); // on a peut-�tre chang� de module
+ pStk->SetBotCall(pt->m_pProg); // on a peut-être changé de module
CBotVar* pthis = pStk->FindVar("this");
pthis->SetUniqNum(-2);
- CBotStack* pStk3 = pStk->RestoreStack(NULL); // pour mettre les param�tres pass�s
+ CBotStack* pStk3 = pStk->RestoreStack(NULL); // pour mettre les paramètres passés
if ( pStk3 == NULL ) return;
- pt->m_Param->RestoreState(pStk3, TRUE); // les param�tres
+ pt->m_Param->RestoreState(pStk3, TRUE); // les paramètres
- if ( pStk->GivState() > 1 && // v�rouillage est effectif ?
+ if ( pStk->GivState() > 1 && // vérouillage est effectif ?
pt->m_bSynchro )
{
CBotProgram* pProgBase = pStk->GivBotCall(TRUE);
- pClass->Lock(pProgBase); // v�rouille la classe
+ pClass->Lock(pProgBase); // vérouille la classe
}
- // finalement appelle la fonction trouv�e
+ // finalement appelle la fonction trouvée
pt->m_Block->RestoreState(pStk3, TRUE); // interrompu !
}
}
-// regarde si la "signature" des param�tres est identique
+// regarde si la "signature" des paramètres est identique
BOOL CBotFunction::CheckParam(CBotDefParam* pParam)
{
CBotDefParam* pp = m_Param;
@@ -888,7 +890,7 @@ CBotString CBotFunction::GivParams() if ( m_Param == NULL ) return CBotString("()");
CBotString params = "( ";
- CBotDefParam* p = m_Param; // liste des param�tres
+ CBotDefParam* p = m_Param; // liste des paramètres
while (p != NULL)
{
@@ -919,7 +921,7 @@ void CBotFunction::AddPublic(CBotFunction* func) /////////////////////////////////////////////////////////////////////////
-// gestion des param�tres
+// gestion des paramètres
CBotDefParam::CBotDefParam()
@@ -934,11 +936,11 @@ CBotDefParam::~CBotDefParam() }
-// compile une liste de param�tres
+// compile une liste de paramètres
CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
{
// surtout pas de pStack->TokenStack ici
- // les variables d�clar�es doivent rester visibles par la suite
+ // les variables déclarées doivent rester visibles par la suite
pStack->SetStartError(p->GivStart());
@@ -950,12 +952,12 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotDefParam* param = new CBotDefParam();
if (list == NULL) list = param;
- else list->AddNext(param); // ajoute � la liste
+ else list->AddNext(param); // ajoute à la liste
CBotClass* pClass = NULL;//= CBotClass::Find(p);
param->m_typename = p->GivString();
CBotTypResult type = param->m_type = TypeParam(p, pStack);
-// if ( type == CBotTypPointer ) type = CBotTypClass; // il faut cr�er un nouvel objet
+// if ( type == CBotTypPointer ) type = CBotTypClass; // il faut créer un nouvel objet
if (param->m_type.GivType() > 0)
{
@@ -964,7 +966,7 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack) if (pStack->IsOk() && IsOfType(p, TokenTypVar) )
{
- // variable d�j� d�clar�e ?
+ // variable déjà déclarée ?
if (pStack->CheckVarLocal(pp))
{
pStack->SetError(TX_REDEFVAR, pp);
@@ -972,9 +974,9 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack) }
if ( type.Eq(CBotTypArrayPointer) ) type.SetType(CBotTypArrayBody);
- CBotVar* var = CBotVar::Create(pp->GivString(), type); // cr�e la variable
+ CBotVar* var = CBotVar::Create(pp->GivString(), type); // crée la variable
// if ( pClass ) var->SetClass(pClass);
- var->SetInit(2); // la marque initialis�e
+ var->SetInit(2); // la marque initialisée
param->m_nIdent = CBotVar::NextUniqNum();
var->SetUniqNum(param->m_nIdent);
pStack->AddVar(var); // la place sur la pile
@@ -1010,10 +1012,10 @@ BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj) while ( p != NULL )
{
- // cr�e une variable locale sur la pile
+ // crée une variable locale sur la pile
CBotVar* newvar = CBotVar::Create(p->m_token.GivString(), p->m_type);
- // proc�de ainsi pour faire la transformation des types :
+ // procède ainsi pour faire la transformation des types :
if ( ppVars != NULL && ppVars[i] != NULL )
{
switch (p->m_type.GivType())
@@ -1059,7 +1061,7 @@ void CBotDefParam::RestoreState(CBotStack* &pj, BOOL bMain) while ( p != NULL )
{
- // cr�e une variable locale sur la pile
+ // crée une variable locale sur la pile
CBotVar* var = pj->FindVar(p->m_token.GivString());
var->SetUniqNum(p->m_nIdent);
p = p->m_next;
@@ -1095,7 +1097,7 @@ CBotString CBotDefParam::GivParamString() //////////////////////////////////////////////////////////////////////////
-// retour des param�tres
+// retour des paramètres
CBotReturn::CBotReturn()
{
@@ -1114,7 +1116,7 @@ CBotInstr* CBotReturn::Compile(CBotToken* &p, CBotCStack* pStack) if (!IsOfType(p, ID_RETURN)) return NULL; // ne devrait jamais arriver
- CBotReturn* inst = new CBotReturn(); // cr�e l'objet
+ CBotReturn* inst = new CBotReturn(); // crée l'objet
inst->SetToken( pp );
CBotTypResult type = pStack->GivRetType();
@@ -1151,8 +1153,8 @@ BOOL CBotReturn::Execute(CBotStack* &pj) if ( pile->GivState() == 0 )
{
- if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return FALSE; // �value le r�sultat
- // le r�sultat est sur la pile
+ if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return FALSE; // évalue le résultat
+ // le résultat est sur la pile
pile->IncState();
}
@@ -1170,13 +1172,13 @@ void CBotReturn::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile->GivState() == 0 )
{
- if ( m_Instr != NULL ) m_Instr->RestoreState(pile, bMain); // �value le r�sultat
+ if ( m_Instr != NULL ) m_Instr->RestoreState(pile, bMain); // évalue le résultat
return;
}
}
////////////////////////////////////////////////////////////////////////////////
-// Les appels � ces fonctions
+// Les appels à ces fonctions
CBotInstrCall::CBotInstrCall()
{
@@ -1208,11 +1210,11 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack) CBotInstrCall* inst = new CBotInstrCall();
inst->SetToken(pp);
- // compile la liste des param�tres
+ // compile la liste des paramètres
if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE)
{
start = p->GivStart();
- pile = pile->TokenStack(); // garde les r�sultats sur la pile
+ pile = pile->TokenStack(); // garde les résultats sur la pile
CBotInstr* param = CBotExpression::Compile(p, pile);
end = p->GivStart();
@@ -1265,7 +1267,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack) if ( inst->m_typRes.GivType() > 0 )
{
CBotVar* pRes = CBotVar::Create("", inst->m_typRes);
- pStack->SetVar(pRes); // pour conna�tre le type du r�sultat
+ pStack->SetVar(pRes); // pour connaître le type du résultat
}
else pStack->SetVar(NULL); // routine retourne void
@@ -1287,16 +1289,16 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile = pile->AddStack(); // de la place sur la pile pour les r�sultats
+ pile = pile->AddStack(); // de la place sur la pile pour les résultats
if ( pile->GivState() == 0 )
{
if (!p->Execute(pile)) return FALSE; // interrompu ici ?
- pile->SetState(1); // marque sp�ciale pour reconna�re les param�tres
+ pile->SetState(1); // marque spéciale pour reconnaîre les paramètres
}
ppVars[i++] = pile->GivVar();
p = p->GivNext();
@@ -1309,7 +1311,7 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj) if ( !pile2->ExecuteCall(m_nFuncIdent, GivToken(), ppVars, m_typRes)) return FALSE; // interrompu
- return pj->Return(pile2); // lib�re toute la pile
+ return pj->Return(pile2); // libère toute la pile
}
void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -1324,19 +1326,19 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain) int i = 0;
CBotVar* ppVars[1000];
CBotInstr* p = m_Parameters;
- // �value les param�tres
+ // évalue les paramètres
// et place les valeurs sur la pile
- // pour pouvoir �tre interrompu n'importe quand
+ // pour pouvoir être interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile = pile->RestoreStack(); // de la place sur la pile pour les r�sultats
+ pile = pile->RestoreStack(); // de la place sur la pile pour les résultats
if ( pile == NULL ) return;
if ( pile->GivState() == 0 )
{
p->RestoreState(pile, bMain); // interrompu ici !
return;
}
- ppVars[i++] = pile->GivVar(); // construit la liste des param�tres
+ ppVars[i++] = pile->GivVar(); // construit la liste des paramètres
p = p->GivNext();
if ( p == NULL) break;
}
@@ -1349,10 +1351,10 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain) }
//////////////////////////////////////////////////////////////////////////////
-// d�claration des classes par l'utilisateur
+// déclaration des classes par l'utilisateur
-// pr�-compile une nouvelle class
-// l'analyse est compl�te � l'execption du corps des routines
+// pré-compile une nouvelle class
+// l'analyse est complète à l'execption du corps des routines
CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
{
@@ -1373,7 +1375,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack) return NULL;
}
- // un nom pour la classe est-il l� ?
+ // un nom pour la classe est-il là ?
if (IsOfType(p, TokenTypVar))
{
CBotClass* pPapa = NULL;
@@ -1391,8 +1393,8 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack) }
#endif
CBotClass* classe = (pOld == NULL) ? new CBotClass(name, pPapa) : pOld;
- classe->Purge(); // vide les anciennes d�finitions
- classe->m_IsDef = FALSE; // d�finition en cours
+ classe->Purge(); // vide les anciennes définitions
+ classe->m_IsDef = FALSE; // définition en cours
if ( !IsOfType( p, ID_OPBLK) )
{
@@ -1431,7 +1433,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) if ( IsOfType(p, ID_STATIC) ) bStatic = TRUE;
// CBotClass* pClass = NULL;
- type = TypeParam(p, pStack); // type du r�sultat
+ type = TypeParam(p, pStack); // type du résultat
if ( type.Eq(-1) )
{
@@ -1442,7 +1444,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) while (pStack->IsOk())
{
CBotToken* pp = p;
- IsOfType(p, ID_NOT); // saute le ~ �ventuel (destructeur)
+ IsOfType(p, ID_NOT); // saute le ~ éventuel (destructeur)
if (IsOfType(p, TokenTypVar))
{
@@ -1454,7 +1456,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) if ( p->GivType() != ID_CLBRK )
i = CBotExpression::Compile( p, pStack ); // expression pour la valeur
else
- i = new CBotEmpty(); // sp�cial si pas de formule
+ i = new CBotEmpty(); // spécial si pas de formule
type = CBotTypResult(CBotTypArrayPointer, type);
@@ -1490,7 +1492,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) }
else
{
- // retrouve la m�thode pr�compil�e en passe 1
+ // retrouve la méthode précompilée en passe 1
CBotFunction* pf = m_pMethod;
CBotFunction* prev = NULL;
while ( pf != NULL )
@@ -1535,7 +1537,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) my = my->m_pParent;
}
- // compile une m�thode
+ // compile une méthode
p = pBase;
CBotFunction* f =
CBotFunction::Compile(p, pile, NULL/*, FALSE*/);
@@ -1544,7 +1546,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) {
f->m_pProg = pStack->GivBotCall();
f->m_bSynchro = bSynchro;
- // remplace l'�l�ment dans la cha�ne
+ // remplace l'élément dans la chaîne
f->m_next = pf->m_next;
pf->m_next = NULL;
delete pf;
@@ -1557,7 +1559,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) return pStack->IsOk();
}
- // d�finition d'un �l�ment
+ // définition d'un élément
if (type.Eq(0))
{
pStack->SetError(TX_ENDOF, p);
@@ -1573,7 +1575,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) }
else
{
- // il y a une assignation � calculer
+ // il y a une assignation à calculer
i = CBotTwoOpExpr::Compile(p, pStack);
}
if ( !pStack->IsOk() ) return FALSE;
@@ -1594,8 +1596,8 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) if ( pv->IsStatic() && pv->m_InitExpr != NULL )
{
- CBotStack* pile = CBotStack::FirstStack(); // une pile ind�pendante
- while(pile->IsOk() && !pv->m_InitExpr->Execute(pile)); // �value l'expression sans timer
+ CBotStack* pile = CBotStack::FirstStack(); // une pile indépendante
+ while(pile->IsOk() && !pv->m_InitExpr->Execute(pile)); // évalue l'expression sans timer
pv->SetVal( pile->GivVar() ) ;
pile->Delete();
}
@@ -1619,26 +1621,26 @@ CBotClass* CBotClass::Compile(CBotToken* &p, CBotCStack* pStack) CBotString name = p->GivString();
- // un nom pour la classe est-il l� ?
+ // un nom pour la classe est-il là ?
if (IsOfType(p, TokenTypVar))
{
- // la classe � �t� cr��e par Compile1
+ // la classe à été créée par Compile1
CBotClass* pOld = CBotClass::Find(name);
#if EXTENDS
if ( IsOfType( p, ID_EXTENDS ) )
{
- IsOfType(p, TokenTypVar); // forc�ment
+ IsOfType(p, TokenTypVar); // forcément
}
#endif
- IsOfType( p, ID_OPBLK); // forc�ment
+ IsOfType( p, ID_OPBLK); // forcément
while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )
{
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);
diff --git a/src/CBot/CBotIf.cpp b/src/CBot/CBotIf.cpp index 797c059..626ef0d 100644 --- a/src/CBot/CBotIf.cpp +++ b/src/CBot/CBotIf.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////
+// instruction if (condition) opération1 else opération2;
#include "CBot.h"
@@ -27,23 +28,23 @@ CBotIf::CBotIf() CBotIf::~CBotIf()
{
- delete m_Condition; // lib�re la condition
- delete m_Block; // lib�re le bloc d'instruction1
- delete m_BlockElse; // lib�re le bloc d'instruction2
+ delete m_Condition; // libère la condition
+ delete m_Block; // libère le bloc d'instruction1
+ delete m_BlockElse; // libère le bloc d'instruction2
}
// compilation (routine statique)
-// appel� lorsque le token "if" a �t� trouv�
+// appelé lorsque le token "if" a été trouvé
CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotToken* pp = p; // conserve le ^au token (d�but instruction)
+ CBotToken* pp = p; // conserve le ^au token (début instruction)
if (!IsOfType(p, ID_IF)) return NULL; // ne doit jamais arriver
CBotCStack* pStk = pStack->TokenStack(pp); // un petit bout de pile svp
- CBotIf* inst = new CBotIf(); // cr�e l'object
+ CBotIf* inst = new CBotIf(); // crée l'object
inst->SetToken( pp );
if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )
@@ -53,7 +54,7 @@ CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
if ( pStk->IsOk() )
{
- // le bloc d'instruction est ok (peut �tre vide)
+ // le bloc d'instruction est ok (peut être vide)
// regarde si l'instruction suivante est le token "else"
if (IsOfType(p, ID_ELSE))
@@ -62,57 +63,57 @@ CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_BlockElse = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
if (!pStk->IsOk())
{
- // il n'y a pas de bloc correct apr�s le else
- // lib�re l'objet, et transmet l'erreur qui est sur la pile
+ // il n'y a pas de bloc correct après le else
+ // libère l'objet, et transmet l'erreur qui est sur la pile
delete inst;
return pStack->Return(NULL, pStk);
}
}
- // rend l'object correct � qui le demande.
+ // rend l'object correct à qui le demande.
return pStack->Return(inst, pStk);
}
}
- // erreur, lib�re l'objet
+ // erreur, libère l'objet
delete inst;
// et transmet l'erreur qui se trouve sur la pile.
return pStack->Return(NULL, pStk);
}
-// ex�cution de l'instruction
+// exécution de l'instruction
BOOL CBotIf :: Execute(CBotStack* &pj)
{
- CBotStack* pile = pj->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE;
if ( pile->IfStep() ) return FALSE;
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
if( pile->GivState() == 0 )
{
- // �value la condition
+ // évalue la condition
if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ?
// termine s'il y a une erreur
if ( !pile->IsOk() )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
- // passe dans le second �tat
- if (!pile->SetState(1)) return FALSE; // pr�t pour la suite
+ // passe dans le second état
+ 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
+ // 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
+ if ( m_Block != NULL && // bloc peut être absent
!m_Block->Execute(pile) ) return FALSE; // interrompu ici ?
}
else
@@ -121,7 +122,7 @@ BOOL CBotIf :: Execute(CBotStack* &pj) !m_BlockElse->Execute(pile) ) return FALSE; // interrompu ici
}
- // transmet le r�sultat et lib�re la pile
+ // transmet le résultat et libère la pile
return pj->Return(pile);
}
@@ -130,23 +131,23 @@ void CBotIf :: RestoreState(CBotStack* &pj, BOOL bMain) {
if ( !bMain ) return;
- CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile
if ( pile == NULL ) return;
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
if( pile->GivState() == 0 )
{
- // �value la condition
+ // évalue la condition
m_Condition->RestoreState(pile, bMain); // interrompu ici !
return;
}
- // second �tat, �value les instructions associ�es
- // le r�sultat de la condition est sur la pile
+ // 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
+ if ( m_Block != NULL ) // bloc peut être absent
m_Block->RestoreState(pile, bMain); // interrompu ici !
}
else
diff --git a/src/CBot/CBotProgram.cpp b/src/CBot/CBotProgram.cpp index a32d51b..f157c4c 100644 --- a/src/CBot/CBotProgram.cpp +++ b/src/CBot/CBotProgram.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.//////////////////////////////////////////////////////////////////////
+// gestion de base d'un programme CBot
#include "CBot.h"
#include <stdio.h>
@@ -67,8 +68,8 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, Stop();
// delete m_pClass;
- m_pClass->Purge(); // purge les anciennes d�finitions des classes
- // mais sans d�truire l'object
+ m_pClass->Purge(); // purge les anciennes définitions des classes
+ // mais sans détruire l'object
m_pClass = NULL;
delete m_Prog; m_Prog= NULL;
@@ -84,12 +85,12 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, CBotCStack* pStack = new CBotCStack(NULL);
- CBotToken* p = pBaseToken->GivNext(); // saute le 1er token (s�parateur)
+ CBotToken* p = pBaseToken->GivNext(); // saute le 1er token (séparateur)
- pStack->SetBotCall(this); // d�fini les routines utilisables
+ pStack->SetBotCall(this); // défini les routines utilisables
CBotCall::SetPUser(pUser);
- // fait une premi�re passe rapide juste pour prendre les ent�tes de routines et de classes
+ // fait une première passe rapide juste pour prendre les entêtes de routines et de classes
while ( pStack->IsOk() && p != NULL && p->GivType() != 0)
{
if ( IsOfType(p, ID_SEP) ) continue; // des point-virgules qui trainent
@@ -120,7 +121,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, // CBotFunction* temp = NULL;
CBotFunction* next = m_Prog; // reprend la liste
- p = pBaseToken->GivNext(); // revient au d�but
+ p = pBaseToken->GivNext(); // revient au début
while ( pStack->IsOk() && p != NULL && p->GivType() != 0 )
{
@@ -130,7 +131,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))
{
m_bCompileClass = TRUE;
- CBotClass::Compile(p, pStack); // compl�te la d�finition de la classe
+ CBotClass::Compile(p, pStack); // complète la définition de la classe
}
else
{
@@ -142,7 +143,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, }
}
-// delete m_Prog; // la liste de la 1�re passe
+// delete m_Prog; // la liste de la 1ère passe
// m_Prog = temp; // la liste de la seconde passe
if ( !pStack->IsOk() )
@@ -184,12 +185,12 @@ BOOL CBotProgram::Start(const char* name) #if STACKMEM
m_pStack = CBotStack::FirstStack();
#else
- m_pStack = new CBotStack(NULL); // cr�e une pile d'ex�cution
+ m_pStack = new CBotStack(NULL); // crée une pile d'exécution
#endif
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)
@@ -217,13 +218,13 @@ BOOL CBotProgram::Run(void* pUser, int timer) if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL)
pUser = m_pInstance->m_pUserPtr;
- m_pStack->Reset(pUser); // vide l'�ventuelle erreur pr�c�dente, et remet le timer
+ m_pStack->Reset(pUser); // vide l'éventuelle erreur précédente, et remet le timer
if ( timer >= 0 ) m_pStack->SetTimer(timer);
m_pStack->SetBotCall(this); // bases pour les routines
#if STACKRUN
- // reprend l'ex�cution sur le haut de la pile
+ // reprend l'exécution sur le haut de la pile
ok = m_pStack->Execute();
if ( ok )
{
@@ -234,7 +235,7 @@ BOOL CBotProgram::Run(void* pUser, int timer) ppVar[2] = NULL;
ok = m_pRun->Execute(ppVar, m_pStack, m_pInstance);
#else
- // revient sur l'ex�cution normale
+ // revient sur l'exécution normale
ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);
#endif
}
@@ -242,7 +243,7 @@ BOOL CBotProgram::Run(void* pUser, int timer) ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);
#endif
- // termin� sur une erreur ?
+ // terminé sur une erreur ?
if (!ok && !m_pStack->IsOk())
{
m_ErrorCode = m_pStack->GivError(m_ErrorStart, m_ErrorEnd);
@@ -252,10 +253,10 @@ 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
+ if ( ok ) m_pRun = NULL; // plus de fonction en exécution
return ok;
error:
@@ -345,7 +346,7 @@ CBotString CBotProgram::GivErrorText(int code) if (TextError.IsEmpty())
{
char buf[100];
- sprintf(buf, "Exception num�ro %d.", code);
+ sprintf(buf, "Exception numéro %d.", code);
TextError = buf;
}
return TextError;
@@ -361,7 +362,7 @@ 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
+ // mémorise les pointeurs aux deux fonctions
return CBotCall::AddFunction(name, rExec, rCompile);
}
@@ -544,12 +545,12 @@ BOOL CBotProgram::RestoreState(FILE* pf) #endif
m_pStack = NULL;
- // r�cup�re la pile depuis l'enregistrement
- // utilise un pointeur NULL (m_pStack) mais c'est ok comme �a
+ // 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;
m_pStack->SetBotCall(this); // bases pour les routines
- // r�tabli certains �tats dans la pile selon la structure
+ // rétabli certains états dans la pile selon la structure
m_pRun->RestoreState(NULL, m_pStack, m_pInstance);
return TRUE;
}
@@ -597,16 +598,16 @@ BOOL CBotCall::AddFunction(const char* name, {
if ( p->GivName() == name )
{
- // lib�re une fonction qu'on red�fini
+ // libère une fonction qu'on redéfini
if ( pp ) pp->m_next = p->m_next;
else m_ListCalls = p->m_next;
pp = p;
p = p->m_next;
- pp->m_next = NULL; // ne pas d�truire la suite de la liste
+ pp->m_next = NULL; // ne pas détruire la suite de la liste
delete pp;
continue;
}
- pp = p; // pointeur pr�c�dent
+ pp = p; // pointeur précédent
p = p->m_next;
}
@@ -620,7 +621,7 @@ BOOL CBotCall::AddFunction(const char* name, // transforme le tableau de pointeurs aux variables
-// en une liste de variables cha�n�es
+// en une liste de variables chaînées
CBotVar* MakeListVars(CBotVar** ppVars, BOOL bSetVal=FALSE)
{
int i = 0;
@@ -644,8 +645,8 @@ CBotVar* MakeListVars(CBotVar** ppVars, BOOL bSetVal=FALSE) return pVar;
}
-// trouve un appel acceptable selon le nom de la proc�dure
-// et les param�tres donn�s
+// trouve un appel acceptable selon le nom de la procédure
+// et les paramètres donnés
CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack* pStack, long& nIdent)
{
@@ -662,7 +663,7 @@ CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack* CBotTypResult r = pt->m_rComp(pVar2, m_pUser);
int ret = r.GivType();
- // si une classe est retourn�e, c'est en fait un pointeur
+ // si une classe est retournée, c'est en fait un pointeur
if ( ret == CBotTypClass ) r.SetType( ret = CBotTypPointer );
if ( ret > 20 )
@@ -743,19 +744,19 @@ int CBotCall::DoCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* fund:
#if !STACKRUN
- // fait la liste des param�tres selon le contenu de la pile (pStackVar)
+ // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVar, TRUE);
CBotVar* pVarToDelete = pVar;
- // cr�e une variable pour le r�sultat
+ // crée une variable pour le résultat
CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);
CBotVar* pRes = pResult;
int Exception = 0;
int res = pt->m_rExec(pVar, pResult, Exception, pStack->GivPUser());
- if ( pResult != pRes ) delete pRes; // si r�sultat diff�rent rendu
+ if ( pResult != pRes ) delete pRes; // si résultat différent rendu
delete pVarToDelete;
if (res == FALSE)
@@ -781,12 +782,12 @@ fund: CBotStack* pile = pStack->AddStackEOX(pt);
if ( pile == EOX ) return TRUE;
- // fait la liste des param�tres selon le contenu de la pile (pStackVar)
+ // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVar, TRUE);
CBotVar* pVarToDelete = pVar;
- // cr�e une variable pour le r�sultat
+ // crée une variable pour le résultat
CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);
pile->SetVar( pVar );
@@ -847,12 +848,12 @@ BOOL CBotCall::Run(CBotStack* pStack) {
pStack->SetError(Exception);
}
- if ( pResult != pRes ) delete pResult; // si r�sultat diff�rent rendu
+ if ( pResult != pRes ) delete pResult; // si résultat différent rendu
return FALSE;
}
if ( pResult != NULL ) pStack->SetCopyVar( pResult );
- if ( pResult != pRes ) delete pResult; // si r�sultat diff�rent rendu
+ if ( pResult != pRes ) delete pResult; // si résultat différent rendu
return TRUE;
}
@@ -878,8 +879,8 @@ CBotCallMethode::~CBotCallMethode() m_next = NULL;
}
-// trouve un appel acceptable selon le nom de la proc�dure
-// et les param�tres donn�s
+// trouve un appel acceptable selon le nom de la procédure
+// et les paramètres donnés
CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis,
CBotVar** ppVar, CBotCStack* pStack,
@@ -939,7 +940,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot {
if ( pt->m_nFuncIdent == nIdent )
{
- // fait la liste des param�tres selon le contenu de la pile (pStackVar)
+ // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVars, TRUE);
CBotVar* pVarToDelete = pVar;
@@ -972,7 +973,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot {
if ( pt->m_name == name )
{
- // fait la liste des param�tres selon le contenu de la pile (pStackVar)
+ // fait la liste des paramètres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVars, TRUE);
CBotVar* pVarToDelete = pVar;
@@ -1038,10 +1039,10 @@ BOOL rCBotDebug( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser )
{
- // pas de param�tre
+ // pas de paramètre
if ( pVar != NULL ) return CBotTypResult( TX_OVERPARAM );
- // la fonction retourne un r�sultat "string"
+ // la fonction retourne un résultat "string"
return CBotTypResult( CBotTypString );
}
@@ -1050,10 +1051,10 @@ CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser ) void CBotProgram::Init()
{
- CBotToken::DefineNum( "CBotErrOpenPar", 5000) ; // manque la parenth�se ouvrante
- CBotToken::DefineNum( "CBotErrClosePar", 5001) ; // manque la parenth�se fermante
- CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ; // l'expression doit �tre un boolean
- CBotToken::DefineNum( "CBotErrUndefVar", 5003) ; // variable non d�clar�e
+ CBotToken::DefineNum( "CBotErrOpenPar", 5000) ; // manque la parenthèse ouvrante
+ CBotToken::DefineNum( "CBotErrClosePar", 5001) ; // manque la parenthèse fermante
+ CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ; // l'expression doit être un boolean
+ CBotToken::DefineNum( "CBotErrUndefVar", 5003) ; // variable non déclarée
CBotToken::DefineNum( "CBotErrBadLeft", 5004) ; // assignation impossible ( 5 = ... )
CBotToken::DefineNum( "CBotErrNoTerminator", 5005) ;// point-virgule attendu
CBotToken::DefineNum( "CBotErrCaseOut", 5006) ; // case en dehors d'un switch
@@ -1061,8 +1062,8 @@ void CBotProgram::Init() CBotToken::DefineNum( "CBotErrElseWhitoutIf", 5009) ;// else sans if correspondant
CBotToken::DefineNum( "CBotErrOpenBlock", 5010) ; // manque " { "
CBotToken::DefineNum( "CBotErrBadType1", 5011) ; // mauvais type pour l'assignation
- CBotToken::DefineNum( "CBotErrRedefVar", 5012) ; // red�finition de la variable
- CBotToken::DefineNum( "CBotErrBadType2", 5013) ; // 2 op�randes de type incompatibles
+ CBotToken::DefineNum( "CBotErrRedefVar", 5012) ; // redéfinition de la variable
+ CBotToken::DefineNum( "CBotErrBadType2", 5013) ; // 2 opérandes de type incompatibles
CBotToken::DefineNum( "CBotErrUndefCall", 5014) ; // routine inconnue
CBotToken::DefineNum( "CBotErrNoDoubleDots", 5015) ;// " : " attendu
CBotToken::DefineNum( "CBotErrBreakOutside", 5017) ;// break en dehors d'une boucle
@@ -1071,28 +1072,28 @@ void CBotProgram::Init() CBotToken::DefineNum( "CBotErrNoCase", 5020) ; // manque " case "
CBotToken::DefineNum( "CBotErrBadNum", 5021) ; // nombre attendu
CBotToken::DefineNum( "CBotErrVoid", 5022) ; // " void " pas possible ici
- CBotToken::DefineNum( "CBotErrNoType", 5023) ; // d�claration de type attendue
+ CBotToken::DefineNum( "CBotErrNoType", 5023) ; // déclaration de type attendue
CBotToken::DefineNum( "CBotErrNoVar", 5024) ; // nom de variable attendu
CBotToken::DefineNum( "CBotErrNoFunc", 5025) ; // nom de fonction attendu
- CBotToken::DefineNum( "CBotErrOverParam", 5026) ; // trop de param�tres
- CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ; // cette fonction existe d�j�
- CBotToken::DefineNum( "CBotErrLowParam", 5028) ; // pas assez de param�tres
- CBotToken::DefineNum( "CBotErrBadParam", 5029) ; // mauvais types de param�tres
- CBotToken::DefineNum( "CBotErrNbParam", 5030) ; // mauvais nombre de param�tres
- CBotToken::DefineNum( "CBotErrUndefItem", 5031) ; // �l�ment n'existe pas dans la classe
+ CBotToken::DefineNum( "CBotErrOverParam", 5026) ; // trop de paramètres
+ CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ; // cette fonction existe déjà
+ CBotToken::DefineNum( "CBotErrLowParam", 5028) ; // pas assez de paramètres
+ CBotToken::DefineNum( "CBotErrBadParam", 5029) ; // mauvais types de paramètres
+ CBotToken::DefineNum( "CBotErrNbParam", 5030) ; // mauvais nombre de paramètres
+ CBotToken::DefineNum( "CBotErrUndefItem", 5031) ; // élément n'existe pas dans la classe
CBotToken::DefineNum( "CBotErrUndefClass", 5032) ; // variable n'est pas une classe
- CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ; // pas de constructeur appropri�
- CBotToken::DefineNum( "CBotErrRedefClass", 5034) ; // classe existe d�j�
+ CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ; // pas de constructeur approprié
+ CBotToken::DefineNum( "CBotErrRedefClass", 5034) ; // classe existe déjà
CBotToken::DefineNum( "CBotErrCloseIndex", 5035) ; // " ] " attendu
- CBotToken::DefineNum( "CBotErrReserved", 5036) ; // mot r�serv� (par un DefineNum)
+ CBotToken::DefineNum( "CBotErrReserved", 5036) ; // mot réservé (par un DefineNum)
-// voici la liste des erreurs pouvant �tre retourn�es par le module
-// pour l'ex�cution
+// voici la liste des erreurs pouvant être retournées par le module
+// pour l'exécution
- CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ; // division par z�ro
- CBotToken::DefineNum( "CBotErrNotInit", 6001) ; // variable non initialis�e
- CBotToken::DefineNum( "CBotErrBadThrow", 6002) ; // throw d'une valeur n�gative
- CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ; // fonction n'a pas retourn� de r�sultat
+ CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ; // division par zéro
+ CBotToken::DefineNum( "CBotErrNotInit", 6001) ; // variable non initialisée
+ CBotToken::DefineNum( "CBotErrBadThrow", 6002) ; // throw d'une valeur négative
+ CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ; // fonction n'a pas retourné de résultat
CBotToken::DefineNum( "CBotErrNoRun", 6004) ; // Run() sans fonction active
CBotToken::DefineNum( "CBotErrUndefFunc", 6005) ; // appel d'une fonction qui n'existe plus
diff --git a/src/CBot/CBotStack.cpp b/src/CBot/CBotStack.cpp index 5c3e2ef..b97c2fd 100644 --- a/src/CBot/CBotStack.cpp +++ b/src/CBot/CBotStack.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.//////////////////////////////////////////////////////////////////////
+// gestion de la pile (stack)
#include "CBot.h"
@@ -20,7 +21,7 @@ #define ITIMER 100
////////////////////////////////////////////////////////////////////////////
-// gestion de la pile d'ex�cution
+// gestion de la pile d'exécution
////////////////////////////////////////////////////////////////////////////
int CBotStack::m_initimer = ITIMER; // init la variable statique
@@ -41,14 +42,14 @@ CBotStack* CBotStack::FirstStack() long size = sizeof(CBotStack);
size *= (MAXSTACK+10);
- // demande une tranche m�moire pour la pile
+ // demande une tranche mémoire pour la pile
p = (CBotStack*)malloc(size);
// la vide totalement
memset(p, 0, size);
p-> m_bBlock = TRUE;
- m_timer = m_initimer; // met le timer au d�but
+ m_timer = m_initimer; // met le timer au début
CBotStack* pp = p;
pp += MAXSTACK;
@@ -67,19 +68,19 @@ CBotStack* CBotStack::FirstStack() }
#endif
- m_error = 0; // �vite des blocages car m_error est static
+ m_error = 0; // évite des blocages car m_error est static
return p;
}
CBotStack::CBotStack(CBotStack* ppapa)
{
- // constructeur doit exister, sinon le destructeur n'est jamais appel� !
+ // constructeur doit exister, sinon le destructeur n'est jamais appelé !
__asm int 3;
}
CBotStack::~CBotStack()
{
- __asm int 3; // utiliser Delete() � la place
+ __asm int 3; // utiliser Delete() à la place
}
void CBotStack::Delete()
@@ -92,10 +93,10 @@ void CBotStack::Delete() if (m_prev != NULL)
{
if ( m_prev->m_next == this )
- m_prev->m_next = NULL; // enl�ve de la cha�ne
+ m_prev->m_next = NULL; // enlève de la chaîne
if ( m_prev->m_next2 == this )
- m_prev->m_next2 = NULL; // enl�ve de la cha�ne
+ m_prev->m_next2 = NULL; // enlève de la chaîne
}
delete m_var;
@@ -107,7 +108,7 @@ void CBotStack::Delete() int n = m_index;
#endif
- // efface le bloc lib�r�
+ // efface le bloc libéré
memset(this, 0, sizeof(CBotStack));
m_bOver = bOver;
#ifdef _DEBUG
@@ -119,7 +120,7 @@ void CBotStack::Delete() }
-// routine optimis�e
+// routine optimisée
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
{
if (m_next != NULL)
@@ -140,7 +141,7 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock) }
while ( p->m_prev != NULL );
- m_next = p; // cha�ne l'�l�ment
+ m_next = p; // chaîne l'élément
p->m_bBlock = bBlock;
p->m_instr = instr;
p->m_prog = m_prog;
@@ -165,7 +166,7 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock) }
CBotStack* p = AddStack(NULL, bBlock);
p->m_call = instr;
- p->m_bFunc = 2; // sp�cial
+ p->m_bFunc = 2; // spécial
return p;
}
@@ -173,7 +174,7 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) {
if (m_next2 != NULL)
{
- m_next2->m_prog = m_prog; // sp�cial �vite un RestoreStack2
+ m_next2->m_prog = m_prog; // spécial évite un RestoreStack2
return m_next2; // reprise dans une pile existante
}
@@ -184,7 +185,7 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) }
while ( p->m_prev != NULL );
- m_next2 = p; // cha�ne l'�l�ment
+ m_next2 = p; // chaîne l'élément
p->m_prev = this;
p->m_bBlock = bBlock;
p->m_prog = m_prog;
@@ -199,13 +200,13 @@ BOOL CBotStack::GivBlock() 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
- pfils->m_var = NULL; // ne pas d�truire la variable
+ if (m_var != NULL) delete m_var; // valeur remplacée ?
+ m_var = pfils->m_var; // résultat transmis
+ pfils->m_var = NULL; // ne pas détruire la variable
- m_next->Delete();m_next = NULL; // lib�re la pile au dessus
+ m_next->Delete();m_next = NULL; // libère la pile au dessus
m_next2->Delete();m_next2 = NULL; // aussi la seconde pile (catch)
return (m_error == 0); // interrompu si erreur
@@ -213,11 +214,11 @@ BOOL CBotStack::Return(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
- pfils->m_var = NULL; // ne pas d�truire la variable
+ if (m_var != NULL) delete m_var; // valeur remplacée ?
+ m_var = pfils->m_var; // résultat transmis
+ pfils->m_var = NULL; // ne pas détruire la variable
return (m_error == 0); // interrompu si erreur
}
@@ -242,7 +243,7 @@ CBotStack::CBotStack(CBotStack* ppapa) m_state = 0;
m_step = 1;
- if (ppapa == NULL) m_timer = m_initimer; // met le timer au d�but
+ if (ppapa == NULL) m_timer = m_initimer; // met le timer au début
m_listVar = NULL;
m_bDontDelete = FALSE;
@@ -260,13 +261,13 @@ CBotStack::~CBotStack() if ( m_next != EOX) delete m_next;
delete m_next2;
if (m_prev != NULL && m_prev->m_next == this )
- m_prev->m_next = NULL; // enl�ve de la cha�ne
+ m_prev->m_next = NULL; // enlève de la chaîne
delete m_var;
if ( !m_bDontDelete ) delete m_listVar;
}
-// routine � optimiser
+// routine à optimiser
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
{
if (m_next != NULL)
@@ -274,7 +275,7 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock) return m_next; // reprise dans une pile existante
}
CBotStack* p = new CBotStack(this);
- m_next = p; // cha�ne l'�l�ment
+ m_next = p; // chaîne l'élément
p->m_bBlock = bBlock;
p->m_instr = instr;
p->m_prog = m_prog;
@@ -294,12 +295,12 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock) return m_next; // reprise dans une pile existante
}
CBotStack* p = new CBotStack(this);
- m_next = p; // cha�ne l'�l�ment
+ m_next = p; // chaîne l'élément
p->m_bBlock = bBlock;
p->m_call = instr;
p->m_prog = m_prog;
p->m_step = 0;
- p->m_bFunc = 2; // sp�cial
+ p->m_bFunc = 2; // spécial
return p;
}
@@ -307,12 +308,12 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) {
if (m_next2 != NULL)
{
- m_next2->m_prog = m_prog; // sp�cial �vite un RestoreStack2
+ m_next2->m_prog = m_prog; // spécial évite un RestoreStack2
return m_next2; // reprise dans une pile existante
}
CBotStack* p = new CBotStack(this);
- m_next2 = p; // cha�ne l'�l�ment
+ m_next2 = p; // chaîne l'élément
p->m_bBlock = bBlock;
p->m_prog = m_prog;
p->m_step = 0;
@@ -322,13 +323,13 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) 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
- pfils->m_var = NULL; // ne pas d�truite la variable
+ if (m_var != NULL) delete m_var; // valeur remplacée ?
+ m_var = pfils->m_var; // résultat transmis
+ pfils->m_var = NULL; // ne pas détruite la variable
- if ( m_next != EOX ) delete m_next; // lib�re la pile au dessus
+ if ( m_next != EOX ) delete m_next; // libère la pile au dessus
delete m_next2;m_next2 = NULL; // aussi la seconde pile (catch)
return (m_error == 0); // interrompu si erreur
@@ -336,7 +337,7 @@ BOOL CBotStack::Return(CBotStack* pfils) 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
@@ -358,7 +359,7 @@ CBotStack* CBotStack::RestoreStack(CBotInstr* instr) {
if (m_next != NULL)
{
- m_next->m_instr = instr; // r�init (si reprise apr�s restitution)
+ m_next->m_instr = instr; // réinit (si reprise après restitution)
m_next->m_prog = m_prog;
return m_next; // reprise dans une pile existante
}
@@ -374,7 +375,7 @@ CBotStack* CBotStack::RestoreStackEOX(CBotCall* instr) -// routine pour l'ex�cution pas � pas
+// routine pour l'exécution pas à pas
BOOL CBotStack::IfStep()
{
if ( m_initimer > 0 || m_step++ > 0 ) return FALSE;
@@ -402,7 +403,7 @@ BOOL CBotStack::IfContinue(int state, const char* name) if (!m_labelBreak.IsEmpty() && (name == NULL || m_labelBreak != name))
return FALSE; // c'est pas pour moi
- m_state = state; // o� reprendre ?
+ m_state = state; // où reprendre ?
m_error = 0;
m_labelBreak.Empty();
if ( m_next != EOX ) m_next->Delete(); // purge la pile au dessus
@@ -411,7 +412,7 @@ BOOL CBotStack::IfContinue(int state, const char* name) void CBotStack::SetBreak(int val, const char* name)
{
- m_error = -val; // r�agit comme une Exception
+ m_error = -val; // réagit comme une Exception
m_labelBreak = name;
if (val == 3) // pour un return
{
@@ -420,7 +421,7 @@ void CBotStack::SetBreak(int val, const char* name) }
}
-// remet sur la pile la valeur calcul�e par le dernier CBotReturn
+// remet sur la pile la valeur calculée par le dernier CBotReturn
BOOL CBotStack::GivRetVar(BOOL bRet)
{
@@ -466,7 +467,7 @@ void CBotStack::SetType(CBotTypResult& type) // trouve une variable par son token
-// ce peut �tre une variable compos�e avec un point
+// ce peut être une variable composée avec un point
CBotVar* CBotStack::FindVar(CBotToken* &pToken, BOOL bUpdate, BOOL bModif)
{
CBotStack* p = this;
@@ -510,7 +511,7 @@ CBotVar* CBotStack::FindVar(const char* name) return NULL;
}
-// retrouve une variable sur la pile selon son num�ro d'identification
+// retrouve une variable sur la pile selon son numéro d'identification
// ce qui va plus vite que de comparer les noms.
CBotVar* CBotStack::FindVar(long ident, BOOL bUpdate, BOOL bModif)
@@ -559,22 +560,22 @@ BOOL CBotStack::SetState(int n, int limite) {
m_state = n;
- m_timer--; // d�compte les op�rations
- return ( m_timer > limite ); // interrompu si timer pass�
+ m_timer--; // décompte les opérations
+ return ( m_timer > limite ); // interrompu si timer passé
}
BOOL CBotStack::IncState(int limite)
{
m_state++;
- m_timer--; // d�compte les op�rations
- return ( m_timer > limite ); // interrompu si timer pass�
+ m_timer--; // décompte les opérations
+ return ( m_timer > limite ); // interrompu si timer passé
}
void CBotStack::SetError(int n, CBotToken* token)
{
- if ( n!= 0 && m_error != 0) return; // ne change pas une erreur d�j� existante
+ if ( n!= 0 && m_error != 0) return; // ne change pas une erreur déjà existante
m_error = n;
if (token != NULL)
{
@@ -603,7 +604,7 @@ void CBotStack::SetTimer(int n) BOOL CBotStack::Execute()
{
- CBotCall* instr = NULL; // instruction la plus �lev�e
+ CBotCall* instr = NULL; // instruction la plus élevée
CBotStack* pile;
CBotStack* p = this;
@@ -619,9 +620,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();
@@ -629,11 +630,11 @@ BOOL CBotStack::Execute() delete pile->m_next;
#endif
- pile->m_next = EOX; // sp�cial pour reprise
+ pile->m_next = EOX; // spécial pour reprise
return TRUE;
}
-// met sur le stack le pointeur � une variable
+// met sur le stack le pointeur à une variable
void CBotStack::SetVar( CBotVar* var )
{
if (m_var) delete m_var; // remplacement d'une variable
@@ -657,7 +658,7 @@ CBotVar* CBotStack::GivVar() CBotVar* CBotStack::GivPtVar()
{
CBotVar* p = m_var;
- m_var = NULL; // ne sera pas d�truit donc
+ m_var = NULL; // ne sera pas détruit donc
return p;
}
@@ -682,7 +683,7 @@ void CBotStack::AddVar(CBotVar* pVar) {
CBotStack* p = this;
- // revient sur l'�lement p�re
+ // revient sur l'élement père
while (p != NULL && p->m_bBlock == 0) p = p->m_prev;
if ( p == NULL ) return;
@@ -692,7 +693,7 @@ void CBotStack::AddVar(CBotVar* pVar) CBotVar** pp = &p->m_listVar;
while ( *pp != NULL ) pp = &(*pp)->m_next;
- *pp = pVar; // ajoute � la suite
+ *pp = pVar; // ajoute à la suite
#ifdef _DEBUG
if ( pVar->GivUniqNum() == 0 ) __asm int 3;
@@ -738,7 +739,7 @@ BOOL CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBo res = m_prog->GivFunctions()->DoCall(nIdent, NULL, ppVar, this, token );
if (res.GivType() >= 0) return res.GivType();
- // si pas trouv� (recompil� ?) cherche selon le nom
+ // si pas trouvé (recompilé ?) cherche selon le nom
nIdent = 0;
res = CBotCall::DoCall(nIdent, token, ppVar, this, rettype );
@@ -769,7 +770,7 @@ BOOL SaveVar(FILE* pf, CBotVar* pVar) return WriteWord(pf, 0); // met un terminateur
}
- if ( !pVar->Save0State(pf)) return FALSE; // ent�te commune
+ if ( !pVar->Save0State(pf)) return FALSE; // entête commune
if ( !pVar->Save1State(pf) ) return FALSE; // sauve selon la classe fille
pVar = pVar->GivNext();
@@ -780,8 +781,8 @@ void CBotStack::GetRunPos(const char* &FunctionName, int &start, int &end) {
CBotProgram* prog = m_prog; // programme courrant
- CBotInstr* funct = NULL; // fonction trouv�e
- CBotInstr* instr = NULL; // instruction la plus �lev�e
+ CBotInstr* funct = NULL; // fonction trouvée
+ CBotInstr* instr = NULL; // instruction la plus élevée
CBotStack* p = this;
@@ -827,7 +828,7 @@ CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level) }
- // descend sur les �l�ments de block
+ // descend sur les éléments de block
while ( p != NULL && !p->m_bBlock ) p = p->m_prev;
while ( p != NULL && level++ < 0 )
@@ -871,12 +872,12 @@ BOOL CBotStack::SaveState(FILE* pf) 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_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_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
@@ -906,13 +907,13 @@ BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack) 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 ?
- pStack->SetState((short)w); // dans le bon �tat
+ 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 ?
- // plus utilis�
+ // 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
@@ -924,10 +925,10 @@ BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack) BOOL CBotVar::Save0State(FILE* pf)
{
- if (!WriteWord(pf, 100+m_mPrivate))return FALSE; // variable priv�e ?
+ if (!WriteWord(pf, 100+m_mPrivate))return FALSE; // variable privée ?
if (!WriteWord(pf, m_bStatic))return FALSE; // variable static ?
if (!WriteWord(pf, m_type.GivType()))return FALSE; // enregiste le type (toujours non nul)
- if (!WriteWord(pf, m_binit))return FALSE; // variable d�finie ?
+ if (!WriteWord(pf, m_binit))return FALSE; // variable définie ?
return WriteString(pf, m_token->GivString()); // et le nom de la variable
}
@@ -935,7 +936,7 @@ BOOL CBotVarInt::Save0State(FILE* pf) {
if ( !m_defnum.IsEmpty() )
{
- if(!WriteWord(pf, 200 )) return FALSE; // marqueur sp�cial
+ if(!WriteWord(pf, 200 )) return FALSE; // marqueur spécial
if(!WriteString(pf, m_defnum)) return FALSE; // nom de la valeur
}
@@ -984,9 +985,9 @@ 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 (!ReadWord(pf, w)) return FALSE; // privé ou type ?
if ( w == 0 ) return TRUE;
CBotString defnum;
@@ -1004,7 +1005,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) if (!ReadWord(pf, w)) return FALSE; // type
}
- if ( w == CBotTypClass ) w = CBotTypIntrinsic; // forc�ment intrins�que
+ if ( w == CBotTypClass ) w = CBotTypIntrinsic; // forcément intrinsèque
if (!ReadWord(pf, wi)) return FALSE; // init ?
@@ -1016,22 +1017,22 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) {
case CBotTypInt:
case CBotTypBoolean:
- pNew = CBotVar::Create(&token, w); // cr�e une variable
+ pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadWord(pf, w)) return FALSE;
pNew->SetValInt((short)w, defnum);
break;
case CBotTypFloat:
- pNew = CBotVar::Create(&token, w); // cr�e une variable
+ pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadFloat(pf, ww)) return FALSE;
pNew->SetValFloat(ww);
break;
case CBotTypString:
- pNew = CBotVar::Create(&token, w); // cr�e une variable
+ pNew = CBotVar::Create(&token, w); // crée une variable
if (!ReadString(pf, s)) return FALSE;
pNew->SetValString(s);
break;
- // restitue un objet intrinsic ou un �l�ment d'un array
+ // restitue un objet intrinsic ou un élément d'un array
case CBotTypIntrinsic:
case CBotTypArrayBody:
{
@@ -1045,7 +1046,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) CBotVar* p = NULL;
if ( id ) p = CBotVarClass::Find(id) ;
- pNew = new CBotVarClass(&token, r); // cr�e directement une instance
+ pNew = new CBotVarClass(&token, r); // crée directement une instance
// attention cptuse = 0
if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return FALSE;
pNew->SetIdent(id);
@@ -1053,7 +1054,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) if ( p != NULL )
{
delete pNew;
- pNew = p; // reprend l'�l�ment connu
+ pNew = p; // reprend l'élément connu
}
}
}
@@ -1063,7 +1064,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) case CBotTypNullPointer:
if (!ReadString(pf, s)) return FALSE;
{
- pNew = CBotVar::Create(&token, CBotTypResult(w, s));// cr�e une variable
+ pNew = CBotVar::Create(&token, CBotTypResult(w, s));// crée une variable
CBotVarClass* p = NULL;
long id;
ReadLong(pf, id);
@@ -1074,7 +1075,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) 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 !
+// if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p ); // plutôt celui-ci !
}
break;
@@ -1084,7 +1085,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) CBotTypResult r;
if (!ReadType(pf, r)) return FALSE;
- pNew = CBotVar::Create(&token, r); // cr�e une variable
+ pNew = CBotVar::Create(&token, r); // crée une variable
// restitue une copie de l'instance d'origine
CBotVar* pInstance = NULL;
@@ -1111,7 +1112,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) ////////////////////////////////////////////////////////////////////////////
-// gestion de la pile � la compilation
+// gestion de la pile à la compilation
////////////////////////////////////////////////////////////////////////////
CBotProgram* CBotCStack::m_prog = NULL; // init la variable statique
@@ -1147,19 +1148,19 @@ CBotCStack::CBotCStack(CBotCStack* ppapa) CBotCStack::~CBotCStack()
{
if (m_next != NULL) delete m_next;
- if (m_prev != NULL) m_prev->m_next = NULL; // enl�ve de la cha�ne
+ if (m_prev != NULL) m_prev->m_next = NULL; // enlève de la chaîne
delete m_var;
delete m_listVar;
}
-// utilis� uniquement � la compilation
+// utilisé uniquement à la compilation
CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, BOOL bBlock)
{
if (m_next != NULL) return m_next; // reprise dans une pile existante
CBotCStack* p = new CBotCStack(this);
- m_next = p; // cha�ne l'�l�ment
+ m_next = p; // chaîne l'élément
p->m_bBlock = bBlock;
if (pToken != NULL) p->SetStartError(pToken->GivStart());
@@ -1172,13 +1173,13 @@ CBotInstr* CBotCStack::Return(CBotInstr* inst, CBotCStack* pfils) {
if ( pfils == this ) return inst;
- if (m_var != NULL) delete m_var; // valeur remplac�e ?
- m_var = pfils->m_var; // r�sultat transmis
- pfils->m_var = NULL; // ne pas d�truire la variable
+ if (m_var != NULL) delete m_var; // valeur remplacée ?
+ m_var = pfils->m_var; // résultat transmis
+ pfils->m_var = NULL; // ne pas détruire la variable
if (m_error)
{
- m_start = pfils->m_start; // r�cup�re la position de l'erreur
+ m_start = pfils->m_start; // récupère la position de l'erreur
m_end = pfils->m_end;
}
@@ -1188,13 +1189,13 @@ CBotInstr* CBotCStack::Return(CBotInstr* inst, CBotCStack* pfils) CBotFunction* CBotCStack::ReturnFunc(CBotFunction* inst, CBotCStack* pfils)
{
- if (m_var != NULL) delete m_var; // valeur remplac�e ?
- m_var = pfils->m_var; // r�sultat transmis
- pfils->m_var = NULL; // ne pas d�truire la variable
+ if (m_var != NULL) delete m_var; // valeur remplacée ?
+ m_var = pfils->m_var; // résultat transmis
+ pfils->m_var = NULL; // ne pas détruire la variable
if (m_error)
{
- m_start = pfils->m_start; // r�cup�re la position de l'erreur
+ m_start = pfils->m_start; // récupère la position de l'erreur
m_end = pfils->m_end;
}
@@ -1248,7 +1249,7 @@ void CBotCStack::SetType(CBotTypResult& type) }
// cherche une variable sur la pile
-// le token peut �tre une suite de TokenTypVar (objet d'une classe)
+// le token peut être une suite de TokenTypVar (objet d'une classe)
// ou un pointeur dans le source
CBotVar* CBotCStack::FindVar(CBotToken* &pToken)
@@ -1297,20 +1298,20 @@ BOOL CBotCStack::IsOk() void CBotCStack::SetStartError( int pos )
{
- if ( m_error != 0) return; // ne change pas une erreur d�j� existante
+ if ( m_error != 0) return; // ne change pas une erreur déjà existante
m_start = pos;
}
void CBotCStack::SetError(int n, int pos)
{
- if ( n!= 0 && m_error != 0) return; // ne change pas une erreur d�j� existante
+ if ( n!= 0 && m_error != 0) return; // ne change pas une erreur déjà existante
m_error = n;
m_end = pos;
}
void CBotCStack::SetError(int n, CBotToken* p)
{
- if (m_error) return; // ne change pas une erreur d�j� existante
+ if (m_error) return; // ne change pas une erreur déjà existante
m_error = n;
m_start = p->GivStart();
m_end = p->GivEnd();
@@ -1379,7 +1380,7 @@ void CBotCStack::AddVar(CBotVar* pVar) {
CBotCStack* p = this;
- // revient sur l'�lement p�re
+ // revient sur l'élement père
while (p != NULL && p->m_bBlock == 0) p = p->m_prev;
if ( p == NULL ) return;
@@ -1387,14 +1388,14 @@ void CBotCStack::AddVar(CBotVar* pVar) CBotVar** pp = &p->m_listVar;
while ( *pp != NULL ) pp = &(*pp)->m_next;
- *pp = pVar; // ajoute � la suite
+ *pp = pVar; // ajoute à la suite
#ifdef _DEBUG
if ( pVar->GivUniqNum() == 0 ) __asm int 3;
#endif
}
-// test si une variable est d�j� d�finie localement
+// test si une variable est déjà définie localement
BOOL CBotCStack::CheckVarLocal(CBotToken* &pToken)
{
@@ -1427,7 +1428,7 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId val = m_prog->GivFunctions()->CompileCall(p->GivString(), ppVars, nIdent);
if ( val.GivType() < 0 )
{
- // pVar = NULL; // l'erreur n'est pas sur un param�tre en particulier
+ // pVar = NULL; // l'erreur n'est pas sur un paramètre en particulier
SetError( -val.GivType(), p );
val.SetType(-val.GivType());
return val;
@@ -1436,7 +1437,7 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId return val;
}
-// test si un nom de proc�dure est d�j� d�fini quelque part
+// test si un nom de procédure est déjà défini quelque part
BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
@@ -1449,7 +1450,7 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) {
if ( pToken->GivString() == pp->GivName() )
{
- // les param�tres sont-ils exactement les m�mes ?
+ // les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
}
@@ -1461,7 +1462,7 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) {
if ( pToken->GivString() == pp->GivName() )
{
- // les param�tres sont-ils exactement les m�mes ?
+ // les paramètres sont-ils exactement les mêmes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
}
diff --git a/src/CBot/CBotString.cpp b/src/CBot/CBotString.cpp index 950b0e1..5d19861 100644 --- a/src/CBot/CBotString.cpp +++ b/src/CBot/CBotString.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,13 +12,16 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/./////////////////////////////////////////////////////
+// gestion de chaine
+// basé sur le CString de MFC
+// mais moins complet
#include "CBot.h"
#include <string.h>
-HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("Cbot.dll"); // comment le r�cup�rer autrement ??
+HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("Cbot.dll"); // comment le récupérer autrement ??
CBotString::CBotString()
@@ -449,7 +452,7 @@ CBotStringArray::CBotStringArray() CBotStringArray::~CBotStringArray()
{
- SetSize(0); // d�truit les donn�es !
+ SetSize(0); // détruit les données !
}
@@ -514,7 +517,7 @@ static void CopyElements(CBotString* pDest, CBotString* pSrc, int nCount) -// s�lect la taille du tableau
+// sélect la taille du tableau
void CBotStringArray::SetSize(int nNewSize)
{
diff --git a/src/CBot/CBotToken.cpp b/src/CBot/CBotToken.cpp index bd81b70..8fd6dbd 100644 --- a/src/CBot/CBotToken.cpp +++ b/src/CBot/CBotToken.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,10 +12,13 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.//////////////////////////////////////////////////////////////////
+// Gestion des Tokens
+// le texte d'un programme est d'abord transformé
+// en une suite de tokens pour facilité l'interprétation
// il faudra traiter le seul cas d'erreur possible
-// qui est un caract�re ill�gal dans une string
+// qui est un caractère illégal dans une string
#include "CBot.h"
@@ -31,7 +34,7 @@ CBotToken::CBotToken() m_next = NULL;
m_prev = NULL;
- m_type = TokenTypVar; // � priori un nom d'une variable
+ m_type = TokenTypVar; // à priori un nom d'une variable
m_IdKeyWord = -1;
}
@@ -64,14 +67,14 @@ CBotToken::CBotToken(const CBotToken* pSrc) CBotToken::CBotToken(CBotString& mot, CBotString& sep, int start, int end)
{
- m_Text = mot; // mot trouv� comme token
- m_Sep = sep; // s�parateurs qui suivent
+ m_Text = mot; // mot trouvé comme token
+ m_Sep = sep; // séparateurs qui suivent
m_next = NULL;
m_prev = NULL;
m_start = start;
m_end = end;
- m_type = TokenTypVar; // � priori un nom d'une variable
+ m_type = TokenTypVar; // à priori un nom d'une variable
m_IdKeyWord = -1;
}
@@ -82,13 +85,13 @@ CBotToken::CBotToken(const char* mot, const char* sep) m_next = NULL;
m_prev = NULL;
- m_type = TokenTypVar; // � priori un nom d'une variable
+ m_type = TokenTypVar; // à priori un nom d'une variable
m_IdKeyWord = -1;
}
CBotToken::~CBotToken()
{
- delete m_next; // r�cursif
+ delete m_next; // récursif
m_next = NULL;
}
@@ -210,54 +213,54 @@ BOOL Char2InList(const char c, const char cc, const char* list) }
static char* sep1 = " \r\n\t,:()[]{}-+*/=;><!~^|&%.";
-static char* sep2 = " \r\n\t"; // s�parateurs pures
-static char* sep3 = ",:()[]{}-+*/=;<>!~^|&%."; // s�parateurs op�rationnels
-static char* num = "0123456789"; // le point (unique) est test� s�par�ment
+static char* sep2 = " \r\n\t"; // séparateurs pures
+static char* sep3 = ",:()[]{}-+*/=;<>!~^|&%."; // séparateurs opérationnels
+static char* num = "0123456789"; // le point (unique) est testé séparément
static char* hexnum = "0123456789ABCDEFabcdef";
-static char* nch = "\"\r\n\t"; // refus� dans les chaines
+static char* nch = "\"\r\n\t"; // refusé dans les chaines
-//static char* duo = "+=-=*=/===!=<=>=++--///**/||&&";// les op�rateurs doubles
+//static char* duo = "+=-=*=/===!=<=>=++--///**/||&&";// les opérateurs doubles
// cherche le prochain token dans une phrase
-// ne doit pas commencer par des s�parateurs
-// qui sont pris avec le token pr�c�dent
+// 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)
{
- CBotString mot; // le mot trouv�
- CBotString sep; // les s�parateurs qui le suivent
+ CBotString mot; // le mot trouvé
+ CBotString sep; // les séparateurs qui le suivent
char c;
BOOL stop = first;
if (*program == 0) return NULL;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
if (!first)
{
mot = c; // construit le mot
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
- // cas particulier pour les cha�nes de caract�res
+ // cas particulier pour les chaînes de caractères
if ( mot[0] == '\"' )
{
while (c != 0 && !CharInList(c, nch))
{
mot += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
if ( c == '\\' )
{
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
if ( c == 'n' ) c = '\n';
if ( c == 'r' ) c = '\r';
if ( c == 't' ) c = '\t';
mot += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
}
}
if ( c == '\"' )
{
- mot += c; // cha�ne compl�te
- c = *(program++); // prochain caract�re
+ mot += c; // chaîne complète
+ c = *(program++); // prochain caractère
}
stop = TRUE;
}
@@ -265,30 +268,30 @@ CBotToken* CBotToken::NextToken(char* &program, int& error, BOOL first) // 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 ?
+ if (mot[0] == '0' && c == 'x') // valeur hexadécimale ?
{
mot += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
liste = hexnum;
}
cw:
while (c != 0 && CharInList(c, liste))
{
cc: mot += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
}
- if ( liste == num ) // pas pour les exad�cimaux
+ if ( liste == num ) // pas pour les exadécimaux
{
if ( !bdot && c == '.' ) { bdot = TRUE; goto cc; }
if ( !bexp && ( c == 'e' || c == 'E' ) )
{
bexp = TRUE;
mot += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
if ( c == '-' ||
c == '+' ) goto cc;
goto cw;
@@ -298,13 +301,13 @@ cc: mot += c; stop = TRUE;
}
- if (CharInList(mot[0], sep3)) // un s�parateur op�rationnel ?
+ if (CharInList(mot[0], sep3)) // un séparateur opérationnel ?
{
CBotString motc = mot;
- while (motc += c, c != 0 && GivKeyWords(motc)>0) // cherche l'op�rande le plus long possible
+ while (motc += c, c != 0 && GivKeyWords(motc)>0) // cherche l'opérande le plus long possible
{
mot += c; // construit le mot
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
}
stop = TRUE;
@@ -321,7 +324,7 @@ cc: mot += c; bis:
while (CharInList(c, sep2))
{
- sep += c; // tous les s�parateurs qui suivent
+ sep += c; // tous les séparateurs qui suivent
c = *(program++);
}
if (c == '/' && *program == '/') // un commentaire dans le tas ?
@@ -329,7 +332,7 @@ bis: while( c != '\n' && c != 0 )
{
sep += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
}
goto bis;
}
@@ -339,14 +342,14 @@ bis: while( c != 0 && (c != '*' || *program != '/'))
{
sep += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
}
if ( c != 0 )
{
sep += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
sep += c;
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
}
goto bis;
}
@@ -367,7 +370,7 @@ bis: }
mot += c; // construit le mot
- c = *(program++); // prochain caract�re
+ c = *(program++); // prochain caractère
}
}
@@ -390,12 +393,12 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error) char* pp = p;
while (NULL != (nxt = NextToken(p, error)))
{
- prv->m_next = nxt; // ajoute � la suite
+ prv->m_next = nxt; // ajoute à la suite
nxt->m_prev = prv;
prv = nxt; // avance
nxt->m_start = pos;
-/* pos += nxt->m_Text.GivLength(); // la cha�ne peut �tre plus courte (BOA supprim�s)
+/* pos += nxt->m_Text.GivLength(); // la chaîne peut être plus courte (BOA supprimés)
nxt->m_end = pos;
pos += nxt->m_Sep.GivLength();*/
pos += (p - pp); // taille totale
@@ -404,10 +407,10 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error) }
// ajoute un token comme terminateur
- // ( utile pour avoir le pr�c�dent )
+ // ( utile pour avoir le précédent )
nxt = new CBotToken();
nxt->m_type = 0;
- prv->m_next = nxt; // ajoute � la suite
+ prv->m_next = nxt; // ajoute à la suite
nxt->m_prev = prv;
return tokenbase;
@@ -428,7 +431,7 @@ int CBotToken::GivKeyWords(const char* w) if (l == 0)
{
- LoadKeyWords(); // prend la liste la premi�re fois
+ LoadKeyWords(); // prend la liste la première fois
l = m_ListKeyWords.GivSize();
}
@@ -522,8 +525,8 @@ BOOL IsOfType(CBotToken* &p, int type1, int type2) return FALSE;
}
-// idem avec un nombre ind�fini d'arguments
-// il faut mettre un z�ro comme dernier argument
+// idem avec un nombre indéfini d'arguments
+// il faut mettre un zéro comme dernier argument
BOOL IsOfTypeList(CBotToken* &p, int type1, ...)
{
int i = type1;
diff --git a/src/CBot/CBotToken.h b/src/CBot/CBotToken.h index 2ac0d4c..2d92409 100644 --- a/src/CBot/CBotToken.h +++ b/src/CBot/CBotToken.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,14 +12,15 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////
+// interpréteur pour le language CBot du jeu COLOBOT
-// un programme �crit est tout d'abord transform� en une liste de tokens
+// un programme écrit est tout d'abord transformé en une liste de tokens
// avant d'aborder le compilateur proprement dit
// par exemple
// int var = 3 * ( pos.y + x )
-// est d�compos� en (chaque ligne est un token)
+// est décomposé en (chaque ligne est un token)
// int
// var
// =
diff --git a/src/CBot/CBotTwoOpExpr b/src/CBot/CBotTwoOpExpr new file mode 100644 index 0000000..ea18736 --- /dev/null +++ b/src/CBot/CBotTwoOpExpr @@ -0,0 +1,15 @@ +// * 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/.
\ No newline at end of file diff --git a/src/CBot/CBotTwoOpExpr ordre inversÚ.cpp b/src/CBot/CBotTwoOpExpr ordre inversÚ.cpp new file mode 100644 index 0000000..4a3a4dc --- /dev/null +++ b/src/CBot/CBotTwoOpExpr ordre inversÚ.cpp @@ -0,0 +1,302 @@ +/////////////////////////////////////////////////// +// expression du genre Opérande1 + Opérande2 +// Opérande1 > Opérande2 + +#include "CBot.h" + +// divers constructeurs + +CBotTwoOpExpr::CBotTwoOpExpr() +{ + m_leftop = + m_rightop = NULL; // NULL pour pouvoir faire delete sans autre + name = "CBotTwoOpExpr"; // debug +} + +CBotTwoOpExpr::~CBotTwoOpExpr() +{ + delete m_leftop; + delete m_rightop; +} + +// type d'opérandes acceptés par les opérations +#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong)) +#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble)) +#define BOOLEEN (1<<CBotTypBoolean) +#define CHAINE (1<<CBotTypString) +#define CLASSE (1<<CBotTypClass) + +// liste des opérations (précéance) +static int ListOp[] = +{ + BOOLEEN, ID_LOG_OR, 0, + BOOLEEN, ID_LOG_AND, 0, + BOOLEEN|ENTIER, ID_OR, 0, + ENTIER, ID_XOR, 0, + BOOLEEN|ENTIER, ID_AND, 0, + BOOLEEN|ENTIER|FLOTANT, ID_EQ, + BOOLEEN|ENTIER|FLOTANT, ID_NE, 0, + ENTIER|FLOTANT, ID_HI, + ENTIER|FLOTANT, ID_LO, + ENTIER|FLOTANT, ID_HS, + ENTIER|FLOTANT, ID_LS, 0, + ENTIER, ID_SR, + ENTIER, ID_SL, + ENTIER, ID_ASR, 0, + ENTIER|FLOTANT|CHAINE, ID_ADD, + ENTIER|FLOTANT, ID_SUB, 0, + ENTIER|FLOTANT, ID_MUL, + ENTIER|FLOTANT, ID_DIV, + ENTIER|FLOTANT, ID_MODULO, 0, + 0, +}; + +BOOL IsInList( int val, int* list, int& typemasque ) +{ + while (TRUE) + { + if ( *list == 0 ) return FALSE; + typemasque = *list++; + if ( *list++ == val ) return TRUE; + } +} + +BOOL TypeOk( int type, int test ) +{ + while (TRUE) + { + if ( type == 0 ) return (test & 1); + type--; test /= 2; + } +} + +// compile une instruction de type A op B + +CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations) +{ + int typemasque; + + if ( pOperations == NULL ) pOperations = ListOp; + int* pOp = pOperations; + while ( *pOp++ != 0 ); // suite de la table + + CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp + + // cherche des instructions qui peuvent convenir à gauche de l'opération + CBotInstr* left = CBotParExpr::Compile( p, pStk ) ; // expression (...) à gauche + + if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet + + + CBotToken* pp = p; + int TypeOp = pp->GetType(); // type d'opération + p = p->Next(); // saute le token de l'opération + + // cherche des instructions qui peuvent convenir à droite + + CBotInstr* right = (*pOp == 0) ? + CBotParExpr::Compile( p, pStk ) : // expression (...) à droite + CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A op B à droite + + if (right == NULL) return pStack->Return(left, pStk); // pas d'opérande à droite ? + + // est-ce qu'on a l'opération prévue entre les deux ? + if ( IsInList( TypeOp, pOperations, typemasque ) ) + { + CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // élément pour opération + inst->SetToken(pp); // mémorise l'opération + + int type1, type2; + type1 = pStk->GetType(); // de quel type le premier opérande ? + + inst->m_rightop = right; + { + // il y a un second opérande acceptable + + type2 = pStk->GetType(); // de quel type le résultat ? + + // quel est le type du résultat ? + int TypeRes = MAX( type1, type2 ); + if (!TypeOk( TypeRes, typemasque )) type1 = 99; // erreur de type + + switch ( TypeOp ) + { + case ID_LOG_OR: + case ID_LOG_AND: + case ID_EQ: + case ID_NE: + case ID_HI: + case ID_LO: + case ID_HS: + case ID_LS: + TypeRes = CBotTypBoolean; + } + if ( TypeCompatible (type1, type2) || // les résultats sont-ils compatibles + // cas particulier pour les concaténation de chaînes + (TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString))) + { + // si ok, enregistre l'opérande dans l'objet + inst->m_leftop = left; + // met une variable sur la pile pour avoir le type de résultat + pStk->SetVar(new CBotVar(NULL, TypeRes)); + // et rend l'object à qui l'a demandé + return pStack->Return(inst, pStk); + } + pStk->SetError(TX_BAD2TYPE, &inst->m_token); + } + + // en cas d'erreur, libère les éléments + delete left; + delete inst; + // et transmet l'erreur qui se trouve sur la pile + return pStack->Return(NULL, pStk); + } + + // si on n'a pas affaire à une opération + ou - + // rend à qui l'a demandé, l'opérande (de gauche) trouvé + // à la place de l'objet "addition" + return pStack->Return(left, pStk); +} + + + + +// fait l'opération d'addition ou de soustraction + +BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) +{ + CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile + // ou le retrouve en cas de reprise +// if ( pStk1 == EOX ) return TRUE; + + + // selon la reprise, on peut être dans l'un des 2 états + + if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche + !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ? + + // passe à l'étape suivante + pStk1->SetState(1); // prêt pour la suite + + // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire + if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE ) + { + CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean); + res->SetValInt(FALSE); + pStk1->SetVar(res); + return pStack->Return(pStk1); // transmet le résultat + } + if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE ) + { + CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean); + res->SetValInt(TRUE); + pStk1->SetVar(res); + return pStack->Return(pStk1); // transmet le résultat + } + + // demande un peu plus de stack pour ne pas toucher le résultat de gauche + // qui se trouve sur la pile, justement. + + CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile + // ou le retrouve en cas de reprise + + // 2e état, évalue l'opérande de droite + if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ? + + int type1 = pStk1->GetType(); // de quels types les résultats ? + int type2 = pStk2->GetType(); + + // crée une variable temporaire pour y mettre le résultat + // quel est le type du résultat ? + int TypeRes = MAX(type1, type2); + switch ( GetTokenType() ) + { + case ID_LOG_OR: + case ID_LOG_AND: + case ID_EQ: + case ID_NE: + case ID_HI: + case ID_LO: + case ID_HS: + case ID_LS: + TypeRes = CBotTypBoolean; + } + CBotVar* result = CBotVar::Create( NULL, TypeRes); + CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) ); + + int err = 0; + // fait l'opération selon la demande + switch (GetTokenType()) + { + case ID_ADD: + result->Add(pStk1->GetVar(), pStk2->GetVar()); // additionne + break; + case ID_SUB: + result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait + break; + case ID_MUL: + result->Mul(pStk1->GetVar(), pStk2->GetVar()); // multiplie + break; + case ID_DIV: + err = result->Div(pStk1->GetVar(), pStk2->GetVar());// divise + break; + case ID_MODULO: + err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division + break; + case ID_LO: + temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur + result->SetValInt(temp->GetValInt()); // converti le résultat + break; + case ID_HI: + temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur + result->SetValInt(temp->GetValInt()); // converti le résultat + break; + case ID_LS: + temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal + result->SetValInt(temp->GetValInt()); // converti le résultat + break; + case ID_HS: + temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal + result->SetValInt(temp->GetValInt()); // converti le résultat + break; + case ID_EQ: + temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal + result->SetValInt(temp->GetValInt()); // converti le résultat + break; + case ID_NE: + temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent + result->SetValInt(temp->GetValInt()); // converti le résultat + break; + case ID_LOG_AND: + case ID_AND: + result->And(pStk1->GetVar(), pStk2->GetVar()); // ET + break; + case ID_LOG_OR: + case ID_OR: + result->Or(pStk1->GetVar(), pStk2->GetVar()); // OU + break; + case ID_XOR: + result->XOr(pStk1->GetVar(), pStk2->GetVar()); // OU exclusif + break; + case ID_ASR: + result->ASR(pStk1->GetVar(), pStk2->GetVar()); + break; + case ID_SR: + result->SR(pStk1->GetVar(), pStk2->GetVar()); + break; + case ID_SL: + result->SL(pStk1->GetVar(), pStk2->GetVar()); + break; + default: + __asm int 3; + } + delete temp; + + pStk2->SetVar(result); // met le résultat sur la pile + if ( err ) pStk2->SetError(err, &m_token); // et l'erreur éventuelle (division par zéro) + + pStk1->Return(pStk2); // libère la pile + return pStack->Return(pStk1); // transmet le résultat +} + + diff --git a/src/CBot/CBotTwoOpExpr.cpp b/src/CBot/CBotTwoOpExpr.cpp index 840278d..8594787 100644 --- a/src/CBot/CBotTwoOpExpr.cpp +++ b/src/CBot/CBotTwoOpExpr.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////
+// expression du genre Opérande1 + Opérande2
+// Opérande1 > Opérande2
#include "CBot.h"
@@ -47,7 +49,7 @@ CBotLogicExpr::~CBotLogicExpr() }
-// type d'op�randes accept�s par les op�rations
+// type d'opérandes acceptés par les opérations
#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
#define BOOLEEN (1<<CBotTypBoolean)
@@ -55,9 +57,9 @@ CBotLogicExpr::~CBotLogicExpr() #define POINTER (1<<CBotTypPointer)
#define INSTANCE (1<<CBotTypClass)
-// liste des op�rations (pr�c�ance)
-// type acceptable, op�rande
-// le z�ro termine un niveau de pr�c�ance
+// liste des opérations (précéance)
+// type acceptable, opérande
+// le zéro termine un niveau de précéance
static int ListOp[] =
{
@@ -124,21 +126,21 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
- // cherche des instructions qui peuvent convenir � gauche de l'op�ration
+ // cherche des instructions qui peuvent convenir à gauche de l'opération
CBotInstr* left = (*pOp == 0) ?
- CBotParExpr::Compile( p, pStk ) : // expression (...) � gauche
- CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B � gauche
+ CBotParExpr::Compile( p, pStk ) : // expression (...) à gauche
+ CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B à gauche
if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
- // est-ce qu'on a l'op�rande pr�vu ensuite ?
+ // est-ce qu'on a l'opérande prévu ensuite ?
int TypeOp = p->GivType();
if ( IsInList( TypeOp, pOperations, typemasque ) )
{
CBotTypResult type1, type2;
- type1 = pStk->GivTypResult(); // de quel type le premier op�rande ?
+ type1 = pStk->GivTypResult(); // de quel type le premier opérande ?
- if ( TypeOp == ID_LOGIC ) // cas sp�cial pour condition ? op1 : op2 ;
+ if ( TypeOp == ID_LOGIC ) // cas spécial pour condition ? op1 : op2 ;
{
if ( !type1.Eq(CBotTypBoolean) )
{
@@ -148,7 +150,7 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera CBotLogicExpr* inst = new CBotLogicExpr();
inst->m_condition = left;
- p = p->GivNext(); // saute le token de l'op�ration
+ p = p->GivNext(); // saute le token de l'opération
inst->m_op1 = CBotExpression::Compile(p, pStk);
CBotToken* pp = p;
if ( inst->m_op1 == NULL || !IsOfType( p, ID_DOTS ) )
@@ -179,32 +181,32 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera return pStack->Return(inst, pStk);
}
- CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // �l�ment pour op�ration
- inst->SetToken(p); // m�morise l'op�ration
+ CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // élément pour opération
+ inst->SetToken(p); // mémorise l'opération
- p = p->GivNext(); // saute le token de l'op�ration
+ p = p->GivNext(); // saute le token de l'opération
- // cherche des instructions qui peuvent convenir � droite
+ // cherche des instructions qui peuvent convenir à droite
if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp )) )
- // expression (...) � droite
+ // expression (...) à droite
{
- // il y a un second op�rande acceptable
+ // il y a un second opérande acceptable
- type2 = pStk->GivTypResult(); // de quel type le r�sultat ?
+ type2 = pStk->GivTypResult(); // de quel type le résultat ?
- // quel est le type du r�sultat ?
+ // quel est le type du résultat ?
int TypeRes = MAX( type1.GivType(3), type2.GivType(3) );
if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
- type2 = type1; // tout type convertible en cha�ne
+ type2 = type1; // tout type convertible en chaîne
}
else if ( TypeOp == ID_ADD && type2.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
- type1 = type2; // tout type convertible en cha�ne
+ type1 = type2; // tout type convertible en chaîne
}
else if (!TypeOk( TypeRes, typemasque )) type1.SetType(99);// erreur de type
@@ -222,25 +224,25 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera case ID_LS:
TypeRes = CBotTypBoolean;
}
- if ( TypeCompatible (type1, type2, TypeOp ) ) // les r�sultats sont-ils compatibles
+ if ( TypeCompatible (type1, type2, TypeOp ) ) // les résultats sont-ils compatibles
{
- // si ok, enregistre l'op�rande dans l'objet
+ // si ok, enregistre l'opérande dans l'objet
inst->m_leftop = left;
- // sp�cial pour �valuer les op�rations de m�me niveau de gauche � droite
- while ( IsInList( p->GivType(), pOperations, typemasque ) ) // m�me(s) op�ration(s) suit ?
+ // spécial pour évaluer les opérations de même niveau de gauche à droite
+ while ( IsInList( p->GivType(), pOperations, typemasque ) ) // même(s) opération(s) suit ?
{
TypeOp = p->GivType();
- CBotTwoOpExpr* i = new CBotTwoOpExpr(); // �l�ment pour op�ration
- i->SetToken(p); // m�morise l'op�ration
- i->m_leftop = inst; // op�rande de gauche
+ CBotTwoOpExpr* i = new CBotTwoOpExpr(); // élément pour opération
+ i->SetToken(p); // mémorise l'opération
+ i->m_leftop = inst; // opérande de gauche
type1 = TypeRes;
- p = p->GivNext(); // avance � la suite
+ p = p->GivNext(); // avance à la suite
i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp );
type2 = pStk->GivTypResult();
- if ( !TypeCompatible (type1, type2, TypeOp) ) // les r�sultats sont-ils compatibles
+ if ( !TypeCompatible (type1, type2, TypeOp) ) // les résultats sont-ils compatibles
{
pStk->SetError(TX_BAD2TYPE, &i->m_token);
delete i;
@@ -254,25 +256,25 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera CBotTypResult t(type1);
t.SetType(TypeRes);
- // met une variable sur la pile pour avoir le type de r�sultat
+ // met une variable sur la pile pour avoir le type de résultat
pStk->SetVar(CBotVar::Create((CBotToken*)NULL, t));
- // et rend l'object � qui l'a demand�
+ // et rend l'object à qui l'a demandé
return pStack->Return(inst, pStk);
}
pStk->SetError(TX_BAD2TYPE, &inst->m_token);
}
- // en cas d'erreur, lib�re les �l�ments
+ // en cas d'erreur, libère les éléments
delete left;
delete inst;
// et transmet l'erreur qui se trouve sur la pile
return pStack->Return(NULL, pStk);
}
- // si on n'a pas affaire � une op�ration + ou -
- // rend � qui l'a demand�, l'op�rande (de gauche) trouv�
- // � la place de l'objet "addition"
+ // si on n'a pas affaire à une opération + ou -
+ // rend à qui l'a demandé, l'opérande (de gauche) trouvé
+ // à la place de l'objet "addition"
return pStack->Return(left, pStk);
}
@@ -288,62 +290,62 @@ BOOL IsNan(CBotVar* left, CBotVar* right, int* err = NULL) }
-// fait l'op�ration sur 2 op�randes
+// fait l'opération sur 2 opérandes
BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE;
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
- if ( pStk1->GivState() == 0 ) // 1er �tat, �value l'op�rande de gauche
+ if ( pStk1->GivState() == 0 ) // 1er état, évalue l'opérande de gauche
{
if (!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- // pour les OU et ET logique, n'�value pas la seconde expression si pas n�cessaire
+ // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == FALSE )
{
CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
res->SetValInt(FALSE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == TRUE )
{
CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
res->SetValInt(TRUE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
- // passe � l'�tape suivante
- pStk1->SetState(1); // pr�t pour la suite
+ // passe à l'étape suivante
+ pStk1->SetState(1); // prêt pour la suite
}
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
+ // demande un peu plus de stack pour ne pas toucher le résultat de gauche
// qui se trouve sur la pile, justement.
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
- // 2e �tat, �value l'op�rande de droite
+ // 2e état, évalue l'opérande de droite
if ( pStk2->GivState() == 0 )
{
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
pStk2->IncState();
}
- CBotTypResult type1 = pStk1->GivTypResult(); // de quels types les r�sultats ?
+ CBotTypResult type1 = pStk1->GivTypResult(); // de quels types les résultats ?
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
+ CBotStack* pStk3 = pStk2->AddStack(this); // ajoute un élément à la pile
+ 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 ?
+ // crée une variable temporaire pour y mettre le résultat
+ // quel est le type du résultat ?
int TypeRes = MAX(type1.GivType(), type2.GivType());
if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
@@ -369,10 +371,10 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) TypeRes = MAX(TypeRes, CBotTypFloat);
}
- // cr�e une variable pour le r�sultat
+ // crée une variable pour le résultat
CBotVar* result = CBotVar::Create( (CBotToken*)NULL, TypeRes);
- // cr�e une variable pour effectuer le calcul dans le type adapt�
+ // crée une variable pour effectuer le calcul dans le type adapté
TypeRes = MAX(type1.GivType(), type2.GivType());
if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
@@ -387,7 +389,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) else temp = CBotVar::Create( (CBotToken*)NULL, TypeRes );
int err = 0;
- // fait l'op�ration selon la demande
+ // fait l'opération selon la demande
CBotVar* left = pStk1->GivVar();
CBotVar* right = pStk2->GivVar();
@@ -413,31 +415,31 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) break;
case ID_LO:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Lo(left , right)); // inf�rieur
+ result->SetValInt(temp->Lo(left , right)); // inférieur
break;
case ID_HI:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Hi(left , right)); // sup�rieur
+ result->SetValInt(temp->Hi(left , right)); // supérieur
break;
case ID_LS:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Ls(left , right)); // inf�rieur ou �gal
+ result->SetValInt(temp->Ls(left , right)); // inférieur ou égal
break;
case ID_HS:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Hs(left , right)); // sup�rieur ou �gal
+ result->SetValInt(temp->Hs(left , right)); // supérieur ou égal
break;
case ID_EQ:
if ( IsNan(left, right) )
result->SetValInt(left->GivInit() == right->GivInit()) ;
else
- result->SetValInt(temp->Eq(left , right)); // �gal
+ result->SetValInt(temp->Eq(left , right)); // égal
break;
case ID_NE:
if ( IsNan(left, right) )
result->SetValInt(left ->GivInit() != right->GivInit()) ;
else
- result->SetValInt(temp->Ne(left , right)); // diff�rent
+ result->SetValInt(temp->Ne(left , right)); // différent
break;
case ID_TXT_AND:
case ID_LOG_AND:
@@ -466,31 +468,31 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) }
delete temp;
- pStk2->SetVar(result); // met le r�sultat sur la pile
- if ( err ) pStk2->SetError(err, &m_token); // et l'erreur �ventuelle (division par z�ro)
+ pStk2->SetVar(result); // met le résultat sur la pile
+ if ( err ) pStk2->SetError(err, &m_token); // et l'erreur éventuelle (division par zéro)
-// pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk2); // transmet le r�sultat
+// pStk1->Return(pStk2); // libère la pile
+ return pStack->Return(pStk2); // transmet le résultat
}
void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
{
if ( !bMain ) return;
- CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un élément à la pile
if ( pStk1 == NULL ) return;
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
- if ( pStk1->GivState() == 0 ) // 1er �tat, �value l'op�rande de gauche
+ if ( pStk1->GivState() == 0 ) // 1er état, évalue l'opérande de gauche
{
m_leftop->RestoreState(pStk1, bMain); // interrompu ici !
return;
}
- CBotStack* pStk2 = pStk1->RestoreStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk2 = pStk1->RestoreStack(); // ajoute un élément à la pile
if ( pStk2 == NULL ) return;
- // 2e �tat, �value l'op�rande de droite
+ // 2e état, évalue l'opérande de droite
if ( pStk2->GivState() == 0 )
{
m_rightop->RestoreState(pStk2, bMain); // interrompu ici !
@@ -501,7 +503,7 @@ void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain) BOOL CBotLogicExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE;
@@ -520,14 +522,14 @@ BOOL CBotLogicExpr::Execute(CBotStack* &pStack) if ( !m_op2->Execute(pStk1) ) return FALSE;
}
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
void CBotLogicExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
{
if ( !bMain ) return;
- CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un élément à la pile
if ( pStk1 == NULL ) return;
if ( pStk1->GivState() == 0 )
@@ -561,4 +563,4 @@ void t(BOOL t) x = 1 + t ? 1 : 3 + 4 * 2 ;
t ? 0 : "test";
}
-#endif
+#endif
\ No newline at end of file diff --git a/src/CBot/CBotVar.cpp b/src/CBot/CBotVar.cpp index 83778b5..9d91759 100644 --- a/src/CBot/CBotVar.cpp +++ b/src/CBot/CBotVar.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,9 +12,11 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////
+// Définition pour la classe CBotVar
+// gestion des variables du langage CBot
-// on ne cr�e jamais d'instance de la class m�re CBotVar
+// on ne crée jamais d'instance de la class mère CBotVar
#include "CBot.h"
@@ -118,7 +120,7 @@ CBotVarClass::CBotVarClass( const CBotToken* name, CBotTypResult& type) //, int void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type ) //, int &nIdent )
{*/
if ( !type.Eq(CBotTypClass) &&
- !type.Eq(CBotTypIntrinsic) && // par comodit� accepte ces types
+ !type.Eq(CBotTypIntrinsic) && // par comodité accepte ces types
!type.Eq(CBotTypPointer) &&
!type.Eq(CBotTypArrayPointer) &&
!type.Eq(CBotTypArrayBody)) __asm int 3;
@@ -154,7 +156,7 @@ void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type CBotClass* pClass2 = pClass->GivParent();
if ( pClass2 != NULL )
{
- // cr�e �galement une instance dans la classe p�re
+ // crée également une instance dans la classe père
m_pParent = new CBotVarClass(name, CBotTypResult(type.GivType(),pClass2) ); //, nIdent);
}
@@ -170,7 +172,7 @@ CBotVarClass::~CBotVarClass( ) if ( m_pParent ) delete m_pParent;
m_pParent = NULL;
- // lib�re l'objet indirect s'il y a lieu
+ // libère l'objet indirect s'il y a lieu
// if ( m_Indirect != NULL )
// m_Indirect->DecrementUse();
@@ -260,7 +262,7 @@ void* CBotVar::GivUserPtr() BOOL CBotVar::Save1State(FILE* pf)
{
- // cette routine "virtual" ne doit jamais �tre appell�e,
+ // cette routine "virtual" ne doit jamais être appellée,
// il doit y avoir une routine pour chaque classe fille (CBotVarInt, CBotVarFloat, etc)
// ( voir le type dans m_type )
__asm int 3;
@@ -274,7 +276,7 @@ void CBotVar::Maj(void* pUser, BOOL bContinu) }
-// cr�e une variable selon son type
+// crée une variable selon son type
CBotVar* CBotVar::Create(const CBotToken* name, int type )
{
@@ -302,7 +304,7 @@ CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type) return new CBotVarClass(name, type);
case CBotTypClass:
- // cr�e une nouvelle instance d'une classe
+ // crée une nouvelle instance d'une classe
// et retourne le POINTER sur cette instance
{
CBotVarClass* instance = new CBotVarClass(name, type);
@@ -324,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;
@@ -372,7 +374,7 @@ CBotVar* CBotVar::Create( const char* n, CBotTypResult type) }
case CBotTypClass:
- // cr�e une nouvelle instance d'une classe
+ // crée une nouvelle instance d'une classe
// et retourne le POINTER sur cette instance
{
CBotVarClass* instance = new CBotVarClass(&name, type);
@@ -395,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;
@@ -464,7 +466,7 @@ void CBotVar::SetType(CBotTypResult& type) int CBotVar::GivInit()
{
- if ( m_type.Eq(CBotTypClass) ) return IS_DEF; // toujours d�fini !
+ if ( m_type.Eq(CBotTypClass) ) return IS_DEF; // toujours défini !
return m_binit;
}
@@ -472,7 +474,7 @@ int CBotVar::GivInit() void CBotVar::SetInit(BOOL bInit)
{
m_binit = bInit;
- if ( bInit == 2 ) m_binit = IS_DEF; // cas sp�cial
+ if ( bInit == 2 ) m_binit = IS_DEF; // cas spécial
if ( m_type.Eq(CBotTypPointer) && bInit == 2 )
{
@@ -537,7 +539,7 @@ CBotVar* CBotVar::GivItem(int row, BOOL bGrow) return NULL;
}
-// dit si une variable appartient � une classe donn�e
+// dit si une variable appartient à une classe donnée
BOOL CBotVar::IsElemOfClass(const char* name)
{
CBotClass* pc = NULL;
@@ -563,7 +565,7 @@ BOOL CBotVar::IsElemOfClass(const char* name) CBotVar* CBotVar::GivStaticVar()
{
- // rend le pointeur � la variable si elle est statique
+ // rend le pointeur à la variable si elle est statique
if ( m_bStatic == 0 || m_pMyThis == NULL ) return this;
CBotClass* pClass = m_pMyThis->GivClass();
@@ -616,7 +618,7 @@ void CBotVar::SetVal(CBotVar* var) __asm int 3;
}
- m_binit = var->m_binit; // copie l'�tat nan s'il y a
+ m_binit = var->m_binit; // copie l'état nan s'il y a
}
void CBotVar::SetStatic(BOOL bStatic)
@@ -656,8 +658,8 @@ CBotVarClass* CBotVar::GivPointer() return NULL;
}
-// toutes ces fonctions doivent �tre d�finies dans les classes filles
-// d�riv�es de la classe CBotVar
+// toutes ces fonctions doivent être définies dans les classes filles
+// dérivées de la classe CBotVar
int CBotVar::GivValInt()
{
@@ -846,7 +848,7 @@ void CBotVarInt::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;
m_pUserPtr = p->m_pUserPtr;
- // garde le m�me idendificateur (par d�faut)
+ // garde le même idendificateur (par défaut)
if (m_ident == 0 ) m_ident = p->m_ident;
m_defnum = p->m_defnum;
@@ -1059,7 +1061,7 @@ void CBotVarFloat::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le m�me idendificateur (par d�faut)
+ // garde le même idendificateur (par défaut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -1220,7 +1222,7 @@ void CBotVarBoolean::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le m�me idendificateur (par d�faut)
+ // garde le même idendificateur (par défaut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -1318,7 +1320,7 @@ void CBotVarString::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le m�me idendificateur (par d�faut)
+ // garde le même idendificateur (par défaut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -1391,7 +1393,7 @@ BOOL CBotVarString::Hs(CBotVar* left, CBotVar* right) // copie une variable dans une autre
void CBotVarClass::Copy(CBotVar* pSrc, BOOL bName)
{
- pSrc = pSrc->GivPointer(); // si source donn� par un pointeur
+ pSrc = pSrc->GivPointer(); // si source donné par un pointeur
if ( pSrc->GivType() != CBotTypClass )
__asm int 3;
@@ -1414,7 +1416,7 @@ __asm int 3; "que faire du pParent"; m_pMyThis = NULL;//p->m_pMyThis;
m_ItemIdent = p->m_ItemIdent;
- // garde le m�me idendificateur (par d�faut)
+ // garde le même idendificateur (par défaut)
if (m_ident == 0 ) m_ident = p->m_ident;
delete m_pVar;
@@ -1451,7 +1453,7 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent) m_pClass = pClass;
- // initialise les variables associ�es � cette classe
+ // initialise les variables associées à cette classe
delete m_pVar;
m_pVar = NULL;
@@ -1461,24 +1463,24 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent) while ( pv != NULL )
{
// cherche les dimensions max du tableau
- CBotInstr* p = pv->m_LimExpr; // les diff�rentes formules
+ CBotInstr* p = pv->m_LimExpr; // les différentes formules
if ( p != NULL )
{
- CBotStack* pile = CBotStack::FirstStack(); // une pile ind�pendante
+ CBotStack* pile = CBotStack::FirstStack(); // une pile indépendante
int n = 0;
int max[100];
while (p != NULL)
{
while( pile->IsOk() && !p->Execute(pile) ) ; // calcul de la taille sans interruptions
- CBotVar* v = pile->GivVar(); // r�sultat
+ CBotVar* v = pile->GivVar(); // résultat
max[n] = v->GivValInt(); // valeur
n++;
p = p->GivNext3();
}
while (n<100) max[n++] = 0;
- pv->m_type.SetArray( max ); // m�morise les limitations
+ pv->m_type.SetArray( max ); // mémorise les limitations
pile->Delete();
}
@@ -1489,20 +1491,20 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent) if ( pv->m_InitExpr != NULL ) // expression pour l'initialisation ?
{
#if STACKMEM
- CBotStack* pile = CBotStack::FirstStack(); // une pile ind�pendante
+ CBotStack* pile = CBotStack::FirstStack(); // une pile indépendante
- while(pile->IsOk() && !pv->m_InitExpr->Execute(pile, pn)); // �value l'expression sans timer
+ while(pile->IsOk() && !pv->m_InitExpr->Execute(pile, pn)); // évalue l'expression sans timer
pile->Delete();
#else
- CBotStack* pile = new CBotStack(NULL); // une pile ind�pendante
- while(!pv->m_InitExpr->Execute(pile)); // �value l'expression sans timer
+ CBotStack* pile = new CBotStack(NULL); // une pile indépendante
+ while(!pv->m_InitExpr->Execute(pile)); // évalue l'expression sans timer
pn->SetVal( pile->GivVar() ) ;
delete pile;
#endif
}
-// pn->SetUniqNum(CBotVar::NextUniqNum()); // num�rote les �l�ments
+// pn->SetUniqNum(CBotVar::NextUniqNum()); // numérote les éléments
pn->SetUniqNum(pv->GivUniqNum()); //++nIdent
pn->m_pMyThis = this;
@@ -1523,12 +1525,12 @@ void CBotVarClass::Maj(void* pUser, BOOL bContinu) /* if (!bContinu && m_pMyThis != NULL)
m_pMyThis->Maj(pUser, TRUE);*/
- // une routine de mise � jour existe-elle ?
+ // une routine de mise à jour existe-elle ?
if ( m_pClass->m_rMaj == NULL ) return;
- // r�cup�re le pointeur user selon la classe
- // ou selon le param�tre pass� au CBotProgram::Run()
+ // récupère le pointeur user selon la classe
+ // ou selon le paramètre passé au CBotProgram::Run()
if ( m_pUserPtr != NULL) pUser = m_pUserPtr;
if ( pUser == OBJECTDELETED ||
@@ -1565,7 +1567,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()
+// bExtend permet d'agrandir le tableau, mais pas au dela de la taille fixée par SetArray()
CBotVar* CBotVarClass::GivItem(int n, BOOL bExtend)
{
@@ -1609,7 +1611,7 @@ CBotString CBotVarClass::GivValString() CBotString res;
- if ( m_pClass != NULL ) // pas utilis� pour un array
+ if ( m_pClass != NULL ) // pas utilisé pour un array
{
res = m_pClass->GivName() + "( ";
@@ -1670,7 +1672,7 @@ void CBotVarClass::DecrementUse() if ( m_CptUse == 0 )
{
// s'il y en a un, appel le destructeur
- // mais seulement si un constructeur avait �t� appel�.
+ // mais seulement si un constructeur avait été appelé.
if ( m_bConstructor )
{
m_CptUse++; // ne revient pas dans le destructeur
@@ -1679,7 +1681,7 @@ void CBotVarClass::DecrementUse() // sauve la valeur pour la remettre ensuite
int err, start, end;
CBotStack* pile = NULL;
- err = pile->GivError(start,end); // pile == NULL �a ne derange pas !!
+ err = pile->GivError(start,end); // pile == NULL ça ne derange pas !!
pile = CBotStack::FirstStack(); // efface l'erreur
CBotVar* ppVars[1];
@@ -1701,7 +1703,7 @@ void CBotVarClass::DecrementUse() m_CptUse--;
}
- delete this; // s'auto-d�truit !!
+ delete this; // s'auto-détruit !!
}
}
@@ -1711,7 +1713,7 @@ CBotVarClass* CBotVarClass::GivPointer() }
-// trouve une instance selon son num�ro unique
+// trouve une instance selon son numéro unique
CBotVarClass* CBotVarClass::Find(long id)
{
@@ -1738,7 +1740,7 @@ BOOL CBotVarClass::Eq(CBotVar* left, CBotVar* right) r = r->GivNext();
}
- // devrait toujours arriv� simultan�ment au bout (m�mes classes)
+ // devrait toujours arrivé simultanément au bout (mêmes classes)
return l == r;
}
@@ -1754,7 +1756,7 @@ BOOL CBotVarClass::Ne(CBotVar* left, CBotVar* right) r = r->GivNext();
}
- // devrait toujours arriv� simultan�ment au bout (m�mes classes)
+ // devrait toujours arrivé simultanément au bout (mêmes classes)
return l != r;
}
@@ -1775,12 +1777,12 @@ CBotVarArray::CBotVarArray(const CBotToken* name, CBotTypResult& type ) m_type.SetType(CBotTypArrayPointer);
m_binit = FALSE;
- m_pInstance = NULL; // la liste des �l�ments du tableau
+ m_pInstance = NULL; // la liste des éléments du tableau
}
CBotVarArray::~CBotVarArray()
{
- if ( m_pInstance != NULL ) m_pInstance->DecrementUse(); // une r�f�rence en moins
+ if ( m_pInstance != NULL ) m_pInstance->DecrementUse(); // une référence en moins
}
// copie une variable dans une autre
@@ -1796,34 +1798,34 @@ void CBotVarArray::Copy(CBotVar* pSrc, BOOL bName) m_pInstance = p->GivPointer();
if ( m_pInstance != NULL )
- m_pInstance->IncrementUse(); // une r�f�rence en plus
+ m_pInstance->IncrementUse(); // une référence en plus
m_binit = p->m_binit;
//- m_bStatic = p->m_bStatic;
m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le m�me idendificateur (par d�faut)
+ // garde le même idendificateur (par défaut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
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
+ 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
if ( pVarClass != NULL )
{
if ( pVarClass->GivType() == CBotTypArrayPointer )
- pVarClass = pVarClass->GivPointer(); // le vrai pointeur � l'objet
+ pVarClass = pVarClass->GivPointer(); // le vrai pointeur à l'objet
if ( !pVarClass->m_type.Eq(CBotTypClass) &&
!pVarClass->m_type.Eq(CBotTypArrayBody))
__asm int 3;
- ((CBotVarClass*)pVarClass)->IncrementUse(); // une r�f�rence en plus
+ ((CBotVarClass*)pVarClass)->IncrementUse(); // une référence en plus
}
if ( m_pInstance != NULL ) m_pInstance->DecrementUse();
@@ -1842,7 +1844,7 @@ CBotVar* CBotVarArray::GivItem(int n, BOOL bExtend) if ( m_pInstance == NULL )
{
if ( !bExtend ) return NULL;
- // cr�e une instance pour le tableau
+ // crée une instance pour le tableau
CBotVarClass* instance = new CBotVarClass(NULL, m_type);
SetPointer( instance );
@@ -1865,18 +1867,18 @@ CBotString CBotVarArray::GivValString() BOOL CBotVarArray::Save1State(FILE* pf)
{
if ( !WriteType(pf, m_type) ) return FALSE;
- return SaveVar(pf, m_pInstance); // sauve l'instance qui g�re le tableau
+ return SaveVar(pf, m_pInstance); // sauve l'instance qui gère le tableau
}
/////////////////////////////////////////////////////////////////////////////
-// gestion des pointeurs � une instance donn�e
+// gestion des pointeurs à une instance donnée
CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type )
{
if ( !type.Eq(CBotTypPointer) &&
!type.Eq(CBotTypNullPointer) &&
- !type.Eq(CBotTypClass) && // par commodit� accepte Class et Intrinsic
+ !type.Eq(CBotTypClass) && // par commodité accepte Class et Intrinsic
!type.Eq(CBotTypIntrinsic) ) __asm int 3;
m_token = new CBotToken(name);
@@ -1889,14 +1891,14 @@ CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type ) m_type.SetType(CBotTypPointer); // quoi qu'il en soit, c'est un pointeur
m_binit = FALSE;
m_pClass = NULL;
- m_pVarClass = NULL; // sera d�fini par un SetPointer()
+ m_pVarClass = NULL; // sera défini par un SetPointer()
SetClass(type.GivClass() );
}
CBotVarPointer::~CBotVarPointer()
{
- if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse(); // une r�f�rence en moins
+ if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse(); // une référence en moins
}
@@ -1911,7 +1913,7 @@ void CBotVarPointer::Maj(void* pUser, BOOL bContinu) CBotVar* CBotVarPointer::GivItem(const char* name)
{
if ( m_pVarClass == NULL) // pas d'instance existant ?
- return m_pClass->GivItem(name); // rend le pointeur dans la classe elle-m�me
+ return m_pClass->GivItem(name); // rend le pointeur dans la classe elle-même
return m_pVarClass->GivItem(name);
}
@@ -1919,7 +1921,7 @@ CBotVar* CBotVarPointer::GivItem(const char* name) CBotVar* CBotVarPointer::GivItemRef(int nIdent)
{
if ( m_pVarClass == NULL) // pas d'instance existant ?
- return m_pClass->GivItemRef(nIdent);// rend le pointeur dans la classe elle-m�me
+ return m_pClass->GivItemRef(nIdent);// rend le pointeur dans la classe elle-même
return m_pVarClass->GivItemRef(nIdent);
}
@@ -1948,21 +1950,21 @@ 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
+ 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
if ( pVarClass != NULL )
{
if ( pVarClass->GivType() == CBotTypPointer )
- pVarClass = pVarClass->GivPointer(); // le vrai pointeur � l'objet
+ pVarClass = pVarClass->GivPointer(); // le vrai pointeur à l'objet
// if ( pVarClass->GivType() != CBotTypClass )
if ( !pVarClass->m_type.Eq(CBotTypClass) )
__asm int 3;
- ((CBotVarClass*)pVarClass)->IncrementUse(); // une r�f�rence en plus
+ ((CBotVarClass*)pVarClass)->IncrementUse(); // une référence en plus
m_pClass = ((CBotVarClass*)pVarClass)->m_pClass;
m_pUserPtr = pVarClass->m_pUserPtr; // pas vraiment indispensable
m_type = CBotTypResult(CBotTypPointer, m_pClass); // un pointeur de quel genre
@@ -2018,7 +2020,7 @@ BOOL CBotVarPointer::Save1State(FILE* pf) 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());
@@ -2039,7 +2041,7 @@ void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName) m_pVarClass = p->GivPointer();
if ( m_pVarClass != NULL )
- m_pVarClass->IncrementUse(); // une r�f�rence en plus
+ m_pVarClass->IncrementUse(); // une référence en plus
m_pClass = p->m_pClass;
m_binit = p->m_binit;
@@ -2048,7 +2050,7 @@ void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le m�me idendificateur (par d�faut)
+ // garde le même idendificateur (par défaut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -2077,7 +2079,7 @@ BOOL CBotVarPointer::Ne(CBotVar* left, CBotVar* right) ///////////////////////////////////////////////////////
-// gestion des types de r�sultats
+// gestion des types de résultats
CBotTypResult::CBotTypResult(int type)
@@ -2197,7 +2199,7 @@ void CBotTypResult::SetArray( int* max ) m_limite = *max;
if (m_limite < 1) m_limite = -1;
- if ( m_pNext != NULL ) // derni�re dimension ?
+ if ( m_pNext != NULL ) // dernière dimension ?
{
m_pNext->SetArray( max+1 );
}
diff --git a/src/CBot/CBotWhile.cpp b/src/CBot/CBotWhile.cpp index 8632fef..124fb3d 100644 --- a/src/CBot/CBotWhile.cpp +++ b/src/CBot/CBotWhile.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,17 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////
+// ce fichier défini les instructions suivantes:
+// CBotWhile "while (condition) {instructions}"
+// CBotDo "do {instructions} while (condition)"
+// CBotFor "for (init, condition, incr) {instructions}"
+// CBotSwitch "switch (val) {instructions}"
+// CBotCase "case val:"
+// CBotBreak "break", "break label", "continu", "continu label"
+// CBotTry "try {instructions}"
+// CBotCatch "catch (condition) {instructions}" ou "finally"
+// CBotThrow "throw execption"
#include "CBot.h"
@@ -31,14 +41,14 @@ CBotWhile::CBotWhile() CBotWhile::~CBotWhile()
{
- delete m_Condition; // lib�re la condition
- delete m_Block; // lib�re le bloc d'instruction
+ delete m_Condition; // libère la condition
+ delete m_Block; // libère le bloc d'instruction
}
CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotWhile* inst = new CBotWhile(); // cr�e l'objet
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotWhile* inst = new CBotWhile(); // crée l'objet
+ CBotToken* pp = p; // conserve le ^au token (position début)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
@@ -61,57 +71,57 @@ CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack) if ( pStk->IsOk() )
{
- // le bloc d'instruction est ok (il peut �tre vide !
+ // le bloc d'instruction est ok (il peut être vide !
- return pStack->Return(inst, pStk); // rend l'objet � qui le demande
+ return pStack->Return(inst, pStk); // rend l'objet à qui le demande
}
}
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile
}
-// ex�cute une instruction "while"
+// exécute une instruction "while"
BOOL CBotWhile :: Execute(CBotStack* &pj)
{
- CBotStack* pile = pj->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE;
if ( pile->IfStep() ) return FALSE;
- while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle
- { // il y a 2 �tats possibles (selon reprise)
+ while( TRUE ) switch( pile->GivState() ) // exécute la boucle
+ { // il y a 2 états possibles (selon reprise)
case 0:
- // �value la condition
+ // évalue la condition
if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ?
- // le r�sultat de la condition est sur la pile
+ // le résultat de la condition est sur la pile
// termine s'il y a une erreur ou si la condition est fausse
if ( !pile->IsOk() || pile->GivVal() != TRUE )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
// la condition est vrai, passe dans le second mode
- 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�
+ // évalue le bloc d'instruction associé
if ( m_Block != NULL &&
!m_Block->Execute(pile) )
{
if (pile->IfContinue(0, m_label)) continue; // si continue, repasse au test
- return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile
+ return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile
}
// termine s'il y a une erreur
if ( !pile->IsOk() )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
// repasse au test pour recommencer
@@ -123,18 +133,18 @@ BOOL CBotWhile :: Execute(CBotStack* &pj) void CBotWhile :: RestoreState(CBotStack* &pj, BOOL bMain)
{
if ( !bMain ) return;
- CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile
if ( pile == NULL ) return;
switch( pile->GivState() )
- { // il y a 2 �tats possibles (selon reprise)
+ { // il y a 2 états possibles (selon reprise)
case 0:
- // �value la condition
+ // évalue la condition
m_Condition->RestoreState(pile, bMain);
return;
case 1:
- // �value le bloc d'instruction associ�
+ // évalue le bloc d'instruction associé
if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);
return;
}
@@ -155,14 +165,14 @@ CBotRepeat::CBotRepeat() CBotRepeat::~CBotRepeat()
{
- delete m_NbIter; // lib�re la condition
- delete m_Block; // lib�re le bloc d'instruction
+ delete m_NbIter; // libère la condition
+ delete m_Block; // libère le bloc d'instruction
}
CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotRepeat* inst = new CBotRepeat(); // cr�e l'objet
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotRepeat* inst = new CBotRepeat(); // crée l'objet
+ CBotToken* pp = p; // conserve le ^au token (position début)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
@@ -177,7 +187,7 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack) if ( IsOfType(p, ID_OPENPAR ) )
{
- CBotToken* ppp = p; // conserve le ^au token (position d�but)
+ CBotToken* ppp = p; // conserve le ^au token (position début)
if ( NULL != (inst->m_NbIter = CBotExpression::Compile( p, pStk )) )
{
if ( pStk->GivType() < CBotTypLong )
@@ -191,9 +201,9 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack) if ( pStk->IsOk() )
{
- // le bloc d'instruction est ok (il peut �tre vide !
+ // le bloc d'instruction est ok (il peut être vide !
- return pStack->Return(inst, pStk); // rend l'objet � qui le demande
+ return pStack->Return(inst, pStk); // rend l'objet à qui le demande
}
}
pStack->SetError(TX_CLOSEPAR, p->GivStart());
@@ -203,59 +213,59 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack) }
pStack->SetError(TX_ENDOF, p);
}
- pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenth�se
+ pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenthèse
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile
}
-// ex�cute une instruction "repeat"
+// exécute une instruction "repeat"
BOOL CBotRepeat :: Execute(CBotStack* &pj)
{
- CBotStack* pile = pj->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE;
if ( pile->IfStep() ) return FALSE;
- while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle
- { // il y a 2 �tats possibles (selon reprise)
+ 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
+ // évalue le nombre d'itération
if ( !m_NbIter->Execute(pile) ) return FALSE; // interrompu ici ?
- // le r�sultat de la condition est sur la pile
+ // le résultat de la condition est sur la pile
// termine s'il y a une erreur ou si la condition est fausse
int n;
if ( !pile->IsOk() || ( n = pile->GivVal() ) < 1 )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
- // met le nombre d'it�ration +1 dans le "state"
+ // met le nombre d'itération +1 dans le "state"
- if (!pile->SetState(n+1)) return FALSE; // pr�t pour la suite
- continue; // passe � la suite
+ if (!pile->SetState(n+1)) return FALSE; // prêt pour la suite
+ continue; // passe à la suite
case 1:
// fin normale de la boucle
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
default:
- // �value le bloc d'instruction associ�
+ // évalue le bloc d'instruction associé
if ( m_Block != NULL &&
!m_Block->Execute(pile) )
{
if (pile->IfContinue(pile->GivState()-1, m_label)) continue; // si continue, repasse au test
- return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile
+ return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile
}
// termine s'il y a une erreur
if ( !pile->IsOk() )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
// repasse au test pour recommencer
@@ -267,18 +277,18 @@ BOOL CBotRepeat :: Execute(CBotStack* &pj) void CBotRepeat :: RestoreState(CBotStack* &pj, BOOL bMain)
{
if ( !bMain ) return;
- CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile
if ( pile == NULL ) return;
switch( pile->GivState() )
- { // il y a 2 �tats possibles (selon reprise)
+ { // il y a 2 états possibles (selon reprise)
case 0:
- // �value la condition
+ // évalue la condition
m_NbIter->RestoreState(pile, bMain);
return;
case 1:
- // �value le bloc d'instruction associ�
+ // évalue le bloc d'instruction associé
if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);
return;
}
@@ -298,15 +308,15 @@ CBotDo::CBotDo() CBotDo::~CBotDo()
{
- delete m_Condition; // lib�re la condition
- delete m_Block; // lib�re le bloc d'instruction
+ delete m_Condition; // libère la condition
+ delete m_Block; // libère le bloc d'instruction
}
CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotDo* inst = new CBotDo(); // cr�e l'objet
+ CBotDo* inst = new CBotDo(); // crée l'objet
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotToken* pp = p; // conserve le ^au token (position début)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
@@ -320,7 +330,7 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack) CBotCStack* pStk = pStack->TokenStack(pp); // un petit bout de pile svp
- // cherche un bloc d'instruction apr�s le do
+ // cherche un bloc d'instruction après le do
IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
DecLvl();
@@ -334,7 +344,7 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack) // la condition existe
if (IsOfType(p, ID_SEP))
{
- return pStack->Return(inst, pStk); // rend l'objet � qui le demande
+ return pStack->Return(inst, pStk); // rend l'objet à qui le demande
}
pStk->SetError(TX_ENDOF, p->GivStart());
}
@@ -342,49 +352,49 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack) pStk->SetError(TX_WHILE, p->GivStart());
}
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile
}
-// ex�cute une instruction "do"
+// exécute une instruction "do"
BOOL CBotDo :: Execute(CBotStack* &pj)
{
- CBotStack* pile = pj->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pile == EOX ) return TRUE;
if ( pile->IfStep() ) return FALSE;
- while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle
- { // il y a 2 �tats possibles (selon reprise)
+ 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�
+ // évalue le bloc d'instruction associé
if ( m_Block != NULL &&
!m_Block->Execute(pile) )
{
if (pile->IfContinue(1, m_label)) continue; // si continue, repasse au test
- return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile
+ return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile
}
// termine s'il y a une erreur
if ( !pile->IsOk() )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
- if (!pile->SetState(1)) return FALSE; // pr�t pour la suite
+ if (!pile->SetState(1)) return FALSE; // prêt pour la suite
case 1:
- // �value la condition
+ // évalue la condition
if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ?
- // le r�sultat de la condition est sur la pile
+ // le résultat de la condition est sur la pile
// termine s'il y a une erreur ou si la condition est fausse
if ( !pile->IsOk() || pile->GivVal() != TRUE )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
// repasse au bloc d'instruction pour recommencer
@@ -397,13 +407,13 @@ void CBotDo :: RestoreState(CBotStack* &pj, BOOL bMain) {
if ( !bMain ) return;
- CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile
if ( pile == NULL ) return;
switch( pile->GivState() )
- { // il y a 2 �tats possibles (selon reprise)
+ { // il y a 2 états possibles (selon reprise)
case 0:
- // restitue le bloc d'instruction associ�
+ // restitue le bloc d'instruction associé
if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);
return;
@@ -434,13 +444,13 @@ CBotFor::~CBotFor() delete m_Init;
delete m_Test;
delete m_Incr;
- delete m_Block; // lib�re le bloc d'instruction
+ delete m_Block; // libère le bloc d'instruction
}
CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotFor* inst = new CBotFor(); // cr�e l'objet
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotFor* inst = new CBotFor(); // crée l'objet
+ CBotToken* pp = p; // conserve le ^au token (position début)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
@@ -451,7 +461,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack) inst->SetToken(p);
if (!IsOfType(p, ID_FOR)) return NULL; // ne devrait jamais arriver
- if ( !IsOfType(p, ID_OPENPAR)) // manque la parenth�se ?
+ if ( !IsOfType(p, ID_OPENPAR)) // manque la parenthèse ?
{
pStack->SetError(TX_OPENPAR, p->GivStart());
return NULL;
@@ -481,7 +491,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_Incr = CBotListExpression::Compile( p, pStk );
if ( pStk->IsOk() )
{
- if ( IsOfType(p, ID_CLOSEPAR)) // manque la parenth�se ?
+ if ( IsOfType(p, ID_CLOSEPAR)) // manque la parenthèse ?
{
IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
@@ -494,65 +504,65 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack) }
}
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile
}
-// ex�cute l'instruction "for"
+// exécute l'instruction "for"
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->IfStep() ) return FALSE;
- while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle
- { // il y a 4 �tats possibles (selon reprise)
+ while( TRUE ) switch( pile->GivState() ) // exécute la boucle
+ { // il y a 4 états possibles (selon reprise)
case 0:
- // �value l'initialisation
+ // é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
+ if (!pile->SetState(1)) return FALSE; // prêt pour la suite
case 1:
- // �value la condition
+ // évalue la condition
if ( m_Test != NULL ) // pas de condition ? -> vrai !
{
if (!m_Test->Execute(pile) ) return FALSE; // interrompu ici ?
- // le r�sultat de la condition est sur la pile
+ // le résultat de la condition est sur la pile
// termine s'il y a une erreur ou si la condition est fausse
if ( !pile->IsOk() || pile->GivVal() != TRUE )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
}
- // la condition est vrai, passe � la suite
- if (!pile->SetState(2)) return FALSE; // pr�t pour la suite
+ // la condition est vrai, passe à la suite
+ if (!pile->SetState(2)) return FALSE; // prêt pour la suite
case 2:
- // �value le bloc d'instruction associ�
+ // évalue le bloc d'instruction associé
if ( m_Block != NULL &&
!m_Block->Execute(pile) )
{
- if (pile->IfContinue(3, m_label)) continue; // si continue, passe � l'incr�mentation
- return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile
+ if (pile->IfContinue(3, m_label)) continue; // si continue, passe à l'incrémentation
+ return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile
}
// termine s'il y a une erreur
if ( !pile->IsOk() )
{
- return pj->Return(pile); // transmet le r�sultat et lib�re la pile
+ return pj->Return(pile); // transmet le résultat et libère la pile
}
- if (!pile->SetState(3)) return FALSE; // pr�t pour la suite
+ if (!pile->SetState(3)) return FALSE; // prêt pour la suite
case 3:
- // �value l'incr�mentation
+ // évalue l'incrémentation
if ( m_Incr != NULL &&
!m_Incr->Execute(pile) ) return FALSE; // interrompu ici ?
@@ -566,34 +576,34 @@ void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain) {
if ( !bMain ) return;
- CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile (variables locales)
+ CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile (variables locales)
if ( pile == NULL ) return;
switch( pile->GivState() )
- { // il y a 4 �tats possibles (selon reprise)
+ { // il y a 4 états possibles (selon reprise)
case 0:
- // �value l'initialisation
+ // évalue l'initialisation
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
+ // évalue la condition
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�
+ // évalue le bloc d'instruction associé
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
+ // évalue l'incrémentation
if ( m_Incr != NULL ) m_Incr->RestoreState(pile, TRUE); // interrompu ici !
return;
}
@@ -601,8 +611,8 @@ void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
// compile une liste d'expression
-// n'est utilis� que pour l'instruction for
-// dans l'intitialisation et dans l'incr�mentation
+// n'est utilisé que pour l'instruction for
+// dans l'intitialisation et dans l'incrémentation
CBotListExpression::CBotListExpression()
{
@@ -615,14 +625,14 @@ CBotListExpression::~CBotListExpression() delete m_Expr;
}
-// cherche une d�claration de variable ou une expression
+// cherche une déclaration de variable ou une expression
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;
}
@@ -631,13 +641,13 @@ CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotListExpression* inst = new CBotListExpression();
- inst->m_Expr = CompileInstrOrDefVar( p, pStack ); // compile la premi�re expression de la liste
+ inst->m_Expr = CompileInstrOrDefVar( p, pStack ); // compile la première expression de la liste
if (pStack->IsOk())
{
while ( IsOfType(p, ID_COMMA) ) // plusieurs instructions ?
{
- CBotInstr* i = CompileInstrOrDefVar( p, pStack ); // est-ce une d�claration d'un entier ?
- inst->m_Expr->AddNext(i); // ajoute � la suite
+ CBotInstr* i = CompileInstrOrDefVar( p, pStack ); // est-ce une déclaration d'un entier ?
+ inst->m_Expr->AddNext(i); // ajoute à la suite
if ( !pStack->IsOk() )
{
delete inst;
@@ -653,17 +663,17 @@ CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack) BOOL CBotListExpression::Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack();// indispensable
- CBotInstr* p = m_Expr; // la premi�re expression
+ CBotInstr* p = m_Expr; // la première expression
int state = pile->GivState();
- while (state-->0) p = p->GivNext(); // revient sur l'op�ration interrompue
+ while (state-->0) p = p->GivNext(); // revient sur l'opération interrompue
if ( p != NULL ) while (TRUE)
{
if ( !p->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);
}
@@ -680,12 +690,12 @@ void CBotListExpression::RestoreState(CBotStack* &pj, BOOL bMain) state = pile->GivState();
}
- CBotInstr* p = m_Expr; // la premi�re expression
+ CBotInstr* p = m_Expr; // la première expression
while (p != NULL && state-->0)
{
p->RestoreState(pile, FALSE);
- p = p->GivNext(); // revient sur l'op�ration interrompue
+ p = p->GivNext(); // revient sur l'opération interrompue
}
if ( p != NULL )
@@ -708,15 +718,15 @@ CBotSwitch::CBotSwitch() CBotSwitch::~CBotSwitch()
{
- delete m_Value; // lib�re la valeur
- delete m_Block; // lib�re le bloc d'instruction
+ delete m_Value; // libère la valeur
+ delete m_Block; // libère le bloc d'instruction
}
CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotSwitch* inst = new CBotSwitch(); // cr�e l'objet
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotSwitch* inst = new CBotSwitch(); // crée l'objet
+ CBotToken* pp = p; // conserve le ^au token (position début)
inst->SetToken(p);
if (!IsOfType(p, ID_SWITCH)) return NULL; // ne devrait jamais arriver
@@ -784,7 +794,7 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk);
}
// le bloc d'instruction est ok
- return pStack->Return(inst, pStk); // rend l'objet � qui le demande
+ return pStack->Return(inst, pStk); // rend l'objet à qui le demande
}
pStk->SetError( TX_OPENBLK, p->GivStart() );
}
@@ -795,18 +805,18 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack) }
pStk->SetError( TX_OPENPAR, p->GivStart());
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile
}
-// ex�cute une instruction "switch"
+// exécute une instruction "switch"
BOOL CBotSwitch :: Execute(CBotStack* &pj)
{
- CBotStack* pile1 = pj->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile
// if ( pile1 == EOX ) return TRUE;
- CBotInstr* p = m_Block; // la premi�re expression
+ CBotInstr* p = m_Block; // la première expression
int state = pile1->GivState();
if (state == 0)
@@ -820,23 +830,23 @@ BOOL CBotSwitch :: Execute(CBotStack* &pj) if ( state == -1 )
{
state = 0;
- int val = pile1->GivVal(); // r�sultat de la valeur
+ int val = pile1->GivVal(); // résultat de la valeur
CBotStack* pile2 = pile1->AddStack();
while ( p != NULL ) // recherche le case correspondant dans la liste
{
state++;
- if ( p->CompCase( pile2, val ) ) break; // trouv� le case
+ if ( p->CompCase( pile2, val ) ) break; // trouvé le case
p = p->GivNext();
}
pile2->Delete();
- if ( p == NULL ) return pj->Return(pile1); // termin� si plus rien
+ if ( p == NULL ) return pj->Return(pile1); // terminé si plus rien
if ( !pile1->SetState(state) ) return FALSE;
}
- p = m_Block; // revient au d�but
+ p = m_Block; // revient au début
while (state-->0) p = p->GivNext(); // avance dans la liste
while( p != NULL )
@@ -852,10 +862,10 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain) {
if ( !bMain ) return;
- CBotStack* pile1 = pj->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile1 = pj->RestoreStack(this); // ajoute un élément à la pile
if ( pile1 == NULL ) return;
- CBotInstr* p = m_Block; // la premi�re expression
+ CBotInstr* p = m_Block; // la première expression
int state = pile1->GivState();
if (state == 0)
@@ -869,7 +879,7 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain) return;
}
-// p = m_Block; // revient au d�but
+// p = m_Block; // revient au début
while ( p != NULL && state-- > 0 )
{
p->RestoreState(pile1, FALSE);
@@ -887,7 +897,7 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain) ///////////////////////////////////////////////////////////////////////////
// compile une instruction "case"
-// on est forc�ment dans un bloc d'instruction "switch"
+// on est forcément dans un bloc d'instruction "switch"
CBotCase::CBotCase()
{
@@ -897,14 +907,14 @@ CBotCase::CBotCase() CBotCase::~CBotCase()
{
- delete m_Value; // lib�re la valeur
+ delete m_Value; // libère la valeur
}
CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotCase* inst = new CBotCase(); // cr�e l'objet
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotCase* inst = new CBotCase(); // crée l'objet
+ CBotToken* pp = p; // conserve le ^au token (position début)
inst->SetToken(p);
if (!IsOfType(p, ID_CASE, ID_DEFAULT)) return NULL; // ne devrait jamais arriver
@@ -930,7 +940,7 @@ CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack) return inst;
}
-// ex�cution de l'instruction "case"
+// exécution de l'instruction "case"
BOOL CBotCase::Execute(CBotStack* &pj)
{
@@ -941,15 +951,15 @@ void CBotCase::RestoreState(CBotStack* &pj, BOOL bMain) {
}
-// routine permettant de trouver le point d'entr�e "case"
-// correspondant � la valeur cherch�e
+// routine permettant de trouver le point d'entrée "case"
+// correspondant à la valeur cherchée
BOOL CBotCase::CompCase(CBotStack* &pile, int val)
{
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
+ return (pile->GivVal() == val); // compare avec la valeur cherchée
}
///////////////////////////////////////////////////////////////////////////
@@ -968,7 +978,7 @@ CBotBreak::~CBotBreak() CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotToken* pp = p; // conserve le ^au token (position début)
int type = p->GivType();
if (!IsOfType(p, ID_BREAK, ID_CONTINUE)) return NULL; // ne devrait jamais arriver
@@ -979,8 +989,8 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack) return NULL; // pas d'objet, l'erreur est sur la pile
}
- CBotBreak* inst = new CBotBreak(); // cr�e l'objet
- inst->SetToken(pp); // garde l'op�ration
+ CBotBreak* inst = new CBotBreak(); // crée l'objet
+ inst->SetToken(pp); // garde l'opération
pp = p;
if ( IsOfType( p, TokenTypVar ) )
@@ -996,7 +1006,7 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack) if (IsOfType(p, ID_SEP))
{
- return inst; // et le donne � qui veux
+ return inst; // et le donne à qui veux
}
delete inst;
@@ -1004,7 +1014,7 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack) return NULL; // pas d'objet, l'erreur est sur la pile
}
-// ex�cution l'instructino "break" ou "continu"
+// exécution l'instructino "break" ou "continu"
BOOL CBotBreak :: Execute(CBotStack* &pj)
{
@@ -1038,15 +1048,15 @@ CBotTry::CBotTry() CBotTry::~CBotTry()
{
- delete m_ListCatch; // lib�re la liste
- delete m_Block; // lib�re le bloc d'instruction
+ delete m_ListCatch; // libère la liste
+ delete m_Block; // libère le bloc d'instruction
delete m_FinalInst;
}
CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotTry* inst = new CBotTry(); // cr�e l'objet
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotTry* inst = new CBotTry(); // crée l'objet
+ CBotToken* pp = p; // conserve le ^au token (position début)
inst->SetToken(p);
if (!IsOfType(p, ID_TRY)) return NULL; // ne devrait jamais arriver
@@ -1070,28 +1080,28 @@ CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack) if (pStk->IsOk())
{
- return pStack->Return(inst, pStk); // rend l'objet � qui le demande
+ return pStack->Return(inst, pStk); // rend l'objet à qui le demande
}
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile
}
-// ex�cute l'instruction Try
-// g�re le retour d'exceptions
-// les arr�ts par suspension
+// exécute l'instruction Try
+// gère le retour d'exceptions
+// les arrêts par suspension
// et les "finaly"
BOOL CBotTry :: Execute(CBotStack* &pj)
{
int val;
- CBotStack* pile1 = pj->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile
// if ( pile1 == EOX ) return TRUE;
if ( pile1->IfStep() ) return FALSE;
// ou le retrouve en cas de reprise
- CBotStack* pile0 = pj->AddStack2(); // ajoute un �l�ment � la pile secondaire
+ CBotStack* pile0 = pj->AddStack2(); // ajoute un élément à la pile secondaire
CBotStack* pile2 = pile0->AddStack();
if ( pile1->GivState() == 0 )
@@ -1107,7 +1117,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) return FALSE; // ne fait pas le catch
pile1->IncState();
- pile2->SetState(val); // m�morise le num�ro de l'erreur
+ pile2->SetState(val); // mémorise le numéro de l'erreur
pile1->SetError(0); // pour l'instant il n'y a plus d'erreur !
if ( val == 0 && CBotStack::m_initimer < 0 ) // en mode de step ?
@@ -1118,7 +1128,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) // voir de quoi il en retourne
CBotCatch* pc = m_ListCatch;
- int state = (short)pile1->GivState(); // o� en �tions-nous ?
+ int state = (short)pile1->GivState(); // où en étions-nous ?
val = pile2->GivState(); // pour quelle erreur ?
pile0->SetState(1); // marquage pour GetRunPos
@@ -1126,7 +1136,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) {
if ( --state <= 0 )
{
- // demande au bloc catch s'il se sent concern�
+ // demande au bloc catch s'il se sent concerné
if ( !pc->TestCatch(pile2, val) ) return FALSE; // suspendu !
pile1->IncState();
}
@@ -1136,7 +1146,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) {
// 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
@@ -1160,8 +1170,8 @@ BOOL CBotTry :: Execute(CBotStack* &pj) return pj->Return(pile2);
}
- pile1->SetState(0); // revient � l'�valuation
- pile0->SetState(0); // revient � l'�valuation
+ pile1->SetState(0); // revient à l'évaluation
+ pile0->SetState(0); // revient à l'évaluation
if ( val != 0 && m_ListCatch == NULL && m_FinalInst == NULL )
return pj->Return(pile2); // termine le try sans exception aucune
@@ -1175,10 +1185,10 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain) if ( !bMain ) return;
int val;
- CBotStack* pile1 = pj->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pile1 = pj->RestoreStack(this); // ajoute un élément à la pile
if ( pile1 == NULL ) return;
// ou le retrouve en cas de reprise
- CBotStack* pile0 = pj->AddStack2(); // ajoute un �l�ment � la pile secondaire
+ CBotStack* pile0 = pj->AddStack2(); // ajoute un élément à la pile secondaire
if ( pile0 == NULL ) return;
CBotStack* pile2 = pile0->RestoreStack();
@@ -1194,14 +1204,14 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain) // voir de quoi il en retourne
CBotCatch* pc = m_ListCatch;
- int state = pile1->GivState(); // o� en �tions-nous ?
+ int state = pile1->GivState(); // où en étions-nous ?
val = pile2->GivState(); // pour quelle erreur ?
if ( val >= 0 && state > 0 ) while ( pc != NULL )
{
if ( --state <= 0 )
{
- // demande au bloc catch s'il se sent concern�
+ // demande au bloc catch s'il se sent concerné
pc->RestoreCondState(pile2, bMain); // suspendu !
return;
}
@@ -1209,7 +1219,7 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain) {
if ( pile2->GivVal() == TRUE )
{
- pc->RestoreState(pile2, bMain); // ex�cute l'op�ration
+ pc->RestoreState(pile2, bMain); // exécute l'opération
return;
}
}
@@ -1239,14 +1249,14 @@ CBotCatch::CBotCatch() CBotCatch::~CBotCatch()
{
- delete m_Cond; // lib�re la liste
- delete m_Block; // lib�re le bloc d'instruction
+ delete m_Cond; // libère la liste
+ delete m_Block; // libère le bloc d'instruction
delete m_next; // et la suite
}
CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotCatch* inst = new CBotCatch(); // cr�e l'objet
+ CBotCatch* inst = new CBotCatch(); // crée l'objet
pStack->SetStartError(p->GivStart());
inst->SetToken(p);
@@ -1262,23 +1272,23 @@ CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack) {
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStack );
if ( pStack->IsOk() )
- return inst; // rend l'objet � qui le demande
+ return inst; // rend l'objet à qui le demande
}
pStack->SetError(TX_CLOSEPAR, p->GivStart());
}
pStack->SetError(TX_BADTYPE, p->GivStart());
}
pStack->SetError(TX_OPENPAR, p->GivStart());
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return NULL; // pas d'objet, l'erreur est sur la pile
}
-// ex�cution de "catch"
+// exécution de "catch"
BOOL CBotCatch :: Execute(CBotStack* &pj)
{
if ( m_Block == NULL ) return TRUE;
- return m_Block->Execute(pj); // ex�cute le bloc associ�
+ return m_Block->Execute(pj); // exécute le bloc associé
}
void CBotCatch :: RestoreState(CBotStack* &pj, BOOL bMain)
@@ -1291,7 +1301,7 @@ void CBotCatch :: RestoreCondState(CBotStack* &pj, BOOL bMain) m_Cond->RestoreState(pj, bMain);
}
-// routine pour savoir si le catch est � faire ou non
+// routine pour savoir si le catch est à faire ou non
BOOL CBotCatch :: TestCatch(CBotStack* &pile, int val)
{
@@ -1328,10 +1338,10 @@ CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack) {
pStack->SetStartError(p->GivStart());
- CBotThrow* inst = new CBotThrow(); // cr�e l'objet
+ CBotThrow* inst = new CBotThrow(); // crée l'objet
inst->SetToken(p);
- CBotToken* pp = p; // conserve le ^au token (position d�but)
+ CBotToken* pp = p; // conserve le ^au token (position début)
if (!IsOfType(p, ID_THROW)) return NULL; // ne devrait jamais arriver
@@ -1339,15 +1349,15 @@ CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack) if (pStack->GivType() < CBotTypLong && pStack->IsOk())
{
- return inst; // rend l'objet � qui le demande
+ return inst; // rend l'objet à qui le demande
}
pStack->SetError(TX_BADTYPE, pp);
- delete inst; // erreur, lib�re la place
+ delete inst; // erreur, libère la place
return NULL; // pas d'objet, l'erreur est sur la pile
}
-// ex�cute l'instruction "throw"
+// exécute l'instruction "throw"
BOOL CBotThrow :: Execute(CBotStack* &pj)
{
@@ -1401,11 +1411,11 @@ CBotInstr* CBotStartDebugDD::Compile(CBotToken* &p, CBotCStack* pStack) if (!IsOfType(p, ID_DEBUGDD)) return NULL; // ne devrait jamais arriver
- return new CBotStartDebugDD(); // cr�e l'objet
+ return new CBotStartDebugDD(); // crée l'objet
}
-// ex�cute l'instruction "throw"
+// exécute l'instruction "throw"
BOOL CBotStartDebugDD :: Execute(CBotStack* &pj)
{
diff --git a/src/CBot/ClassFILE.cpp b/src/CBot/ClassFILE.cpp index 6d284ae..c80e109 100644 --- a/src/CBot/ClassFILE.cpp +++ b/src/CBot/ClassFILE.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// ClassFile.cpp
+//
+// définition des méthodes pour la classe FILE
@@ -24,7 +26,7 @@ static int m_CompteurFileOpen = 0; -// Pr�pare un nom de fichier.
+// Prépare un nom de fichier.
void PrepareFilename(CBotString &filename) //DD!
{
@@ -33,7 +35,7 @@ void PrepareFilename(CBotString &filename) //DD! pos = filename.ReverseFind('\\');
if ( pos > 0 )
{
- filename = filename.Mid(pos+1); // enl�ve les dossiers
+ filename = filename.Mid(pos+1); // enlève les dossiers
}
pos = filename.ReverseFind('/');
@@ -45,7 +47,7 @@ void PrepareFilename(CBotString &filename) //DD! pos = filename.ReverseFind(':');
if ( pos > 0 )
{
- filename = filename.Mid(pos+1); // enl�ve aussi la lettre d'unit� C:
+ filename = filename.Mid(pos+1); // enlève aussi la lettre d'unité C:
}
filename = CBotString("files\\") + filename;
@@ -53,31 +55,31 @@ void PrepareFilename(CBotString &filename) //DD! // constructeur de la classe
-// re�ois le nom du fichier en param�tre
+// reçois le nom du fichier en paramètre
-// ex�cution
+// exécution
BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
CBotString mode;
- // accepte sans param�tre
+ // accepte sans paramètre
if ( pVar == NULL ) return TRUE;
- // qui doit �tre une cha�ne de caract�res
+ // qui doit être une chaîne de caractères
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }
CBotString filename = pVar->GivValString();
PrepareFilename(filename); //DR
- // il peut y avoir un second param�tre
+ // il peut y avoir un second paramètre
pVar = pVar->GivNext();
if ( pVar != NULL )
{
- // r�cup�re le mode
+ // récupère le mode
mode = pVar->GivValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return FALSE; }
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return FALSE; }
}
@@ -87,7 +89,7 @@ BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio if ( ! mode.IsEmpty() )
{
- // ouvre le ficher demand�
+ // ouvre le ficher demandé
FILE* pFile = fopen( filename, mode );
if ( pFile == NULL ) { Exception = CBotErrFileOpen; return FALSE; }
@@ -104,38 +106,38 @@ BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio // compilation
CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
{
- // accepte sans param�tre
+ // accepte sans paramètre
if ( pVar == NULL ) return CBotTypResult( 0 );
- // qui doit �tre une chaine
+ // qui doit être une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // il peut y avoir un second param�tre
+ // il peut y avoir un second paramètre
pVar = pVar->GivNext();
if ( pVar != NULL )
{
- // qui doit �tre une chaine
+ // qui doit être une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
- // le r�sultat est de type void (constructeur)
+ // le résultat est de type void (constructeur)
return CBotTypResult( 0 );
}
// destructeur de la classe
-// ex�cution
+// exécution
BOOL rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // r�cup�re l'�l�ment "handle"
+ // récupère l'élément "handle"
pVar = pThis->GivItem("handle");
- // pas ouvert ? pas de probl�me
+ // pas ouvert ? pas de problème
if ( pVar->GivInit() != IS_DEF) return TRUE;
FILE* pFile= (FILE*)pVar->GivValInt();
@@ -148,22 +150,22 @@ BOOL rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception }
-// m�thode FILE :: open
-// re�ois le mode r/w en param�tre
+// méthode FILE :: open
+// reçois le mode r/w en paramètre
-// ex�cution
+// exécution
BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il doit y avoir un param�tre
+ // il doit y avoir un paramètre
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
- // qui doit �tre une cha�ne de caract�res
+ // qui doit être une chaîne de caractères
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }
- // il peut y avoir un second param�tre
+ // il peut y avoir un second paramètre
if ( pVar->GivNext() != NULL )
{
- // dans ce cas le premier param�tre est le nom du fichier
+ // dans ce cas le premier paramètre est le nom du fichier
CBotString filename = pVar->GivValString();
PrepareFilename(filename); //DR
@@ -171,29 +173,29 @@ BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) CBotVar* pVar2 = pThis->GivItem("filename");
pVar2->SetValString(filename);
- // param�tre suivant est le mode
+ // paramètre suivant est le mode
pVar = pVar -> GivNext();
}
CBotString mode = pVar->GivValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return FALSE; }
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return FALSE; }
- // r�cup�re l'�l�ment "handle"
+ // récupère l'élément "handle"
pVar = pThis->GivItem("handle");
- // qui doit pas �tre initialis�
+ // qui doit pas être initialisé
if ( pVar->GivInit() == IS_DEF) { Exception = CBotErrFileOpen; return FALSE; }
// reprend le nom du fichier
pVar = pThis->GivItem("filename");
CBotString filename = pVar->GivValString();
- PrepareFilename(filename); //DD! (si le nom a �t� attribu� par h.filename = "...";
+ PrepareFilename(filename); //DD! (si le nom a été attribué par h.filename = "...";
- // ouvre le ficher demand�
+ // ouvre le ficher demandé
FILE* pFile = fopen( filename, mode );
if ( pFile == NULL ) //DR
{
@@ -214,39 +216,39 @@ BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)
{
- // il doit y avoir un param�tre
+ // il doit y avoir un paramètre
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
- // qui doit �tre une chaine
+ // qui doit être une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // il peut y avoir un second param�tre
+ // il peut y avoir un second paramètre
pVar = pVar->GivNext();
if ( pVar != NULL )
{
- // qui doit �tre une chaine
+ // qui doit être une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
- // le r�sultat est de type bool
+ // le résultat est de type bool
return CBotTypResult(CBotTypBoolean); //DR
}
-// m�thode FILE :: close
+// méthode FILE :: close
-// ex�cution
+// exécution
BOOL rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il ne doit pas y avoir de param�tre
+ // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) return CBotErrOverParam;
- // r�cup�re l'�l�ment "handle"
+ // récupère l'élément "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -263,27 +265,27 @@ BOOL rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfclose (CBotVar* pThis, CBotVar* &pVar)
{
- // il ne doit pas y avoir de param�tre
+ // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un r�sultat "void"
+ // la fonction retourne un résultat "void"
return CBotTypResult( 0 );
}
-// m�thode FILE :: writeln
+// méthode FILE :: writeln
-// ex�cution
+// exécution
BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il doit y avoir un param�tre
+ // il doit y avoir un paramètre
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
- // qui doit �tre une cha�ne de caract�res
+ // qui doit être une chaîne de caractères
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }
CBotString param = pVar->GivValString();
- // r�cup�re l'�l�ment "handle"
+ // récupère l'élément "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -292,7 +294,7 @@ BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) int res = fputs(param+"\n", pFile);
- // en cas d'erreur g�n�re une exception
+ // en cas d'erreur génère une exception
if ( res < 0 ) { Exception = CBotErrWrite; return FALSE; }
return TRUE;
@@ -301,28 +303,28 @@ BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)
{
- // il doit y avoir un param�tre
+ // il doit y avoir un paramètre
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
- // qui doit �tre une cha�ne de caract�res
+ // qui doit être une chaîne de caractères
if ( pVar->GivType() != CBotTypString ) return CBotTypResult( CBotErrBadString );
- // pas d'autre param�tre
+ // pas d'autre paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un r�sultat void
+ // la fonction retourne un résultat void
return CBotTypResult( 0 );
}
-// m�thode FILE :: readln
+// méthode FILE :: readln
-// ex�cution
+// exécution
BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il ne doit pas y avoir de param�tre
+ // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }
- // r�cup�re l'�l�ment "handle"
+ // récupère l'élément "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -337,7 +339,7 @@ BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) for ( i = 0 ; i < 2000 ; i++ ) if (chaine[i] == '\n') chaine[i] = 0;
- // en cas d'erreur g�n�re une exception
+ // en cas d'erreur génère une exception
if ( ferror(pFile) ) { Exception = CBotErrRead; return FALSE; }
pResult->SetValString( chaine );
@@ -348,22 +350,22 @@ BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfread (CBotVar* pThis, CBotVar* &pVar)
{
- // il ne doit pas y avoir de param�tre
+ // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un r�sultat "string"
+ // la fonction retourne un résultat "string"
return CBotTypResult( CBotTypString );
}
-// m�thode FILE :: readln
+// méthode FILE :: readln
-// ex�cution
+// exécution
BOOL rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il ne doit pas y avoir de param�tre
+ // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }
- // r�cup�re l'�l�ment "handle"
+ // récupère l'élément "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -378,10 +380,10 @@ BOOL rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfeof (CBotVar* pThis, CBotVar* &pVar)
{
- // il ne doit pas y avoir de param�tre
+ // il ne doit pas y avoir de paramètre
if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un r�sultat booleen
+ // la fonction retourne un résultat booleen
return CBotTypResult( CBotTypBoolean );
}
@@ -391,25 +393,25 @@ CBotTypResult cfeof (CBotVar* pThis, CBotVar* &pVar) void InitClassFILE()
{
-// cr�e une classe pour la gestion des fichiers
+// crée une classe pour la gestion des fichiers
// l'utilisation en est la suivante:
// file canal( "NomFichier.txt" )
// canal.open( "r" ); // ouvre en lecture
// s = canal.readln( ); // lit une ligne
// canal.close(); // referme le fichier
- // cr�e la classe FILE
+ // crée la classe FILE
m_pClassFILE = new CBotClass("file", NULL);
// ajoute le composant ".filename"
m_pClassFILE->AddItem("filename", CBotTypString);
// ajoute le composant ".handle"
m_pClassFILE->AddItem("handle", CBotTypInt, PR_PRIVATE);
- // d�fini un constructeur et un destructeur
+ // défini un constructeur et un destructeur
m_pClassFILE->AddFunction("file", rfconstruct, cfconstruct );
m_pClassFILE->AddFunction("~file", rfdestruct, NULL );
- // d�fini les m�thodes associ�es
+ // défini les méthodes associées
m_pClassFILE->AddFunction("open", rfopen, cfopen );
m_pClassFILE->AddFunction("close", rfclose, cfclose );
m_pClassFILE->AddFunction("writeln", rfwrite, cfwrite );
@@ -419,6 +421,6 @@ void InitClassFILE() m_pFuncFile = new CBotProgram( );
CBotStringArray ListFonctions;
m_pFuncFile->Compile( "public file openfile(string name, string mode) {return new file(name, mode);}", ListFonctions);
- m_pFuncFile->SetIdent(-2); // identificateur sp�cial pour RestoreState dans cette fonction
+ m_pFuncFile->SetIdent(-2); // identificateur spécial pour RestoreState dans cette fonction
}
diff --git a/src/CBot/Copie b/src/CBot/Copie new file mode 100644 index 0000000..ea18736 --- /dev/null +++ b/src/CBot/Copie @@ -0,0 +1,15 @@ +// * 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/.
\ No newline at end of file diff --git a/src/CBot/Copie de CBotTwoOpExpr.cpp b/src/CBot/Copie de CBotTwoOpExpr.cpp index 763eb95..7a95b55 100644 --- a/src/CBot/Copie de CBotTwoOpExpr.cpp +++ b/src/CBot/Copie de CBotTwoOpExpr.cpp @@ -1,18 +1,6 @@ -// * 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/.
+///////////////////////////////////////////////////
+// expression du genre Opérande1 + Opérande2
+// Opérande1 > Opérande2
#include "CBot.h"
@@ -31,14 +19,14 @@ CBotTwoOpExpr::~CBotTwoOpExpr() delete m_rightop;
}
-// type d'op�randes accept�s par les op�rations
+// type d'opérandes acceptés par les opérations
#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
#define BOOLEEN (1<<CBotTypBoolean)
#define CHAINE (1<<CBotTypString)
#define CLASSE (1<<CBotTypClass)
-// liste des op�rations (pr�c�ance)
+// liste des opérations (précéance)
static int ListOp[] =
{
BOOLEEN, ID_LOG_OR, 0,
@@ -94,35 +82,35 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
- // cherche des instructions qui peuvent convenir � gauche de l'op�ration
+ // cherche des instructions qui peuvent convenir à gauche de l'opération
CBotInstr* left = (*pOp == 0) ?
- CBotParExpr::Compile( p, pStk ) : // expression (...) � gauche
- CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B � gauche
+ CBotParExpr::Compile( p, pStk ) : // expression (...) à gauche
+ CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B à gauche
if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
- // est-ce qu'on a l'op�rande pr�vu ensuite ?
+ // est-ce qu'on a l'opérande prévu ensuite ?
int TypeOp = p->GetType();
if ( IsInList( TypeOp, pOperations, typemasque ) )
{
- CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // �l�ment pour op�ration
- inst->SetToken(p); // m�morise l'op�ration
+ CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // élément pour opération
+ inst->SetToken(p); // mémorise l'opération
int type1, type2;
- type1 = pStk->GetType(); // de quel type le premier op�rande ?
+ type1 = pStk->GetType(); // de quel type le premier opérande ?
- p = p->Next(); // saute le token de l'op�ration
+ p = p->Next(); // saute le token de l'opération
- // cherche des instructions qui peuvent convenir � droite
+ // cherche des instructions qui peuvent convenir à droite
if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOperations )) )
- // expression (...) � droite
+ // expression (...) à droite
{
- // il y a un second op�rande acceptable
+ // il y a un second opérande acceptable
- type2 = pStk->GetType(); // de quel type le r�sultat ?
+ type2 = pStk->GetType(); // de quel type le résultat ?
- // quel est le type du r�sultat ?
+ // quel est le type du résultat ?
int TypeRes = MAX( type1, type2 );
if (!TypeOk( TypeRes, typemasque )) type1 = 99; // erreur de type
@@ -138,81 +126,81 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera case ID_LS:
TypeRes = CBotTypBoolean;
}
- if ( TypeCompatible (type1, type2) || // les r�sultats sont-ils compatibles
- // cas particulier pour les concat�nation de cha�nes
+ if ( TypeCompatible (type1, type2) || // les résultats sont-ils compatibles
+ // cas particulier pour les concaténation de chaînes
(TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString)))
{
- // si ok, enregistre l'op�rande dans l'objet
+ // si ok, enregistre l'opérande dans l'objet
inst->m_leftop = left;
- // met une variable sur la pile pour avoir le type de r�sultat
+ // met une variable sur la pile pour avoir le type de résultat
pStk->SetVar(new CBotVar(NULL, TypeRes));
- // et rend l'object � qui l'a demand�
+ // et rend l'object à qui l'a demandé
return pStack->Return(inst, pStk);
}
pStk->SetError(TX_BAD2TYPE, &inst->m_token);
}
- // en cas d'erreur, lib�re les �l�ments
+ // en cas d'erreur, libère les éléments
delete left;
delete inst;
// et transmet l'erreur qui se trouve sur la pile
return pStack->Return(NULL, pStk);
}
- // si on n'a pas affaire � une op�ration + ou -
- // rend � qui l'a demand�, l'op�rande (de gauche) trouv�
- // � la place de l'objet "addition"
+ // si on n'a pas affaire à une opération + ou -
+ // rend à qui l'a demandé, l'opérande (de gauche) trouvé
+ // à la place de l'objet "addition"
return pStack->Return(left, pStk);
}
-// fait l'op�ration d'addition ou de soustraction
+// fait l'opération d'addition ou de soustraction
BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
- if ( pStk1->GetState() == 0 && // 1er �tat, �value l'op�rande de gauche
+ if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- // passe � l'�tape suivante
- pStk1->SetState(1); // pr�t pour la suite
+ // passe à l'étape suivante
+ pStk1->SetState(1); // prêt pour la suite
- // pour les OU et ET logique, n'�value pas la seconde expression si pas n�cessaire
+ // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE )
{
CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
res->SetValInt(FALSE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE )
{
CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
res->SetValInt(TRUE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
+ // demande un peu plus de stack pour ne pas toucher le résultat de gauche
// qui se trouve sur la pile, justement.
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
- // 2e �tat, �value l'op�rande de droite
+ // 2e état, évalue l'opérande de droite
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
- int type1 = pStk1->GetType(); // de quels types les r�sultats ?
+ int type1 = pStk1->GetType(); // de quels types les résultats ?
int type2 = pStk2->GetType();
- // cr�e une variable temporaire pour y mettre le r�sultat
- // quel est le type du r�sultat ?
+ // crée une variable temporaire pour y mettre le résultat
+ // quel est le type du résultat ?
int TypeRes = MAX(type1, type2);
switch ( GetTokenType() )
{
@@ -230,7 +218,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) );
int err = 0;
- // fait l'op�ration selon la demande
+ // fait l'opération selon la demande
switch (GetTokenType())
{
case ID_ADD:
@@ -249,28 +237,28 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division
break;
case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
+ temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
+ result->SetValInt(temp->GetValInt()); // converti le résultat
break;
case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
+ temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
+ result->SetValInt(temp->GetValInt()); // converti le résultat
break;
case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
+ temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
+ result->SetValInt(temp->GetValInt()); // converti le résultat
break;
case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
+ temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
+ result->SetValInt(temp->GetValInt()); // converti le résultat
break;
case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
+ temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
+ result->SetValInt(temp->GetValInt()); // converti le résultat
break;
case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
+ temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
+ result->SetValInt(temp->GetValInt()); // converti le résultat
break;
case ID_LOG_AND:
case ID_AND:
@@ -297,11 +285,11 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) }
delete temp;
- pStk2->SetVar(result); // met le r�sultat sur la pile
- if ( err ) pStk2->SetError(err, &m_token); // et l'erreur �ventuelle (division par z�ro)
+ pStk2->SetVar(result); // met le résultat sur la pile
+ if ( err ) pStk2->SetError(err, &m_token); // et l'erreur éventuelle (division par zéro)
- pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk1); // transmet le r�sultat
+ pStk1->Return(pStk2); // libère la pile
+ return pStack->Return(pStk1); // transmet le résultat
}
diff --git a/src/CBot/StringFunctions.cpp b/src/CBot/StringFunctions.cpp index 0555426..2c3cfc2 100644 --- a/src/CBot/StringFunctions.cpp +++ b/src/CBot/StringFunctions.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,24 +12,24 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// définition des fonctions sur les chaînes
-// donne la longueur d'une cha�ne
-// ex�cution
+// donne la longueur d'une chaîne
+// exécution
BOOL rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // pas de second param�tre
+ // pas de second paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
// met la longueur sur la pile
@@ -42,49 +42,49 @@ BOOL rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cIntStr( CBotVar* &pVar, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADPARAM );
- // pas de second param�tre
+ // pas de second paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le r�sultat final est un nombre entier
+ // le résultat final est un nombre entier
return CBotTypResult( CBotTypInt );
}
-// donne la partie gauche d'une cha�ne
-// ex�cution
+// donne la partie gauche d'une chaîne
+// exécution
BOOL rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second param�tre
+ // il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre un nombre
+ // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // r�cup�re ce nombre
+ // récupère ce nombre
int n = pVar->GivValInt();
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // prend la partie int�ressante
+ // prend la partie intéressante
s = s.Left( n );
// la met sur la pile
@@ -97,56 +97,56 @@ BOOL rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cStrStrInt( CBotVar* &pVar, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // il faut un second param�tre
+ // il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre un nombre
+ // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le r�sultat final est une string
+ // le résultat final est une string
return CBotTypResult( CBotTypString );
}
-// donne la partie droite d'une cha�ne
-// ex�cution
+// donne la partie droite d'une chaîne
+// exécution
BOOL rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second param�tre
+ // il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre un nombre
+ // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // r�cup�re ce nombre
+ // récupère ce nombre
int n = pVar->GivValInt();
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // prend la partie int�ressante
+ // prend la partie intéressante
s = s.Right( n );
// la met sur la pile
@@ -154,50 +154,50 @@ BOOL rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) return TRUE;
}
-// donne la partie centrale d'une cha�ne
-// ex�cution
+// donne la partie centrale d'une chaîne
+// exécution
BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second param�tre
+ // il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre un nombre
+ // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // r�cup�re ce nombre
+ // récupère ce nombre
int n = pVar->GivValInt();
- // 3e param�tre optionnel
+ // 3e paramètre optionnel
if ( pVar->GivNext() != NULL )
{
pVar = pVar->GivNext();
- // qui doit �tre un nombre
+ // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // r�cup�re ce nombre
+ // récupère ce nombre
int l = pVar->GivValInt();
- // mais pas de 4e param�tre
+ // mais pas de 4e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
- // prend la partie int�ressante
+ // prend la partie intéressante
s = s.Mid( n, l );
}
else
{
- // prend la partie int�ressante
+ // prend la partie intéressante
s = s.Mid( n );
}
@@ -206,59 +206,59 @@ BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) return TRUE;
}
-// donne la partie centrale d'une cha�ne
+// donne la partie centrale d'une chaîne
// compilation
CBotTypResult cStrStrIntInt( CBotVar* &pVar, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // il faut un second param�tre
+ // il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre un nombre
+ // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
- // 3e param�tre optionnel
+ // 3e paramètre optionnel
if ( pVar->GivNext() != NULL )
{
pVar = pVar->GivNext();
- // qui doit �tre un nombre
+ // qui doit être un nombre
if ( pVar->GivType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
- // pas de 4e param�tre
+ // pas de 4e paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
}
- // le r�sultat final est une string
+ // le résultat final est une string
return CBotTypResult( CBotTypString );
}
-// donne le nombre contenu dans une cha�ne
-// ex�cution
+// donne le nombre contenu dans une chaîne
+// exécution
BOOL rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
- // mais pas de 2e param�tre
+ // mais pas de 2e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
float val = GivNumFloat(s);
@@ -273,49 +273,49 @@ BOOL rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cFloatStr( CBotVar* &pVar, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // pas de 2e param�tre
+ // pas de 2e paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le r�sultat final est un nombre
+ // le résultat final est un nombre
return CBotTypResult( CBotTypFloat );
}
// trouve une chaine dans une autre
-// ex�cution
+// exécution
BOOL rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second param�tre
+ // il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // r�cup�re ce nombre
+ // récupère ce nombre
CBotString s2 = pVar->GivValString();
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // met le r�sultat sur la pile
+ // met le résultat sur la pile
int res = s.Find(s2);
pResult->SetValInt( res );
if ( res < 0 ) pResult->SetInit( IS_NAN );
@@ -327,43 +327,43 @@ BOOL rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cIntStrStr( CBotVar* &pVar, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // il faut un second param�tre
+ // il faut un second paramètre
pVar = pVar->GivNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // pas de 3e param�tre
+ // pas de 3e paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le r�sultat final est un nombre
+ // le résultat final est un nombre
return CBotTypResult( CBotTypInt );
}
// donne une chaine en majuscule
-// ex�cution
+// exécution
BOOL rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
- // mais pas de 2e param�tre
+ // mais pas de 2e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
@@ -375,20 +375,20 @@ BOOL rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) }
// donne une chaine en minuscules
-// ex�cution
+// exécution
BOOL rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recup�re le contenu de la string
+ // recupére le contenu de la string
CBotString s = pVar->GivValString();
- // mais pas de 2e param�tre
+ // mais pas de 2e paramètre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
@@ -404,17 +404,17 @@ BOOL rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cStrStr( CBotVar* &pVar, void* pUser )
{
- // il faut un param�tre
+ // il faut un paramètre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit �tre une string
+ // qui doit être une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // pas de 2e param�tre
+ // pas de 2e paramètre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le r�sultat final est une string
+ // le résultat final est une string
return CBotTypResult( CBotTypString );
}
diff --git a/src/CBot/TestCBot/CBotConsoleDlg.cpp b/src/CBot/TestCBot/CBotConsoleDlg.cpp index a6056df..2305bf3 100644 --- a/src/CBot/TestCBot/CBotConsoleDlg.cpp +++ b/src/CBot/TestCBot/CBotConsoleDlg.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// CBotConsoleDlg.cpp : implementation file
+//
#include "stdafx.h"
#include "TestCBot.h"
@@ -117,7 +118,7 @@ UINT ThreadProc(ThreadInfo *info) CTimeSpan ts = t - t0;
char buffer[200];
- sprintf( buffer, "\r\nEx�cution termin�e en %d secondes.\r\nInterrompue %d fois.\r\n",
+ sprintf( buffer, "\r\nExécution terminée en %d secondes.\r\nInterrompue %d fois.\r\n",
ts.GetTotalSeconds(), Cpt);
info->m_pEdit1->ReplaceSel(buffer);
@@ -181,7 +182,7 @@ void CBotConsoleDlg::OnOK() m_Edit2.EnableWindow(FALSE);
m_cOK.EnableWindow(FALSE);
- // lance un processus paral�le pour l'ex�cution
+ // lance un processus paralèle pour l'exécution
m_threadinfo.m_pWndMessage = this ;
m_threadinfo.m_pEdit1 = &m_Edit1;
diff --git a/src/CBot/TestCBot/CBotConsoleDlg.h b/src/CBot/TestCBot/CBotConsoleDlg.h index f87e168..52a6e16 100644 --- a/src/CBot/TestCBot/CBotConsoleDlg.h +++ b/src/CBot/TestCBot/CBotConsoleDlg.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,8 +12,7 @@ // * 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/.
-#if !defined(AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_)
+// * along with this program. If not, see http://www.gnu.org/licenses/.#if !defined(AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_)
#define AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
diff --git a/src/CBot/TestCBot/ChildFrm.cpp b/src/CBot/TestCBot/ChildFrm.cpp index 36a76d5..eb7f2b7 100644 --- a/src/CBot/TestCBot/ChildFrm.cpp +++ b/src/CBot/TestCBot/ChildFrm.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// ChildFrm.cpp : implementation of the CChildFrame class
+//
#include "stdafx.h"
#include "TestCBot.h"
diff --git a/src/CBot/TestCBot/ChildFrm.h b/src/CBot/TestCBot/ChildFrm.h index 04ee783..d8918d4 100644 --- a/src/CBot/TestCBot/ChildFrm.h +++ b/src/CBot/TestCBot/ChildFrm.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// ChildFrm.h : interface of the CChildFrame class
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_CHILDFRM_H__4D1BB909_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_CHILDFRM_H__4D1BB909_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/MainFrm.cpp b/src/CBot/TestCBot/MainFrm.cpp index d0ab4c6..c3f6b9f 100644 --- a/src/CBot/TestCBot/MainFrm.cpp +++ b/src/CBot/TestCBot/MainFrm.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// MainFrm.cpp : implementation of the CMainFrame class
+//
#include "stdafx.h"
#include "TestCBot.h"
diff --git a/src/CBot/TestCBot/MainFrm.h b/src/CBot/TestCBot/MainFrm.h index 1bdf61b..0c4e737 100644 --- a/src/CBot/TestCBot/MainFrm.h +++ b/src/CBot/TestCBot/MainFrm.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// MainFrm.h : interface of the CMainFrame class
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_MAINFRM_H__4D1BB907_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_MAINFRM_H__4D1BB907_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/PerformDlg.cpp b/src/CBot/TestCBot/PerformDlg.cpp index af855d7..f5ccd7b 100644 --- a/src/CBot/TestCBot/PerformDlg.cpp +++ b/src/CBot/TestCBot/PerformDlg.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// PerformDlg.cpp : implementation file
+//
#include "stdafx.h"
#include "testcbot.h"
@@ -135,7 +136,7 @@ BOOL CPerformDlg::OnInitDialog() CBotStringArray liste;
- // cr�e les scripts pour les tests
+ // crée les scripts pour les tests
for ( int i = 0; i < 100; i++ )
{
m_pProg[i] = new CBotProgram();
@@ -143,7 +144,7 @@ BOOL CPerformDlg::OnInitDialog() m_pProg[i]->Start(liste[0]);
}
- // lance un processus paral�le pour l'ex�cution
+ // lance un processus paralèle pour l'exécution
// m_threadinfo2.m_pWndMessage = this ;
m_threadinfo2.m_pEdit = &m_Edit1;
diff --git a/src/CBot/TestCBot/PerformDlg.h b/src/CBot/TestCBot/PerformDlg.h index e83f542..6a9a845 100644 --- a/src/CBot/TestCBot/PerformDlg.h +++ b/src/CBot/TestCBot/PerformDlg.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,8 +12,7 @@ // * 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/.
-#if !defined(AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_)
+// * along with this program. If not, see http://www.gnu.org/licenses/.#if !defined(AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_)
#define AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
diff --git a/src/CBot/TestCBot/Routines.cpp b/src/CBot/TestCBot/Routines.cpp index 77808e2..b37f027 100644 --- a/src/CBot/TestCBot/Routines.cpp +++ b/src/CBot/TestCBot/Routines.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -14,12 +14,11 @@ // * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
-
////////////////////////////////////////////////////////////////////
// routine show()
-// utilisable depuis le programme �crit en CBot
+// utilisable depuis le programme écrit en CBot
-// ex�cution
+// exécution
BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
CString s;
@@ -47,15 +46,15 @@ BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser ) CBotTypResult cShow( CBotVar* &pVar, void* pUser)
{
if ( pVar == NULL ) return CBotTypResult(5028);
- return CBotTypResult(0); // tous param�tres accept�s, void en retour
+ return CBotTypResult(0); // tous paramètres acceptés, void en retour
}
////////////////////////////////////////////////////////////////////
// routine print()
-// utilisable depuis le programme �crit en CBot
+// utilisable depuis le programme écrit en CBot
-// ex�cution
+// exécution
BOOL rPrintLn( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
CString s;
@@ -105,19 +104,19 @@ BOOL rPrint( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser ) CBotTypResult cPrint( CBotVar* &pVar, void* pUser)
{
- return CBotTypResult(0); // tous param�tres accept�s, un entier en retour
+ return CBotTypResult(0); // tous paramètres acceptés, un entier en retour
}
//////////////////////////////////////////////////////////////////
// class CPoint pour essayer
-// ex�cution
+// exécution
BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
- if ( pVar == NULL )return TRUE; // constructeur sans param�tres est ok
+ if ( pVar == NULL )return TRUE; // constructeur sans paramètres est ok
CBotVar* pX = pThis->GivItem("x");
pX->SetValFloat( pVar->GivValFloat() );
@@ -132,20 +131,20 @@ BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception ) CBotTypResult cCPoint( CBotVar* pThis, CBotVar* &pVar)
{
- // ok si aucun param�tres !
+ // ok si aucun paramètres !
if ( pVar == NULL ) return CBotTypResult(0);
- // param�tre de type num�rique svp
+ // paramètre de type numérique svp
if ( pVar->GivType() > CBotTypDouble ) return CBotTypResult(5011);
pVar = pVar->GivNext();
- // il doit y avoir un second param�tre
+ // il doit y avoir un second paramètre
if ( pVar == NULL ) return 5028;
- // �galement de type num�rique
+ // également de type numérique
if ( pVar->GivType() > CBotTypDouble )return CBotTypResult(5011);
pVar = pVar->GivNext();
- // et pas plus de 2 param�tres svp
+ // et pas plus de 2 paramètres svp
if ( pVar != NULL ) return CBotTypResult(5026);
return CBotTypResult(0); // cette fonction retourne void
diff --git a/src/CBot/TestCBot/StdAfx.cpp b/src/CBot/TestCBot/StdAfx.cpp index a3471af..7dd0f00 100644 --- a/src/CBot/TestCBot/StdAfx.cpp +++ b/src/CBot/TestCBot/StdAfx.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// stdafx.cpp : source file that includes just the standard includes
+// TestCBot.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
diff --git a/src/CBot/TestCBot/StdAfx.h b/src/CBot/TestCBot/StdAfx.h index 8f3f644..c3659fb 100644 --- a/src/CBot/TestCBot/StdAfx.h +++ b/src/CBot/TestCBot/StdAfx.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,10 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
#if !defined(AFX_STDAFX_H__4D1BB905_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_STDAFX_H__4D1BB905_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/TestCBot.cpp b/src/CBot/TestCBot/TestCBot.cpp index afebeac..a76040a 100644 --- a/src/CBot/TestCBot/TestCBot.cpp +++ b/src/CBot/TestCBot/TestCBot.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBot.cpp : Defines the class behaviors for the application.
+//
#include "stdafx.h"
#include "TestCBot.h"
@@ -68,7 +69,7 @@ static char BASED_CODE szFilename[] = "File1"; #include "../ClassFILE.cpp"
-// routine pour mettre � jour l'instance de la classe Bot courante
+// routine pour mettre à jour l'instance de la classe Bot courante
void rMajObject( CBotVar* pThis, void* pUser )
{
if (!pThis->IsElemOfClass("object"))
@@ -89,7 +90,7 @@ void rMajObject( CBotVar* pThis, void* pUser ) // pX = pThis->GivItem( "xx" );
// pX->SetValFloat( (float)22 );
- // cr�e une instance sur une classe object
+ // crée une instance sur une classe object
// CBotVar* pAutre = CBotVar::Create("autre", CBotTypClass, "object");
// pAutre->SetUserPtr( (void*)3 );
// pPt->SetPointer( pAutre );
@@ -101,13 +102,13 @@ void rMajObject( CBotVar* pThis, void* pUser ) BOOL CTestCBotApp::InitInstance()
{
//////////////////////////////////////////////
-// d�fini les mots clefs suppl�mentaires
+// défini les mots clefs supplémentaires
// -------------------------------------------
CBotProgram::Init();
//////////////////////////////////////////////
-// d�fini les fonctions "show()" et "print()"
+// défini les fonctions "show()" et "print()"
// -------------------------------------------
CBotProgram::AddFunction("show", rShow, cShow);
@@ -116,7 +117,7 @@ BOOL CTestCBotApp::InitInstance() ///////////////////////////////////
-// d�finie la classe globale CPoint
+// définie la classe globale CPoint
// --------------------------------
m_pClassPoint = new CBotClass("CPoint", NULL);
@@ -139,7 +140,7 @@ BOOL CTestCBotApp::InitInstance() // ajoute le constructeur pour cette classe
m_pClassPointIntr->AddFunction("point", rCPoint, cCPoint);
- // d�fini la classe "object"
+ // défini la classe "object"
CBotClass* pClassObject = new CBotClass( "object", NULL ) ;
pClassObject->AddItem( "xx", CBotTypFloat );
pClassObject->AddItem( "position", CBotTypResult( CBotTypIntrinsic, "point" ) );
diff --git a/src/CBot/TestCBot/TestCBot.h b/src/CBot/TestCBot/TestCBot.h index 4067423..b3b15db 100644 --- a/src/CBot/TestCBot/TestCBot.h +++ b/src/CBot/TestCBot/TestCBot.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBot.h : main header file for the TESTCBOT application
+//
#if !defined(AFX_TESTCBOT_H__4D1BB903_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOT_H__4D1BB903_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/TestCBotDoc.cpp b/src/CBot/TestCBot/TestCBotDoc.cpp index 44d88a9..fdb8604 100644 --- a/src/CBot/TestCBot/TestCBotDoc.cpp +++ b/src/CBot/TestCBot/TestCBotDoc.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBotDoc.cpp : implementation of the CTestCBotDoc class
+//
#include "stdafx.h"
#include "TestCBot.h"
@@ -138,7 +139,7 @@ void CTestCBotDoc::OnRun() m_pProg = NULL;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
@@ -149,7 +150,7 @@ void CTestCBotDoc::OnRun() if( m_Liste.GivSize() == 0 )
{
- AfxMessageBox("Aucune fonction marqu�e \"extern\" !");
+ AfxMessageBox("Aucune fonction marquée \"extern\" !");
return;
}
@@ -173,7 +174,7 @@ void CTestCBotDoc::OnRun() TextError = m_pProg->GivErrorText( dlg.m_code );
m_pEdit->SetSel( dlg.m_start, dlg.m_end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
AfxMessageBox(TextError);
}
@@ -200,7 +201,7 @@ BOOL CTestCBotDoc::Compile() if ( m_pProg == NULL ) m_pProg = new CBotProgram();
char buffer[100];
- strcpy(buffer, "le pointeur � passer pour voir");
+ strcpy(buffer, "le pointeur à passer pour voir");
if (m_bModified && !m_pProg->Compile(m_DocText, m_Liste, (void*)buffer))
{
@@ -209,7 +210,7 @@ BOOL CTestCBotDoc::Compile() m_pProg = NULL;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
@@ -222,7 +223,7 @@ BOOL CTestCBotDoc::Compile() if ( m_pProg->GetPosition( "TheTest", start, end) )
{
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
}
m_bModified = FALSE;
@@ -232,7 +233,7 @@ BOOL CTestCBotDoc::Compile() static int compt = 0;
-// routine retournant le "pointeur" � un autre object
+// routine retournant le "pointeur" à un autre object
BOOL rRetObject( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
pResult->SetPointer( NULL );
@@ -331,7 +332,7 @@ CBotTypResult cRadar( CBotVar* &pVar, void* pUser ) return CBotTypResult( CBotTypPointer, "object");
}
-// routine retournant le "pointeur" � un autre object
+// routine retournant le "pointeur" à un autre object
BOOL rTEST( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
test = 1 ;
@@ -351,7 +352,7 @@ CBotTypResult cTEST( CBotVar* &pVar, void* pUser ) return CBotTypResult( 0 );
}
-// routine retournant le "pointeur" � un autre object
+// routine retournant le "pointeur" à un autre object
BOOL rF( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
if ( pResult == NULL ) return TRUE;
@@ -366,7 +367,7 @@ CBotTypResult cF( CBotVar* &pVar, void* pUser ) /////////////////////////////////////////////////////////////////
-// Compilation d'une proc�dure avec un "point".
+// Compilation d'une procédure avec un "point".
CBotTypResult cPoint(CBotVar* &var, void* user)
{
@@ -394,7 +395,7 @@ CBotTypResult cPoint(CBotVar* &var, void* user) return CBotTypResult( CBotErrBadParam );
}
-// Donne un param�tre de type "point".
+// Donne un paramètre de type "point".
#define UNIT 1
@@ -508,13 +509,13 @@ void CTestCBotDoc::OnTest() // dlg.m_Script = m_DocText;
// dlg.DoModal();
- // d�fini la routine RetObject
+ // défini la routine RetObject
CBotProgram::AddFunction( "Radar", rRetObject, cRetObject );
// ajoute une routine pour cette classe
CBotProgram::AddFunction("Space", rSpace, cSpace);
- // d�fini la routine Test
+ // défini la routine Test
CBotProgram::AddFunction( "TEST", rTEST, cTEST );
CBotProgram::AddFunction( "F", rF, cF );
@@ -522,13 +523,13 @@ void CTestCBotDoc::OnTest() CBotProgram::AddFunction( "fire", rTurn, cTurn );
CBotProgram::AddFunction( "radar", rRadar, cRadar );
- // cr�e une instance de la classe "Bot" pour ce robot
+ // crée une instance de la classe "Bot" pour ce robot
CBotVar* pThisRobot = CBotVar::Create( "", CBotTypResult(CBotTypClass, "object") );
pThisRobot->SetUserPtr( (void*)1 );
pThisRobot->SetIdent( 1234 );
delete m_pProg;
- // cr�e un objet programme associ� � cette instance
+ // crée un objet programme associé à cette instance
m_pProg = new CBotProgram(pThisRobot);
// compile le programme
@@ -545,7 +546,7 @@ void CTestCBotDoc::OnTest() delete pThisRobot;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
@@ -554,14 +555,14 @@ void CTestCBotDoc::OnTest() return;
}
- // ex�cute pour voir
+ // exécute pour voir
m_pProg->Start(m_Liste[0]);
int mode = -1;
if ( mode >= 0 ) {
- // sauve et restore � chaque pas possible
+ // sauve et restore à chaque pas possible
while (!m_pProg->Run(NULL, 1))
{
const char* FunctionName;
@@ -588,7 +589,7 @@ if ( mode == 2 ) if (!m_pProg->Compile(m_DocText, m_Liste, (void*) 44)) delete pThisRobot;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
diff --git a/src/CBot/TestCBot/TestCBotDoc.h b/src/CBot/TestCBot/TestCBotDoc.h index d80a397..548607f 100644 --- a/src/CBot/TestCBot/TestCBotDoc.h +++ b/src/CBot/TestCBot/TestCBotDoc.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBotDoc.h : interface of the CTestCBotDoc class
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_TESTCBOTDOC_H__4D1BB90B_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOTDOC_H__4D1BB90B_8E74_11D4_A439_00D059085115__INCLUDED_
@@ -30,8 +32,8 @@ protected: // create from serialization only // Attributes
public:
- CEdit* m_pEdit; // pour m�moriser le texte, et l'afficher
- CBotProgram* m_pProg; // le programme compil�
+ CEdit* m_pEdit; // pour mémoriser le texte, et l'afficher
+ CBotProgram* m_pProg; // le programme compilé
CString m_DocText;
CBotStringArray m_Liste;
BOOL m_bModified;
diff --git a/src/CBot/TestCBot/TestCBotView.cpp b/src/CBot/TestCBot/TestCBotView.cpp index 7f531e5..e4710cb 100644 --- a/src/CBot/TestCBot/TestCBotView.cpp +++ b/src/CBot/TestCBot/TestCBotView.cpp @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,8 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBotView.cpp : implementation of the CTestCBotView class
+//
#include "stdafx.h"
#include "TestCBot.h"
@@ -106,7 +107,7 @@ void CTestCBotView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* if ( !bActivate && !pDoc->Compile() )
{
-// comment faire pour r�activer l'ancien document
+// comment faire pour réactiver l'ancien document
}
CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
diff --git a/src/CBot/TestCBot/TestCBotView.h b/src/CBot/TestCBot/TestCBotView.h index 14de389..065ee08 100644 --- a/src/CBot/TestCBot/TestCBotView.h +++ b/src/CBot/TestCBot/TestCBotView.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,9 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBotView.h : interface of the CTestCBotView class
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_TESTCBOTVIEW_H__4D1BB90D_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOTVIEW_H__4D1BB90D_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/až1.txt b/src/CBot/TestCBot/až1.txt new file mode 100644 index 0000000..165bc95 --- /dev/null +++ b/src/CBot/TestCBot/až1.txt @@ -0,0 +1,96 @@ +object radarGuepe(point orig, float dist) +{ + int i; + object pr, r; + float mindist; + + i = 0; + mindist = 1000; + while (i<30) + { + pr = radar(i); + if (pr != null) + { + + if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3) + { + mindist = distance(orig, pr.position); + r = pr; + } + } + i = i+1; + } + if (mindist < dist) return(r); else return(null); +} + + +class Guepe +{ + + point pos; + + + void cherche(point orig, float dist) + { + object p; + point o; + + p = radarGuepe(orig, dist); + while (p == null) + { + wait(0.1); + p = radarGuepe(orig, dist); + } + + pos.x = p.position.x; + pos.y = p.position.y; + pos.z = p.position.z; + + //o = p.position; + //wait(0.1); + + //vitessex = (p.position.x - o.x)/0.1; + //vitessey = (p.position.y - o.y)/0.1; + //vitessez = (p.position.z - o.z)/0.1; + + } + + + void tire(point orig, float orient) + { + //float t = 3; //temps d'anticipation + float angle; + point cible; + + cible.x = pos.x;// + t*vitessex; + cible.y = pos.y;// + t*vitessey; + cible.z = pos.z;// + t*vitessez; + + if (cible.x == 0) angle = 90; else + angle = atan(cible.y / cible.x); + if (cible.x < 0) angle = angle + 180; + angle = angle - orient; + if (angle > 180) angle = angle - 360; + if (angle < -180) angle = angle + 360; + turn(angle); + + angle = atan((cible.z-orig.z) / distance2d(orig, cible)); + aim(angle); + + fire(0.1); + + } +} + +extern void object::Fourmi6() +{ + //fps(1000); + Guepe guepe = new Guepe(); + + while (true) + { + guepe.cherche(position, 50); + + guepe.tire(position, orientation); + } +} diff --git a/src/CBot/TestCBot/resource.h b/src/CBot/TestCBot/resource.h index 0797131..d661201 100644 --- a/src/CBot/TestCBot/resource.h +++ b/src/CBot/TestCBot/resource.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,10 @@ // * 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/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by TestCBot.rc
+//
#define IDD_ABOUTBOX 100
#define IDR_MAINFRAME 128
#define IDR_TESTCBTYPE 129
diff --git a/src/CBot/old b/src/CBot/old new file mode 100644 index 0000000..ea18736 --- /dev/null +++ b/src/CBot/old @@ -0,0 +1,15 @@ +// * 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/.
\ No newline at end of file diff --git a/src/CBot/old CBotAddExpr.cpp b/src/CBot/old CBotAddExpr.cpp index b04e3e0..85b7588 100644 --- a/src/CBot/old CBotAddExpr.cpp +++ b/src/CBot/old CBotAddExpr.cpp @@ -1,18 +1,6 @@ -// * 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/.
+///////////////////////////////////////////////////
+// expression du genre Opérande1 + Opérande2
+// Opérande1 - Opérande2
#include "CBot.h"
@@ -38,9 +26,9 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
- // cherche des instructions qui peuvent convenir � gauche de l'op�ration + ou -
+ // cherche des instructions qui peuvent convenir à gauche de l'opération + ou -
- CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B � gauche
+ CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B à gauche
if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
// est-ce qu'on a le token + ou - ensuite ?
@@ -48,82 +36,82 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotCStack* pStack) if ( p->GetType() == ID_ADD ||
p->GetType() == ID_SUB) // plus ou moins
{
- CBotAddExpr* inst = new CBotAddExpr(); // �l�ment pour op�ration
- inst->SetToken(p); // m�morise l'op�ration
+ CBotAddExpr* inst = new CBotAddExpr(); // élément pour opération
+ inst->SetToken(p); // mémorise l'opération
int type1, type2;
- type1 = pStk->GetType(CBotTypChar); // de quel type le premier op�rande ?
+ type1 = pStk->GetType(CBotTypChar); // de quel type le premier opérande ?
- p = p->Next(); // saute le token de l'op�ration
+ p = p->Next(); // saute le token de l'opération
- // cherche des instructions qui peuvent convenir � droite
+ // cherche des instructions qui peuvent convenir à droite
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) � droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) à droite
{
- // il y a un second op�rande acceptable
+ // il y a un second opérande acceptable
- type2 = pStk->GetType(CBotTypChar); // de quel type le r�sultat ?
+ type2 = pStk->GetType(CBotTypChar); // de quel type le résultat ?
- if ( type1 == type2 && // les r�sultats sont-ils compatibles
+ if ( type1 == type2 && // les résultats sont-ils compatibles
type1 != CBotTypBoolean &&
(inst->m_token.GetType() != ID_SUB ||
- type1 < CBotTypBoolean )) // pas de soustraction de cha�nes !
+ type1 < CBotTypBoolean )) // pas de soustraction de chaînes !
{
- // si ok, enregistre l'op�rande dans l'objet
+ // si ok, enregistre l'opérande dans l'objet
inst->m_leftop = left;
- // et rend l'object � qui l'a demand�
+ // et rend l'object à qui l'a demandé
return pStack->Return(inst, pStk);
}
pStk->SetError(TX_BAD2TYPE, &inst->m_token);
}
- // en cas d'erreur, lib�re les �l�ments
+ // en cas d'erreur, libère les éléments
delete left;
delete inst;
// et transmet l'erreur qui se trouve sur la pile
return pStack->Return(NULL, pStk);
}
- // si on n'a pas affaire � une op�ration + ou -
- // rend � qui l'a demand�, l'op�rande (de gauche) trouv�
- // � la place de l'objet "addition"
+ // si on n'a pas affaire à une opération + ou -
+ // rend à qui l'a demandé, l'opérande (de gauche) trouvé
+ // à la place de l'objet "addition"
return pStack->Return(left, pStk);
}
-// fait l'op�ration d'addition ou de soustraction
+// fait l'opération d'addition ou de soustraction
BOOL CBotAddExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
- if ( pStk1->GetState() == 0 && // 1er �tat, �value l'op�rande de gauche
+ if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- // passe � l'�tape suivante
- pStk1->SetState(1); // pr�t pour la suite
+ // passe à l'étape suivante
+ pStk1->SetState(1); // prêt pour la suite
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
+ // demande un peu plus de stack pour ne pas toucher le résultat de gauche
// qui se trouve sur la pile, justement.
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
- // 2e �tat, �value l'op�rande de droite
+ // 2e état, évalue l'opérande de droite
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
- int type1 = pStk1->GetType(); // de quels types les r�sultats ?
+ int type1 = pStk1->GetType(); // de quels types les résultats ?
int type2 = pStk2->GetType();
- // cr�e une variable temporaire pour y mettre le r�sultat
+ // crée une variable temporaire pour y mettre le résultat
CBotVar* result = CBotVar::Create( NULL, MAX(type1, type2));
- // fait l'op�ration selon la demande
+ // fait l'opération selon la demande
switch (GetTokenType())
{
case ID_ADD:
@@ -133,10 +121,10 @@ BOOL CBotAddExpr::Execute(CBotStack* &pStack) result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
break;
}
- pStk2->SetVar(result); // met le r�sultat sur la pile
+ pStk2->SetVar(result); // met le résultat sur la pile
- pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk1); // transmet le r�sultat
+ pStk1->Return(pStk2); // libère la pile
+ return pStack->Return(pStk1); // transmet le résultat
}
diff --git a/src/CBot/old CBotCompExpr.cpp b/src/CBot/old CBotCompExpr.cpp index f098e7d..e7439b7 100644 --- a/src/CBot/old CBotCompExpr.cpp +++ b/src/CBot/old CBotCompExpr.cpp @@ -1,18 +1,7 @@ -// * 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/.
+///////////////////////////////////////////////////
+// expression du genre Opérande1 > Opérande2
+// Opérande1 != Opérande2
+// etc.
#include "CBot.h"
@@ -38,7 +27,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotCStack* pStk = pStack->TokenStack();
- CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B � gauche
+ CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B à gauche
if (left == NULL) return pStack->Return(NULL, pStk); // erreur
if ( p->GetType() == ID_HI ||
@@ -48,22 +37,22 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) p->GetType() == ID_EQ ||
p->GetType() == ID_NE) // les diverses comparaisons
{
- CBotCompExpr* inst = new CBotCompExpr(); // �l�ment pour op�ration
- inst->SetToken(p); // m�morise l'op�ration
+ CBotCompExpr* inst = new CBotCompExpr(); // élément pour opération
+ inst->SetToken(p); // mémorise l'opération
int type1, type2;
type1 = pStk->GetType(CBotTypChar);
p = p->Next();
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B � droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B à droite
{
type2 = pStk->GetType(CBotTypChar);
- // les r�sultats sont-ils compatibles
+ // les résultats sont-ils compatibles
if ( type1 == type2 && type1 != CBotTypBoolean && type1 != CBotTypClass)
{
inst->m_leftop = left;
pStk->SetVar(new CBotVar(NULL, CBotTypBoolean));
- // le r�sultat est un boolean
+ // le résultat est un boolean
return pStack->Return(inst, pStk);
}
pStk->SetError(TX_BAD2TYPE, &inst->m_token);
@@ -78,7 +67,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) }
-// fait l'op�ration
+// fait l'opération
BOOL CBotCompExpr::Execute(CBotStack* &pStack)
{
@@ -86,9 +75,9 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) if ( pStk1->GetState() == 0 && !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- pStk1->SetState(1); // op�ration termin�e
+ pStk1->SetState(1); // opération terminée
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
+ // demande un peu plus de stack pour ne pas toucher le résultat de gauche
CBotStack* pStk2 = pStk1->AddStack();
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
@@ -102,30 +91,30 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) switch (GetTokenType())
{
case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
+ temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
break;
case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
+ temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
break;
case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
+ temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
break;
case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
+ temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
break;
case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
+ temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
break;
case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
+ temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
break;
}
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
+ result->SetValInt(temp->GetValInt()); // converti le résultat
delete temp;
- pStk2->SetVar(result); // met le r�sultat sur la pile
+ pStk2->SetVar(result); // met le résultat sur la pile
- pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk1); // transmet le r�sultat
+ pStk1->Return(pStk2); // libère la pile
+ return pStack->Return(pStk1); // transmet le résultat
}
diff --git a/src/CBot/old TstCBot/BotConsoleDlg.cpp b/src/CBot/old TstCBot/BotConsoleDlg.cpp index bd1cb11..077f080 100644 --- a/src/CBot/old TstCBot/BotConsoleDlg.cpp +++ b/src/CBot/old TstCBot/BotConsoleDlg.cpp @@ -1,18 +1,5 @@ -// * 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/.
+// BotConsoleDlg.cpp : implementation file
+//
#include "stdafx.h"
#include "TstCBot.h"
@@ -81,7 +68,7 @@ UINT ThreadProc(ThreadInfo *info) CTimeSpan ts = t - t0;
char buffer[200];
- sprintf( buffer, "\r\nEx�cution termin�e en %d secondes.\r\nInterrompue %d fois.\r\n",
+ sprintf( buffer, "\r\nExécution terminée en %d secondes.\r\nInterrompue %d fois.\r\n",
ts.GetTotalSeconds(), Cpt);
info->m_pEdit1->ReplaceSel(buffer);
@@ -139,7 +126,7 @@ void CBotConsoleDlg::OnOK() m_Edit2.EnableWindow(FALSE);
m_cOK.EnableWindow(FALSE);
- // lance un processus paral�le pour l'ex�cution
+ // lance un processus paralèle pour l'exécution
m_threadinfo.m_pWndMessage = this ;
m_threadinfo.m_pEdit1 = &m_Edit1;
diff --git a/src/CBot/old TstCBot/BotConsoleDlg.h b/src/CBot/old TstCBot/BotConsoleDlg.h index aa23b0d..9b54ff2 100644 --- a/src/CBot/old TstCBot/BotConsoleDlg.h +++ b/src/CBot/old TstCBot/BotConsoleDlg.h @@ -1,18 +1,3 @@ -// * 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/.
#if !defined(AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_)
#define AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/old TstCBot/BotErrorDlg.cpp b/src/CBot/old TstCBot/BotErrorDlg.cpp index 4d3cf04..87d56f0 100644 --- a/src/CBot/old TstCBot/BotErrorDlg.cpp +++ b/src/CBot/old TstCBot/BotErrorDlg.cpp @@ -1,18 +1,5 @@ -// * 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/.
+// BotErrorDlg.cpp : implementation file
+//
#include "stdafx.h"
#include "TstCBot.h"
diff --git a/src/CBot/old TstCBot/BotErrorDlg.h b/src/CBot/old TstCBot/BotErrorDlg.h index 0efaefc..522afad 100644 --- a/src/CBot/old TstCBot/BotErrorDlg.h +++ b/src/CBot/old TstCBot/BotErrorDlg.h @@ -1,18 +1,3 @@ -// * 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/.
#if !defined(AFX_BOTERRORDLG_H__80E73D20_7454_11D4_A439_00D059085115__INCLUDED_)
#define AFX_BOTERRORDLG_H__80E73D20_7454_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/old TstCBot/CMyThread.cpp b/src/CBot/old TstCBot/CMyThread.cpp index ed1e2ea..ca92c77 100644 --- a/src/CBot/old TstCBot/CMyThread.cpp +++ b/src/CBot/old TstCBot/CMyThread.cpp @@ -1,18 +1,5 @@ -// * 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/.
+// CMyThread.cpp : pour créer un processus pour la console
+//
#include "stdafx.h"
#include "TstCBot.h"
@@ -51,7 +38,7 @@ BOOL CMyThread::InitInstance() CTstCBotApp* pApp = (CTstCBotApp*)AfxGetApp();
- // ouvre une fen�tre pour afficher les sorties
+ // ouvre une fenêtre pour afficher les sorties
CRect rect;
AfxGetMainWnd()->GetClientRect( rect );
rect += CPoint(30,30);
diff --git a/src/CBot/old TstCBot/CMyThread.h b/src/CBot/old TstCBot/CMyThread.h index 89b8fa2..1134077 100644 --- a/src/CBot/old TstCBot/CMyThread.h +++ b/src/CBot/old TstCBot/CMyThread.h @@ -1,18 +1,6 @@ -// * 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/.
+// CMyThread.h : pour créer un processus pour la console
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_MAINFRM_H__20B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_MAINFRM_H__20B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/MainFrm.cpp b/src/CBot/old TstCBot/MainFrm.cpp index 6b55222..6c0962c 100644 --- a/src/CBot/old TstCBot/MainFrm.cpp +++ b/src/CBot/old TstCBot/MainFrm.cpp @@ -1,18 +1,5 @@ -// * 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/.
+// MainFrm.cpp : implementation of the CMainFrame class
+//
#include "stdafx.h"
#include "TstCBot.h"
diff --git a/src/CBot/old TstCBot/MainFrm.h b/src/CBot/old TstCBot/MainFrm.h index 3eb4271..56b9c41 100644 --- a/src/CBot/old TstCBot/MainFrm.h +++ b/src/CBot/old TstCBot/MainFrm.h @@ -1,18 +1,6 @@ -// * 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/.
+// MainFrm.h : interface of the CMainFrame class
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_MAINFRM_H__70B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_MAINFRM_H__70B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/Resource.h b/src/CBot/old TstCBot/Resource.h index 326e0e0..6863fd8 100644 --- a/src/CBot/old TstCBot/Resource.h +++ b/src/CBot/old TstCBot/Resource.h @@ -1,18 +1,7 @@ -// * 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/.
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by TstCBot.rc
+//
#define IDD_ABOUTBOX 100
#define IDR_MAINFRAME 128
#define IDR_TSTCBOTYPE 129
diff --git a/src/CBot/old TstCBot/StdAfx.cpp b/src/CBot/old TstCBot/StdAfx.cpp index a3471af..ae0ec93 100644 --- a/src/CBot/old TstCBot/StdAfx.cpp +++ b/src/CBot/old TstCBot/StdAfx.cpp @@ -1,18 +1,6 @@ -// * 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/.
+// stdafx.cpp : source file that includes just the standard includes
+// TstCBot.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
diff --git a/src/CBot/old TstCBot/StdAfx.h b/src/CBot/old TstCBot/StdAfx.h index 42fdf52..7d46ace 100644 --- a/src/CBot/old TstCBot/StdAfx.h +++ b/src/CBot/old TstCBot/StdAfx.h @@ -1,18 +1,7 @@ -// * 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/.
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
#if !defined(AFX_STDAFX_H__70B3756A_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_STDAFX_H__70B3756A_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/TstCBot.cpp b/src/CBot/old TstCBot/TstCBot.cpp index 2cc2c9b..8ac4557 100644 --- a/src/CBot/old TstCBot/TstCBot.cpp +++ b/src/CBot/old TstCBot/TstCBot.cpp @@ -1,18 +1,5 @@ -// * 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/.
+// TstCBot.cpp : Defines the class behaviors for the application.
+//
#include "stdafx.h"
#include "TstCBot.h"
@@ -32,9 +19,9 @@ static char THIS_FILE[] = __FILE__; ////////////////////////////////////////////////////////////////////
// routine show()
-// utilisable depuis le programme �crit en CBot
+// utilisable depuis le programme écrit en CBot
-// ex�cution
+// exécution
BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
@@ -69,7 +56,7 @@ BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception ) int cShow( CBotVar* &pVar, CBotString& RetClass)
{
if ( pVar == NULL ) return 22;
- return CBotTypInt; // tous param�tres accept�s, un entier en retour
+ return CBotTypInt; // tous paramètres acceptés, un entier en retour
}
int cErr( CBotVar* &pVar, CBotString& RetClass)
@@ -80,9 +67,9 @@ int cErr( CBotVar* &pVar, CBotString& RetClass) ////////////////////////////////////////////////////////////////////
// routine print()
-// utilisable depuis le programme �crit en CBot
+// utilisable depuis le programme écrit en CBot
-// ex�cution
+// exécution
BOOL rPrintLn( CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
@@ -131,19 +118,19 @@ BOOL rPrint( CBotVar* pVar, CBotVar* pResult, int& Exception ) int cPrint( CBotVar* &pVar, CBotString& RetClass)
{
- return 0; // tous param�tres accept�s, un entier en retour
+ return 0; // tous paramètres acceptés, un entier en retour
}
//////////////////////////////////////////////////////////////////
// class CPoint pour essayer
-// ex�cution
+// exécution
BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
- if ( pVar == NULL )return TRUE; // constructeur sans param�tres est ok
+ if ( pVar == NULL )return TRUE; // constructeur sans paramètres est ok
if ( pVar->RetType() > CBotTypDouble )
{
@@ -188,41 +175,41 @@ BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception ) int cCPoint( CBotVar* pThis, CBotVar* &pVar, CBotString& RetClass)
{
- // l'objet doit �tre de la classe CPoint
+ // l'objet doit être de la classe CPoint
if ( !pThis->IsElemOfClass("CPoint") ) return 6021;
- // ok si aucun param�tres !
+ // ok si aucun paramètres !
if ( pVar == NULL ) return 0;
- // param�tre de type num�rique svp
+ // paramètre de type numérique svp
if ( pVar->RetType() > CBotTypDouble ) return 6023;
pVar = pVar->RetNext();
- // il doit y avoir un second param�tre
+ // il doit y avoir un second paramètre
if ( pVar == NULL ) return 6022;
- // �galement de type num�rique
+ // également de type numérique
if ( pVar->RetType() > CBotTypDouble )return 6023;
pVar = pVar->RetNext();
- // et pas plus de 2 param�tres svp
+ // et pas plus de 2 paramètres svp
if ( pVar != NULL ) return 6025;
return 0; // cette fonction retourne void
}
-// m�thode d�terminant l'oppos�
+// méthode déterminant l'opposé
BOOL rOppose( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
- if ( pVar != NULL ) // pas de param�tre
+ if ( pVar != NULL ) // pas de paramètre
{
Exception = 6025; return FALSE;
}
- CBotVar* pvar = pThis->RetItemList(); // demande la cha�ne des items
+ CBotVar* pvar = pThis->RetItemList(); // demande la chaîne des items
- // tous les param�tres sont des nombres
+ // tous les paramètres sont des nombres
while (pvar != NULL)
{
pvar->SetValFloat( -pvar->RetValFloat() );
@@ -235,15 +222,15 @@ BOOL rOppose( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception ) int cOppose( CBotVar* pThis, CBotVar* &pVar, CBotString& RetClass)
{
- // l'objet doit �tre de la classe CPoint
+ // l'objet doit être de la classe CPoint
if ( !pThis->IsElemOfClass("CPoint") ) return 6021;
RetClass = "CPoint"; // l'objet rendu est de cette class
- // ok si aucun param�tres !
- if ( pVar == NULL ) return CBotTypClass; // le param�tre retourn� est une instance de la classe
+ // ok si aucun paramètres !
+ if ( pVar == NULL ) return CBotTypClass; // le paramètre retourné est une instance de la classe
- return TX_OVERPARAM; // �a va pas
+ return TX_OVERPARAM; // ça va pas
}
@@ -326,7 +313,7 @@ BOOL CTstCBotApp::InitInstance() ///////////////////////////////////
-// d�fini la fonction "show()"
+// défini la fonction "show()"
// --------------------------------
CBotProgram::AddFunction("show", rShow, cShow);
@@ -336,7 +323,7 @@ BOOL CTstCBotApp::InitInstance() ///////////////////////////////////
-// d�finie la classe globale CPoint
+// définie la classe globale CPoint
// --------------------------------
CBotClass* m_pClassPoint;
@@ -349,8 +336,8 @@ BOOL CTstCBotApp::InitInstance() // ajoute le constructeur pour cette classe
m_pClassPoint->AddFunction("CPoint", rCPoint, cCPoint);
- // ajoute la m�thode Oppos�
- m_pClassPoint->AddFunction("Oppos�", rOppose, cOppose);
+ // ajoute la méthode Opposé
+ m_pClassPoint->AddFunction("Opposé", rOppose, cOppose);
//////////////////////////////////////////////////////////////////
@@ -361,7 +348,7 @@ BOOL CTstCBotApp::InitInstance() CBotStringArray Liste;
p->Compile(" public void MonProgram( ) { show (\"mon programme\") ;}", Liste );
- // l'objet n'est pas d�truit et plus r�f�renc�
+ // l'objet n'est pas détruit et plus référencé
// je sais c'est pas bien
diff --git a/src/CBot/old TstCBot/TstCBot.h b/src/CBot/old TstCBot/TstCBot.h index df38f3d..616db43 100644 --- a/src/CBot/old TstCBot/TstCBot.h +++ b/src/CBot/old TstCBot/TstCBot.h @@ -1,18 +1,5 @@ -// * 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/.
+// TstCBot.h : main header file for the TSTCBOT application
+//
#if !defined(AFX_TSTCBOT_H__70B37568_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_TSTCBOT_H__70B37568_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/TstCBotDoc.cpp b/src/CBot/old TstCBot/TstCBotDoc.cpp index 4949b0e..7d7e2ef 100644 --- a/src/CBot/old TstCBot/TstCBotDoc.cpp +++ b/src/CBot/old TstCBot/TstCBotDoc.cpp @@ -1,18 +1,5 @@ -// * 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/.
+// TstCBotDoc.cpp : implementation of the CTstCBotDoc class
+//
#include "stdafx.h"
#include "TstCBot.h"
diff --git a/src/CBot/old TstCBot/TstCBotDoc.h b/src/CBot/old TstCBot/TstCBotDoc.h index 976982c..ae1d0f7 100644 --- a/src/CBot/old TstCBot/TstCBotDoc.h +++ b/src/CBot/old TstCBot/TstCBotDoc.h @@ -1,18 +1,6 @@ -// * 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/.
+// TstCBotDoc.h : interface of the CTstCBotDoc class
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_TSTCBOTDOC_H__70B3756E_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_TSTCBOTDOC_H__70B3756E_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/TstCBotView.cpp b/src/CBot/old TstCBot/TstCBotView.cpp index 4c82e2a..3ee9094 100644 --- a/src/CBot/old TstCBot/TstCBotView.cpp +++ b/src/CBot/old TstCBot/TstCBotView.cpp @@ -1,18 +1,5 @@ -// * 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/.
+// TstCBotView.cpp : implementation of the CTstCBotView class
+//
#include "stdafx.h"
#include "TstCBot.h"
@@ -202,13 +189,13 @@ void CTstCBotView::OnCp1() m_pProg = NULL;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError.LoadString( code );
if (TextError.IsEmpty())
{
char buf[100];
- sprintf(buf, "Erreur num�ro %d.", code);
+ sprintf(buf, "Erreur numéro %d.", code);
TextError = buf;
}
AfxMessageBox( TextError );
@@ -227,13 +214,13 @@ void CTstCBotView::OnExe() if( m_pProg == NULL)
{
- AfxMessageBox("Pas de programme compil� !");
+ AfxMessageBox("Pas de programme compilé !");
return;
}
if( pApp->m_Liste.RetSize() == 0 )
{
- AfxMessageBox("Aucune fonction marqu�e \"extern\" !");
+ AfxMessageBox("Aucune fonction marquée \"extern\" !");
return;
}
@@ -247,13 +234,13 @@ void CTstCBotView::OnExe() CString TextError;
m_pEdit->SetSel( dlg.m_start, dlg.m_end );
- m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
+ m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError.LoadString( dlg.m_code );
if (TextError.IsEmpty())
{
char buf[100];
- sprintf(buf, "Erreur num�ro %d.", dlg.m_code);
+ sprintf(buf, "Erreur numéro %d.", dlg.m_code);
TextError = buf;
}
// AfxMessageBox( TextError );
diff --git a/src/CBot/old TstCBot/TstCBotView.h b/src/CBot/old TstCBot/TstCBotView.h index 7c755d7..d5aede5 100644 --- a/src/CBot/old TstCBot/TstCBotView.h +++ b/src/CBot/old TstCBot/TstCBotView.h @@ -1,18 +1,6 @@ -// * 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/.
+// TstCBotView.h : interface of the CTstCBotView class
+//
+/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_TSTCBOTVIEW_H__70B37570_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_TSTCBOTVIEW_H__70B37570_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
@@ -32,9 +20,9 @@ protected: // create from serialization only CTstCBotView();
DECLARE_DYNCREATE(CTstCBotView)
- CEdit* m_pEdit; // texte en �dition
+ CEdit* m_pEdit; // texte en édition
CWnd* m_pWnd;
- CBotProgram* m_pProg; // programme compil�
+ CBotProgram* m_pProg; // programme compilé
// Attributes
public:
diff --git a/src/CBot/resource.h b/src/CBot/resource.h index 0188fac..7e57d32 100644 --- a/src/CBot/resource.h +++ b/src/CBot/resource.h @@ -1,4 +1,4 @@ -// * This file is part of the COLOBOT source code
+// * 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
@@ -12,7 +12,10 @@ // * 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/.
+// * 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
|