Added license info using a small program SrcHead.

1 files changed, 90 insertions, 78 deletions

diff --git a/src/CBot/CBotTwoOpExpr.cpp b/src/CBot/CBotTwoOpExpr.cpp
index bc06873..d86b444 100644
--- a/src/CBot/CBotTwoOpExpr.cpp
+++ b/src/CBot/CBotTwoOpExpr.cpp
@@ -1,6 +1,18 @@
-///////////////////////////////////////////////////

-// expression du genre Opérande1 + Opérande2

-//					   Opérande1 > Opérande2

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

 

 #include "CBot.h"

 

@@ -35,7 +47,7 @@ CBotLogicExpr::~CBotLogicExpr()
 }

 

 

-// type d'opérandes acceptés par les opérations

+// type d'op�randes accept�s par les op�rations

 #define		ENTIER		((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))

 #define		FLOTANT		((1<<CBotTypFloat)|(1<<CBotTypDouble))

 #define		BOOLEEN		(1<<CBotTypBoolean)

@@ -43,9 +55,9 @@ CBotLogicExpr::~CBotLogicExpr()
 #define		POINTER		(1<<CBotTypPointer)

 #define		INSTANCE	(1<<CBotTypClass)

 

-// liste des opérations (précéance)

-//	type acceptable, opérande

-//	le zéro termine un niveau de précéance

+// liste des op�rations (pr�c�ance)

+//	type acceptable, op�rande

+//	le z�ro termine un niveau de pr�c�ance

 

 static int	ListOp[] = 

 {

@@ -112,21 +124,21 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
 

 	CBotCStack* pStk = pStack->TokenStack();					// un bout de pile svp

 

-	// cherche des instructions qui peuvent convenir à gauche de l'opération

+	// cherche des instructions qui peuvent convenir � gauche de l'op�ration

 	CBotInstr*	left = (*pOp == 0) ?

-						CBotParExpr::Compile( p, pStk ) :		// expression (...) à gauche

-						CBotTwoOpExpr::Compile( p, pStk, pOp );	// expression A * B à gauche

+						CBotParExpr::Compile( p, pStk ) :		// expression (...) � gauche

+						CBotTwoOpExpr::Compile( p, pStk, pOp );	// expression A * B � gauche

 

 	if (left == NULL) return pStack->Return(NULL, pStk);		// si erreur, la transmet

 

-	// est-ce qu'on a l'opérande prévu ensuite ?

+	// est-ce qu'on a l'op�rande pr�vu ensuite ?

 	int	TypeOp = p->GivType();

 	if ( IsInList( TypeOp, pOperations, typemasque ) )

 	{

 		CBotTypResult	 type1, type2;

-		type1 = pStk->GivTypResult();							// de quel type le premier opérande ?

+		type1 = pStk->GivTypResult();							// de quel type le premier op�rande ?

 

-		if ( TypeOp == ID_LOGIC )		// cas spécial pour condition ? op1 : op2 ;

+		if ( TypeOp == ID_LOGIC )		// cas sp�cial pour condition ? op1 : op2 ;

 		{

 			if ( !type1.Eq(CBotTypBoolean) )

 			{

@@ -136,7 +148,7 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
 			CBotLogicExpr* inst = new CBotLogicExpr();

 			inst->m_condition = left;

 

-			p = p->GivNext();										// saute le token de l'opération 

+			p = p->GivNext();										// saute le token de l'op�ration 

 			inst->m_op1 = CBotExpression::Compile(p, pStk);

 			CBotToken* pp = p;

 			if ( inst->m_op1 == NULL || !IsOfType( p, ID_DOTS ) )

@@ -167,32 +179,32 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
 			return pStack->Return(inst, pStk);

 		}

 

-		CBotTwoOpExpr* inst = new CBotTwoOpExpr();				// élément pour opération

-		inst->SetToken(p);										// mémorise l'opération

+		CBotTwoOpExpr* inst = new CBotTwoOpExpr();				// �l�ment pour op�ration

+		inst->SetToken(p);										// m�morise l'op�ration

 

 

-		p = p->GivNext();											// saute le token de l'opération 

+		p = p->GivNext();											// saute le token de l'op�ration 

 

-		// cherche des instructions qui peuvent convenir à droite

+		// cherche des instructions qui peuvent convenir � droite

 

 		if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp )) )

-																// expression (...) à droite

