summaryrefslogtreecommitdiffstats
path: root/src/CBot/CBotTwoOpExpr.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/CBot/CBotTwoOpExpr.cpp')
-rw-r--r--src/CBot/CBotTwoOpExpr.cpp156
1 files changed, 79 insertions, 77 deletions
diff --git a/src/CBot/CBotTwoOpExpr.cpp b/src/CBot/CBotTwoOpExpr.cpp
index 840278d..8594787 100644
--- a/src/CBot/CBotTwoOpExpr.cpp
+++ b/src/CBot/CBotTwoOpExpr.cpp
@@ -1,4 +1,4 @@
-// * This file is part of the COLOBOT source code
+// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
@@ -12,7 +12,9 @@
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
-// * along with this program. If not, see http://www.gnu.org/licenses/.
+// * along with this program. If not, see http://www.gnu.org/licenses/.///////////////////////////////////////////////////
+// expression du genre Opérande1 + Opérande2
+// Opérande1 > Opérande2
#include "CBot.h"
@@ -47,7 +49,7 @@ CBotLogicExpr::~CBotLogicExpr()
}
-// type d'op�randes accept�s par les op�rations
+// type d'opérandes acceptés par les opérations
#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
#define BOOLEEN (1<<CBotTypBoolean)
@@ -55,9 +57,9 @@ CBotLogicExpr::~CBotLogicExpr()
#define POINTER (1<<CBotTypPointer)
#define INSTANCE (1<<CBotTypClass)
-// liste des op�rations (pr�c�ance)
-// type acceptable, op�rande
-// le z�ro termine un niveau de pr�c�ance
+// liste des opérations (précéance)
+// type acceptable, opérande
+// le zéro termine un niveau de précéance
static int ListOp[] =
{
@@ -124,21 +126,21 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
- // cherche des instructions qui peuvent convenir � gauche de l'op�ration
+ // cherche des instructions qui peuvent convenir à gauche de l'opération
CBotInstr* left = (*pOp == 0) ?
- CBotParExpr::Compile( p, pStk ) : // expression (...) � gauche
- CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B � gauche
+ CBotParExpr::Compile( p, pStk ) : // expression (...) à gauche
+ CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B à gauche
if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
- // est-ce qu'on a l'op�rande pr�vu ensuite ?
+ // est-ce qu'on a l'opérande prévu ensuite ?
int TypeOp = p->GivType();
if ( IsInList( TypeOp, pOperations, typemasque ) )
{
CBotTypResult type1, type2;
- type1 = pStk->GivTypResult(); // de quel type le premier op�rande ?
+ type1 = pStk->GivTypResult(); // de quel type le premier opérande ?
- if ( TypeOp == ID_LOGIC ) // cas sp�cial pour condition ? op1 : op2 ;
+ if ( TypeOp == ID_LOGIC ) // cas spécial pour condition ? op1 : op2 ;
{
if ( !type1.Eq(CBotTypBoolean) )
{
@@ -148,7 +150,7 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
CBotLogicExpr* inst = new CBotLogicExpr();
inst->m_condition = left;
- p = p->GivNext(); // saute le token de l'op�ration
+ p = p->GivNext(); // saute le token de l'opération
inst->m_op1 = CBotExpression::Compile(p, pStk);
CBotToken* pp = p;
if ( inst->m_op1 == NULL || !IsOfType( p, ID_DOTS ) )
@@ -179,32 +181,32 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
return pStack->Return(inst, pStk);
}
- CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // �l�ment pour op�ration
- inst->SetToken(p); // m�morise l'op�ration
+ CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // élément pour opération
+ inst->SetToken(p); // mémorise l'opération
- p = p->GivNext(); // saute le token de l'op�ration
+ p = p->GivNext(); // saute le token de l'opération
- // cherche des instructions qui peuvent convenir � droite
+ // cherche des instructions qui peuvent convenir à droite
if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp )) )
- // expression (...) � droite
+ // expression (...) à droite
{
- // il y a un second op�rande acceptable
+ // il y a un second opérande acceptable
- type2 = pStk->GivTypResult(); // de quel type le r�sultat ?
+ type2 = pStk->GivTypResult(); // de quel type le résultat ?
- // quel est le type du r�sultat ?
+ // quel est le type du résultat ?
int TypeRes = MAX( type1.GivType(3), type2.GivType(3) );
if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
- type2 = type1; // tout type convertible en cha�ne
+ type2 = type1; // tout type convertible en chaîne
}
else if ( TypeOp == ID_ADD && type2.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
- type1 = type2; // tout type convertible en cha�ne
+ type1 = type2; // tout type convertible en chaîne
}
else if (!TypeOk( TypeRes, typemasque )) type1.SetType(99);// erreur de type
@@ -222,25 +224,25 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
case ID_LS:
TypeRes = CBotTypBoolean;
}
- if ( TypeCompatible (type1, type2, TypeOp ) ) // les r�sultats sont-ils compatibles
+ if ( TypeCompatible (type1, type2, TypeOp ) ) // les résultats sont-ils compatibles
{
- // si ok, enregistre l'op�rande dans l'objet
+ // si ok, enregistre l'opérande dans l'objet
inst->m_leftop = left;
- // sp�cial pour �valuer les op�rations de m�me niveau de gauche � droite
- while ( IsInList( p->GivType(), pOperations, typemasque ) ) // m�me(s) op�ration(s) suit ?
+ // spécial pour évaluer les opérations de même niveau de gauche à droite
+ while ( IsInList( p->GivType(), pOperations, typemasque ) ) // même(s) opération(s) suit ?
{
TypeOp = p->GivType();
- CBotTwoOpExpr* i = new CBotTwoOpExpr(); // �l�ment pour op�ration
- i->SetToken(p); // m�morise l'op�ration
- i->m_leftop = inst; // op�rande de gauche
+ CBotTwoOpExpr* i = new CBotTwoOpExpr(); // élément pour opération
+ i->SetToken(p); // mémorise l'opération
+ i->m_leftop = inst; // opérande de gauche
type1 = TypeRes;
- p = p->GivNext(); // avance � la suite
+ p = p->GivNext(); // avance à la suite
i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp );
type2 = pStk->GivTypResult();
- if ( !TypeCompatible (type1, type2, TypeOp) ) // les r�sultats sont-ils compatibles
+ if ( !TypeCompatible (type1, type2, TypeOp) ) // les résultats sont-ils compatibles
{
pStk->SetError(TX_BAD2TYPE, &i->m_token);
delete i;
@@ -254,25 +256,25 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
CBotTypResult t(type1);
t.SetType(TypeRes);
- // met une variable sur la pile pour avoir le type de r�sultat
+ // met une variable sur la pile pour avoir le type de résultat
pStk->SetVar(CBotVar::Create((CBotToken*)NULL, t));
- // et rend l'object � qui l'a demand�
+ // et rend l'object à qui l'a demandé
return pStack->Return(inst, pStk);
}
pStk->SetError(TX_BAD2TYPE, &inst->m_token);
}
- // en cas d'erreur, lib�re les �l�ments
+ // en cas d'erreur, libère les éléments
delete left;
delete inst;
// et transmet l'erreur qui se trouve sur la pile
return pStack->Return(NULL, pStk);
}
- // si on n'a pas affaire � une op�ration + ou -
- // rend � qui l'a demand�, l'op�rande (de gauche) trouv�
- // � la place de l'objet "addition"
+ // si on n'a pas affaire à une opération + ou -
+ // rend à qui l'a demandé, l'opérande (de gauche) trouvé
+ // à la place de l'objet "addition"
return pStack->Return(left, pStk);
}
@@ -288,62 +290,62 @@ BOOL IsNan(CBotVar* left, CBotVar* right, int* err = NULL)
}
-// fait l'op�ration sur 2 op�randes
+// fait l'opération sur 2 opérandes
BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE;
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
- if ( pStk1->GivState() == 0 ) // 1er �tat, �value l'op�rande de gauche
+ if ( pStk1->GivState() == 0 ) // 1er état, évalue l'opérande de gauche
{
if (!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- // pour les OU et ET logique, n'�value pas la seconde expression si pas n�cessaire
+ // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == FALSE )
{
CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
res->SetValInt(FALSE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == TRUE )
{
CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
res->SetValInt(TRUE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
- // passe � l'�tape suivante
- pStk1->SetState(1); // pr�t pour la suite
+ // passe à l'étape suivante
+ pStk1->SetState(1); // prêt pour la suite
}
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
+ // demande un peu plus de stack pour ne pas toucher le résultat de gauche
// qui se trouve sur la pile, justement.
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
- // 2e �tat, �value l'op�rande de droite
+ // 2e état, évalue l'opérande de droite
if ( pStk2->GivState() == 0 )
{
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
pStk2->IncState();
}
- CBotTypResult type1 = pStk1->GivTypResult(); // de quels types les r�sultats ?
+ CBotTypResult type1 = pStk1->GivTypResult(); // de quels types les résultats ?
CBotTypResult type2 = pStk2->GivTypResult();
- CBotStack* pStk3 = pStk2->AddStack(this); // ajoute un �l�ment � la pile
- if ( pStk3->IfStep() ) return FALSE; // montre l'op�ration si step by step
+ CBotStack* pStk3 = pStk2->AddStack(this); // ajoute un élément à la pile
+ if ( pStk3->IfStep() ) return FALSE; // montre l'opération si step by step
- // cr�e une variable temporaire pour y mettre le r�sultat
- // quel est le type du r�sultat ?
+ // crée une variable temporaire pour y mettre le résultat
+ // quel est le type du résultat ?
int TypeRes = MAX(type1.GivType(), type2.GivType());
if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
@@ -369,10 +371,10 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
TypeRes = MAX(TypeRes, CBotTypFloat);
}
- // cr�e une variable pour le r�sultat
+ // crée une variable pour le résultat
CBotVar* result = CBotVar::Create( (CBotToken*)NULL, TypeRes);
- // cr�e une variable pour effectuer le calcul dans le type adapt�
+ // crée une variable pour effectuer le calcul dans le type adapté
TypeRes = MAX(type1.GivType(), type2.GivType());
if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
@@ -387,7 +389,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
else temp = CBotVar::Create( (CBotToken*)NULL, TypeRes );
int err = 0;
- // fait l'op�ration selon la demande
+ // fait l'opération selon la demande
CBotVar* left = pStk1->GivVar();
CBotVar* right = pStk2->GivVar();
@@ -413,31 +415,31 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
break;
case ID_LO:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Lo(left , right)); // inf�rieur
+ result->SetValInt(temp->Lo(left , right)); // inférieur
break;
case ID_HI:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Hi(left , right)); // sup�rieur
+ result->SetValInt(temp->Hi(left , right)); // supérieur
break;
case ID_LS:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Ls(left , right)); // inf�rieur ou �gal
+ result->SetValInt(temp->Ls(left , right)); // inférieur ou égal
break;
case ID_HS:
if ( !IsNan(left, right, &err) )
- result->SetValInt(temp->Hs(left , right)); // sup�rieur ou �gal
+ result->SetValInt(temp->Hs(left , right)); // supérieur ou égal
break;
case ID_EQ:
if ( IsNan(left, right) )
result->SetValInt(left->GivInit() == right->GivInit()) ;
else
- result->SetValInt(temp->Eq(left , right)); // �gal
+ result->SetValInt(temp->Eq(left , right)); // égal
break;
case ID_NE:
if ( IsNan(left, right) )
result->SetValInt(left ->GivInit() != right->GivInit()) ;
else
- result->SetValInt(temp->Ne(left , right)); // diff�rent
+ result->SetValInt(temp->Ne(left , right)); // différent
break;
case ID_TXT_AND:
case ID_LOG_AND:
@@ -466,31 +468,31 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
}
delete temp;
- pStk2->SetVar(result); // met le r�sultat sur la pile
- if ( err ) pStk2->SetError(err, &m_token); // et l'erreur �ventuelle (division par z�ro)
+ pStk2->SetVar(result); // met le résultat sur la pile
+ if ( err ) pStk2->SetError(err, &m_token); // et l'erreur éventuelle (division par zéro)
-// pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk2); // transmet le r�sultat
+// pStk1->Return(pStk2); // libère la pile
+ return pStack->Return(pStk2); // transmet le résultat
}
void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
{
if ( !bMain ) return;
- CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un élément à la pile
if ( pStk1 == NULL ) return;
- // selon la reprise, on peut �tre dans l'un des 2 �tats
+ // selon la reprise, on peut être dans l'un des 2 états
- if ( pStk1->GivState() == 0 ) // 1er �tat, �value l'op�rande de gauche
+ if ( pStk1->GivState() == 0 ) // 1er état, évalue l'opérande de gauche
{
m_leftop->RestoreState(pStk1, bMain); // interrompu ici !
return;
}
- CBotStack* pStk2 = pStk1->RestoreStack(); // ajoute un �l�ment � la pile
+ CBotStack* pStk2 = pStk1->RestoreStack(); // ajoute un élément à la pile
if ( pStk2 == NULL ) return;
- // 2e �tat, �value l'op�rande de droite
+ // 2e état, évalue l'opérande de droite
if ( pStk2->GivState() == 0 )
{
m_rightop->RestoreState(pStk2, bMain); // interrompu ici !
@@ -501,7 +503,7 @@ void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
BOOL CBotLogicExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->AddStack(this); // ajoute un élément à la pile
// ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE;
@@ -520,14 +522,14 @@ BOOL CBotLogicExpr::Execute(CBotStack* &pStack)
if ( !m_op2->Execute(pStk1) ) return FALSE;
}
- return pStack->Return(pStk1); // transmet le r�sultat
+ return pStack->Return(pStk1); // transmet le résultat
}
void CBotLogicExpr::RestoreState(CBotStack* &pStack, BOOL bMain)
{
if ( !bMain ) return;
- CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un �l�ment � la pile
+ CBotStack* pStk1 = pStack->RestoreStack(this); // ajoute un élément à la pile
if ( pStk1 == NULL ) return;
if ( pStk1->GivState() == 0 )
@@ -561,4 +563,4 @@ void t(BOOL t)
x = 1 + t ? 1 : 3 + 4 * 2 ;
t ? 0 : "test";
}
-#endif
+#endif \ No newline at end of file
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-07-05 18:32:00 +0000