From 0919796df7ab9025bb53ef2dc56d0888de8c7e73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Konopacki?= Date: Wed, 8 Aug 2012 02:01:06 +0200 Subject: Transation of comments complete --- src/CBot/CBotAddExpr.cpp | 286 ++++++++++++++++++++++++----------------------- 1 file changed, 144 insertions(+), 142 deletions(-) (limited to 'src/CBot/CBotAddExpr.cpp') diff --git a/src/CBot/CBotAddExpr.cpp b/src/CBot/CBotAddExpr.cpp index d94946e..8e4ed85 100644 --- a/src/CBot/CBotAddExpr.cpp +++ b/src/CBot/CBotAddExpr.cpp @@ -1,142 +1,144 @@ -// * 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" - -// 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, CBotStack* pStack) -{ - CBotStack* 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 = pStack->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 = CBotAddExpr::Compile( p, pStk )) ) // expression (...) à droite - { - // il y a un second opérande acceptable - - type2 = pStack->GetType(); // de quel type le résultat ? - - if ( type1 == type2 ) // les résultats sont-ils compatibles - { - // 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); - } - } - - // 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(this); // ajoute un élément à la pile - // ou le retrouve en cas de reprise -// if ( pSk1 == 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 - - // 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 = new CBotVar( 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 -} - - +// * 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/. + +/////////////////////////////////////////////////// +// expressions of type Operand1 + Operand2 +// Operand1 - Operand2 + +#include "CBot.h" + +// various constructors + +CBotAddExpr::CBotAddExpr() +{ + m_leftop = + m_rightop = NULL; // NULL to be able to delete without further + name = "CBotAddExpr"; // debug +} + +CBotAddExpr::~CBotAddExpr() +{ + delete m_leftop; + delete m_rightop; +} + + +// compile une instruction de type A + B + +CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack) +{ + CBotStack* pStk = pStack->TokenStack(); // one end of stack please + + // looking statements that may be suitable to the left of the operation + or - + + CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B left + if (left == NULL) return pStack->Return(NULL, pStk); // if error, transmit + + // do we have the token + or - next? + + if ( p->GetType() == ID_ADD || + p->GetType() == ID_SUB) // more or less + { + CBotAddExpr* inst = new CBotAddExpr(); // element for operation + inst->SetToken(p); // stores the operation + + int type1, type2; + type1 = pStack->GetType(); // what kind of the first operand? + + p = p->Next(); // skip the token of the operation + + // looking statements that may be suitable for right + + if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) rigth + { + // there is an acceptable second operand + + type2 = pStack->GetType(); // what kind of results? + + if ( type1 == type2 ) // are the results consistent ? + { + // ok so, saves the operand in the object + inst->m_leftop = left; + // and makes the object on demand + return pStack->Return(inst, pStk); + } + } + + // in case of error, free the elements + delete left; + delete inst; + // and transmits the error that is on the stack + return pStack->Return(NULL, pStk); + } + + // if we are not dealing with an operation + or - + // goes to that requested, the operand (left) found + // place the object "addition" + return pStack->Return(left, pStk); +} + + + + +// operation is addition or subtraction + +bool CBotAddExpr::Execute(CBotStack* &pStack) +{ + CBotStack* pStk1 = pStack->AddStack(this); // adds an item to the stack + // or is found in case of recovery +// if ( pSk1 == EOX ) return TRUE; + + + // according to recovery, it may be in one of two states + + if ( pStk1->GetState() == 0 && // first state, evaluates the left operand + !m_leftop->Execute(pStk1) ) return FALSE; // interrupted here? + + // passes to the next step + pStk1->SetState(1); // ready for further + + // requires a little more stack to not touch the result of the left + // which is on the stack, precisely. + + CBotStack* pStk2 = pStk1->AddStack(); // adds an item to the stack + // or is found in case of recovery + + // Second state, evaluates the right operand + if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrupted here? + + int type1 = pStk1->GetType(); // what kind of results? + int type2 = pStk2->GetType(); + + // creates a temporary variable to put the result + CBotVar* result = new CBotVar( NULL, MAX(type1, type2)); + + // is the operation as requested + switch (GetTokenType()) + { + case ID_ADD: + result->Add(pStk1->GetVar(), pStk2->GetVar()); // addition + break; + case ID_SUB: + result->Sub(pStk1->GetVar(), pStk2->GetVar()); // subtraction + break; + } + pStk2->SetVar(result); // puts the result on the stack + + pStk1->Return(pStk2); // frees the stack + return pStack->Return(pStk1); // transmits the result +} + + -- cgit v1.2.3-1-g7c22