+																// expression (...) � droite

 		{

-			// il y a un second opérande acceptable

+			// il y a un second op�rande acceptable

 

-			type2 = pStk->GivTypResult();						// de quel type le résultat ?

+			type2 = pStk->GivTypResult();						// de quel type le r�sultat ?

 

-			// quel est le type du résultat ?

+			// quel est le type du r�sultat ?

 			int	TypeRes = MAX( type1.GivType(3), type2.GivType(3) );

 			if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) )

 			{

 				TypeRes = CBotTypString;

-				type2 = type1;	// tout type convertible en chaîne

+				type2 = type1;	// tout type convertible en cha�ne

 			}

 			else if ( TypeOp == ID_ADD && type2.Eq(CBotTypString) )

 			{

 				TypeRes = CBotTypString;

-				type1 = type2;	// tout type convertible en chaîne

+				type1 = type2;	// tout type convertible en cha�ne

 			}

 			else if (!TypeOk( TypeRes, typemasque )) type1.SetType(99);// erreur de type

 

@@ -210,25 +222,25 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
 			case ID_LS:

 				TypeRes = CBotTypBoolean;

 			}

-			if ( TypeCompatible (type1, type2, TypeOp ) )				// les résultats sont-ils compatibles

+			if ( TypeCompatible (type1, type2, TypeOp ) )				// les r�sultats sont-ils compatibles

 			{

-				// si ok, enregistre l'opérande dans l'objet

+				// si ok, enregistre l'op�rande dans l'objet

 				inst->m_leftop = left;

 

-				// spécial pour évaluer les opérations de même niveau de gauche à droite

-				while ( IsInList( p->GivType(), pOperations, typemasque ) ) // même(s) opération(s) suit ?

+				// sp�cial pour �valuer les op�rations de m�me niveau de gauche � droite

+				while ( IsInList( p->GivType(), pOperations, typemasque ) ) // m�me(s) op�ration(s) suit ?

 				{

 					TypeOp = p->GivType();

-					CBotTwoOpExpr* i = new CBotTwoOpExpr();				// élément pour opération

-					i->SetToken(p);										// mémorise l'opération

-					i->m_leftop = inst;									// opérande de gauche

+					CBotTwoOpExpr* i = new CBotTwoOpExpr();				// �l�ment pour op�ration

+					i->SetToken(p);										// m�morise l'op�ration

+					i->m_leftop = inst;									// op�rande de gauche

 					type1 = TypeRes;

 

-					p = p->GivNext();										// avance à la suite

+					p = p->GivNext();										// avance � la suite

 					i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp );

 					type2 = pStk->GivTypResult();

 

-					if ( !TypeCompatible (type1, type2, TypeOp) )		// les résultats sont-ils compatibles

+					if ( !TypeCompatible (type1, type2, TypeOp) )		// les r�sultats sont-ils compatibles

 					{

 						pStk->SetError(TX_BAD2TYPE, &i->m_token);

 						delete i;

@@ -242,25 +254,25 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
 

 				CBotTypResult t(type1);

 					t.SetType(TypeRes);

-				// met une variable sur la pile pour avoir le type de résultat

+				// met une variable sur la pile pour avoir le type de r�sultat

 				pStk->SetVar(CBotVar::Create((CBotToken*)NULL, t));

 

-				// et rend l'object à qui l'a demandé

+				// et rend l'object � qui l'a demand�

 				return pStack->Return(inst, pStk);

 			}

 			pStk->SetError(TX_BAD2TYPE, &inst->m_token);

 		}

 

-		// en cas d'erreur, libère les éléments

+		// en cas d'erreur, lib�re les �l�ments

 		delete left;

 		delete inst;

 		// et transmet l'erreur qui se trouve sur la pile

 		return pStack->Return(NULL, pStk);

 	}

 

-	// si on n'a pas affaire à une opération + ou -

-	// rend à qui l'a demandé, l'opérande (de gauche) trouvé

-	// à la place de l'objet "addition"

+	// si on n'a pas affaire � une op�ration + ou -

+	// rend � qui l'a demand�, l'op�rande (de gauche) trouv�

+	// � la place de l'objet "addition"

 	return pStack->Return(left, pStk);

 }

 

@@ -276,62 +288,62 @@ BOOL IsNan(CBotVar* left, CBotVar* right, int* err = NULL)
 }

 

 

-// fait l'opération sur 2 opérandes

