From 84d1f79fdf02e0010e4b2d118458e8cd8ce0dd71 Mon Sep 17 00:00:00 2001 From: Krzysztof H Date: Fri, 9 Mar 2012 17:08:05 +0100 Subject: Added license info using a small program SrcHead. --- src/CBot/CBotTwoOpExpr.cpp | 168 ++++++++++++++++++++++++--------------------- 1 file changed, 90 insertions(+), 78 deletions(-) (limited to 'src/CBot/CBotTwoOpExpr.cpp') 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<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 -- cgit v1.2.3-1-g7c22