Last coding fix ;)

1 files changed, 59 insertions, 71 deletions

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

 }