+// fait l'op�ration sur 2 op�randes

 

 BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)

 {

-	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un élément à la pile

+	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un �l�ment � la pile

 												// ou le retrouve en cas de reprise

 //	if ( pStk1 == EOX ) return TRUE;

 

-	// selon la reprise, on peut être dans l'un des 2 états

+	// selon la reprise, on peut �tre dans l'un des 2 �tats

 

-	if ( pStk1->GivState() == 0 )					// 1er état, évalue l'opérande de gauche

+	if ( pStk1->GivState() == 0 )					// 1er �tat, �value l'op�rande de gauche

 	{

 		if (!m_leftop->Execute(pStk1) ) return FALSE;	// interrompu ici ?

 

-		// pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire

+		// pour les OU et ET logique, n'�value pas la seconde expression si pas n�cessaire

 		if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == FALSE )

 		{

 			CBotVar*	res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);

 			res->SetValInt(FALSE);

 			pStk1->SetVar(res);

-			return pStack->Return(pStk1);				// transmet le résultat

+			return pStack->Return(pStk1);				// transmet le r�sultat

 		}

 		if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == TRUE )

 		{

 			CBotVar*	res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);

 			res->SetValInt(TRUE);

 			pStk1->SetVar(res);

-			return pStack->Return(pStk1);				// transmet le résultat

+			return pStack->Return(pStk1);				// transmet le r�sultat

 		}

 

-		// passe à l'étape suivante

-		pStk1->SetState(1);			// prêt pour la suite

+		// passe � l'�tape suivante

+		pStk1->SetState(1);			// pr�t pour la suite

 	}

 

 

-	// demande un peu plus de stack pour ne pas toucher le résultat de gauche

+	// demande un peu plus de stack pour ne pas toucher le r�sultat de gauche

 	// qui se trouve sur la pile, justement.

 

-	CBotStack* pStk2 = pStk1->AddStack();				// ajoute un élément à la pile

+	CBotStack* pStk2 = pStk1->AddStack();				// ajoute un �l�ment � la pile

 														// ou le retrouve en cas de reprise

 

-	// 2e état, évalue l'opérande de droite

+	// 2e �tat, �value l'op�rande de droite

 	if ( pStk2->GivState() == 0 )

 	{

 		if ( !m_rightop->Execute(pStk2) ) return FALSE;		// interrompu ici ?

 		pStk2->IncState();

 	}

 

-	CBotTypResult		type1 = pStk1->GivTypResult();		// de quels types les résultats ?

+	CBotTypResult		type1 = pStk1->GivTypResult();		// de quels types les r�sultats ?

 	CBotTypResult		type2 = pStk2->GivTypResult();

 

-	CBotStack* pStk3 = pStk2->AddStack(this);				// ajoute un élément à la pile

-	if ( pStk3->IfStep() ) return FALSE;					// montre l'opération si step by step

+	CBotStack* pStk3 = pStk2->AddStack(this);				// ajoute un �l�ment � la pile

+	if ( pStk3->IfStep() ) return FALSE;					// montre l'op�ration si step by step

 

-	// crée une variable temporaire pour y mettre le résultat

-	// quel est le type du résultat ?

+	// cr�e une variable temporaire pour y mettre le r�sultat

+	// quel est le type du r�sultat ?

 	int	TypeRes = MAX(type1.GivType(), type2.GivType());

 

 	if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )

@@ -357,10 +369,10 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
 		TypeRes = MAX(TypeRes, CBotTypFloat);

 	}

 

-	// crée une variable pour le résultat

+	// cr�e une variable pour le r�sultat

 	CBotVar*	result = CBotVar::Create( (CBotToken*)NULL, TypeRes);

 

-	// crée une variable pour effectuer le calcul dans le type adapté

+	// cr�e une variable pour effectuer le calcul dans le type adapt�

 	TypeRes = MAX(type1.GivType(), type2.GivType());

 

 	if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )

@@ -375,7 +387,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
 	else						   temp = CBotVar::Create( (CBotToken*)NULL, TypeRes );

 

 	int	err = 0;

-	// fait l'opération selon la demande

+	// fait l'op�ration selon la demande

 	CBotVar*	left  = pStk1->GivVar();

 	CBotVar*	right = pStk2->GivVar();

 

@@ -401,31 +413,31 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
 		break;

 	case ID_LO:

 		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Lo(left , right));	// inférieur

+			result->SetValInt(temp->Lo(left , right));	// inf�rieur

 		break;

 	case ID_HI:

 		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Hi(left , right));	// supérieur

