Last coding fix ;)

1 files changed, 330 insertions, 327 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)