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/CBotWhile.cpp | 392 +++++++++++++++++++++++++------------------------ 1 file changed, 198 insertions(+), 194 deletions(-) (limited to 'src/CBot/CBotWhile.cpp') diff --git a/src/CBot/CBotWhile.cpp b/src/CBot/CBotWhile.cpp index 7a1ca1f..7ed857c 100644 --- a/src/CBot/CBotWhile.cpp +++ b/src/CBot/CBotWhile.cpp @@ -1,14 +1,18 @@ -/////////////////////////////////////////////////////////////////////// -// ce fichier défini les instructions suivantes: -// CBotWhile "while (condition) {instructions}" -// CBotDo "do {instructions} while (condition)" -// CBotFor "for (init, condition, incr) {instructions}" -// CBotSwitch "switch (val) {instructions}" -// CBotCase "case val:" -// CBotBreak "break", "break label", "continu", "continu label" -// CBotTry "try {instructions}" -// CBotCatch "catch (condition) {instructions}" ou "finally" -// CBotThrow "throw execption" +// * 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" @@ -27,14 +31,14 @@ CBotWhile::CBotWhile() CBotWhile::~CBotWhile() { - delete m_Condition; // libère la condition - delete m_Block; // libère le bloc d'instruction + delete m_Condition; // lib�re la condition + delete m_Block; // lib�re le bloc d'instruction } CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotWhile* inst = new CBotWhile(); // crée l'objet - CBotToken* pp = p; // conserve le ^au token (position début) + CBotWhile* inst = new CBotWhile(); // cr�e l'objet + CBotToken* pp = p; // conserve le ^au token (position d�but) if ( IsOfType( p, TokenTypVar ) && IsOfType( p, ID_DOTS ) ) @@ -57,57 +61,57 @@ CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack) if ( pStk->IsOk() ) { - // le bloc d'instruction est ok (il peut être vide ! + // le bloc d'instruction est ok (il peut �tre vide ! - return pStack->Return(inst, pStk); // rend l'objet à qui le demande + return pStack->Return(inst, pStk); // rend l'objet � qui le demande } } - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile } -// exécute une instruction "while" +// ex�cute une instruction "while" BOOL CBotWhile :: Execute(CBotStack* &pj) { - CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile + CBotStack* pile = pj->AddStack(this); // ajoute un �l�ment � la pile // ou le retrouve en cas de reprise // if ( pile == EOX ) return TRUE; if ( pile->IfStep() ) return FALSE; - while( TRUE ) switch( pile->GivState() ) // exécute la boucle - { // il y a 2 états possibles (selon reprise) + while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle + { // il y a 2 �tats possibles (selon reprise) case 0: - // évalue la condition + // �value la condition if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ? - // le résultat de la condition est sur la pile + // le r�sultat de la condition est sur la pile // termine s'il y a une erreur ou si la condition est fausse if ( !pile->IsOk() || pile->GivVal() != TRUE ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } // la condition est vrai, passe dans le second mode - if (!pile->SetState(1)) return FALSE; // prêt pour la suite + if (!pile->SetState(1)) return FALSE; // pr�t pour la suite case 1: - // évalue le bloc d'instruction associé + // �value le bloc d'instruction associ� if ( m_Block != NULL && !m_Block->Execute(pile) ) { if (pile->IfContinue(0, m_label)) continue; // si continue, repasse au test - return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile + return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile } // termine s'il y a une erreur if ( !pile->IsOk() ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } // repasse au test pour recommencer @@ -119,18 +123,18 @@ BOOL CBotWhile :: Execute(CBotStack* &pj) void CBotWhile :: RestoreState(CBotStack* &pj, BOOL bMain) { if ( !bMain ) return; - CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile + CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile if ( pile == NULL ) return; switch( pile->GivState() ) - { // il y a 2 états possibles (selon reprise) + { // il y a 2 �tats possibles (selon reprise) case 0: - // évalue la condition + // �value la condition m_Condition->RestoreState(pile, bMain); return; case 1: - // évalue le bloc d'instruction associé + // �value le bloc d'instruction associ� if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain); return; } @@ -151,14 +155,14 @@ CBotRepeat::CBotRepeat() CBotRepeat::~CBotRepeat() { - delete m_NbIter; // libère la condition - delete m_Block; // libère le bloc d'instruction + delete m_NbIter; // lib�re la condition + delete m_Block; // lib�re le bloc d'instruction } CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotRepeat* inst = new CBotRepeat(); // crée l'objet - CBotToken* pp = p; // conserve le ^au token (position début) + CBotRepeat* inst = new CBotRepeat(); // cr�e l'objet + CBotToken* pp = p; // conserve le ^au token (position d�but) if ( IsOfType( p, TokenTypVar ) && IsOfType( p, ID_DOTS ) ) @@ -173,7 +177,7 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack) if ( IsOfType(p, ID_OPENPAR ) ) { - CBotToken* ppp = p; // conserve le ^au token (position début) + CBotToken* ppp = p; // conserve le ^au token (position d�but) if ( NULL != (inst->m_NbIter = CBotExpression::Compile( p, pStk )) ) { if ( pStk->GivType() < CBotTypLong ) @@ -187,9 +191,9 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack) if ( pStk->IsOk() ) { - // le bloc d'instruction est ok (il peut être vide ! + // le bloc d'instruction est ok (il peut �tre vide ! - return pStack->Return(inst, pStk); // rend l'objet à qui le demande + return pStack->Return(inst, pStk); // rend l'objet � qui le demande } } pStack->SetError(TX_CLOSEPAR, p->GivStart()); @@ -199,59 +203,59 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack) } pStack->SetError(TX_ENDOF, p); } - pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenthèse + pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenth�se - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile } -// exécute une instruction "repeat" +// ex�cute une instruction "repeat" BOOL CBotRepeat :: Execute(CBotStack* &pj) { - CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile + CBotStack* pile = pj->AddStack(this); // ajoute un �l�ment � la pile // ou le retrouve en cas de reprise // if ( pile == EOX ) return TRUE; if ( pile->IfStep() ) return FALSE; - while( TRUE ) switch( pile->GivState() ) // exécute la boucle - { // il y a 2 états possibles (selon reprise) + while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle + { // il y a 2 �tats possibles (selon reprise) case 0: - // évalue le nombre d'itération + // �value le nombre d'it�ration if ( !m_NbIter->Execute(pile) ) return FALSE; // interrompu ici ? - // le résultat de la condition est sur la pile + // le r�sultat de la condition est sur la pile // termine s'il y a une erreur ou si la condition est fausse int n; if ( !pile->IsOk() || ( n = pile->GivVal() ) < 1 ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } - // met le nombre d'itération +1 dans le "state" + // met le nombre d'it�ration +1 dans le "state" - if (!pile->SetState(n+1)) return FALSE; // prêt pour la suite - continue; // passe à la suite + if (!pile->SetState(n+1)) return FALSE; // pr�t pour la suite + continue; // passe � la suite case 1: // fin normale de la boucle - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile default: - // évalue le bloc d'instruction associé + // �value le bloc d'instruction associ� if ( m_Block != NULL && !m_Block->Execute(pile) ) { if (pile->IfContinue(pile->GivState()-1, m_label)) continue; // si continue, repasse au test - return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile + return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile } // termine s'il y a une erreur if ( !pile->IsOk() ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } // repasse au test pour recommencer @@ -263,18 +267,18 @@ BOOL CBotRepeat :: Execute(CBotStack* &pj) void CBotRepeat :: RestoreState(CBotStack* &pj, BOOL bMain) { if ( !bMain ) return; - CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile + CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile if ( pile == NULL ) return; switch( pile->GivState() ) - { // il y a 2 états possibles (selon reprise) + { // il y a 2 �tats possibles (selon reprise) case 0: - // évalue la condition + // �value la condition m_NbIter->RestoreState(pile, bMain); return; case 1: - // évalue le bloc d'instruction associé + // �value le bloc d'instruction associ� if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain); return; } @@ -294,15 +298,15 @@ CBotDo::CBotDo() CBotDo::~CBotDo() { - delete m_Condition; // libère la condition - delete m_Block; // libère le bloc d'instruction + delete m_Condition; // lib�re la condition + delete m_Block; // lib�re le bloc d'instruction } CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotDo* inst = new CBotDo(); // crée l'objet + CBotDo* inst = new CBotDo(); // cr�e l'objet - CBotToken* pp = p; // conserve le ^au token (position début) + CBotToken* pp = p; // conserve le ^au token (position d�but) if ( IsOfType( p, TokenTypVar ) && IsOfType( p, ID_DOTS ) ) @@ -316,7 +320,7 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack) CBotCStack* pStk = pStack->TokenStack(pp); // un petit bout de pile svp - // cherche un bloc d'instruction après le do + // cherche un bloc d'instruction apr�s le do IncLvl(inst->m_label); inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); DecLvl(); @@ -330,7 +334,7 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack) // la condition existe if (IsOfType(p, ID_SEP)) { - return pStack->Return(inst, pStk); // rend l'objet à qui le demande + return pStack->Return(inst, pStk); // rend l'objet � qui le demande } pStk->SetError(TX_ENDOF, p->GivStart()); } @@ -338,49 +342,49 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack) pStk->SetError(TX_WHILE, p->GivStart()); } - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile } -// exécute une instruction "do" +// ex�cute une instruction "do" BOOL CBotDo :: Execute(CBotStack* &pj) { - CBotStack* pile = pj->AddStack(this); // ajoute un élément à la pile + CBotStack* pile = pj->AddStack(this); // ajoute un �l�ment � la pile // ou le retrouve en cas de reprise // if ( pile == EOX ) return TRUE; if ( pile->IfStep() ) return FALSE; - while( TRUE ) switch( pile->GivState() ) // exécute la boucle - { // il y a 2 états possibles (selon reprise) + while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle + { // il y a 2 �tats possibles (selon reprise) case 0: - // évalue le bloc d'instruction associé + // �value le bloc d'instruction associ� if ( m_Block != NULL && !m_Block->Execute(pile) ) { if (pile->IfContinue(1, m_label)) continue; // si continue, repasse au test - return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile + return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile } // termine s'il y a une erreur if ( !pile->IsOk() ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } - if (!pile->SetState(1)) return FALSE; // prêt pour la suite + if (!pile->SetState(1)) return FALSE; // pr�t pour la suite case 1: - // évalue la condition + // �value la condition if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ? - // le résultat de la condition est sur la pile + // le r�sultat de la condition est sur la pile // termine s'il y a une erreur ou si la condition est fausse if ( !pile->IsOk() || pile->GivVal() != TRUE ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } // repasse au bloc d'instruction pour recommencer @@ -393,13 +397,13 @@ void CBotDo :: RestoreState(CBotStack* &pj, BOOL bMain) { if ( !bMain ) return; - CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile + CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile if ( pile == NULL ) return; switch( pile->GivState() ) - { // il y a 2 états possibles (selon reprise) + { // il y a 2 �tats possibles (selon reprise) case 0: - // restitue le bloc d'instruction associé + // restitue le bloc d'instruction associ� if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain); return; @@ -430,13 +434,13 @@ CBotFor::~CBotFor() delete m_Init; delete m_Test; delete m_Incr; - delete m_Block; // libère le bloc d'instruction + delete m_Block; // lib�re le bloc d'instruction } CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotFor* inst = new CBotFor(); // crée l'objet - CBotToken* pp = p; // conserve le ^au token (position début) + CBotFor* inst = new CBotFor(); // cr�e l'objet + CBotToken* pp = p; // conserve le ^au token (position d�but) if ( IsOfType( p, TokenTypVar ) && IsOfType( p, ID_DOTS ) ) @@ -447,7 +451,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack) inst->SetToken(p); if (!IsOfType(p, ID_FOR)) return NULL; // ne devrait jamais arriver - if ( !IsOfType(p, ID_OPENPAR)) // manque la parenthèse ? + if ( !IsOfType(p, ID_OPENPAR)) // manque la parenth�se ? { pStack->SetError(TX_OPENPAR, p->GivStart()); return NULL; @@ -477,7 +481,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_Incr = CBotListExpression::Compile( p, pStk ); if ( pStk->IsOk() ) { - if ( IsOfType(p, ID_CLOSEPAR)) // manque la parenthèse ? + if ( IsOfType(p, ID_CLOSEPAR)) // manque la parenth�se ? { IncLvl(inst->m_label); inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE ); @@ -490,65 +494,65 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack) } } - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile } -// exécute l'instruction "for" +// ex�cute l'instruction "for" BOOL CBotFor :: Execute(CBotStack* &pj) { - CBotStack* pile = pj->AddStack(this, TRUE); // ajoute un élément à la pile (variables locales) + CBotStack* pile = pj->AddStack(this, TRUE); // ajoute un �l�ment � la pile (variables locales) // ou le retrouve en cas de reprise // if ( pile == EOX ) return TRUE; if ( pile->IfStep() ) return FALSE; - while( TRUE ) switch( pile->GivState() ) // exécute la boucle - { // il y a 4 états possibles (selon reprise) + while( TRUE ) switch( pile->GivState() ) // ex�cute la boucle + { // il y a 4 �tats possibles (selon reprise) case 0: - // évalue l'initialisation + // �value l'initialisation if ( m_Init != NULL && !m_Init->Execute(pile) ) return FALSE; // interrompu ici ? - if (!pile->SetState(1)) return FALSE; // prêt pour la suite + if (!pile->SetState(1)) return FALSE; // pr�t pour la suite case 1: - // évalue la condition + // �value la condition if ( m_Test != NULL ) // pas de condition ? -> vrai ! { if (!m_Test->Execute(pile) ) return FALSE; // interrompu ici ? - // le résultat de la condition est sur la pile + // le r�sultat de la condition est sur la pile // termine s'il y a une erreur ou si la condition est fausse if ( !pile->IsOk() || pile->GivVal() != TRUE ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } } - // la condition est vrai, passe à la suite - if (!pile->SetState(2)) return FALSE; // prêt pour la suite + // la condition est vrai, passe � la suite + if (!pile->SetState(2)) return FALSE; // pr�t pour la suite case 2: - // évalue le bloc d'instruction associé + // �value le bloc d'instruction associ� if ( m_Block != NULL && !m_Block->Execute(pile) ) { - if (pile->IfContinue(3, m_label)) continue; // si continue, passe à l'incrémentation - return pj->BreakReturn(pile, m_label); // transmet le résultat et libère la pile + if (pile->IfContinue(3, m_label)) continue; // si continue, passe � l'incr�mentation + return pj->BreakReturn(pile, m_label); // transmet le r�sultat et lib�re la pile } // termine s'il y a une erreur if ( !pile->IsOk() ) { - return pj->Return(pile); // transmet le résultat et libère la pile + return pj->Return(pile); // transmet le r�sultat et lib�re la pile } - if (!pile->SetState(3)) return FALSE; // prêt pour la suite + if (!pile->SetState(3)) return FALSE; // pr�t pour la suite case 3: - // évalue l'incrémentation + // �value l'incr�mentation if ( m_Incr != NULL && !m_Incr->Execute(pile) ) return FALSE; // interrompu ici ? @@ -562,34 +566,34 @@ void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain) { if ( !bMain ) return; - CBotStack* pile = pj->RestoreStack(this); // ajoute un élément à la pile (variables locales) + CBotStack* pile = pj->RestoreStack(this); // ajoute un �l�ment � la pile (variables locales) if ( pile == NULL ) return; switch( pile->GivState() ) - { // il y a 4 états possibles (selon reprise) + { // il y a 4 �tats possibles (selon reprise) case 0: - // évalue l'initialisation + // �value l'initialisation if ( m_Init != NULL ) m_Init->RestoreState(pile, TRUE); // interrompu ici ! return; case 1: - if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // définitions variables + if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // d�finitions variables - // évalue la condition + // �value la condition if ( m_Test != NULL ) m_Test->RestoreState(pile, TRUE); // interrompu ici ! return; case 2: - if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // définitions variables + if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // d�finitions variables - // évalue le bloc d'instruction associé + // �value le bloc d'instruction associ� if ( m_Block != NULL ) m_Block->RestoreState(pile, TRUE); return; case 3: - if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // définitions variables + if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE); // d�finitions variables - // évalue l'incrémentation + // �value l'incr�mentation if ( m_Incr != NULL ) m_Incr->RestoreState(pile, TRUE); // interrompu ici ! return; } @@ -597,8 +601,8 @@ void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain) ////////////////////////////////////////////////////////////////////////////////////// // compile une liste d'expression -// n'est utilisé que pour l'instruction for -// dans l'intitialisation et dans l'incrémentation +// n'est utilis� que pour l'instruction for +// dans l'intitialisation et dans l'incr�mentation CBotListExpression::CBotListExpression() { @@ -611,14 +615,14 @@ CBotListExpression::~CBotListExpression() delete m_Expr; } -// cherche une déclaration de variable ou une expression +// cherche une d�claration de variable ou une expression static CBotInstr* CompileInstrOrDefVar(CBotToken* &p, CBotCStack* pStack) { - CBotInstr* i = CBotInt::Compile( p, pStack, FALSE, TRUE ); // est-ce une déclaration d'un entier ? - if ( i== NULL ) i = CBotFloat::Compile( p, pStack, FALSE, TRUE ); // ou d'un nombre réel ? - if ( i== NULL ) i = CBotBoolean::Compile( p, pStack, FALSE, TRUE ); // ou d'un booléen ? - if ( i== NULL ) i = CBotIString::Compile( p, pStack, FALSE, TRUE ); // ou d'une chaîne ? + CBotInstr* i = CBotInt::Compile( p, pStack, FALSE, TRUE ); // est-ce une d�claration d'un entier ? + if ( i== NULL ) i = CBotFloat::Compile( p, pStack, FALSE, TRUE ); // ou d'un nombre r�el ? + if ( i== NULL ) i = CBotBoolean::Compile( p, pStack, FALSE, TRUE ); // ou d'un bool�en ? + if ( i== NULL ) i = CBotIString::Compile( p, pStack, FALSE, TRUE ); // ou d'une cha�ne ? if ( i== NULL ) i = CBotExpression::Compile( p, pStack ); // compile une expression return i; } @@ -627,13 +631,13 @@ CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack) { CBotListExpression* inst = new CBotListExpression(); - inst->m_Expr = CompileInstrOrDefVar( p, pStack ); // compile la première expression de la liste + inst->m_Expr = CompileInstrOrDefVar( p, pStack ); // compile la premi�re expression de la liste if (pStack->IsOk()) { while ( IsOfType(p, ID_COMMA) ) // plusieurs instructions ? { - CBotInstr* i = CompileInstrOrDefVar( p, pStack ); // est-ce une déclaration d'un entier ? - inst->m_Expr->AddNext(i); // ajoute à la suite + CBotInstr* i = CompileInstrOrDefVar( p, pStack ); // est-ce une d�claration d'un entier ? + inst->m_Expr->AddNext(i); // ajoute � la suite if ( !pStack->IsOk() ) { delete inst; @@ -649,17 +653,17 @@ CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack) BOOL CBotListExpression::Execute(CBotStack* &pj) { CBotStack* pile = pj->AddStack();// indispensable - CBotInstr* p = m_Expr; // la première expression + CBotInstr* p = m_Expr; // la premi�re expression int state = pile->GivState(); - while (state-->0) p = p->GivNext(); // revient sur l'opération interrompue + while (state-->0) p = p->GivNext(); // revient sur l'op�ration interrompue if ( p != NULL ) while (TRUE) { if ( !p->Execute(pile) ) return FALSE; p = p->GivNext(); if ( p == NULL ) break; - if (!pile->IncState()) return FALSE; // prêt pour la suivante + if (!pile->IncState()) return FALSE; // pr�t pour la suivante } return pj->Return(pile); } @@ -676,12 +680,12 @@ void CBotListExpression::RestoreState(CBotStack* &pj, BOOL bMain) state = pile->GivState(); } - CBotInstr* p = m_Expr; // la première expression + CBotInstr* p = m_Expr; // la premi�re expression while (p != NULL && state-->0) { p->RestoreState(pile, FALSE); - p = p->GivNext(); // revient sur l'opération interrompue + p = p->GivNext(); // revient sur l'op�ration interrompue } if ( p != NULL ) @@ -704,15 +708,15 @@ CBotSwitch::CBotSwitch() CBotSwitch::~CBotSwitch() { - delete m_Value; // libère la valeur - delete m_Block; // libère le bloc d'instruction + delete m_Value; // lib�re la valeur + delete m_Block; // lib�re le bloc d'instruction } CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotSwitch* inst = new CBotSwitch(); // crée l'objet - CBotToken* pp = p; // conserve le ^au token (position début) + CBotSwitch* inst = new CBotSwitch(); // cr�e l'objet + CBotToken* pp = p; // conserve le ^au token (position d�but) inst->SetToken(p); if (!IsOfType(p, ID_SWITCH)) return NULL; // ne devrait jamais arriver @@ -780,7 +784,7 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk); } // le bloc d'instruction est ok - return pStack->Return(inst, pStk); // rend l'objet à qui le demande + return pStack->Return(inst, pStk); // rend l'objet � qui le demande } pStk->SetError( TX_OPENBLK, p->GivStart() ); } @@ -791,18 +795,18 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack) } pStk->SetError( TX_OPENPAR, p->GivStart()); - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile } -// exécute une instruction "switch" +// ex�cute une instruction "switch" BOOL CBotSwitch :: Execute(CBotStack* &pj) { - CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile + CBotStack* pile1 = pj->AddStack(this); // ajoute un �l�ment � la pile // if ( pile1 == EOX ) return TRUE; - CBotInstr* p = m_Block; // la première expression + CBotInstr* p = m_Block; // la premi�re expression int state = pile1->GivState(); if (state == 0) @@ -816,23 +820,23 @@ BOOL CBotSwitch :: Execute(CBotStack* &pj) if ( state == -1 ) { state = 0; - int val = pile1->GivVal(); // résultat de la valeur + int val = pile1->GivVal(); // r�sultat de la valeur CBotStack* pile2 = pile1->AddStack(); while ( p != NULL ) // recherche le case correspondant dans la liste { state++; - if ( p->CompCase( pile2, val ) ) break; // trouvé le case + if ( p->CompCase( pile2, val ) ) break; // trouv� le case p = p->GivNext(); } pile2->Delete(); - if ( p == NULL ) return pj->Return(pile1); // terminé si plus rien + if ( p == NULL ) return pj->Return(pile1); // termin� si plus rien if ( !pile1->SetState(state) ) return FALSE; } - p = m_Block; // revient au début + p = m_Block; // revient au d�but while (state-->0) p = p->GivNext(); // avance dans la liste while( p != NULL ) @@ -848,10 +852,10 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain) { if ( !bMain ) return; - CBotStack* pile1 = pj->RestoreStack(this); // ajoute un élément à la pile + CBotStack* pile1 = pj->RestoreStack(this); // ajoute un �l�ment � la pile if ( pile1 == NULL ) return; - CBotInstr* p = m_Block; // la première expression + CBotInstr* p = m_Block; // la premi�re expression int state = pile1->GivState(); if (state == 0) @@ -865,7 +869,7 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain) return; } -// p = m_Block; // revient au début +// p = m_Block; // revient au d�but while ( p != NULL && state-- > 0 ) { p->RestoreState(pile1, FALSE); @@ -883,7 +887,7 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain) /////////////////////////////////////////////////////////////////////////// // compile une instruction "case" -// on est forcément dans un bloc d'instruction "switch" +// on est forc�ment dans un bloc d'instruction "switch" CBotCase::CBotCase() { @@ -893,14 +897,14 @@ CBotCase::CBotCase() CBotCase::~CBotCase() { - delete m_Value; // libère la valeur + delete m_Value; // lib�re la valeur } CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotCase* inst = new CBotCase(); // crée l'objet - CBotToken* pp = p; // conserve le ^au token (position début) + CBotCase* inst = new CBotCase(); // cr�e l'objet + CBotToken* pp = p; // conserve le ^au token (position d�but) inst->SetToken(p); if (!IsOfType(p, ID_CASE, ID_DEFAULT)) return NULL; // ne devrait jamais arriver @@ -926,7 +930,7 @@ CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack) return inst; } -// exécution de l'instruction "case" +// ex�cution de l'instruction "case" BOOL CBotCase::Execute(CBotStack* &pj) { @@ -937,15 +941,15 @@ void CBotCase::RestoreState(CBotStack* &pj, BOOL bMain) { } -// routine permettant de trouver le point d'entrée "case" -// correspondant à la valeur cherchée +// routine permettant de trouver le point d'entr�e "case" +// correspondant � la valeur cherch�e BOOL CBotCase::CompCase(CBotStack* &pile, int val) { if ( m_Value == NULL ) return TRUE; // cas pour "default" while (!m_Value->Execute(pile)); // met sur la pile la valeur correpondant (sans interruption) - return (pile->GivVal() == val); // compare avec la valeur cherchée + return (pile->GivVal() == val); // compare avec la valeur cherch�e } /////////////////////////////////////////////////////////////////////////// @@ -964,7 +968,7 @@ CBotBreak::~CBotBreak() CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotToken* pp = p; // conserve le ^au token (position début) + CBotToken* pp = p; // conserve le ^au token (position d�but) int type = p->GivType(); if (!IsOfType(p, ID_BREAK, ID_CONTINUE)) return NULL; // ne devrait jamais arriver @@ -975,8 +979,8 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack) return NULL; // pas d'objet, l'erreur est sur la pile } - CBotBreak* inst = new CBotBreak(); // crée l'objet - inst->SetToken(pp); // garde l'opération + CBotBreak* inst = new CBotBreak(); // cr�e l'objet + inst->SetToken(pp); // garde l'op�ration pp = p; if ( IsOfType( p, TokenTypVar ) ) @@ -992,7 +996,7 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack) if (IsOfType(p, ID_SEP)) { - return inst; // et le donne à qui veux + return inst; // et le donne � qui veux } delete inst; @@ -1000,7 +1004,7 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack) return NULL; // pas d'objet, l'erreur est sur la pile } -// exécution l'instructino "break" ou "continu" +// ex�cution l'instructino "break" ou "continu" BOOL CBotBreak :: Execute(CBotStack* &pj) { @@ -1034,15 +1038,15 @@ CBotTry::CBotTry() CBotTry::~CBotTry() { - delete m_ListCatch; // libère la liste - delete m_Block; // libère le bloc d'instruction + delete m_ListCatch; // lib�re la liste + delete m_Block; // lib�re le bloc d'instruction delete m_FinalInst; } CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotTry* inst = new CBotTry(); // crée l'objet - CBotToken* pp = p; // conserve le ^au token (position début) + CBotTry* inst = new CBotTry(); // cr�e l'objet + CBotToken* pp = p; // conserve le ^au token (position d�but) inst->SetToken(p); if (!IsOfType(p, ID_TRY)) return NULL; // ne devrait jamais arriver @@ -1066,28 +1070,28 @@ CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack) if (pStk->IsOk()) { - return pStack->Return(inst, pStk); // rend l'objet à qui le demande + return pStack->Return(inst, pStk); // rend l'objet � qui le demande } - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return pStack->Return(NULL, pStk); // pas d'objet, l'erreur est sur la pile } -// exécute l'instruction Try -// gère le retour d'exceptions -// les arrêts par suspension +// ex�cute l'instruction Try +// g�re le retour d'exceptions +// les arr�ts par suspension // et les "finaly" BOOL CBotTry :: Execute(CBotStack* &pj) { int val; - CBotStack* pile1 = pj->AddStack(this); // ajoute un élément à la pile + CBotStack* pile1 = pj->AddStack(this); // ajoute un �l�ment � la pile // if ( pile1 == EOX ) return TRUE; if ( pile1->IfStep() ) return FALSE; // ou le retrouve en cas de reprise - CBotStack* pile0 = pj->AddStack2(); // ajoute un élément à la pile secondaire + CBotStack* pile0 = pj->AddStack2(); // ajoute un �l�ment � la pile secondaire CBotStack* pile2 = pile0->AddStack(); if ( pile1->GivState() == 0 ) @@ -1103,7 +1107,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) return FALSE; // ne fait pas le catch pile1->IncState(); - pile2->SetState(val); // mémorise le numéro de l'erreur + pile2->SetState(val); // m�morise le num�ro de l'erreur pile1->SetError(0); // pour l'instant il n'y a plus d'erreur ! if ( val == 0 && CBotStack::m_initimer < 0 ) // en mode de step ? @@ -1114,7 +1118,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) // voir de quoi il en retourne CBotCatch* pc = m_ListCatch; - int state = (short)pile1->GivState(); // où en étions-nous ? + int state = (short)pile1->GivState(); // o� en �tions-nous ? val = pile2->GivState(); // pour quelle erreur ? pile0->SetState(1); // marquage pour GetRunPos @@ -1122,7 +1126,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) { if ( --state <= 0 ) { - // demande au bloc catch s'il se sent concerné + // demande au bloc catch s'il se sent concern� if ( !pc->TestCatch(pile2, val) ) return FALSE; // suspendu ! pile1->IncState(); } @@ -1132,7 +1136,7 @@ BOOL CBotTry :: Execute(CBotStack* &pj) { // pile0->SetState(1); - if ( !pc->Execute(pile2) ) return FALSE; // exécute l'opération + if ( !pc->Execute(pile2) ) return FALSE; // ex�cute l'op�ration if ( m_FinalInst == NULL ) return pj->Return(pile2); // termine le try @@ -1156,8 +1160,8 @@ BOOL CBotTry :: Execute(CBotStack* &pj) return pj->Return(pile2); } - pile1->SetState(0); // revient à l'évaluation - pile0->SetState(0); // revient à l'évaluation + pile1->SetState(0); // revient � l'�valuation + pile0->SetState(0); // revient � l'�valuation if ( val != 0 && m_ListCatch == NULL && m_FinalInst == NULL ) return pj->Return(pile2); // termine le try sans exception aucune @@ -1171,10 +1175,10 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain) if ( !bMain ) return; int val; - CBotStack* pile1 = pj->RestoreStack(this); // ajoute un élément à la pile + CBotStack* pile1 = pj->RestoreStack(this); // ajoute un �l�ment � la pile if ( pile1 == NULL ) return; // ou le retrouve en cas de reprise - CBotStack* pile0 = pj->AddStack2(); // ajoute un élément à la pile secondaire + CBotStack* pile0 = pj->AddStack2(); // ajoute un �l�ment � la pile secondaire if ( pile0 == NULL ) return; CBotStack* pile2 = pile0->RestoreStack(); @@ -1190,14 +1194,14 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain) // voir de quoi il en retourne CBotCatch* pc = m_ListCatch; - int state = pile1->GivState(); // où en étions-nous ? + int state = pile1->GivState(); // o� en �tions-nous ? val = pile2->GivState(); // pour quelle erreur ? if ( val >= 0 && state > 0 ) while ( pc != NULL ) { if ( --state <= 0 ) { - // demande au bloc catch s'il se sent concerné + // demande au bloc catch s'il se sent concern� pc->RestoreCondState(pile2, bMain); // suspendu ! return; } @@ -1205,7 +1209,7 @@ void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain) { if ( pile2->GivVal() == TRUE ) { - pc->RestoreState(pile2, bMain); // exécute l'opération + pc->RestoreState(pile2, bMain); // ex�cute l'op�ration return; } } @@ -1235,14 +1239,14 @@ CBotCatch::CBotCatch() CBotCatch::~CBotCatch() { - delete m_Cond; // libère la liste - delete m_Block; // libère le bloc d'instruction + delete m_Cond; // lib�re la liste + delete m_Block; // lib�re le bloc d'instruction delete m_next; // et la suite } CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack) { - CBotCatch* inst = new CBotCatch(); // crée l'objet + CBotCatch* inst = new CBotCatch(); // cr�e l'objet pStack->SetStartError(p->GivStart()); inst->SetToken(p); @@ -1258,23 +1262,23 @@ CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack) { inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStack ); if ( pStack->IsOk() ) - return inst; // rend l'objet à qui le demande + return inst; // rend l'objet � qui le demande } pStack->SetError(TX_CLOSEPAR, p->GivStart()); } pStack->SetError(TX_BADTYPE, p->GivStart()); } pStack->SetError(TX_OPENPAR, p->GivStart()); - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return NULL; // pas d'objet, l'erreur est sur la pile } -// exécution de "catch" +// ex�cution de "catch" BOOL CBotCatch :: Execute(CBotStack* &pj) { if ( m_Block == NULL ) return TRUE; - return m_Block->Execute(pj); // exécute le bloc associé + return m_Block->Execute(pj); // ex�cute le bloc associ� } void CBotCatch :: RestoreState(CBotStack* &pj, BOOL bMain) @@ -1287,7 +1291,7 @@ void CBotCatch :: RestoreCondState(CBotStack* &pj, BOOL bMain) m_Cond->RestoreState(pj, bMain); } -// routine pour savoir si le catch est à faire ou non +// routine pour savoir si le catch est � faire ou non BOOL CBotCatch :: TestCatch(CBotStack* &pile, int val) { @@ -1324,10 +1328,10 @@ CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack) { pStack->SetStartError(p->GivStart()); - CBotThrow* inst = new CBotThrow(); // crée l'objet + CBotThrow* inst = new CBotThrow(); // cr�e l'objet inst->SetToken(p); - CBotToken* pp = p; // conserve le ^au token (position début) + CBotToken* pp = p; // conserve le ^au token (position d�but) if (!IsOfType(p, ID_THROW)) return NULL; // ne devrait jamais arriver @@ -1335,15 +1339,15 @@ CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack) if (pStack->GivType() < CBotTypLong && pStack->IsOk()) { - return inst; // rend l'objet à qui le demande + return inst; // rend l'objet � qui le demande } pStack->SetError(TX_BADTYPE, pp); - delete inst; // erreur, libère la place + delete inst; // erreur, lib�re la place return NULL; // pas d'objet, l'erreur est sur la pile } -// exécute l'instruction "throw" +// ex�cute l'instruction "throw" BOOL CBotThrow :: Execute(CBotStack* &pj) { @@ -1397,11 +1401,11 @@ CBotInstr* CBotStartDebugDD::Compile(CBotToken* &p, CBotCStack* pStack) if (!IsOfType(p, ID_DEBUGDD)) return NULL; // ne devrait jamais arriver - return new CBotStartDebugDD(); // crée l'objet + return new CBotStartDebugDD(); // cr�e l'objet } -// exécute l'instruction "throw" +// ex�cute l'instruction "throw" BOOL CBotStartDebugDD :: Execute(CBotStack* &pj) { -- cgit v1.2.3-1-g7c22