+			result->SetValInt(temp->Hi(left , right));	// sup�rieur

 		break;

 	case ID_LS:

 		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Ls(left , right));	// inférieur ou égal

+			result->SetValInt(temp->Ls(left , right));	// inf�rieur ou �gal

 		break;

 	case ID_HS:

 		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Hs(left , right));	// supérieur ou égal

+			result->SetValInt(temp->Hs(left , right));	// sup�rieur ou �gal

 		break;

 	case ID_EQ:

 		if ( IsNan(left, right) )

 			result->SetValInt(left->GivInit() ==  right->GivInit()) ;

 		else

-			result->SetValInt(temp->Eq(left , right));	// égal

+			result->SetValInt(temp->Eq(left , right));	// �gal

 		break;

 	case ID_NE:

 		if ( IsNan(left, right) )

 			 result->SetValInt(left ->GivInit() !=  right->GivInit()) ;

 		else

-			result->SetValInt(temp->Ne(left , right));	// différent

+			result->SetValInt(temp->Ne(left , right));	// diff�rent

 		break;

 	case ID_TXT_AND:

 	case ID_LOG_AND:

@@ -454,31 +466,31 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
 	}

 	delete temp;

 

-	pStk2->SetVar(result);						// met le résultat sur la pile

-	if ( err ) pStk2->SetError(err, &m_token);	// et l'erreur éventuelle (division par zéro)

+	pStk2->SetVar(result);						// met le r�sultat sur la pile

+	if ( err ) pStk2->SetError(err, &m_token);	// et l'erreur �ventuelle (division par z�ro)

 

-//	pStk1->Return(pStk2);						// libère la pile

-	return pStack->Return(pStk2);				// transmet le résultat

+//	pStk1->Return(pStk2);						// lib�re la pile

+	return pStack->Return(pStk2);				// transmet le r�sultat

 }

 

 void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain)

 {

 	if ( !bMain ) return;

-	CBotStack* pStk1 = pStack->RestoreStack(this);	// ajoute un élément à la pile

+	CBotStack* pStk1 = pStack->RestoreStack(this);	// ajoute un �l�ment � la pile

 	if ( pStk1 == NULL ) return;

 

-	// selon la reprise, on peut être dans l'un des 2 états

+	// selon la reprise, on peut �tre dans l'un des 2 �tats

 

-	if ( pStk1->GivState() == 0 )					// 1er état, évalue l'opérande de gauche

+	if ( pStk1->GivState() == 0 )					// 1er �tat, �value l'op�rande de gauche

 	{

 		m_leftop->RestoreState(pStk1, bMain);		// interrompu ici !

 		return;

 	}

 

-	CBotStack* pStk2 = pStk1->RestoreStack();			// ajoute un élément à la pile

+	CBotStack* pStk2 = pStk1->RestoreStack();			// ajoute un �l�ment � la pile

 	if ( pStk2 == NULL ) return;

 

-	// 2e état, évalue l'opérande de droite

+	// 2e �tat, �value l'op�rande de droite

 	if ( pStk2->GivState() == 0 )

 	{

 		m_rightop->RestoreState(pStk2, bMain);			// interrompu ici !

@@ -489,7 +501,7 @@ void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
 

 BOOL CBotLogicExpr::Execute(CBotStack* &pStack)

 {

-	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un élément à la pile

+	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un �l�ment � la pile

 												// ou le retrouve en cas de reprise

 //	if ( pStk1 == EOX ) return TRUE;

 

@@ -508,14 +520,14 @@ BOOL CBotLogicExpr::Execute(CBotStack* &pStack)
 		if ( !m_op2->Execute(pStk1) ) return FALSE;

 	}

 

-	return pStack->Return(pStk1);					// transmet le résultat

+	return pStack->Return(pStk1);					// transmet le r�sultat

 }

 

 void CBotLogicExpr::RestoreState(CBotStack* &pStack, BOOL bMain)

 {

 	if ( !bMain ) return;

 

-	CBotStack* pStk1 = pStack->RestoreStack(this);	// ajoute un élément à la pile

+	CBotStack* pStk1 = pStack->RestoreStack(this);	// ajoute un �l�ment � la pile

 	if ( pStk1 == NULL ) return;

 

 	if ( pStk1->GivState() == 0 )

@@ -549,4 +561,4 @@ void t(BOOL t)
 	x = 1 + t ? 1 : 3 + 4 * 2 ;

 	t ? 0 : "test";

 }

-#endif
\ No newline at end of file
+#endif