summaryrefslogtreecommitdiffstats
path: root/src/CBot/CBotWhile.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/CBot/CBotWhile.cpp')
-rw-r--r--src/CBot/CBotWhile.cpp392
1 files changed, 198 insertions, 194 deletions
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)
{
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-09-06 17:47:30 +0000