summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/CBot/CBotTwoOpExpr15
-rw-r--r--src/CBot/CBotTwoOpExpr ordre inversÚ.cpp302
-rw-r--r--src/CBot/CBotTwoOpExpr ordre inversé.cpp314
-rw-r--r--src/CBot/Copie15
-rw-r--r--src/CBot/Copie de CBot.rc184
-rw-r--r--src/CBot/Copie de CBotTwoOpExpr.cpp295
-rw-r--r--src/CBot/old CBotAddExpr.cpp130
-rw-r--r--src/CBot/old CBotCompExpr.cpp120
8 files changed, 0 insertions, 1375 deletions
diff --git a/src/CBot/CBotTwoOpExpr b/src/CBot/CBotTwoOpExpr
deleted file mode 100644
index ea18736..0000000
--- a/src/CBot/CBotTwoOpExpr
+++ /dev/null
@@ -1,15 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// *
-// * This program is free software: you can redistribute it and/or modify
-// * it under the terms of the GNU General Public License as published by
-// * the Free Software Foundation, either version 3 of the License, or
-// * (at your option) any later version.
-// *
-// * This program is distributed in the hope that it will be useful,
-// * but WITHOUT ANY WARRANTY; without even the implied warranty of
-// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// * GNU General Public License for more details.
-// *
-// * You should have received a copy of the GNU General Public License
-// * along with this program. If not, see http://www.gnu.org/licenses/. \ No newline at end of file
diff --git a/src/CBot/CBotTwoOpExpr ordre inversÚ.cpp b/src/CBot/CBotTwoOpExpr ordre inversÚ.cpp
deleted file mode 100644
index 4a3a4dc..0000000
--- a/src/CBot/CBotTwoOpExpr ordre inversÚ.cpp
+++ /dev/null
@@ -1,302 +0,0 @@
-///////////////////////////////////////////////////
-// expression du genre Opérande1 + Opérande2
-// Opérande1 > Opérande2
-
-#include "CBot.h"
-
-// divers constructeurs
-
-CBotTwoOpExpr::CBotTwoOpExpr()
-{
- m_leftop =
- m_rightop = NULL; // NULL pour pouvoir faire delete sans autre
- name = "CBotTwoOpExpr"; // debug
-}
-
-CBotTwoOpExpr::~CBotTwoOpExpr()
-{
- delete m_leftop;
- delete m_rightop;
-}
-
-// type d'opérandes acceptés par les opérations
-#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
-#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
-#define BOOLEEN (1<<CBotTypBoolean)
-#define CHAINE (1<<CBotTypString)
-#define CLASSE (1<<CBotTypClass)
-
-// liste des opérations (précéance)
-static int ListOp[] =
-{
- BOOLEEN, ID_LOG_OR, 0,
- BOOLEEN, ID_LOG_AND, 0,
- BOOLEEN|ENTIER, ID_OR, 0,
- ENTIER, ID_XOR, 0,
- BOOLEEN|ENTIER, ID_AND, 0,
- BOOLEEN|ENTIER|FLOTANT, ID_EQ,
- BOOLEEN|ENTIER|FLOTANT, ID_NE, 0,
- ENTIER|FLOTANT, ID_HI,
- ENTIER|FLOTANT, ID_LO,
- ENTIER|FLOTANT, ID_HS,
- ENTIER|FLOTANT, ID_LS, 0,
- ENTIER, ID_SR,
- ENTIER, ID_SL,
- ENTIER, ID_ASR, 0,
- ENTIER|FLOTANT|CHAINE, ID_ADD,
- ENTIER|FLOTANT, ID_SUB, 0,
- ENTIER|FLOTANT, ID_MUL,
- ENTIER|FLOTANT, ID_DIV,
- ENTIER|FLOTANT, ID_MODULO, 0,
- 0,
-};
-
-BOOL IsInList( int val, int* list, int& typemasque )
-{
- while (TRUE)
- {
- if ( *list == 0 ) return FALSE;
- typemasque = *list++;
- if ( *list++ == val ) return TRUE;
- }
-}
-
-BOOL TypeOk( int type, int test )
-{
- while (TRUE)
- {
- if ( type == 0 ) return (test & 1);
- type--; test /= 2;
- }
-}
-
-// compile une instruction de type A op B
-
-CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations)
-{
- int typemasque;
-
- if ( pOperations == NULL ) pOperations = ListOp;
- int* pOp = pOperations;
- while ( *pOp++ != 0 ); // suite de la table
-
- CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
-
- // cherche des instructions qui peuvent convenir à gauche de l'opération
- CBotInstr* left = CBotParExpr::Compile( p, pStk ) ; // expression (...) à gauche
-
- if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
-
-
- CBotToken* pp = p;
- int TypeOp = pp->GetType(); // type d'opération
- p = p->Next(); // saute le token de l'opération
-
- // cherche des instructions qui peuvent convenir à droite
-
- CBotInstr* right = (*pOp == 0) ?
- CBotParExpr::Compile( p, pStk ) : // expression (...) à droite
- CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A op B à droite
-
- if (right == NULL) return pStack->Return(left, pStk); // pas d'opérande à droite ?
-
- // est-ce qu'on a l'opération prévue entre les deux ?
- if ( IsInList( TypeOp, pOperations, typemasque ) )
- {
- CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // élément pour opération
- inst->SetToken(pp); // mémorise l'opération
-
- int type1, type2;
- type1 = pStk->GetType(); // de quel type le premier opérande ?
-
- inst->m_rightop = right;
- {
- // il y a un second opérande acceptable
-
- type2 = pStk->GetType(); // de quel type le résultat ?
-
- // quel est le type du résultat ?
- int TypeRes = MAX( type1, type2 );
- if (!TypeOk( TypeRes, typemasque )) type1 = 99; // erreur de type
-
- switch ( TypeOp )
- {
- case ID_LOG_OR:
- case ID_LOG_AND:
- case ID_EQ:
- case ID_NE:
- case ID_HI:
- case ID_LO:
- case ID_HS:
- case ID_LS:
- TypeRes = CBotTypBoolean;
- }
- if ( TypeCompatible (type1, type2) || // les résultats sont-ils compatibles
- // cas particulier pour les concaténation de chaînes
- (TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString)))
- {
- // si ok, enregistre l'opérande dans l'objet
- inst->m_leftop = left;
- // met une variable sur la pile pour avoir le type de résultat
- pStk->SetVar(new CBotVar(NULL, TypeRes));
- // et rend l'object à qui l'a demandé
- return pStack->Return(inst, pStk);
- }
- pStk->SetError(TX_BAD2TYPE, &inst->m_token);
- }
-
- // en cas d'erreur, libère les éléments
- delete left;
- delete inst;
- // et transmet l'erreur qui se trouve sur la pile
- return pStack->Return(NULL, pStk);
- }
-
- // si on n'a pas affaire à une opération + ou -
- // rend à qui l'a demandé, l'opérande (de gauche) trouvé
- // à la place de l'objet "addition"
- return pStack->Return(left, pStk);
-}
-
-
-
-
-// fait l'opération d'addition ou de soustraction
-
-BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
-{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile
- // ou le retrouve en cas de reprise
-// if ( pStk1 == EOX ) return TRUE;
-
-
- // selon la reprise, on peut être dans l'un des 2 états
-
- if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
- !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
-
- // passe à l'étape suivante
- pStk1->SetState(1); // prêt pour la suite
-
- // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
- if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE )
- {
- CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
- res->SetValInt(FALSE);
- pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
- }
- if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE )
- {
- CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
- res->SetValInt(TRUE);
- pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
- }
-
- // demande un peu plus de stack pour ne pas toucher le résultat de gauche
- // qui se trouve sur la pile, justement.
-
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
- // ou le retrouve en cas de reprise
-
- // 2e état, évalue l'opérande de droite
- if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
-
- int type1 = pStk1->GetType(); // de quels types les résultats ?
- int type2 = pStk2->GetType();
-
- // crée une variable temporaire pour y mettre le résultat
- // quel est le type du résultat ?
- int TypeRes = MAX(type1, type2);
- switch ( GetTokenType() )
- {
- case ID_LOG_OR:
- case ID_LOG_AND:
- case ID_EQ:
- case ID_NE:
- case ID_HI:
- case ID_LO:
- case ID_HS:
- case ID_LS:
- TypeRes = CBotTypBoolean;
- }
- CBotVar* result = CBotVar::Create( NULL, TypeRes);
- CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) );
-
- int err = 0;
- // fait l'opération selon la demande
- switch (GetTokenType())
- {
- case ID_ADD:
- result->Add(pStk1->GetVar(), pStk2->GetVar()); // additionne
- break;
- case ID_SUB:
- result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
- break;
- case ID_MUL:
- result->Mul(pStk1->GetVar(), pStk2->GetVar()); // multiplie
- break;
- case ID_DIV:
- err = result->Div(pStk1->GetVar(), pStk2->GetVar());// divise
- break;
- case ID_MODULO:
- err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division
- break;
- case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_LOG_AND:
- case ID_AND:
- result->And(pStk1->GetVar(), pStk2->GetVar()); // ET
- break;
- case ID_LOG_OR:
- case ID_OR:
- result->Or(pStk1->GetVar(), pStk2->GetVar()); // OU
- break;
- case ID_XOR:
- result->XOr(pStk1->GetVar(), pStk2->GetVar()); // OU exclusif
- break;
- case ID_ASR:
- result->ASR(pStk1->GetVar(), pStk2->GetVar());
- break;
- case ID_SR:
- result->SR(pStk1->GetVar(), pStk2->GetVar());
- break;
- case ID_SL:
- result->SL(pStk1->GetVar(), pStk2->GetVar());
- break;
- default:
- __asm int 3;
- }
- delete temp;
-
- pStk2->SetVar(result); // met le résultat sur la pile
- if ( err ) pStk2->SetError(err, &m_token); // et l'erreur éventuelle (division par zéro)
-
- pStk1->Return(pStk2); // libère la pile
- return pStack->Return(pStk1); // transmet le résultat
-}
-
-
diff --git a/src/CBot/CBotTwoOpExpr ordre inversé.cpp b/src/CBot/CBotTwoOpExpr ordre inversé.cpp
deleted file mode 100644
index e34e26f..0000000
--- a/src/CBot/CBotTwoOpExpr ordre inversé.cpp
+++ /dev/null
@@ -1,314 +0,0 @@
-// * 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/.
-
-#include "CBot.h"
-
-// divers constructeurs
-
-CBotTwoOpExpr::CBotTwoOpExpr()
-{
- m_leftop =
- m_rightop = NULL; // NULL pour pouvoir faire delete sans autre
- name = "CBotTwoOpExpr"; // debug
-}
-
-CBotTwoOpExpr::~CBotTwoOpExpr()
-{
- delete m_leftop;
- delete m_rightop;
-}
-
-// type d'op�randes accept�s par les op�rations
-#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
-#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
-#define BOOLEEN (1<<CBotTypBoolean)
-#define CHAINE (1<<CBotTypString)
-#define CLASSE (1<<CBotTypClass)
-
-// liste des op�rations (pr�c�ance)
-static int ListOp[] =
-{
- BOOLEEN, ID_LOG_OR, 0,
- BOOLEEN, ID_LOG_AND, 0,
- BOOLEEN|ENTIER, ID_OR, 0,
- ENTIER, ID_XOR, 0,
- BOOLEEN|ENTIER, ID_AND, 0,
- BOOLEEN|ENTIER|FLOTANT, ID_EQ,
- BOOLEEN|ENTIER|FLOTANT, ID_NE, 0,
- ENTIER|FLOTANT, ID_HI,
- ENTIER|FLOTANT, ID_LO,
- ENTIER|FLOTANT, ID_HS,
- ENTIER|FLOTANT, ID_LS, 0,
- ENTIER, ID_SR,
- ENTIER, ID_SL,
- ENTIER, ID_ASR, 0,
- ENTIER|FLOTANT|CHAINE, ID_ADD,
- ENTIER|FLOTANT, ID_SUB, 0,
- ENTIER|FLOTANT, ID_MUL,
- ENTIER|FLOTANT, ID_DIV,
- ENTIER|FLOTANT, ID_MODULO, 0,
- 0,
-};
-
-BOOL IsInList( int val, int* list, int& typemasque )
-{
- while (TRUE)
- {
- if ( *list == 0 ) return FALSE;
- typemasque = *list++;
- if ( *list++ == val ) return TRUE;
- }
-}
-
-BOOL TypeOk( int type, int test )
-{
- while (TRUE)
- {
- if ( type == 0 ) return (test & 1);
- type--; test /= 2;
- }
-}
-
-// compile une instruction de type A op B
-
-CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations)
-{
- int typemasque;
-
- if ( pOperations == NULL ) pOperations = ListOp;
- int* pOp = pOperations;
- while ( *pOp++ != 0 ); // suite de la table
-
- CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
-
- // cherche des instructions qui peuvent convenir � gauche de l'op�ration
- CBotInstr* left = CBotParExpr::Compile( p, pStk ) ; // expression (...) � gauche
-
- if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
-
-
- CBotToken* pp = p;
- int TypeOp = pp->GetType(); // type d'op�ration
- p = p->Next(); // saute le token de l'op�ration
-
- // cherche des instructions qui peuvent convenir � droite
-
- CBotInstr* right = (*pOp == 0) ?
- CBotParExpr::Compile( p, pStk ) : // expression (...) � droite
- CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A op B � droite
-
- if (right == NULL) return pStack->Return(left, pStk); // pas d'op�rande � droite ?
-
- // est-ce qu'on a l'op�ration pr�vue entre les deux ?
- if ( IsInList( TypeOp, pOperations, typemasque ) )
- {
- CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // �l�ment pour op�ration
- inst->SetToken(pp); // m�morise l'op�ration
-
- int type1, type2;
- type1 = pStk->GetType(); // de quel type le premier op�rande ?
-
- inst->m_rightop = right;
- {
- // il y a un second op�rande acceptable
-
- type2 = pStk->GetType(); // de quel type le r�sultat ?
-
- // quel est le type du r�sultat ?
- int TypeRes = MAX( type1, type2 );
- if (!TypeOk( TypeRes, typemasque )) type1 = 99; // erreur de type
-
- switch ( TypeOp )
- {
- case ID_LOG_OR:
- case ID_LOG_AND:
- case ID_EQ:
- case ID_NE:
- case ID_HI:
- case ID_LO:
- case ID_HS:
- case ID_LS:
- TypeRes = CBotTypBoolean;
- }
- if ( TypeCompatible (type1, type2) || // les r�sultats sont-ils compatibles
- // cas particulier pour les concat�nation de cha�nes
- (TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString)))
- {
- // si ok, enregistre l'op�rande dans l'objet
- inst->m_leftop = left;
- // met une variable sur la pile pour avoir le type de r�sultat
- pStk->SetVar(new CBotVar(NULL, TypeRes));
- // et rend l'object � qui l'a demand�
- return pStack->Return(inst, pStk);
- }
- pStk->SetError(TX_BAD2TYPE, &inst->m_token);
- }
-
- // en cas d'erreur, lib�re les �l�ments
- delete left;
- delete inst;
- // et transmet l'erreur qui se trouve sur la pile
- return pStack->Return(NULL, pStk);
- }
-
- // si on n'a pas affaire � une op�ration + ou -
- // rend � qui l'a demand�, l'op�rande (de gauche) trouv�
- // � la place de l'objet "addition"
- return pStack->Return(left, pStk);
-}
-
-
-
-
-// fait l'op�ration d'addition ou de soustraction
-
-BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
-{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un �l�ment � la pile
- // ou le retrouve en cas de reprise
-// if ( pStk1 == EOX ) return TRUE;
-
-
- // selon la reprise, on peut �tre dans l'un des 2 �tats
-
- if ( pStk1->GetState() == 0 && // 1er �tat, �value l'op�rande de gauche
- !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
-
- // passe � l'�tape suivante
- pStk1->SetState(1); // pr�t pour la suite
-
- // pour les OU et ET logique, n'�value pas la seconde expression si pas n�cessaire
- if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE )
- {
- CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
- res->SetValInt(FALSE);
- pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
- }
- if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE )
- {
- CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
- res->SetValInt(TRUE);
- pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le r�sultat
- }
-
- // demande un peu plus de stack pour ne pas toucher le r�sultat de gauche
- // qui se trouve sur la pile, justement.
-
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un �l�ment � la pile
- // ou le retrouve en cas de reprise
-
- // 2e �tat, �value l'op�rande de droite
- if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
-
- int type1 = pStk1->GetType(); // de quels types les r�sultats ?
- int type2 = pStk2->GetType();
-
- // cr�e une variable temporaire pour y mettre le r�sultat
- // quel est le type du r�sultat ?
- int TypeRes = MAX(type1, type2);
- switch ( GetTokenType() )
- {
- case ID_LOG_OR:
- case ID_LOG_AND:
- case ID_EQ:
- case ID_NE:
- case ID_HI:
- case ID_LO:
- case ID_HS:
- case ID_LS:
- TypeRes = CBotTypBoolean;
- }
- CBotVar* result = CBotVar::Create( NULL, TypeRes);
- CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) );
-
- int err = 0;
- // fait l'op�ration selon la demande
- switch (GetTokenType())
- {
- case ID_ADD:
- result->Add(pStk1->GetVar(), pStk2->GetVar()); // additionne
- break;
- case ID_SUB:
- result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
- break;
- case ID_MUL:
- result->Mul(pStk1->GetVar(), pStk2->GetVar()); // multiplie
- break;
- case ID_DIV:
- err = result->Div(pStk1->GetVar(), pStk2->GetVar());// divise
- break;
- case ID_MODULO:
- err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division
- break;
- case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
- break;
- case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
- break;
- case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
- break;
- case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
- break;
- case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
- break;
- case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
- result->SetValInt(temp->GetValInt()); // converti le r�sultat
- break;
- case ID_LOG_AND:
- case ID_AND:
- result->And(pStk1->GetVar(), pStk2->GetVar()); // ET
- break;
- case ID_LOG_OR:
- case ID_OR:
- result->Or(pStk1->GetVar(), pStk2->GetVar()); // OU
- break;
- case ID_XOR:
- result->XOr(pStk1->GetVar(), pStk2->GetVar()); // OU exclusif
- break;
- case ID_ASR:
- result->ASR(pStk1->GetVar(), pStk2->GetVar());
- break;
- case ID_SR:
- result->SR(pStk1->GetVar(), pStk2->GetVar());
- break;
- case ID_SL:
- result->SL(pStk1->GetVar(), pStk2->GetVar());
- break;
- default:
- __asm int 3;
- }
- delete temp;
-
- pStk2->SetVar(result); // met le r�sultat sur la pile
- if ( err ) pStk2->SetError(err, &m_token); // et l'erreur �ventuelle (division par z�ro)
-
- pStk1->Return(pStk2); // lib�re la pile
- return pStack->Return(pStk1); // transmet le r�sultat
-}
-
-
diff --git a/src/CBot/Copie b/src/CBot/Copie
deleted file mode 100644
index ea18736..0000000
--- a/src/CBot/Copie
+++ /dev/null
@@ -1,15 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// *
-// * This program is free software: you can redistribute it and/or modify
-// * it under the terms of the GNU General Public License as published by
-// * the Free Software Foundation, either version 3 of the License, or
-// * (at your option) any later version.
-// *
-// * This program is distributed in the hope that it will be useful,
-// * but WITHOUT ANY WARRANTY; without even the implied warranty of
-// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// * GNU General Public License for more details.
-// *
-// * You should have received a copy of the GNU General Public License
-// * along with this program. If not, see http://www.gnu.org/licenses/. \ No newline at end of file
diff --git a/src/CBot/Copie de CBot.rc b/src/CBot/Copie de CBot.rc
deleted file mode 100644
index 52ef23a..0000000
--- a/src/CBot/Copie de CBot.rc
+++ /dev/null
@@ -1,184 +0,0 @@
-//Microsoft Developer Studio generated resource script.
-//
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
-#include "afxres.h"
-
-/////////////////////////////////////////////////////////////////////////////
-#undef APSTUDIO_READONLY_SYMBOLS
-
-/////////////////////////////////////////////////////////////////////////////
-// French (France) resources
-
-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
-#ifdef _WIN32
-LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
-#pragma code_page(1252)
-#endif //_WIN32
-
-#ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
-1 TEXTINCLUDE DISCARDABLE
-BEGIN
- "resource.h\0"
-END
-
-2 TEXTINCLUDE DISCARDABLE
-BEGIN
- "#include ""afxres.h""\r\n"
- "\0"
-END
-
-3 TEXTINCLUDE DISCARDABLE
-BEGIN
- "\r\n"
- "\0"
-END
-
-#endif // APSTUDIO_INVOKED
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// String Table
-//
-
-STRINGTABLE DISCARDABLE
-BEGIN
- ID_IF "if"
- ID_ELSE "else"
- ID_WHILE "while"
- ID_DO "do"
- ID_ADD "+"
- ID_SUB "-"
- ID_MUL "*"
- ID_DIV "/"
- ID_OPENPAR "("
- ID_CLOSEPAR ")"
- ID_SEP ";"
- ID_INT "int"
- ID_ASS "="
- ID_TRUE "true"
- ID_FALSE "false"
- ID_OPBLK "{"
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
- ID_CLBLK "}"
- ID_FOR "for"
- ID_COMMA ","
- ID_LO "<"
- ID_HI ">"
- ID_LS "<="
- ID_HS ">="
- ID_EQ "=="
- ID_NE "!="
- ID_FLOAT "float"
- ID_STRING "String"
- ID_BOOLEAN "boolean"
- ID_AND "&"
- ID_XOR "^"
- ID_OR "|"
- ID_LOG_AND "&&"
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
- TX_OPENPAR "Il manque une parenthèse ouvrante."
- TX_CLOSEPAR "Il manque une parenthèse fermante."
- TX_NOTBOOL "L'expression doit être un boolean."
- TX_UNDEFVAR "Variable non déclarée."
- TX_BADLEFT "Assignation impossible."
- TX_ENDOF "Instruction non terminée."
- TX_OUTCASE "Instruction ""case"" hors d'un bloc ""switch""."
- TX_NOTERM "Instructions après la fin."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
- TX_CLOSEBLK "Il manque la fin du bloc."
- TX_ELSEWITHOUTIF "Instruction ""else"" sans ""if"" correspondant."
- TX_OPENBLK "Début d'un bloc attendu."
- TX_BADTYPE "Mauvais type de résultat pour l'assignation."
- TX_REDEFVAR "Redéfinition d'une variable."
- TX_BAD2TYPE "Les deux opérandes ne sont pas de types compatibles."
- TX_UNDEFCALL "Routine inconnue."
- TX_MISDOTS "Séparateur "" : "" attendu."
- TX_WHILE "Manque le mot ""while""."
- TX_BREAK "Instruction ""break"" en dehors d'une boucle."
- TX_LABEL "Un label ne peut se placer que devant un ""for"", un ""while"", un ""do"" ou un ""switch""."
- TX_NOLABEL "Cette étiquette n'existe pas"
- TX_NOCASE "Manque une instruction ""case""."
- TX_BADNUM "Un nombre est attendu."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
- TX_DIVZERO "Division par zéro."
- TX_NOTINIT "Variable non initialisée."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
- ID_LOG_OR "||"
- ID_LOG_NOT "!"
- ID_NOT "~"
- ID_ASSADD "+="
- ID_ASSSUB "-="
- ID_ASSMUL "*="
- ID_ASSDIV "/="
- ID_ASSOR "|="
- ID_ASSAND "&="
- ID_ASSXOR "^="
- ID_ASSSL "<<="
- ID_ASSSR ">>>="
- ID_ASSASR ">>="
- ID_SL "<<"
- ID_SR ">>>"
- ID_ASR ">>"
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
- ID_INC "++"
- ID_DEC "--"
- ID_MODULO "%"
- ID_ASSMODULO "%="
- ID_LOGIC "?"
- ID_DOTS ":"
- ID_BREAK "break"
- ID_SWITCH "switch"
- ID_CASE "case"
- ID_CONTINUE "continue"
- ID_TRY "try"
- ID_CATCH "catch"
- ID_THROW "throw"
- ID_FINALLY "finally"
- ID_DEFAULT "default"
-END
-
-#endif // French (France) resources
-/////////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 3 resource.
-//
-
-
-/////////////////////////////////////////////////////////////////////////////
-#endif // not APSTUDIO_INVOKED
-
diff --git a/src/CBot/Copie de CBotTwoOpExpr.cpp b/src/CBot/Copie de CBotTwoOpExpr.cpp
deleted file mode 100644
index 7a95b55..0000000
--- a/src/CBot/Copie de CBotTwoOpExpr.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-///////////////////////////////////////////////////
-// expression du genre Opérande1 + Opérande2
-// Opérande1 > Opérande2
-
-#include "CBot.h"
-
-// divers constructeurs
-
-CBotTwoOpExpr::CBotTwoOpExpr()
-{
- m_leftop =
- m_rightop = NULL; // NULL pour pouvoir faire delete sans autre
- name = "CBotTwoOpExpr"; // debug
-}
-
-CBotTwoOpExpr::~CBotTwoOpExpr()
-{
- delete m_leftop;
- delete m_rightop;
-}
-
-// type d'opérandes acceptés par les opérations
-#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
-#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
-#define BOOLEEN (1<<CBotTypBoolean)
-#define CHAINE (1<<CBotTypString)
-#define CLASSE (1<<CBotTypClass)
-
-// liste des opérations (précéance)
-static int ListOp[] =
-{
- BOOLEEN, ID_LOG_OR, 0,
- BOOLEEN, ID_LOG_AND, 0,
- BOOLEEN|ENTIER, ID_OR, 0,
- ENTIER, ID_XOR, 0,
- BOOLEEN|ENTIER, ID_AND, 0,
- BOOLEEN|ENTIER|FLOTANT, ID_EQ,
- BOOLEEN|ENTIER|FLOTANT, ID_NE, 0,
- ENTIER|FLOTANT, ID_HI,
- ENTIER|FLOTANT, ID_LO,
- ENTIER|FLOTANT, ID_HS,
- ENTIER|FLOTANT, ID_LS, 0,
- ENTIER, ID_SR,
- ENTIER, ID_SL,
- ENTIER, ID_ASR, 0,
- ENTIER|FLOTANT|CHAINE, ID_ADD,
- ENTIER|FLOTANT, ID_SUB, 0,
- ENTIER|FLOTANT, ID_MUL,
- ENTIER|FLOTANT, ID_DIV,
- ENTIER|FLOTANT, ID_MODULO, 0,
- 0,
-};
-
-BOOL IsInList( int val, int* list, int& typemasque )
-{
- while (TRUE)
- {
- if ( *list == 0 ) return FALSE;
- typemasque = *list++;
- if ( *list++ == val ) return TRUE;
- }
-}
-
-BOOL TypeOk( int type, int test )
-{
- while (TRUE)
- {
- if ( type == 0 ) return (test & 1);
- type--; test /= 2;
- }
-}
-
-// compile une instruction de type A op B
-
-CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations)
-{
- int typemasque;
-
- if ( pOperations == NULL ) pOperations = ListOp;
- int* pOp = pOperations;
- while ( *pOp++ != 0 ); // suite de la table
-
- CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
-
- // cherche des instructions qui peuvent convenir à gauche de l'opération
- CBotInstr* left = (*pOp == 0) ?
- 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 ?
- 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
-
- int type1, type2;
- type1 = pStk->GetType(); // de quel type le premier opérande ?
-
- p = p->Next(); // saute le token de l'opération
-
- // cherche des instructions qui peuvent convenir à droite
-
- if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOperations )) )
- // expression (...) à droite
- {
- // il y a un second opérande acceptable
-
- type2 = pStk->GetType(); // de quel type le résultat ?
-
- // quel est le type du résultat ?
- int TypeRes = MAX( type1, type2 );
- if (!TypeOk( TypeRes, typemasque )) type1 = 99; // erreur de type
-
- switch ( TypeOp )
- {
- case ID_LOG_OR:
- case ID_LOG_AND:
- case ID_EQ:
- case ID_NE:
- case ID_HI:
- case ID_LO:
- case ID_HS:
- case ID_LS:
- TypeRes = CBotTypBoolean;
- }
- if ( TypeCompatible (type1, type2) || // les résultats sont-ils compatibles
- // cas particulier pour les concaténation de chaînes
- (TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString)))
- {
- // si ok, enregistre l'opérande dans l'objet
- inst->m_leftop = left;
- // met une variable sur la pile pour avoir le type de résultat
- pStk->SetVar(new CBotVar(NULL, TypeRes));
- // et rend l'object à qui l'a demandé
- return pStack->Return(inst, pStk);
- }
- pStk->SetError(TX_BAD2TYPE, &inst->m_token);
- }
-
- // en cas d'erreur, libère les éléments
- delete left;
- delete inst;
- // et transmet l'erreur qui se trouve sur la pile
- return pStack->Return(NULL, pStk);
- }
-
- // si on n'a pas affaire à une opération + ou -
- // rend à qui l'a demandé, l'opérande (de gauche) trouvé
- // à la place de l'objet "addition"
- return pStack->Return(left, pStk);
-}
-
-
-
-
-// fait l'opération d'addition ou de soustraction
-
-BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
-{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile
- // ou le retrouve en cas de reprise
-
- // selon la reprise, on peut être dans l'un des 2 états
-
- if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
- !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
-
- // passe à l'étape suivante
- pStk1->SetState(1); // prêt pour la suite
-
- // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
- if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE )
- {
- CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
- res->SetValInt(FALSE);
- pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
- }
- if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE )
- {
- CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
- res->SetValInt(TRUE);
- pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
- }
-
- // demande un peu plus de stack pour ne pas toucher le résultat de gauche
- // qui se trouve sur la pile, justement.
-
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
- // ou le retrouve en cas de reprise
-
- // 2e état, évalue l'opérande de droite
- if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
-
- int type1 = pStk1->GetType(); // de quels types les résultats ?
- int type2 = pStk2->GetType();
-
- // crée une variable temporaire pour y mettre le résultat
- // quel est le type du résultat ?
- int TypeRes = MAX(type1, type2);
- switch ( GetTokenType() )
- {
- case ID_LOG_OR:
- case ID_LOG_AND:
- case ID_EQ:
- case ID_NE:
- case ID_HI:
- case ID_LO:
- case ID_HS:
- case ID_LS:
- TypeRes = CBotTypBoolean;
- }
- CBotVar* result = CBotVar::Create( NULL, TypeRes);
- CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) );
-
- int err = 0;
- // fait l'opération selon la demande
- switch (GetTokenType())
- {
- case ID_ADD:
- result->Add(pStk1->GetVar(), pStk2->GetVar()); // additionne
- break;
- case ID_SUB:
- result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
- break;
- case ID_MUL:
- result->Mul(pStk1->GetVar(), pStk2->GetVar()); // multiplie
- break;
- case ID_DIV:
- err = result->Div(pStk1->GetVar(), pStk2->GetVar());// divise
- break;
- case ID_MODULO:
- err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division
- break;
- case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
- result->SetValInt(temp->GetValInt()); // converti le résultat
- break;
- case ID_LOG_AND:
- case ID_AND:
- result->And(pStk1->GetVar(), pStk2->GetVar()); // ET
- break;
- case ID_LOG_OR:
- case ID_OR:
- result->Or(pStk1->GetVar(), pStk2->GetVar()); // OU
- break;
- case ID_XOR:
- result->XOr(pStk1->GetVar(), pStk2->GetVar()); // OU exclusif
- break;
- case ID_ASR:
- result->ASR(pStk1->GetVar(), pStk2->GetVar());
- break;
- case ID_SR:
- result->SR(pStk1->GetVar(), pStk2->GetVar());
- break;
- case ID_SL:
- result->SL(pStk1->GetVar(), pStk2->GetVar());
- break;
- default:
- __asm int 3;
- }
- delete temp;
-
- pStk2->SetVar(result); // met le résultat sur la pile
- if ( err ) pStk2->SetError(err, &m_token); // et l'erreur éventuelle (division par zéro)
-
- pStk1->Return(pStk2); // libère la pile
- return pStack->Return(pStk1); // transmet le résultat
-}
-
-
diff --git a/src/CBot/old CBotAddExpr.cpp b/src/CBot/old CBotAddExpr.cpp
deleted file mode 100644
index 85b7588..0000000
--- a/src/CBot/old CBotAddExpr.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-///////////////////////////////////////////////////
-// expression du genre Opérande1 + Opérande2
-// Opérande1 - Opérande2
-
-#include "CBot.h"
-
-// divers constructeurs
-
-CBotAddExpr::CBotAddExpr()
-{
- m_leftop =
- m_rightop = NULL; // NULL pour pouvoir faire delete sans autre
- name = "CBotAddExpr"; // debug
-}
-
-CBotAddExpr::~CBotAddExpr()
-{
- delete m_leftop;
- delete m_rightop;
-}
-
-
-// compile une instruction de type A + B
-
-CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotCStack* pStack)
-{
- CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
-
- // cherche des instructions qui peuvent convenir à gauche de l'opération + ou -
-
- CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B à gauche
- if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
-
- // est-ce qu'on a le token + ou - ensuite ?
-
- if ( p->GetType() == ID_ADD ||
- p->GetType() == ID_SUB) // plus ou moins
- {
- CBotAddExpr* inst = new CBotAddExpr(); // élément pour opération
- inst->SetToken(p); // mémorise l'opération
-
- int type1, type2;
- type1 = pStk->GetType(CBotTypChar); // de quel type le premier opérande ?
-
- p = p->Next(); // saute le token de l'opération
-
- // cherche des instructions qui peuvent convenir à droite
-
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) à droite
- {
- // il y a un second opérande acceptable
-
- type2 = pStk->GetType(CBotTypChar); // de quel type le résultat ?
-
- if ( type1 == type2 && // les résultats sont-ils compatibles
- type1 != CBotTypBoolean &&
- (inst->m_token.GetType() != ID_SUB ||
- type1 < CBotTypBoolean )) // pas de soustraction de chaînes !
- {
- // si ok, enregistre l'opérande dans l'objet
- inst->m_leftop = left;
- // et rend l'object à qui l'a demandé
- return pStack->Return(inst, pStk);
- }
- pStk->SetError(TX_BAD2TYPE, &inst->m_token);
- }
-
- // en cas d'erreur, libère les éléments
- delete left;
- delete inst;
- // et transmet l'erreur qui se trouve sur la pile
- return pStack->Return(NULL, pStk);
- }
-
- // si on n'a pas affaire à une opération + ou -
- // rend à qui l'a demandé, l'opérande (de gauche) trouvé
- // à la place de l'objet "addition"
- return pStack->Return(left, pStk);
-}
-
-
-
-
-// fait l'opération d'addition ou de soustraction
-
-BOOL CBotAddExpr::Execute(CBotStack* &pStack)
-{
- 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
-
- 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
-
- // demande un peu plus de stack pour ne pas toucher le résultat de gauche
- // qui se trouve sur la pile, justement.
-
- CBotStack* pStk2 = pStk1->AddStack(); // ajoute un élément à la pile
- // ou le retrouve en cas de reprise
-
- // 2e état, évalue l'opérande de droite
- if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
-
- int type1 = pStk1->GetType(); // de quels types les résultats ?
- int type2 = pStk2->GetType();
-
- // crée une variable temporaire pour y mettre le résultat
- CBotVar* result = CBotVar::Create( NULL, MAX(type1, type2));
-
- // fait l'opération selon la demande
- switch (GetTokenType())
- {
- case ID_ADD:
- result->Add(pStk1->GetVar(), pStk2->GetVar()); // additionne
- break;
- case ID_SUB:
- result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
- break;
- }
- pStk2->SetVar(result); // met le résultat sur la pile
-
- pStk1->Return(pStk2); // libère la pile
- return pStack->Return(pStk1); // transmet le résultat
-}
-
-
diff --git a/src/CBot/old CBotCompExpr.cpp b/src/CBot/old CBotCompExpr.cpp
deleted file mode 100644
index e7439b7..0000000
--- a/src/CBot/old CBotCompExpr.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-///////////////////////////////////////////////////
-// expression du genre Opérande1 > Opérande2
-// Opérande1 != Opérande2
-// etc.
-
-#include "CBot.h"
-
-// divers constructeurs
-
-CBotCompExpr::CBotCompExpr()
-{
- m_leftop =
- m_rightop = NULL;
- name = "CBotCompExpr";
-}
-
-CBotCompExpr::~CBotCompExpr()
-{
- delete m_leftop;
- delete m_rightop;
-}
-
-
-// compile une instruction de type A < B
-
-CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack)
-{
- CBotCStack* pStk = pStack->TokenStack();
-
- CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B à gauche
- if (left == NULL) return pStack->Return(NULL, pStk); // erreur
-
- if ( p->GetType() == ID_HI ||
- p->GetType() == ID_LO ||
- p->GetType() == ID_HS ||
- p->GetType() == ID_LS ||
- p->GetType() == ID_EQ ||
- p->GetType() == ID_NE) // les diverses comparaisons
- {
- CBotCompExpr* inst = new CBotCompExpr(); // élément pour opération
- inst->SetToken(p); // mémorise l'opération
-
- int type1, type2;
- type1 = pStk->GetType(CBotTypChar);
-
- p = p->Next();
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B à droite
- {
- type2 = pStk->GetType(CBotTypChar);
- // les résultats sont-ils compatibles
- if ( type1 == type2 && type1 != CBotTypBoolean && type1 != CBotTypClass)
- {
- inst->m_leftop = left;
- pStk->SetVar(new CBotVar(NULL, CBotTypBoolean));
- // le résultat est un boolean
- return pStack->Return(inst, pStk);
- }
- pStk->SetError(TX_BAD2TYPE, &inst->m_token);
- }
-
- delete left;
- delete inst;
- return pStack->Return(NULL, pStk);
- }
-
- return pStack->Return(left, pStk);
-}
-
-
-// fait l'opération
-
-BOOL CBotCompExpr::Execute(CBotStack* &pStack)
-{
- CBotStack* pStk1 = pStack->AddStack();
-
- if ( pStk1->GetState() == 0 && !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
-
- pStk1->SetState(1); // opération terminée
-
- // demande un peu plus de stack pour ne pas toucher le résultat de gauche
- CBotStack* pStk2 = pStk1->AddStack();
-
- if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
-
- int type1 = pStk1->GetType();
- int type2 = pStk2->GetType();
-
- CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) );
- CBotVar* result = CBotVar::Create( NULL, CBotTypBoolean );
-
- switch (GetTokenType())
- {
- case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
- break;
- case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
- break;
- case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
- break;
- case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
- break;
- case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
- break;
- case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
- break;
- }
- result->SetValInt(temp->GetValInt()); // converti le résultat
- delete temp;
-
- pStk2->SetVar(result); // met le résultat sur la pile
-
- pStk1->Return(pStk2); // libère la pile
- return pStack->Return(pStk1); // transmet le résultat
-}
-
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-07-09 10:58:40 +0000