diff options
Diffstat (limited to 'src/CBot')
58 files changed, 2797 insertions, 2082 deletions
diff --git a/src/CBot/CBot.cpp b/src/CBot/CBot.cpp index 79a0b6f..02f6d50 100644 --- a/src/CBot/CBot.cpp +++ b/src/CBot/CBot.cpp @@ -1,12 +1,23 @@ -///////////////////////////////////////////////////////////////////////
-// compilation des diverses instructions
-// toutes les routines Compile sont statiques
-// et retournent un object selon ce qui a été trouvé comme instruction
+// * 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 .
// principe de compilation:
-// les routines Compile retournent un objet de la classe correspondant à l'opération trouvée
+// les routines Compile retournent un objet de la classe correspondant � l'op�ration trouv�e
// il s'agit toujours d'une classe fille de CBotInstr.
-// ( les objets CBotInstr ne sont jamais utilisés directement )
+// ( les objets CBotInstr ne sont jamais utilis�s directement )
// si la routine Compile retourne NULL, c'est que l'instruction est fausse
// ou incomprise.
@@ -16,7 +27,7 @@ #include "CBot.h"
// les divers constructeurs / destructeurs
-// pour libérer tout selon l'arbre établi
+// pour lib�rer tout selon l'arbre �tabli
CBotInstr::CBotInstr()
{
name = "CBotInstr";
@@ -34,8 +45,8 @@ CBotInstr::~CBotInstr() delete m_next3b;
}
-// compteur de boucles imbriquées,
-// pour détermniner les break et continue valides
+// compteur de boucles imbriqu�es,
+// pour d�termniner les break et continue valides
// et liste des labels utilisables
int CBotInstr::m_LoopLvl = 0;
@@ -58,14 +69,14 @@ void CBotInstr::IncLvl() m_LoopLvl++;
}
-// libère un niveau
+// lib�re un niveau
void CBotInstr::DecLvl()
{
m_LoopLvl--;
m_labelLvl[m_LoopLvl].Empty();
}
-// controle la validité d'un break ou continu
+// controle la validit� d'un break ou continu
BOOL CBotInstr::ChkLvl(CBotString& label, int type)
{
int i = m_LoopLvl;
@@ -87,7 +98,7 @@ BOOL CBotInstr::IsOfClass(CBotString n) ////////////////////////////////////////////////////////////////////////////
// gestion de base de la classe CBotInstr
-// définie le token correspondant à l'instruction
+// d�finie le token correspondant � l'instruction
void CBotInstr::SetToken(CBotToken* p)
{
@@ -100,21 +111,21 @@ void CBotInstr::SetToken(CBotString* name, int start, int end) }
-// rend le type du token associé à l'instruction
+// rend le type du token associ� � l'instruction
int CBotInstr::GivTokenType()
{
return m_token.GivType();
}
-// rend le token associé
+// rend le token associ�
CBotToken* CBotInstr::GivToken()
{
return &m_token;
}
-// ajoute une instruction à la suite des autres
+// ajoute une instruction � la suite des autres
void CBotInstr::AddNext(CBotInstr* n)
{
@@ -155,10 +166,10 @@ CBotInstr* CBotInstr::GivNext3b() }
///////////////////////////////////////////////////////////////////////////
-// compile une instruction, qui peut être
+// compile une instruction, qui peut �tre
// while, do, try, throw, if, for, switch, break, continu, return
// int, float, boolean, string,
-// déclaration d'une instance d'une classe
+// d�claration d'une instance d'une classe
// expression quelconque
CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack)
@@ -182,7 +193,7 @@ CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack) }
}
- // appel la routine de compilation correspondant au token trouvé
+ // appel la routine de compilation correspondant au token trouv�
switch (type)
{
case ID_WHILE:
@@ -245,25 +256,25 @@ CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack) pStack->SetStartError(p->GivStart());
- // ne doit pas être un mot réservé par DefineNum
+ // ne doit pas �tre un mot r�serv� par DefineNum
if ( p->GivType() == TokenTypDef )
{
pStack->SetError(TX_RESERVED, p);
return NULL;
}
- // ce peut être une définition d'instance de class
+ // ce peut �tre une d�finition d'instance de class
CBotToken* ppp = p;
if ( IsOfType( ppp, TokenTypVar ) /* && IsOfType( ppp, TokenTypVar )*/ )
{
if ( CBotClass::Find(p) != NULL )
{
- // oui, compile la déclaration de l'instance
+ // oui, compile la d�claration de l'instance
return CBotClassInst::Compile(p, pStack);
}
}
- // ce peut être une instruction arithmétique
+ // ce peut �tre une instruction arithm�tique
CBotInstr* inst = CBotExpression::Compile(p, pStack);
if (IsOfType(p, ID_SEP))
{
@@ -314,9 +325,9 @@ void CBotInstr::RestoreStateVar(CBotStack* &pile, BOOL bMain) __asm int 3; // papa sait pas faire, voir les filles
}
-// cette routine n'est définie que pour la classe fille CBotCase
+// cette routine n'est d�finie que pour la classe fille CBotCase
// cela permet de faire l'appel CompCase sur toutes les instructions
-// pour savoir s'il s'agit d'un case pour la valeur désirée.
+// pour savoir s'il s'agit d'un case pour la valeur d�sir�e.
BOOL CBotInstr::CompCase(CBotStack* &pj, int val)
{
@@ -330,7 +341,7 @@ BOOL CBotInstr::CompCase(CBotStack* &pj, int val) // compile un bloc d'instruction " { i ; i ; } "
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourné par Compile est généralement de type CBotListInstr
+// l'objet retourn� par Compile est g�n�ralement de type CBotListInstr
CBotInstr* CBotBlock::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal)
@@ -346,7 +357,7 @@ CBotInstr* CBotBlock::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal) return inst;
}
- pStack->SetError(TX_CLOSEBLK, p->GivStart()); // manque la parenthèse
+ pStack->SetError(TX_CLOSEBLK, p->GivStart()); // manque la parenth�se
delete inst;
return NULL;
}
@@ -360,9 +371,9 @@ CBotInstr* CBotBlock::CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, BOOL b // est-ce un nouveau bloc ?
if ( p->GivType() == ID_OPBLK ) return CBotBlock::Compile(p, pStack);
- // sinon, cherche une instruction unique à la place
+ // sinon, cherche une instruction unique � la place
- // pour gérer les cas avec définition local à l'instructin (*)
+ // pour g�rer les cas avec d�finition local � l'instructin (*)
CBotCStack* pStk = pStack->TokenStack(p, bLocal);
return pStack->Return( CBotInstr::Compile(p, pStk), // une instruction unique
@@ -371,14 +382,14 @@ CBotInstr* CBotBlock::CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, BOOL b // (*) c'est le cas dans l'instruction suivante
// if ( 1 == 1 ) int x = 0;
-// où la variable x n'est connue que dans le bloc qui suit le if.
+// o� la variable x n'est connue que dans le bloc qui suit le if.
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// compile une liste d'instruction, séparés par des points-virgules
+// compile une liste d'instruction, s�par�s par des points-virgules
CBotListInstr::CBotListInstr()
{
@@ -401,8 +412,8 @@ CBotInstr* CBotListInstr::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal {
if ( p == NULL ) break;
- if (IsOfType(p, ID_SEP)) continue; // instruction vide ignorée
- if ( p->GivType() == ID_CLBLK ) break; // déja plus d'instruction
+ if (IsOfType(p, ID_SEP)) continue; // instruction vide ignor�e
+ if ( p->GivType() == ID_CLBLK ) break; // d�ja plus d'instruction
if (IsOfType(p, 0))
{
@@ -420,12 +431,12 @@ CBotInstr* CBotListInstr::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal }
if ( inst->m_Instr == NULL ) inst->m_Instr = i;
- else inst->m_Instr->AddNext(i); // ajoute à la suite
+ else inst->m_Instr->AddNext(i); // ajoute � la suite
}
return pStack->Return(inst, pStk);
}
-// exécute une liste d'instructions
+// ex�cute une liste d'instructions
BOOL CBotListInstr::Execute(CBotStack* &pj)
{
@@ -434,10 +445,10 @@ BOOL CBotListInstr::Execute(CBotStack* &pj) if ( pile->StackOver() ) return pj->Return( pile );
- CBotInstr* p = m_Instr; // la première expression
+ CBotInstr* p = m_Instr; // 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)
{
@@ -446,7 +457,7 @@ BOOL CBotListInstr::Execute(CBotStack* &pj) 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 ); // transmet en dessous
@@ -459,13 +470,13 @@ void CBotListInstr::RestoreState(CBotStack* &pj, BOOL bMain) CBotStack* pile = pj->RestoreStack(this);
if ( pile == NULL ) return;
- CBotInstr* p = m_Instr; // la première expression
+ CBotInstr* p = m_Instr; // la premi�re expression
int state = pile->GivState();
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 ) p->RestoreState(pile, TRUE);
@@ -474,7 +485,7 @@ void CBotListInstr::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// compilation d'un élément se trouvant à gauche d'une assignation
+// compilation d'un �l�ment se trouvant � gauche d'une assignation
CBotLeftExprVar::CBotLeftExprVar()
{
@@ -489,7 +500,7 @@ CBotLeftExprVar::~CBotLeftExprVar() CBotInstr* CBotLeftExprVar::Compile(CBotToken* &p, CBotCStack* pStack)
{
- // vérifie que le token est un nom de variable
+ // v�rifie que le token est un nom de variable
if (p->GivType() != TokenTypVar)
{
pStack->SetError( TX_NOVAR, p->GivStart());
@@ -503,7 +514,7 @@ CBotInstr* CBotLeftExprVar::Compile(CBotToken* &p, CBotCStack* pStack) return inst;
}
-// crée une variable et lui assigne le résultat de la pile
+// cr�e une variable et lui assigne le r�sultat de la pile
BOOL CBotLeftExprVar::Execute(CBotStack* &pj)
{
CBotVar* var1;
@@ -516,7 +527,7 @@ BOOL CBotLeftExprVar::Execute(CBotStack* &pj) var2 = pj->GivVar(); // resultat sur la pile
if ( var2 ) var1->SetVal(var2); // fait l'assignation
- return TRUE; // opération faite
+ return TRUE; // op�ration faite
}
void CBotLeftExprVar::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -534,7 +545,7 @@ void CBotLeftExprVar::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// définition d'un tableau de n'importe quel type
+// d�finition d'un tableau de n'importe quel type
// int a[12];
// point x[];
@@ -556,15 +567,15 @@ CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu {
CBotCStack* pStk = pStack->TokenStack(p);
- CBotInstArray* inst = new CBotInstArray(); // crée l'objet
+ CBotInstArray* inst = new CBotInstArray(); // cr�e l'objet
CBotToken* vartoken = p;
inst->SetToken(vartoken);
- // détermine l'expression valable pour l'élément gauche
+ // d�termine l'expression valable pour l'�l�ment gauche
if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
- if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable ?
+ if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable ?
{
pStk->SetError(TX_REDEFVAR, vartoken);
goto error;
@@ -576,7 +587,7 @@ CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu if ( p->GivType() != ID_CLBRK )
i = CBotExpression::Compile( p, pStk ); // expression pour la valeur
else
- i = new CBotEmpty(); // spécial si pas de formule
+ i = new CBotEmpty(); // sp�cial si pas de formule
inst->AddNext3b(i); // construit une liste
type = CBotTypResult(CBotTypArrayPointer, type);
@@ -588,12 +599,12 @@ CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu }
}
- CBotVar* var = CBotVar::Create(vartoken, type); // crée avec une instance
+ CBotVar* var = CBotVar::Create(vartoken, type); // cr�e avec une instance
inst->m_typevar = type;
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un numéro unique
+ // lui attribut un num�ro unique
pStack->AddVar(var); // la place sur la pile
if ( IsOfType(p, ID_ASS) ) // avec une assignation
@@ -610,7 +621,7 @@ error: }
-// exécute la définition d'un tableau
+// ex�cute la d�finition d'un tableau
BOOL CBotInstArray::Execute(CBotStack* &pj)
{
@@ -622,7 +633,7 @@ BOOL CBotInstArray::Execute(CBotStack* &pj) if ( pile1->GivState() == 0 )
{
// cherche les dimensions max du tableau
- CBotInstr* p = GivNext3b(); // les différentes formules
+ CBotInstr* p = GivNext3b(); // les diff�rentes formules
int nb = 0;
while (p != NULL)
@@ -644,8 +655,8 @@ BOOL CBotInstArray::Execute(CBotStack* &pj) while (p != NULL)
{
- pile = pile->AddStack(); // récupère la même petite place
- CBotVar* v = pile->GivVar(); // résultat
+ pile = pile->AddStack(); // r�cup�re la m�me petite place
+ CBotVar* v = pile->GivVar(); // r�sultat
max[n] = v->GivValInt(); // valeur
if (max[n]>MAXARRAYSIZE)
{
@@ -657,9 +668,9 @@ BOOL CBotInstArray::Execute(CBotStack* &pj) }
while (n<100) max[n++] = 0;
- m_typevar.SetArray( max ); // mémorise les limitations
+ m_typevar.SetArray( max ); // m�morise les limitations
- // crée simplement un pointeur null
+ // cr�e simplement un pointeur null
CBotVar* var = CBotVar::Create(m_var->GivToken(), m_typevar);
var->SetPointer(NULL);
var->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);
@@ -708,7 +719,7 @@ void CBotInstArray::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile1->GivState() == 0 )
{
// cherche les dimensions max du tableau
- CBotInstr* p = GivNext3b(); // les différentes formules
+ CBotInstr* p = GivNext3b(); // les diff�rentes formules
while (p != NULL)
{
@@ -747,7 +758,7 @@ void CBotEmpty :: RestoreState(CBotStack* &pj, BOOL bMain) }
//////////////////////////////////////////////////////////////////////////////////////
-// définition d'une liste d'initialisation pour un tableau
+// d�finition d'une liste d'initialisation pour un tableau
// int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;
@@ -775,14 +786,14 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu inst->SetToken( pp );
// CBotVar* var = CBotVar::Create("", CBotTypNullPointer);
// pStk->SetVar(var);
- return pStack->Return(inst, pStk); // ok avec élément vide
+ return pStack->Return(inst, pStk); // ok avec �l�ment vide
}
- CBotListArray* inst = new CBotListArray(); // crée l'objet
+ CBotListArray* inst = new CBotListArray(); // cr�e l'objet
if ( IsOfType( p, ID_OPENPAR ) )
{
- // prend chaque élément l'un après l'autre
+ // prend chaque �l�ment l'un apr�s l'autre
if ( type.Eq( CBotTypArrayPointer ) )
{
type = type.GivTypElem();
@@ -793,7 +804,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu goto error;
}
- while ( IsOfType( p, ID_COMMA ) ) // d'autres éléments ?
+ while ( IsOfType( p, ID_COMMA ) ) // d'autres �l�ments ?
{
pStk->SetStartError(p->GivStart());
@@ -813,7 +824,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu {
goto error;
}
- CBotVar* pv = pStk->GivVar(); // le résultat de l'expression
+ CBotVar* pv = pStk->GivVar(); // le r�sultat de l'expression
if ( pv == NULL || !TypesCompatibles( type, pv->GivTypResult() )) // type compatible ?
{
@@ -821,7 +832,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu goto error;
}
- while ( IsOfType( p, ID_COMMA ) ) // d'autres éléments ?
+ while ( IsOfType( p, ID_COMMA ) ) // d'autres �l�ments ?
{
pStk->SetStartError(p->GivStart());
@@ -831,7 +842,7 @@ CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResu goto error;
}
- CBotVar* pv = pStk->GivVar(); // le résultat de l'expression
+ CBotVar* pv = pStk->GivVar(); // le r�sultat de l'expression
if ( pv == NULL || !TypesCompatibles( type, pv->GivTypResult() )) // type compatible ?
{
@@ -857,7 +868,7 @@ error: }
-// exécute la définition d'un tableau
+// ex�cute la d�finition d'un tableau
BOOL CBotListArray::Execute(CBotStack* &pj, CBotVar* pVar)
{
@@ -875,7 +886,7 @@ BOOL CBotListArray::Execute(CBotStack* &pj, CBotVar* pVar) pVar2 = pVar->GivItem(n, TRUE);
- if ( !p->Execute(pile1, pVar2) ) return FALSE; // évalue l'expression
+ if ( !p->Execute(pile1, pVar2) ) return FALSE; // �value l'expression
pile1->IncState();
}
@@ -903,12 +914,12 @@ void CBotListArray::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// définition d'une variable entière
+// d�finition d'une variable enti�re
// int a, b = 12;
CBotInt::CBotInt()
{
- m_next = NULL; // pour les définitions multiples
+ m_next = NULL; // pour les d�finitions multiples
m_var =
m_expr = NULL;
name = "CBotInt";
@@ -935,13 +946,13 @@ CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypRes if ( inst != NULL || !pStack->IsOk() ) return inst;
}
- // compile une déclaration de tableau
+ // compile une d�claration de tableau
if (first) return NULL ;
CBotInstr* inst = CBotInstArray::Compile( p, pStack, type );
if ( inst == NULL ) return NULL;
- if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
+ if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
{
if ( NULL != ( inst->m_next2b = CBotInstArray::CompileArray(p, pStack, type, FALSE) )) // compile la suivante
{
@@ -951,7 +962,7 @@ CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypRes return NULL;
}
- if (IsOfType(p, ID_SEP)) // instruction terminée
+ if (IsOfType(p, ID_SEP)) // instruction termin�e
{
return inst;
}
@@ -963,7 +974,7 @@ CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypRes CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL noskip)
{
- CBotToken* pp = cont ? NULL : p; // pas de répétition du token "int"
+ CBotToken* pp = cont ? NULL : p; // pas de r�p�tition du token "int"
if (!cont && !IsOfType(p, ID_INT)) return NULL;
@@ -972,18 +983,18 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n CBotCStack* pStk = pStack->TokenStack(pp);
- inst = new CBotInt(); // crée l'objet
+ inst = new CBotInt(); // cr�e l'objet
inst->m_expr = NULL;
CBotToken* vartoken = p;
inst->SetToken( vartoken );
- // détermine l'expression valable pour l'élément gauche
+ // d�termine l'expression valable pour l'�l�ment gauche
if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypInt;
- if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
{
pStk->SetError(TX_REDEFVAR, vartoken);
goto error;
@@ -994,7 +1005,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une déclaration de tableau
+ // compile une d�claration de tableau
CBotInstr* inst2 = CBotInstArray::Compile( p, pStk, CBotTypInt );
@@ -1004,7 +1015,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n goto error;
}
- if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
+ if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
{
if ( NULL != ( inst2->m_next2b = CBotInt::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1012,7 +1023,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n }
}
inst = (CBotInt*)inst2;
- goto suite; // pas d'assignation, variable déjà créée
+ goto suite; // pas d'assignation, variable d�j� cr��e
}
if (IsOfType(p, ID_ASS)) // avec une assignation ?
@@ -1029,15 +1040,15 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n }
{
- CBotVar* var = CBotVar::Create(vartoken, CBotTypInt);// crée la variable (après l'assignation évaluée)
- var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
+ CBotVar* var = CBotVar::Create(vartoken, CBotTypInt);// cr�e la variable (apr�s l'assignation �valu�e)
+ var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un numéro unique
+ // lui attribut un num�ro unique
pStack->AddVar(var); // la place sur la pile
}
- if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
+ if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
{
if ( NULL != ( inst->m_next2b = CBotInt::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1045,7 +1056,7 @@ CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL n }
}
suite:
- if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
+ if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
{
return pStack->Return(inst, pStk);
}
@@ -1058,7 +1069,7 @@ error: return pStack->Return(NULL, pStk);
}
-// exécute la définition de la variable entière
+// ex�cute la d�finition de la variable enti�re
BOOL CBotInt::Execute(CBotStack* &pj)
{
@@ -1068,7 +1079,7 @@ BOOL CBotInt::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // crée et fait l'assigation du résultat
+ m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1076,7 +1087,7 @@ BOOL CBotInt::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !m_next2b->Execute(pile)) return FALSE; // autre(s) définition(s)
+ !m_next2b->Execute(pile)) return FALSE; // autre(s) d�finition(s)
return pj->Return( pile ); // transmet en dessous
}
@@ -1098,14 +1109,14 @@ void CBotInt::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState(pile, bMain);
- if ( m_next2b ) m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
+ if ( m_next2b ) m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// définition d'une variable booléen
+// d�finition d'une variable bool�en
// int a, b = false;
CBotBoolean::CBotBoolean()
@@ -1143,7 +1154,7 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypBoolean;
- if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
{
pStk->SetError(TX_REDEFVAR, vartoken);
goto error;
@@ -1154,7 +1165,7 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une déclaration de tableau
+ // compile une d�claration de tableau
inst = (CBotBoolean*)CBotInstArray::Compile( p, pStk, CBotTypBoolean );
@@ -1163,7 +1174,7 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO pStk->SetError(TX_CLBRK, p->GivStart());
goto error;
}
- goto suite; // pas d'assignation, variable déjà créée
+ goto suite; // pas d'assignation, variable d�j� cr��e
}
if (IsOfType(p, ID_ASS)) // avec une assignation ?
@@ -1179,14 +1190,14 @@ CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO }
}
- var = CBotVar::Create(vartoken, CBotTypBoolean);// crée la variable (après l'assignation évaluée)
- var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
+ var = CBotVar::Create(vartoken, CBotTypBoolean);// cr�e la variable (apr�s l'assignation �valu�e)
+ var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un numéro unique
+ // lui attribut un num�ro unique
pStack->AddVar(var); // la place sur la pile
suite:
- if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
+ if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
{
if ( NULL != ( inst->m_next2b = CBotBoolean::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1194,7 +1205,7 @@ suite: }
}
- if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
+ if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
{
return pStack->Return(inst, pStk);
}
@@ -1207,7 +1218,7 @@ error: return pStack->Return(NULL, pStk);
}
-// exécute une définition de variable booléenne
+// ex�cute une d�finition de variable bool�enne
BOOL CBotBoolean::Execute(CBotStack* &pj)
{
@@ -1217,7 +1228,7 @@ BOOL CBotBoolean::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // crée et fait l'assigation du résultat
+ m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1225,7 +1236,7 @@ BOOL CBotBoolean::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !m_next2b->Execute(pile)) return FALSE; // autre(s) définition(s)
+ !m_next2b->Execute(pile)) return FALSE; // autre(s) d�finition(s)
return pj->Return( pile ); // transmet en dessous
}
@@ -1248,14 +1259,14 @@ void CBotBoolean::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState( pile, bMain ); //
if ( m_next2b )
- m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// définition d'une variable réelle
+// d�finition d'une variable r�elle
// int a, b = 12.4;
CBotFloat::CBotFloat()
@@ -1293,7 +1304,7 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypFloat;
- if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
{
pStk->SetStartError(vartoken->GivStart());
pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
@@ -1305,7 +1316,7 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une déclaration de tableau
+ // compile une d�claration de tableau
inst = (CBotFloat*)CBotInstArray::Compile( p, pStk, CBotTypFloat );
@@ -1314,7 +1325,7 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL pStk->SetError(TX_CLBRK, p->GivStart());
goto error;
}
- goto suite; // pas d'assignation, variable déjà créée
+ goto suite; // pas d'assignation, variable d�j� cr��e
}
if (IsOfType(p, ID_ASS)) // avec une assignation ?
@@ -1330,14 +1341,14 @@ CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL }
}
- var = CBotVar::Create(vartoken, CBotTypFloat); // crée la variable (après l'assignation évaluée)
- var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
+ var = CBotVar::Create(vartoken, CBotTypFloat); // cr�e la variable (apr�s l'assignation �valu�e)
+ var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un numéro unique
+ // lui attribut un num�ro unique
pStack->AddVar(var); // la place sur la pile
suite:
- if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
+ if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
{
if ( NULL != ( inst->m_next2b = CBotFloat::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1345,7 +1356,7 @@ suite: }
}
- if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
+ if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
{
return pStack->Return(inst, pStk);
}
@@ -1358,7 +1369,7 @@ error: return pStack->Return(NULL, pStk);
}
-// exécute la défintion de la variable réelle
+// ex�cute la d�fintion de la variable r�elle
BOOL CBotFloat::Execute(CBotStack* &pj)
{
@@ -1368,7 +1379,7 @@ BOOL CBotFloat::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // crée et fait l'assigation du résultat
+ m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1376,7 +1387,7 @@ BOOL CBotFloat::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !m_next2b->Execute(pile)) return FALSE; // autre(s) définition(s)
+ !m_next2b->Execute(pile)) return FALSE; // autre(s) d�finition(s)
return pj->Return( pile ); // transmet en dessous
}
@@ -1399,14 +1410,14 @@ void CBotFloat::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState( pile, bMain ); //
if ( m_next2b )
- m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// définition d'une variable chaîne de caractères
+// d�finition d'une variable cha�ne de caract�res
// int a, b = "salut";
CBotIString::CBotIString()
@@ -1443,7 +1454,7 @@ CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypString;
- if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
{
pStk->SetStartError(vartoken->GivStart());
pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
@@ -1463,14 +1474,14 @@ CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO }*/
}
- CBotVar* var = CBotVar::Create(vartoken, CBotTypString); // crée la variable (après l'assignation évaluée)
- var->SetInit(inst->m_expr != NULL); // la marque initialisée si avec assignation
+ CBotVar* var = CBotVar::Create(vartoken, CBotTypString); // cr�e la variable (apr�s l'assignation �valu�e)
+ var->SetInit(inst->m_expr != NULL); // la marque initialis�e si avec assignation
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un numéro unique
+ // lui attribut un num�ro unique
pStack->AddVar(var); // la place sur la pile
- if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
+ if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
{
if ( NULL != ( inst->m_next2b = CBotIString::Compile(p, pStk, TRUE, noskip) )) // compile la suivante
{
@@ -1478,7 +1489,7 @@ CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BO }
}
- if (noskip || IsOfType(p, ID_SEP)) // instruction terminée
+ if (noskip || IsOfType(p, ID_SEP)) // instruction termin�e
{
return pStack->Return(inst, pStk);
}
@@ -1491,7 +1502,7 @@ error: return pStack->Return(NULL, pStk);
}
-// exécute la définition de la variable string
+// ex�cute la d�finition de la variable string
BOOL CBotIString::Execute(CBotStack* &pj)
{
@@ -1501,7 +1512,7 @@ BOOL CBotIString::Execute(CBotStack* &pj) if ( pile->GivState()==0)
{
if (m_expr && !m_expr->Execute(pile)) return FALSE; // valeur initiale // interrompu?
- m_var->Execute( pile ); // crée et fait l'assigation du résultat
+ m_var->Execute( pile ); // cr�e et fait l'assigation du r�sultat
if (!pile->SetState(1)) return FALSE;
}
@@ -1509,7 +1520,7 @@ BOOL CBotIString::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b &&
- !m_next2b->Execute(pile)) return FALSE; // autre(s) définition(s)
+ !m_next2b->Execute(pile)) return FALSE; // autre(s) d�finition(s)
return pj->Return( pile ); // transmet en dessous
}
@@ -1533,7 +1544,7 @@ void CBotIString::RestoreState(CBotStack* &pj, BOOL bMain) m_var->RestoreState( pile, bMain ); //
if ( m_next2b )
- m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -1589,7 +1600,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) CBotTypResult type1 = pStack->GivTypResult();
- // récupère la variable pour la marquer assignée
+ // r�cup�re la variable pour la marquer assign�e
CBotVar* var = NULL;
inst->m_leftop->ExecuteVar(var, pStack);
if ( var == NULL )
@@ -1617,7 +1628,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) {
/* CBotClass* c1 = type1.GivClass();
CBotClass* c2 = type2.GivClass();
- if ( !c1->IsChildOf(c2) ) type2.SetType(-1); // pas la même classe
+ if ( !c1->IsChildOf(c2) ) type2.SetType(-1); // pas la m�me classe
//- if ( !type1.Eq(CBotTypClass) ) var->SetPointer(pStack->GivVar()->GivPointer());*/
var->SetInit(2);
}
@@ -1651,7 +1662,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) // p = p->GivNext();
int start, end, error = pStack->GivError(start, end);
- p = pp; // revient au début
+ p = pp; // revient au d�but
pStack->SetError(0,0); // oublie l'erreur
// return CBotTwoOpExpr::Compile(p, pStack); // essaie sans assignation
@@ -1661,7 +1672,7 @@ CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack) return i;
}
-// exécute une expression avec assignation
+// ex�cute une expression avec assignation
BOOL CBotExpression::Execute(CBotStack* &pj)
{
@@ -1676,8 +1687,8 @@ BOOL CBotExpression::Execute(CBotStack* &pj) BOOL IsInit = TRUE;
CBotVar* result = NULL;
- // doit être fait avant pour les indices éventuels (pile peut être changée)
- if ( !m_leftop->ExecuteVar(pVar, pile, NULL, FALSE) ) return FALSE; // variable avant évaluation de la valeur droite
+ // doit �tre fait avant pour les indices �ventuels (pile peut �tre chang�e)
+ if ( !m_leftop->ExecuteVar(pVar, pile, NULL, FALSE) ) return FALSE; // variable avant �valuation de la valeur droite
// DEBUG( "CBotExpression::Execute", -1, pj);
if ( pile1->GivState()==0)
@@ -1700,7 +1711,7 @@ BOOL CBotExpression::Execute(CBotStack* &pj) // DEBUG( "CBotExpression::Execute", -3, pj);
if ( m_token.GivType() != ID_ASS )
{
- pVar = pile1->GivVar(); // récupére si interrompu
+ pVar = pile1->GivVar(); // r�cup�re si interrompu
IsInit = pVar->GivInit();
if ( IsInit == IS_NAN )
{
@@ -1716,51 +1727,51 @@ BOOL CBotExpression::Execute(CBotStack* &pj) break;
case ID_ASSADD:
result->Add(pile1->GivVar(), pile2->GivVar()); // additionne
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSSUB:
result->Sub(pile1->GivVar(), pile2->GivVar()); // soustrait
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSMUL:
result->Mul(pile1->GivVar(), pile2->GivVar()); // multiplie
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSDIV:
if (IsInit &&
result->Div(pile1->GivVar(), pile2->GivVar())) // divise
pile2->SetError(TX_DIVZERO, &m_token);
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSMODULO:
if (IsInit &&
result->Modulo(pile1->GivVar(), pile2->GivVar())) // reste de la division
pile2->SetError(TX_DIVZERO, &m_token);
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSAND:
result->And(pile1->GivVar(), pile2->GivVar()); // multiplie
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSXOR:
result->XOr(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSOR:
result->Or(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSSL:
result->SL(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSSR:
result->SR(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
case ID_ASSASR:
result->ASR(pile1->GivVar(), pile2->GivVar());
- pile2->SetVar(result); // re-place le résultat
+ pile2->SetVar(result); // re-place le r�sultat
break;
default:
__asm int 3;
@@ -1773,7 +1784,7 @@ BOOL CBotExpression::Execute(CBotStack* &pj) // DEBUG( "CBotExpression::Execute", -4, pj);
if ( !m_leftop->Execute( pile2, pile1 ) )
- return FALSE; // crée et fait l'assigation du résultat
+ return FALSE; // cr�e et fait l'assigation du r�sultat
return pj->Return( pile2 ); // transmet en dessous
}
@@ -1794,11 +1805,11 @@ void CBotExpression::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile1->GivState()==0)
{
- m_leftop->RestoreStateVar(pile, TRUE); // variable avant évaluation de la valeur droite
+ m_leftop->RestoreStateVar(pile, TRUE); // variable avant �valuation de la valeur droite
return;
}
- m_leftop->RestoreStateVar(pile, FALSE); // variable avant évaluation de la valeur droite
+ m_leftop->RestoreStateVar(pile, FALSE); // variable avant �valuation de la valeur droite
CBotStack* pile2 = pile->RestoreStack(); // attention pile et surtout pas pile1
if ( pile2 == NULL ) return;
@@ -1816,10 +1827,10 @@ void CBotExpression::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
// compile une instruction de type " ( condition ) "
-// la condition doit être de type booléen
+// la condition doit �tre de type bool�en
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourné par Compile est généralement de type CBotExpression
+// l'objet retourn� par Compile est g�n�ralement de type CBotExpression
CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack)
{
@@ -1833,12 +1844,12 @@ CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack) {
return inst;
}
- pStack->SetError(TX_CLOSEPAR, p->GivStart()); // manque la parenthèse
+ pStack->SetError(TX_CLOSEPAR, p->GivStart()); // manque la parenth�se
}
delete inst;
}
- pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenthèse
+ pStack->SetError(TX_OPENPAR, p->GivStart()); // manque la parenth�se
return NULL;
}
@@ -1846,10 +1857,10 @@ CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack) //////////////////////////////////////////////////////////////////////////////////////
// compile une instruction de type " condition "
-// la condition doit être de type booléen
+// la condition doit �tre de type bool�en
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourné par Compile est généralement de type CBotExpression
+// l'objet retourn� par Compile est g�n�ralement de type CBotExpression
CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack)
{
@@ -1863,7 +1874,7 @@ CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
return inst;
}
- pStack->SetError(TX_NOTBOOL, p->GivStart()); // n'est pas un booléan
+ pStack->SetError(TX_NOTBOOL, p->GivStart()); // n'est pas un bool�an
}
delete inst;
@@ -1875,17 +1886,17 @@ CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack) //////////////////////////////////////////////////////////////////////////////////////
// compile soit :
-// une instruction entre parenthèses (...)
-// une expression unaire (négatif, not)
+// une instruction entre parenth�ses (...)
+// une expression unaire (n�gatif, not)
// nom de variable
-// les variables prè et post incrémentées ou décrémentées
-// un nombre donné par DefineNum
+// les variables pr� et post incr�ment�es ou d�cr�ment�es
+// un nombre donn� par DefineNum
// une constante
-// un appel de procédure
+// un appel de proc�dure
// l'instruction new
// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe
-// l'objet retourné par Compile est de la classe correspondant à l'instruction
+// l'objet retourn� par Compile est de la classe correspondant � l'instruction
CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack)
{
@@ -1893,7 +1904,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) pStk->SetStartError(p->GivStart());
- // est-ce une expression entre parenthèse ?
+ // est-ce une expression entre parenth�se ?
if (IsOfType(p, ID_OPENPAR))
{
CBotInstr* inst = CBotExpression::Compile( p, pStk );
@@ -1910,7 +1921,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk);
}
- // est-ce une opération unaire ?
+ // est-ce une op�ration unaire ?
CBotInstr* inst = CBotExprUnaire::Compile(p, pStk);
if (inst != NULL || !pStk->IsOk())
return pStack->Return(inst, pStk);
@@ -1918,12 +1929,12 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) // est-ce un nom de variable ?
if (p->GivType() == TokenTypVar)
{
- // c'est peut-être un appel de méthode sans le "this." devant
+ // c'est peut-�tre un appel de m�thode sans le "this." devant
inst = CBotExprVar::CompileMethode(p, pStk);
if ( inst != NULL ) return pStack->Return(inst, pStk);
- // est-ce un appel de procédure ?
+ // est-ce un appel de proc�dure ?
inst = CBotInstrCall::Compile(p, pStk);
if ( inst != NULL || !pStk->IsOk() )
return pStack->Return(inst, pStk);
@@ -1934,7 +1945,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) inst = CBotExprVar::Compile(p, pStk);
CBotToken* pp = p;
- // post incrémenté ou décrémenté ?
+ // post incr�ment� ou d�cr�ment� ?
if (IsOfType(p, ID_INC, ID_DEC))
{
if ( pStk->GivType() >= CBotTypBoolean )
@@ -1952,13 +1963,13 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) CBotPostIncExpr* i = new CBotPostIncExpr();
i->SetToken(pp);
- i->m_Instr = inst; // instruction associée
+ i->m_Instr = inst; // instruction associ�e
return pStack->Return(i, pStk);
}
return pStack->Return(inst, pStk);
}
- // est-ce une variable préincrémentée ou prédécrémentée ?
+ // est-ce une variable pr�incr�ment�e ou pr�d�cr�ment�e ?
CBotToken* pp = p;
if (IsOfType(p, ID_INC, ID_DEC))
{
@@ -1997,7 +2008,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
- // est un élément "true" ou "false"
+ // est un �l�ment "true" ou "false"
if (p->GivType() == ID_TRUE ||
p->GivType() == ID_FALSE )
{
@@ -2005,7 +2016,7 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
- // est un objet à créer avec new
+ // est un objet � cr�er avec new
if (p->GivType() == ID_NEW)
{
CBotInstr* inst = CBotNew::Compile( p, pStk );
@@ -2040,9 +2051,9 @@ CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack) //////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// gestion du post et pré- incrément/décrément
+// gestion du post et pr�- incr�ment/d�cr�ment
-// il n'y a pas de routine Compile, l'objet est créé directement
+// il n'y a pas de routine Compile, l'objet est cr�� directement
// dans CBotParExpr::Compile
CBotPostIncExpr::CBotPostIncExpr()
@@ -2074,10 +2085,10 @@ BOOL CBotPostIncExpr::Execute(CBotStack* &pj) CBotVar* var1 = NULL;
- if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // récupère la variable selon champs et index
+ if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // r�cup�re la variable selon champs et index
pile1->SetState(1);
- pile1->SetCopyVar(var1); // place le résultat (avant incrémentation);
+ pile1->SetCopyVar(var1); // place le r�sultat (avant incr�mentation);
CBotStack* pile3 = pile2->AddStack(this);
if ( pile3->IfStep() ) return FALSE;
@@ -2095,7 +2106,7 @@ BOOL CBotPostIncExpr::Execute(CBotStack* &pj) if (GivTokenType() == ID_INC) var1->Inc();
else var1->Dec();
- return pj->Return(pile1); // opération faite, résultat sur pile2
+ return pj->Return(pile1); // op�ration faite, r�sultat sur pile2
}
void CBotPostIncExpr::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -2122,19 +2133,19 @@ BOOL CBotPreIncExpr::Execute(CBotStack* &pj) if ( pile->GivState() == 0 )
{
CBotStack* pile2 = pile;
- if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // récupère la variable selon champs et index
- // pile2 est modifié en retour
+ if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE; // r�cup�re la variable selon champs et index
+ // pile2 est modifi� en retour
if ( var1->GivInit() == IS_NAN )
{
pile->SetError( TX_OPNAN, &m_token );
- return pj->Return(pile); // opération faite
+ return pj->Return(pile); // op�ration faite
}
if ( var1->GivInit() != IS_DEF )
{
pile->SetError( TX_NOTINIT, &m_token );
- return pj->Return(pile); // opération faite
+ return pj->Return(pile); // op�ration faite
}
if (GivTokenType() == ID_INC) var1->Inc();
@@ -2144,7 +2155,7 @@ BOOL CBotPreIncExpr::Execute(CBotStack* &pj) }
if ( !m_Instr->Execute(pile) ) return FALSE;
- return pj->Return(pile); // opération faite
+ return pj->Return(pile); // op�ration faite
}
@@ -2202,9 +2213,9 @@ CBotInstr* CBotExprUnaire::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
if ( op == ID_NOT && pStk->GivType() < CBotTypFloat ) // seulement avec des entiers
return pStack->Return(inst, pStk);
- if ( op == ID_LOG_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des booléens
+ if ( op == ID_LOG_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des bool�ens
return pStack->Return(inst, pStk);
- if ( op == ID_TXT_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des booléens
+ if ( op == ID_TXT_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des bool�ens
return pStack->Return(inst, pStk);
pStk->SetError(TX_BADTYPE, &inst->m_token);
@@ -2213,7 +2224,7 @@ CBotInstr* CBotExprUnaire::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk);
}
-// exécute l'expresson unaire
+// ex�cute l'expresson unaire
BOOL CBotExprUnaire::Execute(CBotStack* &pj)
{
@@ -2229,7 +2240,7 @@ BOOL CBotExprUnaire::Execute(CBotStack* &pj) CBotStack* pile2 = pile->AddStack();
if ( pile2->IfStep() ) return FALSE;
- CBotVar* var = pile->GivVar(); // récupère le résultat sur la pile
+ CBotVar* var = pile->GivVar(); // r�cup�re le r�sultat sur la pile
switch (GivTokenType())
{
@@ -2279,14 +2290,14 @@ CBotIndexExpr::~CBotIndexExpr() delete m_expr;
}
-// trouve un champ à partir de l'instance à la compilation
+// trouve un champ � partir de l'instance � la compilation
BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
{
if ( pVar->GivType(1) != CBotTypArrayPointer )
__asm int 3;
- pVar = ((CBotVarArray*)pVar)->GivItem(0, FALSE); // à la compilation rend l'élément [0]
+ pVar = ((CBotVarArray*)pVar)->GivItem(0, FALSE); // � la compilation rend l'�l�ment [0]
if ( pVar == NULL )
{
pile->SetError(TX_OUTARRAY, m_token.GivEnd());
@@ -2296,9 +2307,9 @@ BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile) return TRUE;
}
-// idem à l'exécution
-// attention, modifie le pointeur à la pile volontairement
-// place les index calculés sur la pile supplémentaire
+// idem � l'ex�cution
+// attention, modifie le pointeur � la pile volontairement
+// place les index calcul�s sur la pile suppl�mentaire
BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend)
{
@@ -2318,7 +2329,7 @@ BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev }
// traite les tableaux
- CBotVar* p = pile->GivVar(); // résultat sur la pile
+ CBotVar* p = pile->GivVar(); // r�sultat sur la pile
if ( p == NULL || p->GivType() > CBotTypDouble )
{
@@ -2345,8 +2356,8 @@ BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev !m_next3->ExecuteVar(pVar, pile, prevToken, bStep, bExtend) ) return FALSE;
// DEBUG( "CBotIndexExpr::ExecuteVar", -4 , pj);
- return TRUE; // ne libère pas la pile
- // pour éviter de recalculer les index deux fois le cas échéant
+ return TRUE; // ne lib�re pas la pile
+ // pour �viter de recalculer les index deux fois le cas �ch�ant
}
void CBotIndexExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain)
@@ -2367,7 +2378,7 @@ void CBotIndexExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// gestion des champs dans une instance (opérateur point)
+// gestion des champs dans une instance (op�rateur point)
// toto.x
@@ -2387,7 +2398,7 @@ void CBotFieldExpr::SetUniqNum(int num) }
-// trouve un champ à partir de l'instance à la compilation
+// trouve un champ � partir de l'instance � la compilation
BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
{
@@ -2408,7 +2419,7 @@ BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile) return TRUE;
}
-// idem à l'exécution
+// idem � l'ex�cution
BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend)
{
@@ -2446,20 +2457,20 @@ BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev if ( pVar->IsStatic() )
{
// DEBUG( "IsStatic", 0, pj) ;
- // pour une variable statique, la prend dans la classe elle-même
+ // pour une variable statique, la prend dans la classe elle-m�me
CBotClass* pClass = pItem->GivClass();
pVar = pClass->GivItem(m_token.GivString());
// DEBUG( "done "+pVar->GivName(), 0, pj) ;
}
- // demande la mise à jour de l'élément, s'il y a lieu
+ // demande la mise � jour de l'�l�ment, s'il y a lieu
pVar->Maj(pile->GivPUser(), TRUE);
if ( m_next3 != NULL &&
!m_next3->ExecuteVar(pVar, pile, &m_token, bStep, bExtend) ) return FALSE;
- return TRUE; // ne libère pas la pile
- // pour conserver l'état SetState() correspondant à l'étape
+ return TRUE; // ne lib�re pas la pile
+ // pour conserver l'�tat SetState() correspondant � l'�tape
}
void CBotFieldExpr::RestoreStateVar(CBotStack* &pj, BOOL bMain)
@@ -2474,7 +2485,7 @@ void CBotFieldExpr::RestoreStateVar(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
-// compile un opérande gauche pour une assignation
+// compile un op�rande gauche pour une assignation
CBotLeftExpr::CBotLeftExpr()
{
@@ -2486,8 +2497,8 @@ CBotLeftExpr::~CBotLeftExpr() {
}
-// compile une expression pour un left-opérande ( à gauche d'une assignation)
-// cela peut être
+// compile une expression pour un left-op�rande ( � gauche d'une assignation)
+// cela peut �tre
// toto
// toto[ 3 ]
// toto.x
@@ -2505,7 +2516,7 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) // est-ce un nom de variable ?
if (p->GivType() == TokenTypVar)
{
- CBotLeftExpr* inst = new CBotLeftExpr(); // crée l'objet
+ CBotLeftExpr* inst = new CBotLeftExpr(); // cr�e l'objet
inst->SetToken(p);
@@ -2522,15 +2533,15 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) pStk->SetError( TX_PRIVATE, p );
goto err;
}
- // il s'agit d'un élement de la classe courante
- // ajoute l'équivalent d'un this. devant
+ // il s'agit d'un �lement de la classe courante
+ // ajoute l'�quivalent d'un this. devant
CBotToken pthis("this");
inst->SetToken(&pthis);
inst->m_nIdent = -2; // ident pour this
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
i->SetToken( p ); // garde le nom du token
- inst->AddNext3(i); // ajoute à la suite
+ inst->AddNext3(i); // ajoute � la suite
var = pStk->FindVar(pthis);
var = var->GivItem(p->GivString());
@@ -2546,7 +2557,7 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotIndexExpr* i = new CBotIndexExpr();
i->m_expr = CBotExpression::Compile(p, pStk); // compile la formule
- inst->AddNext3(i); // ajoute à la chaine
+ inst->AddNext3(i); // ajoute � la chaine
var = ((CBotVarArray*)var)->GivItem(0,TRUE); // donne le composant [0]
@@ -2571,13 +2582,13 @@ CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotToken* pp = p;
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
i->SetToken( pp ); // garde le nom du token
- inst->AddNext3(i); // ajoute à la suite
+ inst->AddNext3(i); // ajoute � la suite
- if ( p->GivType() == TokenTypVar ) // doit être un nom
+ if ( p->GivType() == TokenTypVar ) // doit �tre un nom
{
- var = var->GivItem(p->GivString()); // récupère l'item correpondant
+ var = var->GivItem(p->GivString()); // r�cup�re l'item correpondant
if ( var != NULL )
{
if ( var->IsPrivate(PR_READ) &&
@@ -2612,7 +2623,7 @@ err: return (CBotLeftExpr*) pStack->Return(NULL, pStk);
}
-// exécute, trouve une variable et lui assigne le résultat de la pile
+// ex�cute, trouve une variable et lui assigne le r�sultat de la pile
BOOL CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array)
{
@@ -2631,7 +2642,7 @@ BOOL CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array) if ( var1 )
{
- var2 = pj->GivVar(); // resultat sur la pile d'entrée
+ var2 = pj->GivVar(); // resultat sur la pile d'entr�e
if ( var2 )
{
CBotTypResult t1 = var1->GivTypResult();
@@ -2644,16 +2655,16 @@ BOOL CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array) {
CBotToken* pt = &m_token;
pile->SetError(TX_BADTYPE, pt);
- return pj->Return(pile); // opération faite
+ return pj->Return(pile); // op�ration faite
}
}
var1->SetVal(var2); // fait l'assignation
}
- pile->SetCopyVar( var1 ); // remplace sur la pile par une copie de la variable elle-même
+ pile->SetCopyVar( var1 ); // remplace sur la pile par une copie de la variable elle-m�me
// (pour avoir le nom)
}
- return pj->Return(pile); // opération faite
+ return pj->Return(pile); // op�ration faite
}
// retrouve une variable pendant la compilation
@@ -2669,11 +2680,11 @@ BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile) return TRUE;
}
-// retrouve une variable à l'exécution
+// retrouve une variable � l'ex�cution
BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep)
{
- pile = pile->AddStack( this ); // déplace la pile
+ pile = pile->AddStack( this ); // d�place la pile
pVar = pile->FindVar(m_nIdent);
if ( pVar == NULL )
@@ -2695,7 +2706,7 @@ BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevT void CBotLeftExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain)
{
- pile = pile->RestoreStack( this ); // déplace la pile
+ pile = pile->RestoreStack( this ); // d�place la pile
if ( pile == NULL ) return;
if ( m_next3 != NULL )
@@ -2704,8 +2715,8 @@ void CBotLeftExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// transforme une chaîne en nombre entier
-// peut être de la forme 0xabc123
+// transforme une cha�ne en nombre entier
+// peut �tre de la forme 0xabc123
long GivNumInt( const char* p )
{
@@ -2740,7 +2751,7 @@ long GivNumInt( const char* p ) return num;
}
-// transforme une chaîne en un nombre réel
+// transforme une cha�ne en un nombre r�el
extern float GivNumFloat( const char* p )
{
@@ -2805,7 +2816,7 @@ extern float GivNumFloat( const char* p ) //////////////////////////////////////////////////////////////////////////////////////
-// compile un token représentant un nombre
+// compile un token repr�sentant un nombre
CBotExprNum::CBotExprNum()
{
@@ -2854,7 +2865,7 @@ CBotInstr* CBotExprNum::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(NULL, pStk);
}
-// exécute, retourne le nombre correspondant
+// ex�cute, retourne le nombre correspondant
BOOL CBotExprNum::Execute(CBotStack* &pj)
{
@@ -2895,7 +2906,7 @@ void CBotExprNum::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
-// compile un token représentant une chaine de caractères
+// compile un token repr�sentant une chaine de caract�res
CBotExprAlpha::CBotExprAlpha()
{
@@ -2921,7 +2932,7 @@ CBotInstr* CBotExprAlpha::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
-// exécute, retourne la chaîne correspondante
+// ex�cute, retourne la cha�ne correspondante
BOOL CBotExprAlpha::Execute(CBotStack* &pj)
{
@@ -2933,7 +2944,7 @@ BOOL CBotExprAlpha::Execute(CBotStack* &pj) CBotVar* var = CBotVar::Create((CBotToken*)NULL, CBotTypString);
CBotString chaine = m_token.GivString();
- chaine = chaine.Mid(1, chaine.GivLength()-2); // enlève les guillemets
+ chaine = chaine.Mid(1, chaine.GivLength()-2); // enl�ve les guillemets
var->SetValString( chaine ); // valeur du nombre
@@ -2951,7 +2962,7 @@ void CBotExprAlpha::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
-// compile un token représentant true ou false
+// compile un token repr�sentant true ou false
CBotExprBool::CBotExprBool()
{
@@ -2971,7 +2982,7 @@ CBotInstr* CBotExprBool::Compile(CBotToken* &p, CBotCStack* pStack) p->GivType() == ID_FALSE )
{
inst = new CBotExprBool();
- inst->SetToken(p); // mémorise l'opération false ou true
+ inst->SetToken(p); // m�morise l'op�ration false ou true
p = p->GivNext();
CBotVar* var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);
@@ -2981,7 +2992,7 @@ CBotInstr* CBotExprBool::Compile(CBotToken* &p, CBotCStack* pStack) return pStack->Return(inst, pStk);
}
-// exécute, retourne true ou false
+// ex�cute, retourne true ou false
BOOL CBotExprBool::Execute(CBotStack* &pj)
{
@@ -3006,7 +3017,7 @@ void CBotExprBool::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// gestion de l'opérande "null"
+// gestion de l'op�rande "null"
CBotExprNull::CBotExprNull()
{
@@ -3017,7 +3028,7 @@ CBotExprNull::~CBotExprNull() {
}
-// exécute, retourne un pointeur vide
+// ex�cute, retourne un pointeur vide
BOOL CBotExprNull::Execute(CBotStack* &pj)
{
@@ -3039,7 +3050,7 @@ void CBotExprNull::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// gestion de l'opérande "nan"
+// gestion de l'op�rande "nan"
CBotExprNan::CBotExprNan()
{
@@ -3050,7 +3061,7 @@ CBotExprNan::~CBotExprNan() {
}
-// exécute, retourne un pointeur vide
+// ex�cute, retourne un pointeur vide
BOOL CBotExprNan::Execute(CBotStack* &pj)
{
@@ -3072,8 +3083,8 @@ void CBotExprNan::RestoreState(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////
// compile un nom de variable
-// vérifie qu'elle est connue sur la pile
-// et qu'elle a été initialisée
+// v�rifie qu'elle est connue sur la pile
+// et qu'elle a �t� initialis�e
CBotExprVar::CBotExprVar()
{
@@ -3095,7 +3106,7 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) // est-ce un nom de variable ?
if (p->GivType() == TokenTypVar)
{
- CBotInstr* inst = new CBotExprVar(); // crée l'objet
+ CBotInstr* inst = new CBotExprVar(); // cr�e l'objet
inst->SetToken(p);
@@ -3104,7 +3115,7 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) if ( NULL != (var = pStk->FindVar(p)) ) // cherche si variable connue
{
int ident = var->GivUniqNum();
- ((CBotExprVar*)inst)->m_nIdent = ident; // l'identifie par son numéro
+ ((CBotExprVar*)inst)->m_nIdent = ident; // l'identifie par son num�ro
if (ident > 0 && ident < 9000)
{
@@ -3115,15 +3126,15 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) goto err;
}
- // il s'agit d'un élement de la classe courante
- // ajoute l'équivalent d'un this. devant
+ // il s'agit d'un �lement de la classe courante
+ // ajoute l'�quivalent d'un this. devant
inst->SetToken(&CBotToken("this"));
((CBotExprVar*)inst)->m_nIdent = -2; // ident pour this
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
i->SetToken( p ); // garde le nom du token
i->SetUniqNum(ident);
- inst->AddNext3(i); // ajoute à la suite
+ inst->AddNext3(i); // ajoute � la suite
}
p = p->GivNext(); // token suivant
@@ -3136,7 +3147,7 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) {
CBotIndexExpr* i = new CBotIndexExpr();
i->m_expr = CBotExpression::Compile(p, pStk); // compile la formule
- inst->AddNext3(i); // ajoute à la chaine
+ inst->AddNext3(i); // ajoute � la chaine
var = ((CBotVarArray*)var)->GivItem(0,TRUE); // donne le composant [0]
@@ -3160,21 +3171,21 @@ CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat) {
CBotToken* pp = p;
- if ( p->GivType() == TokenTypVar ) // doit être un nom
+ if ( p->GivType() == TokenTypVar ) // doit �tre un nom
{
- if ( p->GivNext()->GivType() == ID_OPENPAR )// un appel de méthode ?
+ if ( p->GivNext()->GivType() == ID_OPENPAR )// un appel de m�thode ?
{
CBotInstr* i = CBotInstrMethode::Compile(p, pStk, var);
if ( !pStk->IsOk() ) goto err;
- inst->AddNext3(i); // ajoute à la suite
+ inst->AddNext3(i); // ajoute � la suite
return pStack->Return(inst, pStk);
}
else
{
- CBotFieldExpr* i = new CBotFieldExpr(); // nouvel élément
+ CBotFieldExpr* i = new CBotFieldExpr(); // nouvel �l�ment
i->SetToken( pp ); // garde le nom du token
- inst->AddNext3(i); // ajoute à la suite
- var = var->GivItem(p->GivString()); // récupère l'item correpondant
+ inst->AddNext3(i); // ajoute � la suite
+ var = var->GivItem(p->GivString()); // r�cup�re l'item correpondant
if ( var != NULL )
{
i->SetUniqNum(var->GivUniqNum());
@@ -3230,27 +3241,27 @@ CBotInstr* CBotExprVar::CompileMethode(CBotToken* &p, CBotCStack* pStack) CBotVar* var = pStk->FindVar(pthis);
if ( var == 0 ) return pStack->Return(NULL, pStk);
- CBotInstr* inst = new CBotExprVar(); // crée l'objet
+ CBotInstr* inst = new CBotExprVar(); // cr�e l'objet
- // il s'agit d'un élement de la classe courante
- // ajoute l'équivalent d'un this. devant
+ // il s'agit d'un �lement de la classe courante
+ // ajoute l'�quivalent d'un this. devant
inst->SetToken(&pthis);
((CBotExprVar*)inst)->m_nIdent = -2; // ident pour this
CBotToken* pp = p;
- if ( pp->GivType() == TokenTypVar ) // doit être un nom
+ if ( pp->GivType() == TokenTypVar ) // doit �tre un nom
{
- if ( pp->GivNext()->GivType() == ID_OPENPAR ) // un appel de méthode ?
+ if ( pp->GivNext()->GivType() == ID_OPENPAR ) // un appel de m�thode ?
{
CBotInstr* i = CBotInstrMethode::Compile(pp, pStk, var);
if ( pStk->IsOk() )
{
- inst->AddNext3(i); // ajoute à la suite
- p = pp; // instructions passées
+ inst->AddNext3(i); // ajoute � la suite
+ p = pp; // instructions pass�es
return pStack->Return(inst, pStk);
}
- pStk->SetError(0,0); // l'erreur n'est pas traitée ici
+ pStk->SetError(0,0); // l'erreur n'est pas trait�e ici
}
}
delete inst;
@@ -3259,7 +3270,7 @@ CBotInstr* CBotExprVar::CompileMethode(CBotToken* &p, CBotCStack* pStack) }
-// exécute, rend la valeur d'une variable
+// ex�cute, rend la valeur d'une variable
BOOL CBotExprVar::Execute(CBotStack* &pj)
{
@@ -3273,19 +3284,19 @@ BOOL CBotExprVar::Execute(CBotStack* &pj) if ( pile1->GivState() == 0 )
{
- if ( !ExecuteVar(pVar, pile, NULL, TRUE) ) return FALSE; // récupère la variable selon champs et index
+ if ( !ExecuteVar(pVar, pile, NULL, TRUE) ) return FALSE; // r�cup�re la variable selon champs et index
// DEBUG("CBotExprVar::Execute", 1 , pj);
if ( pVar ) pile1->SetCopyVar(pVar); // la place une copie sur la pile
else
{
-//-- pile1->SetVar(NULL); // la pile contient déjà le resultat (méthode)
+//-- pile1->SetVar(NULL); // la pile contient d�j� le resultat (m�thode)
return pj->Return(pile1);
}
pile1->IncState();
}
- pVar = pile1->GivVar(); // récupère si interrompu
+ pVar = pile1->GivVar(); // r�cup�re si interrompu
if ( pVar == NULL )
{
@@ -3300,7 +3311,7 @@ BOOL CBotExprVar::Execute(CBotStack* &pj) pile1->SetError(TX_NOTINIT, pt);
return pj->Return(pile1);
}
- return pj->Return(pile1); // opération faite
+ return pj->Return(pile1); // op�ration faite
}
void CBotExprVar::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -3314,12 +3325,12 @@ void CBotExprVar::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile1->GivState() == 0 )
{
- RestoreStateVar(pile, bMain); // récupère la variable selon champs et index
+ RestoreStateVar(pile, bMain); // r�cup�re la variable selon champs et index
return;
}
}
-// retrouve une variable à l'exécution
+// retrouve une variable � l'ex�cution
BOOL CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep)
{
@@ -3328,7 +3339,7 @@ BOOL CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToke if ( bStep && m_nIdent>0 && pj->IfStep() ) return FALSE;
- pVar = pj->FindVar(m_nIdent, TRUE); // cherche la variable avec mise à jour si nécessaire
+ pVar = pj->FindVar(m_nIdent, TRUE); // cherche la variable avec mise � jour si n�cessaire
if ( pVar == NULL )
{
#ifdef _DEBUG
@@ -3339,13 +3350,13 @@ BOOL CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToke }
if ( m_next3 != NULL &&
!m_next3->ExecuteVar(pVar, pj, &m_token, bStep, FALSE) )
- return FALSE; // Champs d'une instance, tableau, méthode ?
+ return FALSE; // Champs d'une instance, tableau, m�thode ?
- return pile->ReturnKeep( pj ); // ne rend pas la pile mais récupère le résultat si une méthode a été appelée
+ return pile->ReturnKeep( pj ); // ne rend pas la pile mais r�cup�re le r�sultat si une m�thode a �t� appel�e
}
-// retrouve une variable à l'exécution
+// retrouve une variable � l'ex�cution
void CBotExprVar::RestoreStateVar(CBotStack* &pj, BOOL bMain)
{
@@ -3358,12 +3369,12 @@ void CBotExprVar::RestoreStateVar(CBotStack* &pj, BOOL bMain) //////////////////////////////////////////////////////////////////////////////////////////
-// compile une liste de paramètres
+// compile une liste de param�tres
CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars)
{
BOOL first = TRUE;
- CBotInstr* ret = NULL; // pour la liste à retourner
+ CBotInstr* ret = NULL; // pour la liste � retourner
// pStack->SetStartError(p->GivStart());
CBotCStack* pile = pStack;
@@ -3375,7 +3386,7 @@ CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars) if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE)
{
start = p->GivStart();
- pile = pile->TokenStack(); // garde les résultats sur la pile
+ pile = pile->TokenStack(); // garde les r�sultats sur la pile
if ( first ) pStack->SetStartError(start);
first = FALSE;
@@ -3420,7 +3431,7 @@ CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars) //////////////////////////////////////////////////////////////////////////////////////
-// compile un appel d'une méthode
+// compile un appel d'une m�thode
CBotInstrMethode::CBotInstrMethode()
{
@@ -3451,17 +3462,17 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* {
inst->m_NomMethod = pp->GivString();
- // compile la liste des paramètres
+ // compile la liste des param�tres
CBotVar* ppVars[1000];
inst->m_Parameters = CompileParams(p, pStack, ppVars);
if ( pStack->IsOk() )
{
- CBotClass* pClass = var->GivClass(); // pointeur à la classe
+ CBotClass* pClass = var->GivClass(); // pointeur � la classe
inst->m_ClassName = pClass->GivName(); // le nom de la classe
CBotTypResult r = pClass->CompileMethode(inst->m_NomMethod, var, ppVars,
pStack, inst->m_MethodeIdent);
- delete pStack->TokenStack(); // libères les paramètres encore sur la pile
+ delete pStack->TokenStack(); // lib�res les param�tres encore sur la pile
inst->m_typRes = r;
if (inst->m_typRes.GivType() > 20)
@@ -3470,7 +3481,7 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* delete inst;
return NULL;
}
- // met un résultat sur la pile pour avoir quelque chose
+ // met un r�sultat sur la pile pour avoir quelque chose
if (inst->m_typRes.GivType() > 0)
{
CBotVar* pResult = CBotVar::Create("", inst->m_typRes);
@@ -3492,7 +3503,7 @@ CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* return NULL;
}
-// exécute l'appel de méthode
+// ex�cute l'appel de m�thode
BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep, BOOL bExtend)
{
@@ -3509,13 +3520,13 @@ BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* pre if ( pile1->IfStep() ) return FALSE;
- CBotStack* pile2 = pile1->AddStack(); // et pour les paramètres à venir
+ CBotStack* pile2 = pile1->AddStack(); // et pour les param�tres � venir
if ( pile1->GivState() == 0)
{
CBotVar* pThis = CBotVar::Create(pVar);
pThis->Copy(pVar);
- // la valeur de This doit être prise avant l'évaluation des paramètres
+ // la valeur de This doit �tre prise avant l'�valuation des param�tres
// Test.Action( Test = Autre );
// Action doit agir sur la valeur avant Test = Autre !!
pThis->SetName("this");
@@ -3527,18 +3538,18 @@ BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* pre int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
- if (!pile2->SetState(1)) return FALSE; // marque spéciale pour reconnaîre les paramètres
+ if (!pile2->SetState(1)) return FALSE; // marque sp�ciale pour reconna�re les param�tres
}
ppVars[i++] = pile2->GivVar(); // construit la liste des pointeurs
- pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
p = p->GivNext();
if ( p == NULL) break;
}
@@ -3561,7 +3572,7 @@ BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* pre if (pRes != pResult) delete pRes;
pVar = NULL; // ne retourne pas une valeur par cela
- return pj->Return(pile2); // libère toute la pile
+ return pj->Return(pile2); // lib�re toute la pile
}
void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, BOOL bMain)
@@ -3572,7 +3583,7 @@ void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, BOOL bMain) CBotStack* pile1 = pile->RestoreStack(this); // une place pour la copie de This
if ( pile1 == NULL ) return;
- CBotStack* pile2 = pile1->RestoreStack(); // et pour les paramètres à venir
+ CBotStack* pile2 = pile1->RestoreStack(); // et pour les param�tres � venir
if ( pile2 == NULL ) return;
CBotVar* pThis = pile1->FindVar("this");
@@ -3582,9 +3593,9 @@ void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, BOOL bMain) int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
if ( pile2->GivState() == 0 )
@@ -3619,12 +3630,12 @@ BOOL CBotInstrMethode::Execute(CBotStack* &pj) if ( pile1->IfStep() ) return FALSE;
- CBotStack* pile2 = pile1->AddStack(); // et pour les paramètres à venir
+ CBotStack* pile2 = pile1->AddStack(); // et pour les param�tres � venir
if ( pile1->GivState() == 0)
{
CBotVar* pThis = pile1->CopyVar(m_token);
- // la valeur de This doit être prise avant l'évaluation des paramètres
+ // la valeur de This doit �tre prise avant l'�valuation des param�tres
// Test.Action( Test = Autre );
// Action doit agir sur la valeur avant Test = Autre !!
pThis->SetName("this");
@@ -3634,18 +3645,18 @@ BOOL CBotInstrMethode::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
- if (!pile2->SetState(1)) return FALSE; // marque spéciale pour reconnaîre les paramètres
+ if (!pile2->SetState(1)) return FALSE; // marque sp�ciale pour reconna�re les param�tres
}
ppVars[i++] = pile2->GivVar(); // construit la liste des pointeurs
- pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
p = p->GivNext();
if ( p == NULL) break;
}
@@ -3666,13 +3677,13 @@ BOOL CBotInstrMethode::Execute(CBotStack* &pj) pThis, ppVars,
pResult, pile2, GivToken())) return FALSE; // interrompu
- // met la nouvelle valeur de this à la place de l'ancienne variable
+ // met la nouvelle valeur de this � la place de l'ancienne variable
CBotVar* old = pile1->FindVar(m_token);
old->Copy(pThis, FALSE);
if (pRes != pResult) delete pRes;
- return pj->Return(pile2); // libère toute la pile
+ return pj->Return(pile2); // lib�re toute la pile
}
///////////////////////////////////////////////////////////////////////////
@@ -3697,7 +3708,7 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) CBotToken* pp = p;
if ( !IsOfType(p, ID_NEW) ) return NULL;
- // vérifie que le token est un nom de classe
+ // v�rifie que le token est un nom de classe
if (p->GivType() != TokenTypVar) return NULL;
CBotClass* pClass = CBotClass::Find(p);
@@ -3718,15 +3729,15 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_vartoken = p;
p = p->GivNext();
- // crée l'objet sur le "tas"
+ // cr�e l'objet sur le "tas"
// avec un pointeur sur cet objet
CBotVar* pVar = CBotVar::Create("", pClass);
// inst->m_nThisIdent = CBotVar::NextUniqNum();
- // fait l'appel du créateur
+ // fait l'appel du cr�ateur
CBotCStack* pStk = pStack->TokenStack();
{
- // regarde s'il y a des paramètres
+ // regarde s'il y a des param�tres
CBotVar* ppVars[1000];
inst->m_Parameters = CompileParams(p, pStk, ppVars);
if ( !pStk->IsOk() ) goto error;
@@ -3734,10 +3745,10 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) // le constructeur existe-il ?
// CBotString noname;
CBotTypResult r = pClass->CompileMethode(pClass->GivName(), pVar, ppVars, pStk, inst->m_nMethodeIdent);
- delete pStk->TokenStack(); // libère le supplément de pile
+ delete pStk->TokenStack(); // lib�re le suppl�ment de pile
int typ = r.GivType();
- // s'il n'y a pas de constructeur, et pas de paramètres non plus, c'est ok
+ // s'il n'y a pas de constructeur, et pas de param�tres non plus, c'est ok
if ( typ == TX_UNDEFCALL && inst->m_Parameters == NULL ) typ = 0;
pVar->SetInit(TRUE); // marque l'instance comme init
@@ -3747,14 +3758,14 @@ CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack) goto error;
}
- // si le constructeur n'existe pas, mais qu'il y a des paramètres
+ // si le constructeur n'existe pas, mais qu'il y a des param�tres
if (typ<0 && inst->m_Parameters != NULL)
{
pStk->SetError(TX_NOCONST, &inst->m_vartoken);
goto error;
}
- // rend le pointeur à l'objet sur la pile
+ // rend le pointeur � l'objet sur la pile
pStk->SetVar(pVar);
return pStack->Return(inst, pStk);
}
@@ -3763,7 +3774,7 @@ error: return pStack->Return(NULL, pStk);
}
-// exécute une instruction "new"
+// ex�cute une instruction "new"
BOOL CBotNew::Execute(CBotStack* &pj)
{
@@ -3779,12 +3790,12 @@ BOOL CBotNew::Execute(CBotStack* &pj) CBotToken* pt = &m_vartoken;
CBotClass* pClass = CBotClass::Find(pt);
- // crée la variable "this" de type pointeur à l'objet
+ // cr�e la variable "this" de type pointeur � l'objet
if ( pile->GivState()==0)
{
- // crée une instance de la classe demandée
- // et initialise le pointeur à cet objet
+ // cr�e une instance de la classe demand�e
+ // et initialise le pointeur � cet objet
pThis = CBotVar::Create("this", pClass);
// pThis->SetUniqNum( m_nThisIdent ) ;
@@ -3794,16 +3805,16 @@ BOOL CBotNew::Execute(CBotStack* &pj) pile->IncState();
}
- // retrouve le pointeur this si on a été interrompu
+ // retrouve le pointeur this si on a �t� interrompu
if ( pThis == NULL)
{
pThis = pile1->GivVar(); // retrouve le pointeur
}
- // y a-t-il une assignation ou des paramètres (constructeur)
+ // y a-t-il une assignation ou des param�tres (constructeur)
if ( pile->GivState()==1)
{
- // évalue le constructeur de l'instance
+ // �value le constructeur de l'instance
CBotVar* ppVars[1000];
CBotStack* pile2 = pile;
@@ -3811,13 +3822,13 @@ BOOL CBotNew::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
@@ -3829,15 +3840,15 @@ BOOL CBotNew::Execute(CBotStack* &pj) }
ppVars[i] = NULL;
- // crée une variable pour le résultat
+ // cr�e une variable pour le r�sultat
CBotVar* pResult = NULL; // constructeurs toujours void
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(),
pThis, ppVars,
pResult, pile2, GivToken())) return FALSE; // interrompu
- pThis->ConstructorSet(); // signale que le constructeur a été appelé
-// pile->Return(pile2); // libère un bout de pile
+ pThis->ConstructorSet(); // signale que le constructeur a �t� appel�
+// pile->Return(pile2); // lib�re un bout de pile
// pile->IncState();
}
@@ -3857,7 +3868,7 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) CBotToken* pt = &m_vartoken;
CBotClass* pClass = CBotClass::Find(pt);
- // crée la variable "this" de type pointeur à l'objet
+ // cr�e la variable "this" de type pointeur � l'objet
if ( pile->GivState()==0)
{
@@ -3868,10 +3879,10 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) // pThis->SetUniqNum( m_nThisIdent );
pThis->SetUniqNum( -2 );
- // y a-t-il une assignation ou des paramètres (constructeur)
+ // y a-t-il une assignation ou des param�tres (constructeur)
if ( pile->GivState()==1)
{
- // évalue le constructeur de l'instance
+ // �value le constructeur de l'instance
CBotVar* ppVars[1000];
CBotStack* pile2 = pile;
@@ -3879,13 +3890,13 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->RestoreStack(); // de la place sur la pile pour les résultats
+ pile2 = pile2->RestoreStack(); // de la place sur la pile pour les r�sultats
if ( pile2 == NULL ) return;
if ( pile2->GivState() == 0 )
@@ -3905,7 +3916,7 @@ void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain) }
/////////////////////////////////////////////////////////////
-// regarde si deux résultats sont compatibles pour faire une opération
+// regarde si deux r�sultats sont compatibles pour faire une op�ration
BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op )
{
@@ -3914,9 +3925,9 @@ BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op ) int max = (t1 > t2) ? t1 : t2;
- if ( max == 99 ) return FALSE; // un résultat est void ?
+ if ( max == 99 ) return FALSE; // un r�sultat est void ?
- // cas particulier pour les concaténation de chaînes
+ // cas particulier pour les concat�nation de cha�nes
if (op == ID_ADD && max >= CBotTypString) return TRUE;
if (op == ID_ASSADD && max >= CBotTypString) return TRUE;
if (op == ID_ASS && t1 == CBotTypString) return TRUE;
@@ -3941,8 +3952,8 @@ BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op ) CBotClass* c2 = type2.GivClass();
return c1->IsChildOf(c2) || c2->IsChildOf(c1);
- // accepte le caste à l'envers,
- // l'opération sera refusée à l'exécution si le pointeur n'est pas compatible
+ // accepte le caste � l'envers,
+ // l'op�ration sera refus�e � l'ex�cution si le pointeur n'est pas compatible
}
return TRUE;
@@ -3953,7 +3964,7 @@ BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op ) return TRUE;
}
-// regarde si deux variables sont compatible pour un passage de paramètre
+// regarde si deux variables sont compatible pour un passage de param�tre
BOOL TypesCompatibles( CBotTypResult& type1, CBotTypResult& type2 )
{
@@ -3965,7 +3976,7 @@ BOOL TypesCompatibles( CBotTypResult& type1, CBotTypResult& type2 ) int max = (t1 > t2) ? t1 : t2;
- if ( max == 99 ) return FALSE; // un résultat est void ?
+ if ( max == 99 ) return FALSE; // un r�sultat est void ?
if ( max >= CBotTypBoolean )
{
@@ -3986,7 +3997,7 @@ BOOL TypesCompatibles( CBotTypResult& type1, CBotTypResult& type2 ) /////////////////////////////////////////////////////////////////////////////////////
// Gestion des fichiers
-// nécessaire car il n'est pas possible de faire le fopen dans le programme principal
+// n�cessaire car il n'est pas possible de faire le fopen dans le programme principal
// et les fwrite ou fread dans une dll en utilisant le FILE* rendu.
FILE* fOpen(const char* name, const char* mode)
diff --git a/src/CBot/CBot.h b/src/CBot/CBot.h index bf95c90..0189cf3 100644 --- a/src/CBot/CBot.h +++ b/src/CBot/CBot.h @@ -1,29 +1,42 @@ -////////////////////////////////////////////////////////////////////
-// interpréteur pour le language CBot du jeu COLOBOT
-
-// dernière révision : 03/10/2002 DD
+// * 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 .
+
+// derni�re r�vision : 03/10/2002 DD
#define EXTENDS TRUE
#include "resource.h"
-#include "CBotDll.h" // définitions publiques
+#include "CBotDll.h" // d�finitions publiques
#include "CBotToken.h" // gestion des tokens
-#define STACKRUN TRUE // reprise de l'exécution direct sur une routine suspendue
-#define STACKMEM TRUE // préréserve la mémoire pour la pile d'exécution
-#define MAXSTACK 990 // taille du stack réservé
+#define STACKRUN TRUE // reprise de l'ex�cution direct sur une routine suspendue
+#define STACKMEM TRUE // pr�r�serve la m�moire pour la pile d'ex�cution
+#define MAXSTACK 990 // taille du stack r�serv�
-#define EOX (CBotStack*)-1 // marqueur condition spéciale
+#define EOX (CBotStack*)-1 // marqueur condition sp�ciale
/////////////////////////////////////////////////////////////////////
-// résumé des classes utilisées, définies ci-après
+// r�sum� des classes utilis�es, d�finies ci-apr�s
class CBotCompExpr; // une expression telle que
// () <= ()
class CBotAddExpr; // une expression telle que
// () + ()
-class CBotParExpr; // un élément de base ou entre parenthèse
+class CBotParExpr; // un �l�ment de base ou entre parenth�se
// Toto.truc
// 12.5
// "chaine"
@@ -33,17 +46,17 @@ class CBotExprVar; // un nom de variable tel que // chose.truc.machin
class CBotWhile; // while (...) {...};
class CBotIf; // if (...) {...} else {...}
-class CBotDefParam; // liste de paramètres d'une fonction
+class CBotDefParam; // liste de param�tres d'une fonction
class CBotRepeat; // repeat (nb) {...}
////////////////////////////////////////////////////////////////////////
-// Gestion de la pile d'exécution
+// Gestion de la pile d'ex�cution
////////////////////////////////////////////////////////////////////////
// en fait, en externe, la seule chose qu'il est possible de faire
-// c'est de créer une instance d'une pile
+// c'est de cr�er une instance d'une pile
// pour l'utiliser pour la routine CBotProgram::Execute(CBotStack)
class CBotStack
@@ -63,15 +76,15 @@ private: static int m_start;
static int m_end;
static
- CBotVar* m_retvar; // résultat d'un return
+ CBotVar* m_retvar; // r�sultat d'un return
- CBotVar* m_var; // résultat des opérations
- CBotVar* m_listVar; // les variables déclarées à ce niveau
+ CBotVar* m_var; // r�sultat des op�rations
+ CBotVar* m_listVar; // les variables d�clar�es � ce niveau
- BOOL m_bBlock; // fait partie d'un bloc (variables sont locales à ce bloc)
+ BOOL m_bBlock; // fait partie d'un bloc (variables sont locales � ce bloc)
BOOL m_bOver; // limites de la pile ?
-// BOOL m_bDontDelete; // spécial, ne pas détruire les variables au delete
- CBotProgram* m_prog; // les fonctions définies par user
+// BOOL m_bDontDelete; // sp�cial, ne pas d�truire les variables au delete
+ CBotProgram* m_prog; // les fonctions d�finies par user
static
int m_initimer;
@@ -83,7 +96,7 @@ private: void* m_pUser;
CBotInstr* m_instr; // l'instruction correspondante
- BOOL m_bFunc; // une entrée d'une fonction ?
+ BOOL m_bFunc; // une entr�e d'une fonction ?
CBotCall* m_call; // point de reprise dans un call extern
friend class CBotTry;
@@ -98,10 +111,10 @@ public: BOOL StackOver();
int GivError(int& start, int& end);
- int GivError(); // rend le numéro d'erreur retourné
+ int GivError(); // rend le num�ro d'erreur retourn�
- void Reset(void* pUser); // plus d'erreur, timer au début
- void SetType(CBotTypResult& type); // détermine le type
+ void Reset(void* pUser); // plus d'erreur, timer au d�but
+ void SetType(CBotTypResult& type); // d�termine le type
int GivType(int mode = 0); // donne le type de valeur sur le stack
CBotTypResult GivTypResult(int mode = 0); // donne le type complet de valeur sur le stack
@@ -120,25 +133,25 @@ public: CBotVar* CopyVar(CBotToken& Token, BOOL bUpdate = FALSE); // trouve et rend une copie
- CBotStack* AddStack(CBotInstr* instr = NULL, BOOL bBlock = FALSE); // étend le stack
- CBotStack* AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE); // étend le stack
+ CBotStack* AddStack(CBotInstr* instr = NULL, BOOL bBlock = FALSE); // �tend le stack
+ CBotStack* AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE); // �tend le stack
CBotStack* RestoreStack(CBotInstr* instr = NULL);
CBotStack* RestoreStackEOX(CBotCall* instr = NULL);
- CBotStack* AddStack2(BOOL bBlock = FALSE); // étend le stack
- BOOL Return(CBotStack* pFils); // transmet le résultat au dessus
- BOOL ReturnKeep(CBotStack* pFils); // transmet le résultat sans réduire la pile
+ CBotStack* AddStack2(BOOL bBlock = FALSE); // �tend le stack
+ BOOL Return(CBotStack* pFils); // transmet le r�sultat au dessus
+ BOOL ReturnKeep(CBotStack* pFils); // transmet le r�sultat sans r�duire la pile
BOOL BreakReturn(CBotStack* pfils, const char* name = NULL);
- // en cas de break éventuel
+ // en cas de break �ventuel
BOOL IfContinue(int state, const char* name);
// ou de "continue"
BOOL IsOk();
- BOOL SetState(int n, int lim = -10); // sélectionne un état
- int GivState(); // dans quel état j'ère ?
- BOOL IncState(int lim = -10); // passe à l'état suivant
- BOOL IfStep(); // faire du pas à pas ?
+ BOOL SetState(int n, int lim = -10); // s�lectionne un �tat
+ int GivState(); // dans quel �tat j'�re ?
+ BOOL IncState(int lim = -10); // passe � l'�tat suivant
+ BOOL IfStep(); // faire du pas � pas ?
BOOL Execute();
void SetVar( CBotVar* var );
@@ -177,7 +190,7 @@ public: int m_temp;
};
-// les routines inline doivent être déclarées dans le fichier .h
+// les routines inline doivent �tre d�clar�es dans le fichier .h
inline BOOL CBotStack::IsOk()
{
@@ -211,13 +224,13 @@ private: int m_end;
int m_start;
- CBotVar* m_var; // résultat des opérations
+ CBotVar* m_var; // r�sultat des op�rations
- BOOL m_bBlock; // fait partie d'un bloc (variables sont locales à ce bloc)
+ BOOL m_bBlock; // fait partie d'un bloc (variables sont locales � ce bloc)
CBotVar* m_listVar;
static
- CBotProgram* m_prog; // liste des fonctions compilées
+ CBotProgram* m_prog; // liste des fonctions compil�es
static
CBotTypResult m_retTyp;
// static
@@ -230,9 +243,9 @@ public: BOOL IsOk();
int GivError();
int GivError(int& start, int& end);
- // rend le numéro d'erreur retourné
+ // rend le num�ro d'erreur retourn�
- void SetType(CBotTypResult& type);// détermine le type
+ void SetType(CBotTypResult& type);// d�termine le type
CBotTypResult GivTypResult(int mode = 0); // donne le type de valeur sur le stack
int GivType(int mode = 0); // donne le type de valeur sur le stack
CBotClass* GivClass(); // donne la classe de la valeur sur le stack
@@ -244,8 +257,8 @@ public: CBotVar* CopyVar(CBotToken& Token); // trouve et rend une copie
CBotCStack* TokenStack(CBotToken* pToken = NULL, BOOL bBlock = FALSE);
- CBotInstr* Return(CBotInstr* p, CBotCStack* pParent); // transmet le résultat au dessus
- CBotFunction* ReturnFunc(CBotFunction* p, CBotCStack* pParent); // transmet le résultat au dessus
+ CBotInstr* Return(CBotInstr* p, CBotCStack* pParent); // transmet le r�sultat au dessus
+ CBotFunction* ReturnFunc(CBotFunction* p, CBotCStack* pParent); // transmet le r�sultat au dessus
void SetVar( CBotVar* var );
void SetCopyVar( CBotVar* var );
@@ -273,7 +286,7 @@ extern BOOL SaveVar(FILE* pf, CBotVar* pVar); /////////////////////////////////////////////////////////////////////
-// classes définissant une instruction
+// classes d�finissant une instruction
class CBotInstr
{
private:
@@ -283,15 +296,15 @@ private: protected:
CBotToken m_token; // conserve le token
CBotString name; // debug
- CBotInstr* m_next; // instructions chaînées
- CBotInstr* m_next2b; // seconde liste pour définition en chaîne
- CBotInstr* m_next3; // troisième liste pour les indices et champs
- CBotInstr* m_next3b; // nécessaire pour la déclaration des tableaux
+ CBotInstr* m_next; // instructions cha�n�es
+ CBotInstr* m_next2b; // seconde liste pour d�finition en cha�ne
+ CBotInstr* m_next3; // troisi�me liste pour les indices et champs
+ CBotInstr* m_next3b; // n�cessaire pour la d�claration des tableaux
/*
par exemple, le programme suivant
int x[]; x[1] = 4;
int y[x[1]][10], z;
- va généré
+ va g�n�r�
CBotInstrArray
m_next3b-> CBotEmpty
m_next->
@@ -368,7 +381,7 @@ class CBotWhile : public CBotInstr private:
CBotInstr* m_Condition; // la condition
CBotInstr* m_Block; // les instructions
- CBotString m_label; // une étiquette s'il y a
+ CBotString m_label; // une �tiquette s'il y a
public:
CBotWhile();
@@ -382,9 +395,9 @@ public: class CBotRepeat : public CBotInstr
{
private:
- CBotInstr* m_NbIter; // le nombre d'itération
+ CBotInstr* m_NbIter; // le nombre d'it�ration
CBotInstr* m_Block; // les instructions
- CBotString m_label; // une étiquette s'il y a
+ CBotString m_label; // une �tiquette s'il y a
public:
CBotRepeat();
@@ -400,7 +413,7 @@ class CBotDo : public CBotInstr private:
CBotInstr* m_Block; // les instructions
CBotInstr* m_Condition; // la condition
- CBotString m_label; // une étiquette s'il y a
+ CBotString m_label; // une �tiquette s'il y a
public:
CBotDo();
@@ -416,9 +429,9 @@ class CBotFor : public CBotInstr private:
CBotInstr* m_Init; // intruction initiale
CBotInstr* m_Test; // la condition de test
- CBotInstr* m_Incr; // instruction pour l'incrément
+ CBotInstr* m_Incr; // instruction pour l'incr�ment
CBotInstr* m_Block; // les instructions
- CBotString m_label; // une étiquette s'il y a
+ CBotString m_label; // une �tiquette s'il y a
public:
CBotFor();
@@ -432,7 +445,7 @@ public: class CBotBreak : public CBotInstr
{
private:
- CBotString m_label; // une étiquette s'il y a
+ CBotString m_label; // une �tiquette s'il y a
public:
CBotBreak();
@@ -446,7 +459,7 @@ public: class CBotReturn : public CBotInstr
{
private:
- CBotInstr* m_Instr; // le paramètre à retourner
+ CBotInstr* m_Instr; // le param�tre � retourner
public:
CBotReturn();
@@ -461,7 +474,7 @@ public: class CBotSwitch : public CBotInstr
{
private:
- CBotInstr* m_Value; // value à chercher
+ CBotInstr* m_Value; // value � chercher
CBotInstr* m_Block; // les instructions
public:
@@ -477,7 +490,7 @@ public: class CBotCase : public CBotInstr
{
private:
- CBotInstr* m_Value; // valeur à comparer
+ CBotInstr* m_Value; // valeur � comparer
public:
CBotCase();
@@ -527,7 +540,7 @@ public: class CBotThrow : public CBotInstr
{
private:
- CBotInstr* m_Value; // la valeur à envoyer
+ CBotInstr* m_Value; // la valeur � envoyer
public:
CBotThrow();
@@ -569,14 +582,14 @@ public: };
-// définition d'un nombre entier
+// d�finition d'un nombre entier
class CBotInt : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable à initialiser
- CBotInstr* m_expr; // la valeur à mettre, s'il y a
-/// CBotInstr* m_next; // plusieurs définitions enchaînées
+ CBotInstr* m_var; // la variable � initialiser
+ CBotInstr* m_expr; // la valeur � mettre, s'il y a
+/// CBotInstr* m_next; // plusieurs d�finitions encha�n�es
public:
CBotInt();
@@ -587,15 +600,15 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// définition d'un tableau
+// d�finition d'un tableau
class CBotInstArray : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable à initialiser
+ CBotInstr* m_var; // la variable � initialiser
CBotInstr* m_listass; // liste d'assignations pour le tableau
CBotTypResult
- m_typevar; // type d'éléments
+ m_typevar; // type d'�l�ments
// CBotString m_ClassName;
public:
@@ -608,14 +621,14 @@ public: };
-// définition d'une liste d'assignation pour un tableau
+// d�finition d'une liste d'assignation pour un tableau
// int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;
class CBotListArray : public CBotInstr
{
private:
- CBotInstr* m_expr; // expression pour un élément
- // les autres sont chaînés avec CBotInstr::m_next3;
+ CBotInstr* m_expr; // expression pour un �l�ment
+ // les autres sont cha�n�s avec CBotInstr::m_next3;
public:
CBotListArray();
~CBotListArray();
@@ -632,13 +645,13 @@ class CBotEmpty : public CBotInstr void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// définition d'un booléen
+// d�finition d'un bool�en
class CBotBoolean : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable à initialiser
- CBotInstr* m_expr; // la valeur à mettre, s'il y a
+ CBotInstr* m_var; // la variable � initialiser
+ CBotInstr* m_expr; // la valeur � mettre, s'il y a
public:
CBotBoolean();
@@ -650,13 +663,13 @@ public: };
-// définition d'un nombre réel
+// d�finition d'un nombre r�el
class CBotFloat : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable à initialiser
- CBotInstr* m_expr; // la valeur à mettre, s'il y a
+ CBotInstr* m_var; // la variable � initialiser
+ CBotInstr* m_expr; // la valeur � mettre, s'il y a
public:
CBotFloat();
@@ -667,13 +680,13 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// définition d'un elément string
+// d�finition d'un el�ment string
class CBotIString : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable à initialiser
- CBotInstr* m_expr; // la valeur à mettre, s'il y a
+ CBotInstr* m_var; // la variable � initialiser
+ CBotInstr* m_expr; // la valeur � mettre, s'il y a
public:
CBotIString();
@@ -684,16 +697,16 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// définition d'un elément dans une classe quelconque
+// d�finition d'un el�ment dans une classe quelconque
class CBotClassInst : public CBotInstr
{
private:
- CBotInstr* m_var; // la variable à initialiser
- CBotClass* m_pClass; // référence à la classe
- CBotInstr* m_Parameters; // les paramètres à évaluer pour le constructeur
- CBotInstr* m_expr; // la valeur à mettre, s'il y a
- BOOL m_hasParams; // il y a des paramètres ?
+ CBotInstr* m_var; // la variable � initialiser
+ CBotClass* m_pClass; // r�f�rence � la classe
+ CBotInstr* m_Parameters; // les param�tres � �valuer pour le constructeur
+ CBotInstr* m_expr; // la valeur � mettre, s'il y a
+ BOOL m_hasParams; // il y a des param�tres ?
long m_nMethodeIdent;
public:
@@ -716,8 +729,8 @@ public: };
-// left opérande
-// n'accepte que les expressions pouvant être à gauche d'une assignation
+// left op�rande
+// n'accepte que les expressions pouvant �tre � gauche d'une assignation
class CBotLeftExpr : public CBotInstr
{
@@ -782,8 +795,8 @@ public: class CBotExpression : public CBotInstr
{
private:
- CBotLeftExpr* m_leftop; // élément de gauche
- CBotInstr* m_rightop; // élément de droite
+ CBotLeftExpr* m_leftop; // �l�ment de gauche
+ CBotInstr* m_rightop; // �l�ment de droite
public:
CBotExpression();
@@ -797,7 +810,7 @@ public: class CBotListExpression : public CBotInstr
{
private:
- CBotInstr* m_Expr; // la 1ère expression à évaluer
+ CBotInstr* m_Expr; // la 1�re expression � �valuer
public:
CBotListExpression();
@@ -811,9 +824,9 @@ public: class CBotLogicExpr : public CBotInstr
{
private:
- CBotInstr* m_condition; // test à évaluer
- CBotInstr* m_op1; // élément de gauche
- CBotInstr* m_op2; // élément de droite
+ CBotInstr* m_condition; // test � �valuer
+ CBotInstr* m_op1; // �l�ment de gauche
+ CBotInstr* m_op2; // �l�ment de droite
friend class CBotTwoOpExpr;
public:
@@ -838,9 +851,9 @@ public: -// une expression éventuellement entre parenthèses ( ... )
+// une expression �ventuellement entre parenth�ses ( ... )
// il n'y a jamais d'instance de cette classe
-// l'objet retourné étant le contenu de la parenthése
+// l'objet retourn� �tant le contenu de la parenth�se
class CBotParExpr : public CBotInstr
{
private:
@@ -854,7 +867,7 @@ public: class CBotExprUnaire : public CBotInstr
{
private:
- CBotInstr* m_Expr; // l'expression à évaluer
+ CBotInstr* m_Expr; // l'expression � �valuer
public:
CBotExprUnaire();
~CBotExprUnaire();
@@ -864,13 +877,13 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// toutes les opérations à 2 opérandes
+// toutes les op�rations � 2 op�randes
class CBotTwoOpExpr : public CBotInstr
{
private:
- CBotInstr* m_leftop; // élément de gauche
- CBotInstr* m_rightop; // élément de droite
+ CBotInstr* m_leftop; // �l�ment de gauche
+ CBotInstr* m_rightop; // �l�ment de droite
public:
CBotTwoOpExpr();
~CBotTwoOpExpr();
@@ -900,7 +913,7 @@ public: class CBotListInstr : public CBotInstr
{
private:
- CBotInstr* m_Instr; // les instructions à faire
+ CBotInstr* m_Instr; // les instructions � faire
public:
CBotListInstr();
@@ -915,11 +928,11 @@ public: class CBotInstrCall : public CBotInstr
{
private:
- CBotInstr* m_Parameters; // les paramètres à évaluer
-// int m_typeRes; // type du résultat
-// CBotString m_RetClassName; // class du résultat
+ CBotInstr* m_Parameters; // les param�tres � �valuer
+// int m_typeRes; // type du r�sultat
+// CBotString m_RetClassName; // class du r�sultat
CBotTypResult
- m_typRes; // type complet du résultat
+ m_typRes; // type complet du r�sultat
long m_nFuncIdent; // id de la fonction
public:
@@ -931,19 +944,19 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// un appel d'une méthode
+// un appel d'une m�thode
class CBotInstrMethode : public CBotInstr
{
private:
- CBotInstr* m_Parameters; // les paramètres à évaluer
-// int m_typeRes; // type du résultat
-// CBotString m_RetClassName; // class du résultat
+ CBotInstr* m_Parameters; // les param�tres � �valuer
+// int m_typeRes; // type du r�sultat
+// CBotString m_RetClassName; // class du r�sultat
CBotTypResult
- m_typRes; // type complet du résultat
+ m_typRes; // type complet du r�sultat
- CBotString m_NomMethod; // nom de la méthode
- long m_MethodeIdent; // identificateur de la méthode
+ CBotString m_NomMethod; // nom de la m�thode
+ long m_MethodeIdent; // identificateur de la m�thode
// long m_nThisIdent; // identificateur pour "this"
CBotString m_ClassName; // nom de la classe
@@ -1017,7 +1030,7 @@ class CBotLeftExprVar : public CBotInstr private:
public:
CBotTypResult
- m_typevar; // type de variable déclarée
+ m_typevar; // type de variable d�clar�e
long m_nIdent; // identificateur unique pour cette variable
public:
@@ -1072,7 +1085,7 @@ public: class CBotNew : public CBotInstr
{
private:
- CBotInstr* m_Parameters; // les paramètres à évaluer
+ CBotInstr* m_Parameters; // les param�tres � �valuer
long m_nMethodeIdent;
// long m_nThisIdent;
CBotToken m_vartoken;
@@ -1087,7 +1100,7 @@ public: void RestoreState(CBotStack* &pj, BOOL bMain);
};
-// expression représentant un nombre
+// expression repr�sentant un nombre
class CBotExprNum : public CBotInstr
{
@@ -1107,7 +1120,7 @@ public: -// expression représentant une chaine de caractères
+// expression repr�sentant une chaine de caract�res
class CBotExprAlpha : public CBotInstr
{
@@ -1131,7 +1144,7 @@ class CBotVarInt : public CBotVar {
private:
int m_val; // la valeur
- CBotString m_defnum; // le nom si donné par DefineNum
+ CBotString m_defnum; // le nom si donn� par DefineNum
friend class CBotVar;
public:
@@ -1179,7 +1192,7 @@ public: };
-// classe pour la gestion des nombres réels (float)
+// classe pour la gestion des nombres r�els (float)
class CBotVarFloat : CBotVar
{
private:
@@ -1220,7 +1233,7 @@ public: };
-// classe pour la gestion des chaînes (String)
+// classe pour la gestion des cha�nes (String)
class CBotVarString : CBotVar
{
private:
@@ -1281,19 +1294,19 @@ class CBotVarClass : public CBotVar {
private:
static
- CBotVarClass* m_ExClass; // liste des instances existantes à un moment donné
- CBotVarClass* m_ExNext; // pour cette liste générale
- CBotVarClass* m_ExPrev; // pour cette liste générale
+ CBotVarClass* m_ExClass; // liste des instances existantes � un moment donn�
+ CBotVarClass* m_ExNext; // pour cette liste g�n�rale
+ CBotVarClass* m_ExPrev; // pour cette liste g�n�rale
private:
- CBotClass* m_pClass; // la définition de la classe
+ CBotClass* m_pClass; // la d�finition de la classe
CBotVarClass* m_pParent; // l'instance dans la classe parent
CBotVar* m_pVar; // contenu
friend class CBotVar; // mon papa est un copain
friend class CBotVarPointer; // et le pointeur aussi
int m_CptUse; // compteur d'utilisation
long m_ItemIdent; // identificateur (unique) de l'instance
- BOOL m_bConstructor; // set si un constructeur a été appelé
+ BOOL m_bConstructor; // set si un constructeur a �t� appel�
public:
CBotVarClass( const CBotToken* name, CBotTypResult& type );
@@ -1304,7 +1317,7 @@ public: void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void SetClass(CBotClass* pClass); //, int &nIdent);
CBotClass* GivClass();
- CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
+ CBotVar* GivItem(const char* name); // rend un �l�ment d'une classe selon son nom (*)
CBotVar* GivItemRef(int nIdent);
CBotVar* GivItem(int n, BOOL bExtend);
@@ -1315,8 +1328,8 @@ public: BOOL Save1State(FILE* pf);
void Maj(void* pUser, BOOL bContinue);
- void IncrementUse(); // une référence en plus
- void DecrementUse(); // une référence en moins
+ void IncrementUse(); // une r�f�rence en plus
+ void DecrementUse(); // une r�f�rence en moins
CBotVarClass*
GivPointer();
@@ -1338,13 +1351,13 @@ public: };
-// classe pour la gestion des pointeurs à une instances de classe
+// classe pour la gestion des pointeurs � une instances de classe
class CBotVarPointer : public CBotVar
{
private:
CBotVarClass*
m_pVarClass; // contenu
- CBotClass* m_pClass; // la classe prévue pour ce pointeur
+ CBotClass* m_pClass; // la classe pr�vue pour ce pointeur
friend class CBotVar; // mon papa est un copain
public:
@@ -1354,7 +1367,7 @@ public: void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void SetClass(CBotClass* pClass);
CBotClass* GivClass();
- CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
+ CBotVar* GivItem(const char* name); // rend un �l�ment d'une classe selon son nom (*)
CBotVar* GivItemRef(int nIdent);
CBotVar* GivItemList();
@@ -1363,8 +1376,8 @@ public: CBotVarClass*
GivPointer();
- void SetIdent(long n); // associe un numéro d'identification (unique)
- long GivIdent(); // donne le numéro d'identification associé
+ void SetIdent(long n); // associe un num�ro d'identification (unique)
+ long GivIdent(); // donne le num�ro d'identification associ�
void ConstructorSet();
BOOL Save1State(FILE* pf);
@@ -1383,7 +1396,7 @@ class CBotVarArray : public CBotVar {
private:
CBotVarClass*
- m_pInstance; // instance gérant le tableau
+ m_pInstance; // instance g�rant le tableau
friend class CBotVar; // papa est un copain
@@ -1396,12 +1409,12 @@ public: GivPointer();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
- CBotVar* GivItem(int n, BOOL bGrow=FALSE); // rend un élément selon son index numérique
- // agrandi le tableau si nécessaire si bExtend
-// CBotVar* GivItem(const char* name); // rend un élément selon son index litéral
- CBotVar* GivItemList(); // donne le premier élément de la liste
+ CBotVar* GivItem(int n, BOOL bGrow=FALSE); // rend un �l�ment selon son index num�rique
+ // agrandi le tableau si n�cessaire si bExtend
+// CBotVar* GivItem(const char* name); // rend un �l�ment selon son index lit�ral
+ CBotVar* GivItemList(); // donne le premier �l�ment de la liste
- CBotString GivValString(); // donne le contenu du tableau dans une chaîne
+ CBotString GivValString(); // donne le contenu du tableau dans une cha�ne
BOOL Save1State(FILE* pf);
};
@@ -1482,7 +1495,7 @@ public: static void Free();
};
-// classe gérant les méthodes déclarées par AddFunction sur une classe
+// classe g�rant les m�thodes d�clar�es par AddFunction sur une classe
class CBotCallMethode
{
@@ -1514,15 +1527,15 @@ public: };
-// une liste de paramètres
+// une liste de param�tres
class CBotDefParam
{
private:
- CBotToken m_token; // nom du paramètre
+ CBotToken m_token; // nom du param�tre
CBotString m_typename; // nom du type
- CBotTypResult m_type; // type de paramètre
- CBotDefParam* m_next; // paramètre suivant
+ CBotTypResult m_type; // type de param�tre
+ CBotDefParam* m_next; // param�tre suivant
long m_nIdent;
public:
@@ -1542,7 +1555,7 @@ public: };
-// une déclaration de fonction
+// une d�claration de fonction
class CBotFunction : CBotInstr
{
@@ -1555,18 +1568,18 @@ private: friend class CBotCStack;
// long m_nThisIdent;
long m_nFuncIdent;
- BOOL m_bSynchro; // méthode synchronisée ?
+ BOOL m_bSynchro; // m�thode synchronis�e ?
private:
- CBotDefParam* m_Param; // liste des paramètres
+ CBotDefParam* m_Param; // liste des param�tres
CBotInstr* m_Block; // le bloc d'instructions
CBotFunction* m_next;
CBotToken m_retToken; // si retourne un CBotTypClass
- CBotTypResult m_retTyp; // type complet du résultat
+ CBotTypResult m_retTyp; // type complet du r�sultat
BOOL m_bPublic; // fonction publique
BOOL m_bExtern; // fonction extern
- CBotString m_MasterClass; // nom de la classe qu'on dérive
+ CBotString m_MasterClass; // nom de la classe qu'on d�rive
CBotProgram* m_pProg;
friend class CBotProgram;
friend class CBotClass;
diff --git a/src/CBot/CBotAddExpr.cpp b/src/CBot/CBotAddExpr.cpp index 1d2555a..067aa88 100644 --- a/src/CBot/CBotAddExpr.cpp +++ b/src/CBot/CBotAddExpr.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"
@@ -26,9 +38,9 @@ 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 -
+ // cherche des instructions qui peuvent convenir � gauche de l'op�ration + ou -
- CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B à gauche
+ 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 ?
@@ -36,80 +48,80 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack) 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
+ 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 ?
+ type1 = pStack->GetType(); // de quel type le premier op�rande ?
- p = p->Next(); // saute le token de l'opération
+ p = p->Next(); // 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 = CBotAddExpr::Compile( p, pStk )) ) // expression (...) à droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) � droite
{
- // il y a un second opérande acceptable
+ // il y a un second op�rande acceptable
- type2 = pStack->GetType(); // de quel type le résultat ?
+ type2 = pStack->GetType(); // de quel type le r�sultat ?
- if ( type1 == type2 ) // les résultats sont-ils compatibles
+ if ( type1 == type2 ) // 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;
- // et rend l'object à qui l'a demandé
+ // et rend l'object � qui l'a demand�
return pStack->Return(inst, pStk);
}
}
- // 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);
}
-// fait l'opération d'addition ou de soustraction
+// 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
+ 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
+ // selon la reprise, on peut �tre dans l'un des 2 �tats
- if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
+ 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
+ // 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 ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
- int type1 = pStk1->GetType(); // de quels types les résultats ?
+ 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
+ // 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
+ // fait l'op�ration selon la demande
switch (GetTokenType())
{
case ID_ADD:
@@ -119,10 +131,10 @@ BOOL CBotAddExpr::Execute(CBotStack* &pStack) result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
break;
}
- pStk2->SetVar(result); // met le résultat sur la pile
+ 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
+ pStk1->Return(pStk2); // lib�re la pile
+ return pStack->Return(pStk1); // transmet le r�sultat
}
diff --git a/src/CBot/CBotClass.cpp b/src/CBot/CBotClass.cpp index 180faf3..7f1fd3f 100644 --- a/src/CBot/CBotClass.cpp +++ b/src/CBot/CBotClass.cpp @@ -1,6 +1,18 @@ -///////////////////////////////////////////////////////////////////////
-// Gestion des variables de type classe
-//
+// * 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"
@@ -50,7 +62,7 @@ CBotClass::~CBotClass() delete m_pCalls;
delete m_pMethod;
- delete m_next; // libère toutes celle de ce niveau
+ delete m_next; // lib�re toutes celle de ce niveau
}
@@ -77,7 +89,7 @@ void CBotClass::Purge() m_nbVar = m_pParent == NULL ? 0 : m_pParent->m_nbVar;
m_next->Purge();
- m_next = NULL; // n'appartient plus à cette chaîne
+ m_next = NULL; // n'appartient plus � cette cha�ne
}
BOOL CBotClass::Lock(CBotProgram* p)
@@ -93,7 +105,7 @@ BOOL CBotClass::Lock(CBotProgram* p) if ( p == m_ProgInLock[0] )
{
m_cptOne++;
- m_cptLock--; // a déjà été compté
+ m_cptLock--; // a d�j� �t� compt�
return TRUE;
}
@@ -102,7 +114,7 @@ BOOL CBotClass::Lock(CBotProgram* p) if ( p == m_ProgInLock[j] )
{
m_cptLock--;
- return FALSE; // déjà en attente
+ return FALSE; // d�j� en attente
}
}
@@ -279,7 +291,7 @@ BOOL CBotClass::AddFunction(const char* name, BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))
{
- // mémorise les pointeurs aux deux fonctions
+ // m�morise les pointeurs aux deux fonctions
CBotCallMethode* p = m_pCalls;
CBotCallMethode* pp = NULL;
@@ -299,7 +311,7 @@ BOOL CBotClass::AddFunction(const char* name, p = new CBotCallMethode(name, rExec, rCompile);
if (m_pCalls == NULL) m_pCalls = p;
- else m_pCalls->AddNext(p); // ajoute à la liste
+ else m_pCalls->AddNext(p); // ajoute � la liste
return TRUE;
}
@@ -310,21 +322,21 @@ BOOL CBotClass::AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) ) return TRUE;
}
-// compile une méthode associée à une instance de classe
-// la méthode peut être déclarée par AddFunction ou par l'utilisateur
+// compile une m�thode associ�e � une instance de classe
+// la m�thode peut �tre d�clar�e par AddFunction ou par l'utilisateur
CBotTypResult CBotClass::CompileMethode(const char* name,
CBotVar* pThis, CBotVar** ppParams,
CBotCStack* pStack, long& nIdent)
{
- nIdent = 0; // oublie le précédent s'il y a lieu
+ nIdent = 0; // oublie le pr�c�dent s'il y a lieu
- // recherche dans les méthodes déclarées par AddFunction
+ // recherche dans les m�thodes d�clar�es par AddFunction
CBotTypResult r = m_pCalls->CompileCall(name, pThis, ppParams, pStack, nIdent);
if ( r.GivType() >= 0) return r;
- // recherche dans les méthodes déclarées par l'utilisateur
+ // recherche dans les m�thodes d�clar�es par l'utilisateur
r = m_pMethod->CompileCall(name, ppParams, nIdent);
if ( r.Eq(TX_UNDEFCALL) && m_pParent != NULL )
@@ -332,7 +344,7 @@ CBotTypResult CBotClass::CompileMethode(const char* name, return r;
}
-// exécute une méthode
+// ex�cute une m�thode
BOOL CBotClass::ExecuteMethode(long& nIdent, const char* name,
CBotVar* pThis, CBotVar** ppParams,
@@ -346,7 +358,7 @@ BOOL CBotClass::ExecuteMethode(long& nIdent, const char* name, return ret;
}
-// rétabli la pile d'exécution
+// r�tabli la pile d'ex�cution
void CBotClass::RestoreMethode(long& nIdent, const char* name, CBotVar* pThis,
CBotVar** ppParams, CBotStack* &pStack)
@@ -361,7 +373,7 @@ BOOL CBotClass::SaveStaticState(FILE* pf) {
if (!WriteWord( pf, CBOTVERSION*2)) return FALSE;
- // sauve l'état des variables statiques dans les classes
+ // sauve l'�tat des variables statiques dans les classes
CBotClass* p = m_ExClass;
while ( p != NULL )
@@ -378,7 +390,7 @@ BOOL CBotClass::SaveStaticState(FILE* pf) if (!WriteWord( pf, 1)) return FALSE;
if (!WriteString( pf, pv->GivName() )) return FALSE;
- if ( !pv->Save0State(pf)) return FALSE; // entête commune
+ if ( !pv->Save0State(pf)) return FALSE; // ent�te commune
if ( !pv->Save1State(pf) ) return FALSE; // sauve selon la classe fille
if ( !WriteWord( pf, 0)) return FALSE;
}
@@ -450,7 +462,7 @@ CBotClassInst::~CBotClassInst() // delete m_next; // fait par le destructeur de la classe de base ~CBotInstr()
}
-// définition de pointeur(s) à un objet
+// d�finition de pointeur(s) � un objet
// du style
// CPoint A, B ;
@@ -463,7 +475,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass = CBotClass::Find(p);
if ( pClass == NULL )
{
- // pas trouvé ? c'est bizare
+ // pas trouv� ? c'est bizare
pStack->SetError(TX_NOCLASS, p);
return NULL;
}
@@ -487,7 +499,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
{
((CBotLeftExprVar*)inst->m_var)->m_typevar = type;
- if (pStk->CheckVarLocal(vartoken)) // redéfinition de la variable
+ if (pStk->CheckVarLocal(vartoken)) // red�finition de la variable
{
pStk->SetStartError(vartoken->GivStart());
pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
@@ -499,7 +511,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* delete inst; // n'est pas de type CBotInt
p = vartoken; // revient sur le nom de la variable
- // compile une déclaration de tableau
+ // compile une d�claration de tableau
inst = (CBotClassInst*)CBotInstArray::Compile( p, pStk, type );
@@ -508,27 +520,27 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pStk->SetError(TX_CLBRK, p->GivStart());
goto error;
}
- goto suite; // pas d'assignation, variable déjà créée
+ goto suite; // pas d'assignation, variable d�j� cr��e
}
CBotVar* var;
- var = CBotVar::Create(vartoken->GivString(), type); // crée l'instance
+ var = CBotVar::Create(vartoken->GivString(), type); // cr�e l'instance
// var->SetClass(pClass);
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
- // lui attribut un numéro unique
+ // lui attribut un num�ro unique
pStack->AddVar(var); // la place sur la pile
- // regarde s'il y a des paramètres
+ // regarde s'il y a des param�tres
inst->m_hasParams = (p->GivType() == ID_OPENPAR);
CBotVar* ppVars[1000];
inst->m_Parameters = CompileParams(p, pStk, ppVars);
if ( !pStk->IsOk() ) goto error;
- // s'il y a des paramètres, fait l'équivalent de l'instruction new
- // CPoint A ( 0, 0 ) est équivalent à
+ // s'il y a des param�tres, fait l'�quivalent de l'instruction new
+ // CPoint A ( 0, 0 ) est �quivalent �
// CPoint A = new CPoint( 0, 0 )
// if ( NULL != inst->m_Parameters )
@@ -537,13 +549,13 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* // le constructeur existe-il ?
// CBotString noname;
CBotTypResult r = pClass->CompileMethode(pClass->GivName(), var, ppVars, pStk, inst->m_nMethodeIdent);
- delete pStk->TokenStack(); // libère le supplément de pile
+ delete pStk->TokenStack(); // lib�re le suppl�ment de pile
int typ = r.GivType();
if (typ == TX_UNDEFCALL)
{
// si le constructeur n'existe pas
- if (inst->m_Parameters != NULL) // avec des paramètres
+ if (inst->m_Parameters != NULL) // avec des param�tres
{
pStk->SetError(TX_NOCONST, vartoken);
goto error;
@@ -582,27 +594,27 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* // if ( !bIntrinsic ) var->SetPointer(pStk->GivVar()->GivPointer());
if ( !bIntrinsic )
{
- // n'utilise pas le résultat sur la pile, pour imposer la classe
+ // n'utilise pas le r�sultat sur la pile, pour imposer la classe
CBotVar* pvar = CBotVar::Create("", pClass);
- var->SetPointer( pvar ); // var déjà déclarée pointe l'instance
+ var->SetPointer( pvar ); // var d�j� d�clar�e pointe l'instance
delete pvar; // supprime le second pointeur
}
var->SetInit(TRUE); // marque le pointeur comme init
}
else if (inst->m_hasParams)
{
- // crée l'objet sur le "tas"
+ // cr�e l'objet sur le "tas"
// avec un pointeur sur cet objet
if ( !bIntrinsic )
{
CBotVar* pvar = CBotVar::Create("", pClass);
- var->SetPointer( pvar ); // var déjà déclarée pointe l'instance
+ var->SetPointer( pvar ); // var d�j� d�clar�e pointe l'instance
delete pvar; // supprime le second pointeur
}
var->SetInit(2); // marque le pointeur comme init
}
suite:
- if (IsOfType(p, ID_COMMA)) // plusieurs définitions enchaînées
+ if (IsOfType(p, ID_COMMA)) // plusieurs d�finitions encha�n�es
{
if ( NULL != ( inst->m_next = CBotClassInst::Compile(p, pStk, pClass) )) // compile la suivante
{
@@ -610,7 +622,7 @@ suite: }
}
- if (IsOfType(p, ID_SEP)) // instruction terminée
+ if (IsOfType(p, ID_SEP)) // instruction termin�e
{
return pStack->Return(inst, pStk);
}
@@ -623,7 +635,7 @@ error: return pStack->Return(NULL, pStk);
}
-// déclaration de l'instance d'une classe, par exemple:
+// d�claration de l'instance d'une classe, par exemple:
// CPoint A, B;
BOOL CBotClassInst::Execute(CBotStack* &pj)
@@ -638,7 +650,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) BOOL bIntrincic = pClass->IsIntrinsic();
- // crée la variable de type pointeur à l'objet
+ // cr�e la variable de type pointeur � l'objet
if ( pile->GivState()==0)
{
@@ -652,7 +664,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) pThis = CBotVar::Create(name, CBotTypResult( CBotTypPointer, pClass ));
}
- pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un numéro unique
+ pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un num�ro unique
pile->AddVar(pThis); // la place sur la pile
pile->IncState();
}
@@ -661,13 +673,13 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) if ( pile->GivState()<3)
{
- // y a-t-il une assignation ou des paramètres (constructeur)
+ // y a-t-il une assignation ou des param�tres (constructeur)
// CBotVarClass* pInstance = NULL;
if ( m_expr != NULL )
{
- // évalue l'expression pour l'assignation
+ // �value l'expression pour l'assignation
if (!m_expr->Execute(pile)) return FALSE;
if ( bIntrincic )
@@ -691,14 +703,14 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) else if ( m_hasParams )
{
- // évalue le constructeur d'une instance
+ // �value le constructeur d'une instance
if ( !bIntrincic && pile->GivState() == 1)
{
CBotToken* pt = &m_token;
CBotClass* pClass = CBotClass::Find(pt);
- // crée une instance de la classe demandée
+ // cr�e une instance de la classe demand�e
CBotVarClass* pInstance;
pInstance = (CBotVarClass*)CBotVar::Create("", pClass);
@@ -714,13 +726,13 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->AddStack(); // de la place sur la pile pour les résultats
+ pile2 = pile2->AddStack(); // de la place sur la pile pour les r�sultats
if ( pile2->GivState() == 0 )
{
if (!p->Execute(pile2)) return FALSE; // interrompu ici ?
@@ -732,7 +744,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) }
ppVars[i] = NULL;
- // crée une variable pour le résultat
+ // cr�e une variable pour le r�sultat
CBotVar* pResult = NULL; // constructeurs toujours void
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(),
@@ -740,8 +752,8 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) pResult, pile2, GivToken())) return FALSE; // interrompu
pThis->SetInit(TRUE);
- pThis->ConstructorSet(); // signale que le constructeur a été appelé
- pile->Return(pile2); // libère un bout de pile
+ pThis->ConstructorSet(); // signale que le constructeur a �t� appel�
+ pile->Return(pile2); // lib�re un bout de pile
// pInstance = pThis->GivPointer();
@@ -755,7 +767,7 @@ BOOL CBotClassInst::Execute(CBotStack* &pj) if ( pile->IfStep() ) return FALSE;
if ( m_next2b != NULL &&
- !m_next2b->Execute(pile)) return FALSE; // autre(s) définition(s)
+ !m_next2b->Execute(pile)) return FALSE; // autre(s) d�finition(s)
return pj->Return( pile ); // transmet en dessous
}
@@ -770,11 +782,11 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) if ( bMain ) pile = pj->RestoreStack(this);
if ( pile == NULL ) return;
- // crée la variable de type pointeur à l'objet
+ // cr�e la variable de type pointeur � l'objet
{
CBotString name = m_var->m_token.GivString();
pThis = pile->FindVar(name);
- pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un numéro unique
+ pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // lui attribut un num�ro unique
}
CBotToken* pt = &m_token;
@@ -783,20 +795,20 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) if ( bMain && pile->GivState()<3)
{
- // y a-t-il une assignation ou des paramètres (constructeur)
+ // y a-t-il une assignation ou des param�tres (constructeur)
// CBotVarClass* pInstance = NULL;
if ( m_expr != NULL )
{
- // évalue l'expression pour l'assignation
+ // �value l'expression pour l'assignation
m_expr->RestoreState(pile, bMain);
return;
}
else if ( m_hasParams )
{
- // évalue le constructeur d'une instance
+ // �value le constructeur d'une instance
if ( !bIntrincic && pile->GivState() == 1)
{
@@ -809,13 +821,13 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile2 = pile2->RestoreStack(); // de la place sur la pile pour les résultats
+ pile2 = pile2->RestoreStack(); // de la place sur la pile pour les r�sultats
if ( pile2 == NULL ) return;
if ( pile2->GivState() == 0 )
@@ -829,7 +841,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) }
ppVars[i] = NULL;
- // crée une variable pour le résultat
+ // cr�e une variable pour le r�sultat
CBotVar* pResult = NULL; // constructeurs toujours void
pClass->RestoreMethode(m_nMethodeIdent, pClass->GivName(), pThis, ppVars, pile2);
@@ -838,11 +850,11 @@ void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain) }
if ( m_next2b != NULL )
- m_next2b->RestoreState(pile, bMain); // autre(s) définition(s)
+ m_next2b->RestoreState(pile, bMain); // autre(s) d�finition(s)
}
-// test si un nom de procédure est déjà défini quelque part
+// test si un nom de proc�dure est d�j� d�fini quelque part
BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
@@ -855,7 +867,7 @@ BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) {
if ( pToken->GivString() == pp->GivName() )
{
- // les paramètres sont-ils exactement les mêmes ?
+ // les param�tres sont-ils exactement les m�mes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
}
diff --git a/src/CBot/CBotCompExpr.cpp b/src/CBot/CBotCompExpr.cpp index 99abfb9..7618e4a 100644 --- a/src/CBot/CBotCompExpr.cpp +++ b/src/CBot/CBotCompExpr.cpp @@ -1,7 +1,18 @@ -///////////////////////////////////////////////////
-// expression du genre Opérande1 > Opérande2
-// Opérande1 != Opérande2
-// etc.
+// * 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"
@@ -28,7 +39,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotCStack* pStk = pStack->AddStack();
- CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B à gauche
+ CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B � gauche
if (left == NULL) return pStack->Return(NULL, pStk); // erreur
if ( p->GetType() == ID_HI ||
@@ -38,22 +49,22 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) p->GetType() == ID_EQ ||
p->GetType() == ID_NE) // les diverses comparaisons
{
- CBotCompExpr* inst = new CBotCompExpr(); // élément pour opération
- inst->SetToken(p); // mémorise l'opération
+ CBotCompExpr* inst = new CBotCompExpr(); // �l�ment pour op�ration
+ inst->SetToken(p); // m�morise l'op�ration
int type1, type2;
type1 = pStack->GetType();
p = p->Next();
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B à droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B � droite
{
type2 = pStack->GetType();
- // les résultats sont-ils compatibles
+ // les r�sultats sont-ils compatibles
if ( type1 == type2 )
{
inst->m_leftop = left;
pStk->SetVar(new CBotVar(NULL, CBotTypBoolean));
- // le résultat est un boolean
+ // le r�sultat est un boolean
return pStack->Return(inst, pStk);
}
}
@@ -67,7 +78,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) }
-// fait l'opération
+// fait l'op�ration
BOOL CBotCompExpr::Execute(CBotStack* &pStack)
{
@@ -76,9 +87,9 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) if ( pStk1->GetState() == 0 && !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- pStk1->SetState(1); // opération terminée
+ pStk1->SetState(1); // op�ration termin�e
- // 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
CBotStack* pStk2 = pStk1->AddStack();
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
@@ -91,27 +102,27 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) switch (GetTokenType())
{
case ID_LO:
- result->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
+ result->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
break;
case ID_HI:
- result->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
+ result->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
break;
case ID_LS:
- result->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
+ result->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
break;
case ID_HS:
- result->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
+ result->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
break;
case ID_EQ:
- result->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
+ result->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
break;
case ID_NE:
- result->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
+ result->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
break;
}
- pStk2->SetVar(result); // met le résultat sur la pile
+ 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
+ pStk1->Return(pStk2); // lib�re la pile
+ return pStack->Return(pStk1); // transmet le r�sultat
}
diff --git a/src/CBot/CBotDll.h b/src/CBot/CBotDll.h index 4e0c5b1..973ccdb 100644 --- a/src/CBot/CBotDll.h +++ b/src/CBot/CBotDll.h @@ -1,7 +1,18 @@ -////////////////////////////////////////////////////////////////////////
-// Librairie pour l'interprétation du language CBOT
-// pour le jeu COLOBOT
-//
+// * 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 "stdafx.h"
@@ -13,26 +24,26 @@ #define CBOTVERSION 104
////////////////////////////////////////////////////////////////////////
-// quelques classes définies par ailleurs
+// quelques classes d�finies par ailleurs
-class CBotToken; // programme transformé en "jetons"
-class CBotStack; // pile pour l'exécution
+class CBotToken; // programme transform� en "jetons"
+class CBotStack; // pile pour l'ex�cution
class CBotClass; // classe d'object
-class CBotInstr; // instruction à exécuter
+class CBotInstr; // instruction � ex�cuter
class CBotFunction; // les fonctions user
class CBotVar; // les variables
class CBotVarClass; // une instance de classe
-class CBotVarPointer; // pointeur à une instance de classe
+class CBotVarPointer; // pointeur � une instance de classe
class CBotCall; // les fonctions
-class CBotCallMethode; // les méthodes
-class CBotDefParam; // liste de paramètres
+class CBotCallMethode; // les m�thodes
+class CBotDefParam; // liste de param�tres
////////////////////////////////////////////////////////////////////////
// Gestion des variables
////////////////////////////////////////////////////////////////////////
-// ces types sont calqués sur les types Java
+// ces types sont calqu�s sur les types Java
// ne pas changer l'ordre de ces types
enum CBotType
@@ -40,24 +51,24 @@ enum CBotType CBotTypVoid = 0, // fonction retournant void
CBotTypByte = 1, //n // nombre entier ( 8 bits)
CBotTypShort = 2, //n // nombre entier (16 bits)
- CBotTypChar = 3, //n // caractère "unicode" (16 bits)
+ CBotTypChar = 3, //n // caract�re "unicode" (16 bits)
CBotTypInt = 4, // nombre entier (32 bits)
CBotTypLong = 5, //n // nombre entier (64 bits)
- CBotTypFloat = 6, // nombre décimal (32 bits)
- CBotTypDouble = 7, //n // nombre décimal (64 bits)
+ CBotTypFloat = 6, // nombre d�cimal (32 bits)
+ CBotTypDouble = 7, //n // nombre d�cimal (64 bits)
CBotTypBoolean = 8, // true ou false exclusivement
- CBotTypString = 9, // chaine de caractère
+ CBotTypString = 9, // chaine de caract�re
CBotTypArrayPointer = 10, // un tableau de variables
- CBotTypArrayBody = 11, // idem mais crée l'instance
+ CBotTypArrayBody = 11, // idem mais cr�e l'instance
- CBotTypPointer = 12, // pointeur à une instance
- CBotTypNullPointer = 13, // pointeur null est spécial
+ CBotTypPointer = 12, // pointeur � une instance
+ CBotTypNullPointer = 13, // pointeur null est sp�cial
CBotTypClass = 15, // instance d'une classe
- CBotTypIntrinsic = 16 // instance d'une classe intrinsèque
+ CBotTypIntrinsic = 16 // instance d'une classe intrins�que
};
- //n = non encore implémenté
+ //n = non encore impl�ment�
// pour SetUserPtr lors de la suppression d'un objet
#define OBJECTDELETED ((void*)-1)
@@ -65,13 +76,13 @@ enum CBotType #define OBJECTCREATED ((void*)-2)
-// classe permettant de définir le type complet d'un résultat
+// classe permettant de d�finir le type complet d'un r�sultat
class CBotTypResult
{
private:
int m_type;
CBotTypResult* m_pNext; // pour les types de types
- CBotClass* m_pClass; // pour les dérivés de classe
+ CBotClass* m_pClass; // pour les d�riv�s de classe
int m_limite; // limitation des tableaux
friend class CBotVarClass;
friend class CBotVarPointer;
@@ -80,13 +91,13 @@ public: // divers constructeurs selon les besoins
DllExport
CBotTypResult(int type);
- // pour les types simples (CBotTypInt à CBotTypString)
+ // pour les types simples (CBotTypInt � CBotTypString)
DllExport
CBotTypResult(int type, const char* name);
// pour les types pointeur et classe intrinsic
DllExport
CBotTypResult(int type, CBotClass* pClass);
- // idem à partir de l'instance d'une classe
+ // idem � partir de l'instance d'une classe
DllExport
CBotTypResult(int type, CBotTypResult elem);
// pour les tableaux de variables
@@ -96,20 +107,20 @@ public: // pour les assignations
DllExport
CBotTypResult();
- // pour par défaut
+ // pour par d�faut
DllExport
~CBotTypResult();
DllExport
int GivType(int mode = 0);
- // rend le type CBotTyp* du résultat
+ // rend le type CBotTyp* du r�sultat
void SetType(int n);
// modifie le type
DllExport
CBotClass* GivClass();
- // rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer)
+ // rend le pointeur � la classe (pour les CBotTypClass, CBotTypPointer)
DllExport
int GivLimite();
@@ -124,7 +135,7 @@ public: DllExport
CBotTypResult& GivTypElem();
- // rend le type des éléments du tableau (CBotTypArray)
+ // rend le type des �l�ments du tableau (CBotTypArray)
DllExport
BOOL Compare(CBotTypResult& typ);
@@ -140,7 +151,7 @@ public: };
/*
-// pour définir un résultat en sortie, utiliser par exemple
+// pour d�finir un r�sultat en sortie, utiliser par exemple
// pour rendre un simple Float
return CBotTypResult( CBotTypFloat );
@@ -157,16 +168,16 @@ public: ////////////////////////////////////////////////////////////////////////
-// Gestion des erreurs compilation et exécution
+// Gestion des erreurs compilation et ex�cution
////////////////////////////////////////////////////////////////////////
-// voici la liste des erreurs pouvant être retournées par le module
+// voici la liste des erreurs pouvant �tre retourn�es par le module
// pour la compilation
-#define CBotErrOpenPar 5000 // manque la parenthèse ouvrante
-#define CBotErrClosePar 5001 // manque la parenthèse fermante
-#define CBotErrNotBoolean 5002 // l'expression doit être un boolean
-#define CBotErrUndefVar 5003 // variable non déclarée
+#define CBotErrOpenPar 5000 // manque la parenth�se ouvrante
+#define CBotErrClosePar 5001 // manque la parenth�se fermante
+#define CBotErrNotBoolean 5002 // l'expression doit �tre un boolean
+#define CBotErrUndefVar 5003 // variable non d�clar�e
#define CBotErrBadLeft 5004 // assignation impossible ( 5 = ... )
#define CBotErrNoTerminator 5005 // point-virgule attendu
#define CBotErrCaseOut 5006 // case en dehors d'un switch
@@ -175,8 +186,8 @@ public: #define CBotErrElseWhitoutIf 5009 // else sans if correspondant
#define CBotErrOpenBlock 5010 // manque " { "
#define CBotErrBadType1 5011 // mauvais type pour l'assignation
-#define CBotErrRedefVar 5012 // redéfinition de la variable
-#define CBotErrBadType2 5013 // 2 opérandes de type incompatibles
+#define CBotErrRedefVar 5012 // red�finition de la variable
+#define CBotErrBadType2 5013 // 2 op�randes de type incompatibles
#define CBotErrUndefCall 5014 // routine inconnue
#define CBotErrNoDoubleDots 5015 // " : " attendu
// CBotErrWhile 5016, plus utile
@@ -186,63 +197,63 @@ public: #define CBotErrNoCase 5020 // manque " case "
#define CBotErrBadNum 5021 // nombre attendu
#define CBotErrVoid 5022 // " void " pas possible ici
-#define CBotErrNoType 5023 // déclaration de type attendue
+#define CBotErrNoType 5023 // d�claration de type attendue
#define CBotErrNoVar 5024 // nom de variable attendu
#define CBotErrNoFunc 5025 // nom de fonction attendu
-#define CBotErrOverParam 5026 // trop de paramètres
-#define CBotErrRedefFunc 5027 // cette fonction existe déjà
-#define CBotErrLowParam 5028 // pas assez de paramètres
-#define CBotErrBadParam 5029 // mauvais types de paramètres
-#define CBotErrNbParam 5030 // mauvais nombre de paramètres
-#define CBotErrUndefItem 5031 // élément n'existe pas dans la classe
+#define CBotErrOverParam 5026 // trop de param�tres
+#define CBotErrRedefFunc 5027 // cette fonction existe d�j�
+#define CBotErrLowParam 5028 // pas assez de param�tres
+#define CBotErrBadParam 5029 // mauvais types de param�tres
+#define CBotErrNbParam 5030 // mauvais nombre de param�tres
+#define CBotErrUndefItem 5031 // �l�ment n'existe pas dans la classe
#define CBotErrUndefClass 5032 // variable n'est pas une classe
-#define CBotErrNoConstruct 5033 // pas de constructeur approprié
-#define CBotErrRedefClass 5034 // classe existe déjà
+#define CBotErrNoConstruct 5033 // pas de constructeur appropri�
+#define CBotErrRedefClass 5034 // classe existe d�j�
#define CBotErrCloseIndex 5035 // " ] " attendu
-#define CBotErrReserved 5036 // mot réservé (par un DefineNum)
-#define CBotErrBadNew 5037 // mauvais paramètre pour new
+#define CBotErrReserved 5036 // mot r�serv� (par un DefineNum)
+#define CBotErrBadNew 5037 // mauvais param�tre pour new
#define CBotErrOpenIndex 5038 // " [ " attendu
-#define CBotErrBadString 5039 // chaîne de caractère attendue
+#define CBotErrBadString 5039 // cha�ne de caract�re attendue
#define CBotErrBadIndex 5040 // mauvais type d'index "[ false ]"
-#define CBotErrPrivate 5041 // élément protégé
+#define CBotErrPrivate 5041 // �l�ment prot�g�
#define CBotErrNoPublic 5042 // manque le mot "public"
-// voici la liste des erreurs pouvant être retournées par le module
-// pour l'exécution
+// voici la liste des erreurs pouvant �tre retourn�es par le module
+// pour l'ex�cution
-#define CBotErrZeroDiv 6000 // division par zéro
-#define CBotErrNotInit 6001 // variable non initialisée
-#define CBotErrBadThrow 6002 // throw d'une valeur négative
-#define CBotErrNoRetVal 6003 // fonction n'a pas retourné de résultat
+#define CBotErrZeroDiv 6000 // division par z�ro
+#define CBotErrNotInit 6001 // variable non initialis�e
+#define CBotErrBadThrow 6002 // throw d'une valeur n�gative
+#define CBotErrNoRetVal 6003 // fonction n'a pas retourn� de r�sultat
#define CBotErrNoRun 6004 // Run() sans fonction active
#define CBotErrUndefFunc 6005 // appel d'une fonction qui n'existe plus
#define CBotErrNotClass 6006 // cette classe n'existe pas
#define CBotErrNull 6007 // pointeur null
#define CBotErrNan 6008 // calcul avec un NAN
#define CBotErrOutArray 6009 // index hors du tableau
-#define CBotErrStackOver 6010 // dépassement de la pile
-#define CBotErrDeletedPtr 6011 // pointeur à un objet détruit
+#define CBotErrStackOver 6010 // d�passement de la pile
+#define CBotErrDeletedPtr 6011 // pointeur � un objet d�truit
#define CBotErrFileOpen 6012 // ouverture du fichier impossible
#define CBotErrNotOpen 6013 // canal pas ouvert
-#define CBotErrRead 6014 // erreur à la lecture
-#define CBotErrWrite 6015 // erreur à l'écriture
+#define CBotErrRead 6014 // erreur � la lecture
+#define CBotErrWrite 6015 // erreur � l'�criture
-// d'autres valeurs peuvent être rendues
+// d'autres valeurs peuvent �tre rendues
// par exemple les exceptions rendues par les routines externes
// et les " throw " avec un nombre quelconque.
////////////////////////////////////////////////////////////////////////
-// définie une classe pour l'utilisation des strings
-// car CString fait partie de MFC pas utilisé ici.
+// d�finie une classe pour l'utilisation des strings
+// car CString fait partie de MFC pas utilis� ici.
//
-// ( toutes les fonctions ne sont pas encore implémentées )
+// ( toutes les fonctions ne sont pas encore impl�ment�es )
class CBotString
{
private:
- char* m_ptr; // pointeur à la chaine
+ char* m_ptr; // pointeur � la chaine
int m_lg; // longueur de la chaine
static
HINSTANCE m_hInstance;
@@ -349,9 +360,9 @@ public: class CBotStringArray : public CBotString
{
private:
- int m_nSize; // nombre d'éléments
- int m_nMaxSize; // taille réservée
- CBotString* m_pData; // ^aux données
+ int m_nSize; // nombre d'�l�ments
+ int m_nMaxSize; // taille r�serv�e
+ CBotString* m_pData; // ^aux donn�es
public:
DllExport
@@ -371,7 +382,7 @@ public: CBotString& ElementAt(int nIndex);
};
-// différents mode pour GetPosition
+// diff�rents mode pour GetPosition
enum CBotGet
{
GetPosExtern = 1,
@@ -381,16 +392,16 @@ enum CBotGet };
////////////////////////////////////////////////////////////////////
-// classe principale gérant un programme CBot
+// classe principale g�rant un programme CBot
//
class CBotProgram
{
private:
- CBotFunction* m_Prog; // les fonctions définies par l'utilisateur
- CBotFunction* m_pRun; // la fonction de base pour l'exécution
- CBotClass* m_pClass; // les classes définies dans cette partie
- CBotStack* m_pStack; // la pile d'exécution
+ CBotFunction* m_Prog; // les fonctions d�finies par l'utilisateur
+ CBotFunction* m_pRun; // la fonction de base pour l'ex�cution
+ CBotClass* m_pClass; // les classes d�finies dans cette partie
+ CBotStack* m_pStack; // la pile d'ex�cution
CBotVar* m_pInstance; // instance de la classe parent
friend class CBotFunction;
@@ -398,12 +409,12 @@ private: int m_ErrorStart;
int m_ErrorEnd;
- long m_Ident; // identificateur associé
+ long m_Ident; // identificateur associ�
public:
static
CBotString m_DebugVarStr; // a fin de debug
- BOOL m_bDebugDD; // idem déclanchable par robot
+ BOOL m_bDebugDD; // idem d�clanchable par robot
BOOL m_bCompileClass;
@@ -411,12 +422,12 @@ public: DllExport
static
void Init();
- // initialise le module (défini les mots clefs pour les erreurs)
- // doit être fait une fois (et une seule) au tout début
+ // initialise le module (d�fini les mots clefs pour les erreurs)
+ // doit �tre fait une fois (et une seule) au tout d�but
DllExport
static
void Free();
- // libère les zones mémoires statiques
+ // lib�re les zones m�moires statiques
DllExport
static
@@ -433,11 +444,11 @@ public: DllExport
BOOL Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
- // compile le programme donné en texte
- // retourne FALSE s'il y a une erreur à la compilation
- // voir GetCompileError() pour récupérer l'erreur
- // ListFonctions retourne le nom des fonctions déclarées extern
- // pUser permet de passer un pointeur pour les routines définies par AddFunction
+ // compile le programme donn� en texte
+ // retourne FALSE s'il y a une erreur � la compilation
+ // voir GetCompileError() pour r�cup�rer l'erreur
+ // ListFonctions retourne le nom des fonctions d�clar�es extern
+ // pUser permet de passer un pointeur pour les routines d�finies par AddFunction
DllExport
void SetIdent(long n);
@@ -454,10 +465,10 @@ public: DllExport
BOOL GetError(int& code, int& start, int& end, CBotProgram* &pProg);
// si TRUE
- // donne l'erreur trouvée à la compilation
- // ou à l'exécution
- // start et end délimite le bloc où se trouve l'erreur
- // pProg permet de savoir dans quel "module" s'est produite l'erreur d'exécution
+ // donne l'erreur trouv�e � la compilation
+ // ou � l'ex�cution
+ // start et end d�limite le bloc o� se trouve l'erreur
+ // pProg permet de savoir dans quel "module" s'est produite l'erreur d'ex�cution
DllExport
static
CBotString GivErrorText(int code);
@@ -465,42 +476,42 @@ public: DllExport
BOOL Start(const char* name);
- // définie quelle fonction doit être exécutée
- // retourne FALSE si la fontion name n'est pas trouvée
+ // d�finie quelle fonction doit �tre ex�cut�e
+ // retourne FALSE si la fontion name n'est pas trouv�e
// le programme ne fait rien, il faut appeller Run() pour cela
DllExport
BOOL Run(void* pUser = NULL, int timer = -1);
- // exécute le programme
- // retourne FALSE si le programme a été suspendu
- // retourne TRUE si le programme s'est terminé avec ou sans erreur
- // timer = 0 permet de faire une avance pas à pas
+ // ex�cute le programme
+ // retourne FALSE si le programme a �t� suspendu
+ // retourne TRUE si le programme s'est termin� avec ou sans erreur
+ // timer = 0 permet de faire une avance pas � pas
DllExport
BOOL GetRunPos(const char* &FunctionName, int &start, int &end);
- // donne la position dans le programme en exécution
- // retourne FALSE si on n'est pas en exécution (programme terminé)
+ // donne la position dans le programme en ex�cution
+ // retourne FALSE si on n'est pas en ex�cution (programme termin�)
// FunctionName est un pointeur rendu sur le nom de la fonction
// start et end la position dans le texte du token en traitement
DllExport
CBotVar* GivStackVars(const char* &FunctionName, int level);
- // permet d'obtenir le pointeur aux variables sur la pile d'exécution
- // level est un paramètre d'entrée, 0 pour le dernier niveau, -1, -2, etc pour les autres niveau
- // la valeur retournée (CBotVar*) est une liste de variable (ou NULL)
- // qui peut être traité que la liste des paramètres reçu par une routine
- // FunctionName donne le nom de la fonction où se trouvent ces variables
+ // permet d'obtenir le pointeur aux variables sur la pile d'ex�cution
+ // level est un param�tre d'entr�e, 0 pour le dernier niveau, -1, -2, etc pour les autres niveau
+ // la valeur retourn�e (CBotVar*) est une liste de variable (ou NULL)
+ // qui peut �tre trait� que la liste des param�tres re�u par une routine
+ // FunctionName donne le nom de la fonction o� se trouvent ces variables
// FunctionName == NULL signifiant qu'on est plus dans le programme (selon level)
DllExport
void Stop();
- // arrête l'exécution du programme
+ // arr�te l'ex�cution du programme
// quitte donc le mode "suspendu"
DllExport
static
void SetTimer(int n);
- // défini le nombre de pas (parties d'instructions) à faire
+ // d�fini le nombre de pas (parties d'instructions) � faire
// dans Run() avant de rendre la main "FALSE"
DllExport
@@ -508,7 +519,7 @@ public: BOOL AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
- // cet appel permet d'ajouter de manière externe (**)
+ // cet appel permet d'ajouter de mani�re externe (**)
// une nouvelle fonction utilisable par le programme CBot
DllExport
@@ -517,20 +528,20 @@ public: DllExport
BOOL SaveState(FILE* pf);
- // sauvegarde l'état d'exécution dans le fichier
- // le fichier doit avoir été ouvert avec l'appel fopen de cette dll
- // sinon le système plante
+ // sauvegarde l'�tat d'ex�cution dans le fichier
+ // le fichier doit avoir �t� ouvert avec l'appel fopen de cette dll
+ // sinon le syst�me plante
DllExport
BOOL RestoreState(FILE* pf);
- // rétablie l'état de l'exécution depuis le fichier
- // le programme compilé doit évidemment être identique
+ // r�tablie l'�tat de l'ex�cution depuis le fichier
+ // le programme compil� doit �videmment �tre identique
DllExport
BOOL GetPosition(const char* name, int& start, int& stop,
CBotGet modestart = GetPosExtern,
CBotGet modestop = GetPosBloc);
// donne la position d'une routine dans le texte d'origine
- // le mode permet de choisir l'élément à trouver pour le début et la fin
+ // le mode permet de choisir l'�l�ment � trouver pour le d�but et la fin
// voir les modes ci-dessus dans CBotGet
@@ -553,21 +564,21 @@ public: #if 0
/*
(**) Note:
- Pour définir une fonction externe, il faut procéder ainsi:
+ Pour d�finir une fonction externe, il faut proc�der ainsi:
- a) définir une routine pour la compilation
- cette routine reçois la liste des paramètres (sans valeurs)
- et retourne soit un type de résultat (CBotTyp... ou 0 = void)
- soit un numéro d'erreur
- b) définir une routine pour l'exécution
- cette rourine reCoit la liste des paramètres (avec valeurs),
- une variable pour stocker le résultat (selon le type donné à la compilation)
+ a) d�finir une routine pour la compilation
+ cette routine re�ois la liste des param�tres (sans valeurs)
+ et retourne soit un type de r�sultat (CBotTyp... ou 0 = void)
+ soit un num�ro d'erreur
+ b) d�finir une routine pour l'ex�cution
+ cette rourine reCoit la liste des param�tres (avec valeurs),
+ une variable pour stocker le r�sultat (selon le type donn� � la compilation)
- Par exemple, une routine qui calcule la moyenne d'une liste de paramètres */
+ Par exemple, une routine qui calcule la moyenne d'une liste de param�tres */
int cMoyenne(CBotVar* &pVar, CBotString& ClassName)
{
- if ( pVar == NULL ) return 6001; // il n'y a aucun paramètre !
+ if ( pVar == NULL ) return 6001; // il n'y a aucun param�tre !
while ( pVar != NULL )
{
@@ -575,7 +586,7 @@ int cMoyenne(CBotVar* &pVar, CBotString& ClassName) pVar = pVar -> GivNext();
}
- return CBotTypFloat; // le type du résultat pourrait dépendre des paramètres !
+ return CBotTypFloat; // le type du r�sultat pourrait d�pendre des param�tres !
}
@@ -591,7 +602,7 @@ BOOL rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception) }
pResult->SetValFloat(total/nb); // retourne la valeur moyenne
- return TRUE; // opération totalement terminée
+ return TRUE; // op�ration totalement termin�e
}
#endif
@@ -599,20 +610,20 @@ BOOL rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception) /////////////////////////////////////////////////////////////////////////////////
// Classe pour la gestion des variables
-// les méthodes marquées DllExport
-// peuvent être utile à l'exterieur du module
-// ( il n'est pour l'instant pas prévu de pouvoir créer ces objets en externe )
+// les m�thodes marqu�es DllExport
+// peuvent �tre utile � l'exterieur du module
+// ( il n'est pour l'instant pas pr�vu de pouvoir cr�er ces objets en externe )
-// résultats pour GivInit()
-#define IS_UNDEF 0 // variable indéfinie
-#define IS_DEF 1 // variable définie
-#define IS_NAN 999 // variable définie comme étant not a number
+// r�sultats pour GivInit()
+#define IS_UNDEF 0 // variable ind�finie
+#define IS_DEF 1 // variable d�finie
+#define IS_NAN 999 // variable d�finie comme �tant not a number
// type de variable SetPrivate / IsPrivate
#define PR_PUBLIC 0 // variable publique
#define PR_READ 1 // read only
-#define PR_PROTECT 2 // protected (héritage)
-#define PR_PRIVATE 3 // strictement privée
+#define PR_PROTECT 2 // protected (h�ritage)
+#define PR_PRIVATE 3 // strictement priv�e
class CBotVar
{
@@ -627,11 +638,11 @@ protected: CBotTypResult m_type; // type de valeur
- int m_binit; // pas initialisée ?
- CBotVarClass* m_pMyThis; // ^élément this correspondant
- void* m_pUserPtr; // ^données user s'il y a lieu
- BOOL m_bStatic; // élément static (dans une classe)
- int m_mPrivate; // élément public, protected ou private ?
+ int m_binit; // pas initialis�e ?
+ CBotVarClass* m_pMyThis; // ^�l�ment this correspondant
+ void* m_pUserPtr; // ^donn�es user s'il y a lieu
+ BOOL m_bStatic; // �l�ment static (dans une classe)
+ int m_mPrivate; // �l�ment public, protected ou private ?
CBotInstr* m_InitExpr; // expression pour le contenu initial
CBotInstr* m_LimExpr; // liste des limites pour un tableau
@@ -651,12 +662,12 @@ virtual ~CBotVar( ); // destructeur /* DllExport
static
CBotVar* Create( const char* name, int type, const char* ClassName = NULL);
- // crée une variable selon son type,*/
+ // cr�e une variable selon son type,*/
DllExport
static
CBotVar* Create( const char* name, CBotTypResult type);
- // idem à partir du type complet
+ // idem � partir du type complet
DllExport
static
@@ -677,16 +688,16 @@ virtual ~CBotVar( ); // destructeur DllExport
void SetUserPtr(void* pUser);
- // associe un pointeur utilisateur à une instance
+ // associe un pointeur utilisateur � une instance
DllExport
virtual void SetIdent(long UniqId);
- // associe un identificateur unique à une instance
- // ( c'est à l'utilisateur de s'assurer que l'id est unique)
+ // associe un identificateur unique � une instance
+ // ( c'est � l'utilisateur de s'assurer que l'id est unique)
DllExport
void* GivUserPtr();
- // rend le pointeur associé à la variable
+ // rend le pointeur associ� � la variable
DllExport
CBotString GivName(); // le nom de la variable, s'il est connu
@@ -705,10 +716,10 @@ virtual ~CBotVar( ); // destructeur void SetType(CBotTypResult& type);
DllExport
- void SetInit(int bInit); // met la variable dans l'état IS_UNDEF, IS_DEF, IS_NAN
+ void SetInit(int bInit); // met la variable dans l'�tat IS_UNDEF, IS_DEF, IS_NAN
DllExport
- int GivInit(); // donne l'état de la variable
+ int GivInit(); // donne l'�tat de la variable
DllExport
void SetStatic(BOOL bStatic);
@@ -729,9 +740,9 @@ virtual ~CBotVar( ); // destructeur DllExport
virtual
- CBotVar* GivItem(const char* name); // rend un élément d'une classe selon son nom (*)
+ CBotVar* GivItem(const char* name); // rend un �l�ment d'une classe selon son nom (*)
virtual
- CBotVar* GivItemRef(int nIdent); // idem à partir du n° ref
+ CBotVar* GivItemRef(int nIdent); // idem � partir du n� ref
DllExport
virtual
@@ -739,18 +750,18 @@ virtual ~CBotVar( ); // destructeur DllExport
virtual
- CBotVar* GivItemList(); // donne la liste des éléments
+ CBotVar* GivItemList(); // donne la liste des �l�ments
DllExport
- CBotVar* GivStaticVar(); // rend le pointeur à la variable si elle est statique
+ CBotVar* GivStaticVar(); // rend le pointeur � la variable si elle est statique
DllExport
BOOL IsElemOfClass(const char* name);
- // dit si l'élément appartient à la classe "name"
+ // dit si l'�l�ment appartient � la classe "name"
// rend TRUE si l'objet est d'une classe fille
DllExport
- CBotVar* GivNext(); // prochaine variable dans la liste (paramètres)
+ CBotVar* GivNext(); // prochaine variable dans la liste (param�tres)
////////////////////////////////////////////////////////////////////////////////////////////
void AddNext(CBotVar* pVar); // ajoute dans une liste
@@ -760,27 +771,27 @@ virtual ~CBotVar( ); // destructeur DllExport
virtual void SetValInt(int val, const char* name = NULL);
- // initialise avec une valeur entière (#)
+ // initialise avec une valeur enti�re (#)
/////////////////////////////////////////////////////////////////////////////////
DllExport
- virtual void SetValFloat(float val); // initialise avec une valeur réelle (#)
+ virtual void SetValFloat(float val); // initialise avec une valeur r�elle (#)
////////////////////////////////////////////////////////////////////////////////
DllExport
- virtual void SetValString(const char* p);// initialise avec une valeur chaîne (#)
+ virtual void SetValString(const char* p);// initialise avec une valeur cha�ne (#)
////////////////////////////////////////////////////////////////////////////////
DllExport
- virtual int GivValInt(); // demande la valeur entière (#)
+ virtual int GivValInt(); // demande la valeur enti�re (#)
////////////////////////////////////////////////////////////////////////
DllExport
- virtual float GivValFloat(); // demande la valeur réelle (#)
+ virtual float GivValFloat(); // demande la valeur r�elle (#)
///////////////////////////////////////////////////////////////////////
virtual
- CBotString GivValString(); // demande la valeur chaîne (#)
+ CBotString GivValString(); // demande la valeur cha�ne (#)
///////////////////////////////////////////////////////////////////////
virtual void SetClass(CBotClass* pClass);
@@ -839,16 +850,16 @@ virtual ~CBotVar( ); // destructeur };
/* NOTE (#)
- les méthodes SetValInt() SetValFloat() et SetValString()
- ne peuvent êtes appellées qu'avec des objets respectivement entier, réelle ou chaîne
- toujours s'assurer du type de la variable avant d'appeller ces méthodes
+ les m�thodes SetValInt() SetValFloat() et SetValString()
+ ne peuvent �tes appell�es qu'avec des objets respectivement entier, r�elle ou cha�ne
+ toujours s'assurer du type de la variable avant d'appeller ces m�thodes
if ( pVar->GivType() == CBotInt() ) pVar->SetValFloat( 3.3 ); // plante !!
- les méthodes GivValInt(), GivValFloat() et GivValString()
+ les m�thodes GivValInt(), GivValFloat() et GivValString()
font des conversions de valeur,
- GivValString() fonctionne sur des nombres (rend la chaîne correspondante)
- par contre il ne faut pas faire de GivValInt() avec une variable de type chaîne !
+ GivValString() fonctionne sur des nombres (rend la cha�ne correspondante)
+ par contre il ne faut pas faire de GivValInt() avec une variable de type cha�ne !
*/
@@ -857,41 +868,41 @@ virtual ~CBotVar( ); // destructeur // Gestion des classes
////////////////////////////////////////////////////////////////////////
-// classe pour définir de nouvelle classes dans le language CBOT
-// par exemple pour définir la classe CPoint (x,y)
+// classe pour d�finir de nouvelle classes dans le language CBOT
+// par exemple pour d�finir la classe CPoint (x,y)
class CBotClass
{
private:
static
- CBotClass* m_ExClass; // liste des classes existante à un moment donné
- CBotClass* m_ExNext; // pour cette liste générale
- CBotClass* m_ExPrev; // pour cette liste générale
+ CBotClass* m_ExClass; // liste des classes existante � un moment donn�
+ CBotClass* m_ExNext; // pour cette liste g�n�rale
+ CBotClass* m_ExPrev; // pour cette liste g�n�rale
private:
CBotClass* m_pParent; // classe parent
CBotString m_name; // nom de cette classe-ci
- int m_nbVar; // nombre de variables dans la chaîne
+ int m_nbVar; // nombre de variables dans la cha�ne
CBotVar* m_pVar; // contenu de la classe
- BOOL m_bIntrinsic; // classe intrinsèque
+ BOOL m_bIntrinsic; // classe intrins�que
CBotClass* m_next; // chaine les classe
- CBotCallMethode* m_pCalls; // liste des méthodes définie en externe
- CBotFunction* m_pMethod; // liste des méthodes compilées
+ CBotCallMethode* m_pCalls; // liste des m�thodes d�finie en externe
+ CBotFunction* m_pMethod; // liste des m�thodes compil�es
void (*m_rMaj) ( CBotVar* pThis, void* pUser );
friend class CBotVarClass;
int m_cptLock; // pour Lock / UnLock
- int m_cptOne; // pour réentrance Lock
+ int m_cptOne; // pour r�entrance Lock
CBotProgram* m_ProgInLock[5];// processus en attente pour synchro
public:
- BOOL m_IsDef; // marque si est définie ou pas encore
+ BOOL m_IsDef; // marque si est d�finie ou pas encore
DllExport
CBotClass( const char* name,
CBotClass* pParent, BOOL bIntrinsic = FALSE ); // constructeur
- // Dès qu'une classe est créée, elle est connue
+ // D�s qu'une classe est cr��e, elle est connue
// partout dans CBot
- // le mode intrinsic donne une classe qui n'est pas gérée par des pointeurs
+ // le mode intrinsic donne une classe qui n'est pas g�r�e par des pointeurs
DllExport
~CBotClass( ); // destructeur
@@ -900,41 +911,41 @@ public: BOOL AddFunction(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));
- // cet appel permet d'ajouter de manière externe (**)
- // une nouvelle méthode utilisable par les objets de cette classe
+ // cet appel permet d'ajouter de mani�re externe (**)
+ // une nouvelle m�thode utilisable par les objets de cette classe
DllExport
BOOL AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) );
- // défini la routine qui sera appellée pour mettre à jour les élements de la classe
+ // d�fini la routine qui sera appell�e pour mettre � jour les �lements de la classe
DllExport
BOOL AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);
- // ajoute un élément à la classe
+ // ajoute un �l�ment � la classe
// DllExport
// BOOL AddItem(CBotString name, CBotClass* pClass);
- // idem pour des éléments appartenant à pClass
+ // idem pour des �l�ments appartenant � pClass
DllExport
BOOL AddItem(CBotVar* pVar);
- // idem en passant le pointeur à une instance d'une variable
- // l'objet est pris tel quel, il ne faut donc pas le détruire
+ // idem en passant le pointeur � une instance d'une variable
+ // l'objet est pris tel quel, il ne faut donc pas le d�truire
- // idem en donnant un élément de type CBotVar
+ // idem en donnant un �l�ment de type CBotVar
void AddNext(CBotClass* pClass);
DllExport
CBotString GivName(); // rend le nom de la classe
DllExport
- CBotClass* GivParent(); // donne la classe père (ou NULL)
+ CBotClass* GivParent(); // donne la classe p�re (ou NULL)
- // dit si une classe est dérivée (Extends) d'une autre
+ // dit si une classe est d�riv�e (Extends) d'une autre
// rend TRUE aussi si les classes sont identiques
DllExport
BOOL IsChildOf(CBotClass* pClass);
static
- CBotClass* Find(CBotToken* &pToken); // trouve une classe d'après son nom
+ CBotClass* Find(CBotToken* &pToken); // trouve une classe d'apr�s son nom
DllExport
static
@@ -950,7 +961,7 @@ public: BOOL ExecuteMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotVar* &pResult, CBotStack* &pStack, CBotToken* pToken);
void RestoreMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotStack* &pStack);
- // compile une classe déclarée par l'utilisateur
+ // compile une classe d�clar�e par l'utilisateur
static
CBotClass* Compile(CBotToken* &p, CBotCStack* pStack);
static
@@ -992,9 +1003,9 @@ public: #define TokenTypDef 5 // une valeur selon DefineNum
#define TokenKeyWord 2000 // les mots clefs du langage
-#define TokenKeyDeclare 2100 // mots clefs pour déclarations (int, float,..)
-#define TokenKeyVal 2200 // les mots représentant une "valeur" (true, false, null, nan)
-#define TokenKeyOp 2300 // les opérateurs
+#define TokenKeyDeclare 2100 // mots clefs pour d�clarations (int, float,..)
+#define TokenKeyVal 2200 // les mots repr�sentant une "valeur" (true, false, null, nan)
+#define TokenKeyOp 2300 // les op�rateurs
class CBotToken
@@ -1006,19 +1017,19 @@ private: int m_ListIdKeyWords[200]; // les codes correspondants
static
- CBotStringArray m_ListKeyDefine; // les noms définis par un DefineNum
+ CBotStringArray m_ListKeyDefine; // les noms d�finis par un DefineNum
static
- long m_ListKeyNums[MAXDEFNUM]; // les valeurs associées
+ long m_ListKeyNums[MAXDEFNUM]; // les valeurs associ�es
private:
CBotToken* m_next; // suivant dans la liste
CBotToken* m_prev;
int m_type; // type de Token
- long m_IdKeyWord; // numéro du mot clef si c'en est un
+ long m_IdKeyWord; // num�ro du mot clef si c'en est un
// ou valeur du "define"
- CBotString m_Text; // mot trouvé comme token
- CBotString m_Sep; // séparateurs qui suivent
+ CBotString m_Text; // mot trouv� comme token
+ CBotString m_Sep; // s�parateurs qui suivent
int m_start; // position dans le texte d'origine (programme)
int m_end; // itou pour la fin du token
@@ -1043,20 +1054,20 @@ public: int GivType(); // rend le type du token
DllExport
- CBotString& GivString(); // rend la chaine correspondant à ce token
+ CBotString& GivString(); // rend la chaine correspondant � ce token
DllExport
- CBotString& GivSep(); // rend le séparateur suivant le token
+ CBotString& GivSep(); // rend le s�parateur suivant le token
DllExport
- int GivStart(); // position du début dans le texte
+ int GivStart(); // position du d�but dans le texte
DllExport
int GivEnd(); // position de fin dans le texte
DllExport
CBotToken* GivNext(); // rend le suivant dans la liste
DllExport
- CBotToken* GivPrev(); // rend le Précédent dans la liste
+ CBotToken* GivPrev(); // rend le Pr�c�dent dans la liste
DllExport
static
@@ -1064,7 +1075,7 @@ public: // transforme tout le programme
DllExport
static
- void Delete(CBotToken* pToken); // libère la liste
+ void Delete(CBotToken* pToken); // lib�re la liste
// fonctions non utiles en export
@@ -1091,10 +1102,10 @@ public: #if 0
////////////////////////////////////////////////////////////////////////
// Exemples d'utilisation
-// Définition de classes et de fonctions
+// D�finition de classes et de fonctions
-// définie la classe globale CPoint
+// d�finie la classe globale CPoint
// --------------------------------
m_pClassPoint = new CBotClass("CPoint", NULL);
// ajoute le composant ".x"
@@ -1104,17 +1115,17 @@ public: // le joueur peut alors utiliser les instructions
// CPoint position; position.x = 12; position.y = -13.6
-// définie la classe CColobotObject
+// d�finie la classe CColobotObject
// --------------------------------
-// cette classe gère tous les objets dans le monde de COLOBOT
-// le programme utilisateur "main" appartient à cette classe
+// cette classe g�re tous les objets dans le monde de COLOBOT
+// le programme utilisateur "main" appartient � cette classe
m_pClassObject = new CBotClass("CColobotObject", m_pClassBase);
// ajoute le composant ".position"
m_pClassObject->AddItem("position", m_pClassPoint);
// ajoute le composant ".type"
m_pClassObject->AddItem("type", CBotTypResult(CBotTypShort));
- // ajoute une définition de constante
- m_pClassObject->AddConst("ROBOT", CBotTypShort, 1); // ROBOT équivalent à la valeur 1
+ // ajoute une d�finition de constante
+ m_pClassObject->AddConst("ROBOT", CBotTypShort, 1); // ROBOT �quivalent � la valeur 1
// ajoute la routine FIND
m_pClassObject->AddFunction( rCompFind, rDoFind );
// le joueur peut maintenant utiliser les instructions
@@ -1122,9 +1133,9 @@ public: -// définie la classe CColobotRobot dérivée de CColobotObject
+// d�finie la classe CColobotRobot d�riv�e de CColobotObject
// ---------------------------------------------------------
-// les programmes "main" associés aux robots font partie de cette classe
+// les programmes "main" associ�s aux robots font partie de cette classe
m_pClassRobot = new CBotClass("CColobotRobot", m_pClassObject);
// ajoute la routine GOTO
m_pClassRobot->AddFunction( rCompGoto, rDoGoto );
@@ -1132,49 +1143,49 @@ public: // GOTO( FIND ( ROBOT ) );
-// crée une instance de la classe Robot
+// cr�e une instance de la classe Robot
// ------------------------------------
-// par exemple un nouveau robot qui vient d'être fabriqué
+// par exemple un nouveau robot qui vient d'�tre fabriqu�
CBotVar* m_pMonRobot = new CBotVar("MonRobot", m_pClassRobot);
-// compile le programme main pour ce robot-là
+// compile le programme main pour ce robot-l�
// ------------------------------------------
CString LeProgramme( "void main() {GOTO(0, 0); return 0;}" );
if ( !m_pMonRobot->Compile( LeProgramme ) ) {gestion d'erreur...};
-// construit une pile pour l'interpréteur
+// construit une pile pour l'interpr�teur
// --------------------------------------
CBotStack* pStack = new CBotStack(NULL);
-// exécute le programme main
+// ex�cute le programme main
// -------------------------
while( FALSE = m_pMonRobot->Execute( "main", pStack ))
{
// programme suspendu
- // on pourrait passer la main à un autre (en sauvegardant pStack pour ce robot-là)
+ // on pourrait passer la main � un autre (en sauvegardant pStack pour ce robot-l�)
};
- // programme "main" terminé !
+ // programme "main" termin� !
-// routine implémentant l'instruction GOTO( CPoint pos )
+// routine impl�mentant l'instruction GOTO( CPoint pos )
BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
{
if (pVar->GivType() != CBotTypeClass ||
pVar->IsElemOfClas("CPoint") ) { exception = 6522; return FALSE; )
- // le paramètre n'est pas de la bonne classe ?
- // NB en fait ce contrôle est déjà fait par la routine pour la compilation
+ // le param�tre n'est pas de la bonne classe ?
+ // NB en fait ce contr�le est d�j� fait par la routine pour la compilation
- m_PosToGo.Copy( pVar ); // garde la position à atteindre (object type CBotVar)
+ m_PosToGo.Copy( pVar ); // garde la position � atteindre (object type CBotVar)
// ou alors
CBotVar* temp;
- temp = pVar->GivItem("x"); // trouve forcément pour un object de type "CPoint"
+ temp = pVar->GivItem("x"); // trouve forc�ment pour un object de type "CPoint"
ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
m_PosToGo.x = temp->GivValFloat();
- temp = pVar->GivItem("y"); // trouve forcément pour un object de type "CPoint"
+ temp = pVar->GivItem("y"); // trouve forc�ment pour un object de type "CPoint"
ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
m_PosToGo.y = temp->GivValFloat();
@@ -1182,4 +1193,4 @@ BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception ) // rend FALSE s'il faut patienter encore
}
-#endif
\ No newline at end of file +#endif
diff --git a/src/CBot/CBotFunction.cpp b/src/CBot/CBotFunction.cpp index 43dbc83..426824e 100644 --- a/src/CBot/CBotFunction.cpp +++ b/src/CBot/CBotFunction.cpp @@ -1,16 +1,28 @@ -///////////////////////////////////////////////////////////////////////
-// compilation des diverses fonctions déclarées par l'utilisateur
-//
+// * 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"
// les divers constructeurs / destructeurs
-// pour libérer tout selon l'arbre établi
+// pour lib�rer tout selon l'arbre �tabli
CBotFunction::CBotFunction()
{
- m_Param = NULL; // liste des paramètres vide
+ m_Param = NULL; // liste des param�tres vide
m_Block = NULL; // le bloc d'instructions
- m_next = NULL; // les fonctions peuvent être chaînées
+ m_next = NULL; // les fonctions peuvent �tre cha�n�es
m_bPublic = FALSE; // fonction non publique
m_bExtern = FALSE; // fonction non externe
m_nextpublic = NULL;
@@ -25,11 +37,11 @@ CBotFunction* CBotFunction::m_listPublic = NULL; CBotFunction::~CBotFunction()
{
- delete m_Param; // liste des paramètres vide
+ delete m_Param; // liste des param�tres vide
delete m_Block; // le bloc d'instructions
delete m_next;
- // enlève de la liste publique s'il y a lieu
+ // enl�ve de la liste publique s'il y a lieu
if ( m_bPublic )
{
if ( m_nextpublic != NULL )
@@ -42,7 +54,7 @@ CBotFunction::~CBotFunction() }
else
{
- // si prev = next = null peut ne pas être dans la liste !
+ // si prev = next = null peut ne pas �tre dans la liste !
if ( m_listPublic == this ) m_listPublic = m_nextpublic;
}
}
@@ -152,8 +164,8 @@ CBotTypResult TypeParam(CBotToken* &p, CBotCStack* pile) }
// compile une nouvelle fonction
-// bLocal permet de mettre la déclaration des paramètres au même niveau
-// que le éléments appartenant à la classe pour les méthodes
+// bLocal permet de mettre la d�claration des param�tres au m�me niveau
+// que le �l�ments appartenant � la classe pour les m�thodes
CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* finput, BOOL bLocal)
{
CBotToken* pp;
@@ -184,7 +196,7 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct func->m_retToken = *p;
// CBotClass* pClass;
- func->m_retTyp = TypeParam(p, pStk); // type du résultat
+ func->m_retTyp = TypeParam(p, pStk); // type du r�sultat
if (func->m_retTyp.GivType() >= 0)
{
@@ -197,10 +209,10 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct func->m_token = d;
}
- // un nom de fonction est-il là ?
+ // un nom de fonction est-il l� ?
if (IsOfType(p, TokenTypVar))
{
- if ( IsOfType( p, ID_DBLDOTS ) ) // méthode pour une classe
+ if ( IsOfType( p, ID_DBLDOTS ) ) // m�thode pour une classe
{
func->m_MasterClass = pp->GivString();
CBotClass* pClass = CBotClass::Find(pp);
@@ -228,8 +240,8 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct pStk->AddVar(pThis);
// initialise les variables selon This
- // n'enregistre que le pointeur à la première,
- // le reste est chainé
+ // n'enregistre que le pointeur � la premi�re,
+ // le reste est chain�
CBotVar* pv = pThis->GivItemList();
// int num = 1;
while (pv != NULL)
@@ -266,7 +278,7 @@ bad: return pStack->ReturnFunc(NULL, pStk);
}
-// pré-compile une nouvelle fonction
+// pr�-compile une nouvelle fonction
CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass)
{
CBotFunction* func = new CBotFunction();
@@ -290,16 +302,16 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas }
func->m_retToken = *p;
- func->m_retTyp = TypeParam(p, pStack); // type du résultat
+ func->m_retTyp = TypeParam(p, pStack); // type du r�sultat
if (func->m_retTyp.GivType() >= 0)
{
CBotToken* pp = p;
func->m_token = *p;
- // un nom de fonction est-il là ?
+ // un nom de fonction est-il l� ?
if (IsOfType(p, TokenTypVar))
{
- if ( IsOfType( p, ID_DBLDOTS ) ) // méthode pour une classe
+ if ( IsOfType( p, ID_DBLDOTS ) ) // m�thode pour une classe
{
func->m_MasterClass = pp->GivString();
CBotClass* pClass = CBotClass::Find(pp);
@@ -355,14 +367,14 @@ static int xx = 0; BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
{
- CBotStack* pile = pj->AddStack(this, 2); // un bout de pile local à cette fonction
+ CBotStack* pile = pj->AddStack(this, 2); // un bout de pile local � cette fonction
// if ( pile == EOX ) return TRUE;
pile->SetBotCall(m_pProg); // bases pour les routines
if ( pile->GivState() == 0 )
{
- if ( !m_Param->Execute(ppVars, pile) ) return FALSE; // défini les paramètres
+ if ( !m_Param->Execute(ppVars, pile) ) return FALSE; // d�fini les param�tres
pile->IncState();
}
@@ -405,7 +417,7 @@ BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance) void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
{
- CBotStack* pile = pj->RestoreStack(this); // un bout de pile local à cette fonction
+ CBotStack* pile = pj->RestoreStack(this); // un bout de pile local � cette fonction
if ( pile == NULL ) return;
CBotStack* pile2 = pile;
@@ -413,13 +425,13 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst if ( pile->GivBlock() < 2 )
{
- CBotStack* pile2 = pile->RestoreStack(NULL); // un bout de pile local à cette fonction
+ CBotStack* pile2 = pile->RestoreStack(NULL); // un bout de pile local � cette fonction
if ( pile2 == NULL ) return;
pile->SetState(pile->GivState() + pile2->GivState());
pile2->Delete();
}
- m_Param->RestoreState(pile2, TRUE); // les paramètres
+ m_Param->RestoreState(pile2, TRUE); // les param�tres
if ( !m_MasterClass.IsEmpty() )
{
@@ -451,7 +463,7 @@ CBotTypResult CBotFunction::CompileCall(const char* name, CBotVar** ppVars, long // trouve une fonction selon son identificateur unique
-// si l'identificateur n'est pas trouvé, cherche selon le nom et les paramètres
+// si l'identificateur n'est pas trouv�, cherche selon le nom et les param�tres
CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, BOOL bPublic)
{
@@ -484,7 +496,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( name == NULL ) return NULL;
int delta = 99999; // cherche la signature la plus faible
- CBotFunction* pFunc = NULL; // la meilleure fonction trouvée
+ CBotFunction* pFunc = NULL; // la meilleure fonction trouv�e
if ( this != NULL )
{
@@ -493,10 +505,10 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pt->m_token.GivString() == name )
{
int i = 0;
- int alpha = 0; // signature des paramètres
- // les paramètres sont-ils compatibles ?
- CBotDefParam* pv = pt->m_Param; // liste des paramètres attendus
- CBotVar* pw = ppVars[i++]; // liste des paramètres fournis
+ int alpha = 0; // signature des param�tres
+ // les param�tres sont-ils compatibles ?
+ CBotDefParam* pv = pt->m_Param; // liste des param�tres attendus
+ CBotVar* pw = ppVars[i++]; // liste des param�tres fournis
while ( pv != NULL && pw != NULL)
{
if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
@@ -505,7 +517,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB break;
}
int d = pv->GivType() - pw->GivType(2);
- alpha += d>0 ? d : -10*d; // perte de qualité, 10 fois plus cher !!
+ alpha += d>0 ? d : -10*d; // perte de qualit�, 10 fois plus cher !!
pv = pv->GivNext();
pw = ppVars[i++];
@@ -515,14 +527,14 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);
- continue; // trop de paramètres
+ continue; // trop de param�tres
}
if ( pv != NULL )
{
if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);
- continue; // pas assez de paramètres
+ continue; // pas assez de param�tres
}
if (alpha == 0) // signature parfaite
@@ -548,10 +560,10 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pt->m_token.GivString() == name )
{
int i = 0;
- int alpha = 0; // signature des paramètres
- // les paramètres sont-ils compatibles ?
- CBotDefParam* pv = pt->m_Param; // liste des paramètres attendus
- CBotVar* pw = ppVars[i++]; // liste des paramètres fournis
+ int alpha = 0; // signature des param�tres
+ // les param�tres sont-ils compatibles ?
+ CBotDefParam* pv = pt->m_Param; // liste des param�tres attendus
+ CBotVar* pw = ppVars[i++]; // liste des param�tres fournis
while ( pv != NULL && pw != NULL)
{
if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
@@ -560,7 +572,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB break;
}
int d = pv->GivType() - pw->GivType(2);
- alpha += d>0 ? d : -10*d; // perte de qualité, 10 fois plus cher !!
+ alpha += d>0 ? d : -10*d; // perte de qualit�, 10 fois plus cher !!
pv = pv->GivNext();
pw = ppVars[i++];
@@ -570,14 +582,14 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);
- continue; // trop de paramètres
+ continue; // trop de param�tres
}
if ( pv != NULL )
{
if ( pFunc != NULL ) continue;
if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);
- continue; // pas assez de paramètres
+ continue; // pas assez de param�tres
}
if (alpha == 0) // signature parfaite
@@ -606,7 +618,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB }
-// fait un appel à une fonction
+// fait un appel � une fonction
int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken)
{
@@ -620,13 +632,13 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS CBotStack* pStk1 = pStack->AddStack(pt, 2); // pour mettre "this"
// if ( pStk1 == EOX ) return TRUE;
- pStk1->SetBotCall(pt->m_pProg); // on a peut-être changé de module
+ pStk1->SetBotCall(pt->m_pProg); // on a peut-�tre chang� de module
if ( pStk1->IfStep() ) return FALSE;
- CBotStack* pStk3 = pStk1->AddStack(NULL, TRUE); // paramètres
+ CBotStack* pStk3 = pStk1->AddStack(NULL, TRUE); // param�tres
- // prépare les paramètres sur la pile
+ // pr�pare les param�tres sur la pile
if ( pStk1->GivState() == 0 )
{
@@ -652,15 +664,15 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS }
- // initialise les variables selon paramètres
- pt->m_Param->Execute(ppVars, pStk3); // ne peut pas être interrompu
+ // initialise les variables selon param�tres
+ pt->m_Param->Execute(ppVars, pStk3); // ne peut pas �tre interrompu
pStk1->IncState();
}
- // finalement exécute la fonction trouvée
+ // finalement ex�cute la fonction trouv�e
- if ( !pStk3->GivRetVar( // remet le résultat sur la pile
+ if ( !pStk3->GivRetVar( // remet le r�sultat sur la pile
pt->m_Block->Execute(pStk3) )) // GivRetVar dit si c'est interrompu
{
if ( !pStk3->IsOk() && pt->m_pProg != m_pProg )
@@ -668,7 +680,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS #ifdef _DEBUG
if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return FALSE;
#endif
- pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure
+ pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de proc�dure
}
return FALSE; // interrompu !
}
@@ -694,11 +706,11 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, pStk1 = pStack->RestoreStack(pt);
if ( pStk1 == NULL ) return;
- pStk1->SetBotCall(pt->m_pProg); // on a peut-être changé de module
+ pStk1->SetBotCall(pt->m_pProg); // on a peut-�tre chang� de module
if ( pStk1->GivBlock() < 2 )
{
- CBotStack* pStk2 = pStk1->RestoreStack(NULL); // plus utilisé
+ CBotStack* pStk2 = pStk1->RestoreStack(NULL); // plus utilis�
if ( pStk2 == NULL ) return;
pStk3 = pStk2->RestoreStack(NULL);
if ( pStk3 == NULL ) return;
@@ -709,7 +721,7 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, if ( pStk3 == NULL ) return;
}
- // prépare les paramètres sur la pile
+ // pr�pare les param�tres sur la pile
{
if ( !pt->m_MasterClass.IsEmpty() )
@@ -728,7 +740,7 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, return;
}
- // initialise les variables selon paramètres
+ // initialise les variables selon param�tres
pt->m_Param->RestoreState(pStk3, FALSE);
pt->m_Block->RestoreState(pStk3, TRUE);
}
@@ -736,8 +748,8 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, -// fait un appel d'une méthode
-// note : this est déjà sur la pile, le pointeur pThis est juste là pour simplifier
+// fait un appel d'une m�thode
+// note : this est d�j� sur la pile, le pointeur pThis est juste l� pour simplifier
int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass)
{
@@ -753,17 +765,17 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar CBotStack* pStk = pStack->AddStack(pt, 2);
// if ( pStk == EOX ) return TRUE;
- pStk->SetBotCall(pt->m_pProg); // on a peut-être changé de module
- CBotStack* pStk3 = pStk->AddStack(NULL, TRUE); // pour mettre les paramètres passés
+ pStk->SetBotCall(pt->m_pProg); // on a peut-�tre chang� de module
+ CBotStack* pStk3 = pStk->AddStack(NULL, TRUE); // pour mettre les param�tres pass�s
- // prépare les paramètres sur la pile
+ // pr�pare les param�tres sur la pile
if ( pStk->GivState() == 0 )
{
// met la variable "this" sur la pile
CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer);
pthis->Copy(pThis, FALSE);
- pthis->SetUniqNum(-2); // valeur spéciale
+ pthis->SetUniqNum(-2); // valeur sp�ciale
pStk->AddVar(pthis);
CBotClass* pClass = pThis->GivClass()->GivParent();
@@ -771,12 +783,12 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar {
// met la variable "super" sur la pile
CBotVar* psuper = CBotVar::Create("super", CBotTypNullPointer);
- psuper->Copy(pThis, FALSE); // en fait identique à "this"
- psuper->SetUniqNum(-3); // valeur spéciale
+ psuper->Copy(pThis, FALSE); // en fait identique � "this"
+ psuper->SetUniqNum(-3); // valeur sp�ciale
pStk->AddVar(psuper);
}
- // initialise les variables selon paramètres
- pt->m_Param->Execute(ppVars, pStk3); // ne peut pas être interrompu
+ // initialise les variables selon param�tres
+ pt->m_Param->Execute(ppVars, pStk3); // ne peut pas �tre interrompu
pStk->IncState();
}
@@ -789,21 +801,21 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar }
pStk->IncState();
}
- // finalement appelle la fonction trouvée
+ // finalement appelle la fonction trouv�e
- if ( !pStk3->GivRetVar( // remet le résultat sur la pile
+ if ( !pStk3->GivRetVar( // remet le r�sultat sur la pile
pt->m_Block->Execute(pStk3) )) // GivRetVar dit si c'est interrompu
{
if ( !pStk3->IsOk() )
{
if ( pt->m_bSynchro )
{
- pClass->Unlock(); // libère la fonction
+ pClass->Unlock(); // lib�re la fonction
}
if ( pt->m_pProg != pProgCurrent )
{
- pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de procédure
+ pStk3->SetPosError(pToken); // indique l'erreur sur l'appel de proc�dure
}
}
return FALSE; // interrompu !
@@ -811,7 +823,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar if ( pt->m_bSynchro )
{
- pClass->Unlock(); // libère la fonction
+ pClass->Unlock(); // lib�re la fonction
}
return pStack->Return( pStk3 );
@@ -828,30 +840,30 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar* pThis, C {
CBotStack* pStk = pStack->RestoreStack(pt);
if ( pStk == NULL ) return;
- pStk->SetBotCall(pt->m_pProg); // on a peut-être changé de module
+ pStk->SetBotCall(pt->m_pProg); // on a peut-�tre chang� de module
CBotVar* pthis = pStk->FindVar("this");
pthis->SetUniqNum(-2);
- CBotStack* pStk3 = pStk->RestoreStack(NULL); // pour mettre les paramètres passés
+ CBotStack* pStk3 = pStk->RestoreStack(NULL); // pour mettre les param�tres pass�s
if ( pStk3 == NULL ) return;
- pt->m_Param->RestoreState(pStk3, TRUE); // les paramètres
+ pt->m_Param->RestoreState(pStk3, TRUE); // les param�tres
- if ( pStk->GivState() > 1 && // vérouillage est effectif ?
+ if ( pStk->GivState() > 1 && // v�rouillage est effectif ?
pt->m_bSynchro )
{
CBotProgram* pProgBase = pStk->GivBotCall(TRUE);
- pClass->Lock(pProgBase); // vérouille la classe
+ pClass->Lock(pProgBase); // v�rouille la classe
}
- // finalement appelle la fonction trouvée
+ // finalement appelle la fonction trouv�e
pt->m_Block->RestoreState(pStk3, TRUE); // interrompu !
}
}
-// regarde si la "signature" des paramètres est identique
+// regarde si la "signature" des param�tres est identique
BOOL CBotFunction::CheckParam(CBotDefParam* pParam)
{
CBotDefParam* pp = m_Param;
@@ -876,7 +888,7 @@ CBotString CBotFunction::GivParams() if ( m_Param == NULL ) return CBotString("()");
CBotString params = "( ";
- CBotDefParam* p = m_Param; // liste des paramètres
+ CBotDefParam* p = m_Param; // liste des param�tres
while (p != NULL)
{
@@ -907,7 +919,7 @@ void CBotFunction::AddPublic(CBotFunction* func) /////////////////////////////////////////////////////////////////////////
-// gestion des paramètres
+// gestion des param�tres
CBotDefParam::CBotDefParam()
@@ -922,11 +934,11 @@ CBotDefParam::~CBotDefParam() }
-// compile une liste de paramètres
+// compile une liste de param�tres
CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
{
// surtout pas de pStack->TokenStack ici
- // les variables déclarées doivent rester visibles par la suite
+ // les variables d�clar�es doivent rester visibles par la suite
pStack->SetStartError(p->GivStart());
@@ -938,12 +950,12 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotDefParam* param = new CBotDefParam();
if (list == NULL) list = param;
- else list->AddNext(param); // ajoute à la liste
+ else list->AddNext(param); // ajoute � la liste
CBotClass* pClass = NULL;//= CBotClass::Find(p);
param->m_typename = p->GivString();
CBotTypResult type = param->m_type = TypeParam(p, pStack);
-// if ( type == CBotTypPointer ) type = CBotTypClass; // il faut créer un nouvel objet
+// if ( type == CBotTypPointer ) type = CBotTypClass; // il faut cr�er un nouvel objet
if (param->m_type.GivType() > 0)
{
@@ -952,7 +964,7 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack) if (pStack->IsOk() && IsOfType(p, TokenTypVar) )
{
- // variable déjà déclarée ?
+ // variable d�j� d�clar�e ?
if (pStack->CheckVarLocal(pp))
{
pStack->SetError(TX_REDEFVAR, pp);
@@ -960,9 +972,9 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack) }
if ( type.Eq(CBotTypArrayPointer) ) type.SetType(CBotTypArrayBody);
- CBotVar* var = CBotVar::Create(pp->GivString(), type); // crée la variable
+ CBotVar* var = CBotVar::Create(pp->GivString(), type); // cr�e la variable
// if ( pClass ) var->SetClass(pClass);
- var->SetInit(2); // la marque initialisée
+ var->SetInit(2); // la marque initialis�e
param->m_nIdent = CBotVar::NextUniqNum();
var->SetUniqNum(param->m_nIdent);
pStack->AddVar(var); // la place sur la pile
@@ -998,10 +1010,10 @@ BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj) while ( p != NULL )
{
- // crée une variable locale sur la pile
+ // cr�e une variable locale sur la pile
CBotVar* newvar = CBotVar::Create(p->m_token.GivString(), p->m_type);
- // procède ainsi pour faire la transformation des types :
+ // proc�de ainsi pour faire la transformation des types :
if ( ppVars != NULL && ppVars[i] != NULL )
{
switch (p->m_type.GivType())
@@ -1047,7 +1059,7 @@ void CBotDefParam::RestoreState(CBotStack* &pj, BOOL bMain) while ( p != NULL )
{
- // crée une variable locale sur la pile
+ // cr�e une variable locale sur la pile
CBotVar* var = pj->FindVar(p->m_token.GivString());
var->SetUniqNum(p->m_nIdent);
p = p->m_next;
@@ -1083,7 +1095,7 @@ CBotString CBotDefParam::GivParamString() //////////////////////////////////////////////////////////////////////////
-// retour des paramètres
+// retour des param�tres
CBotReturn::CBotReturn()
{
@@ -1102,7 +1114,7 @@ CBotInstr* CBotReturn::Compile(CBotToken* &p, CBotCStack* pStack) if (!IsOfType(p, ID_RETURN)) return NULL; // ne devrait jamais arriver
- CBotReturn* inst = new CBotReturn(); // crée l'objet
+ CBotReturn* inst = new CBotReturn(); // cr�e l'objet
inst->SetToken( pp );
CBotTypResult type = pStack->GivRetType();
@@ -1139,8 +1151,8 @@ BOOL CBotReturn::Execute(CBotStack* &pj) if ( pile->GivState() == 0 )
{
- if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return FALSE; // évalue le résultat
- // le résultat est sur la pile
+ if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return FALSE; // �value le r�sultat
+ // le r�sultat est sur la pile
pile->IncState();
}
@@ -1158,13 +1170,13 @@ void CBotReturn::RestoreState(CBotStack* &pj, BOOL bMain) if ( pile->GivState() == 0 )
{
- if ( m_Instr != NULL ) m_Instr->RestoreState(pile, bMain); // évalue le résultat
+ if ( m_Instr != NULL ) m_Instr->RestoreState(pile, bMain); // �value le r�sultat
return;
}
}
////////////////////////////////////////////////////////////////////////////////
-// Les appels à ces fonctions
+// Les appels � ces fonctions
CBotInstrCall::CBotInstrCall()
{
@@ -1196,11 +1208,11 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack) CBotInstrCall* inst = new CBotInstrCall();
inst->SetToken(pp);
- // compile la liste des paramètres
+ // compile la liste des param�tres
if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE)
{
start = p->GivStart();
- pile = pile->TokenStack(); // garde les résultats sur la pile
+ pile = pile->TokenStack(); // garde les r�sultats sur la pile
CBotInstr* param = CBotExpression::Compile(p, pile);
end = p->GivStart();
@@ -1253,7 +1265,7 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack) if ( inst->m_typRes.GivType() > 0 )
{
CBotVar* pRes = CBotVar::Create("", inst->m_typRes);
- pStack->SetVar(pRes); // pour connaître le type du résultat
+ pStack->SetVar(pRes); // pour conna�tre le type du r�sultat
}
else pStack->SetVar(NULL); // routine retourne void
@@ -1275,16 +1287,16 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj) int i = 0;
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile = pile->AddStack(); // de la place sur la pile pour les résultats
+ pile = pile->AddStack(); // de la place sur la pile pour les r�sultats
if ( pile->GivState() == 0 )
{
if (!p->Execute(pile)) return FALSE; // interrompu ici ?
- pile->SetState(1); // marque spéciale pour reconnaîre les paramètres
+ pile->SetState(1); // marque sp�ciale pour reconna�re les param�tres
}
ppVars[i++] = pile->GivVar();
p = p->GivNext();
@@ -1297,7 +1309,7 @@ BOOL CBotInstrCall::Execute(CBotStack* &pj) if ( !pile2->ExecuteCall(m_nFuncIdent, GivToken(), ppVars, m_typRes)) return FALSE; // interrompu
- return pj->Return(pile2); // libère toute la pile
+ return pj->Return(pile2); // lib�re toute la pile
}
void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain)
@@ -1312,19 +1324,19 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain) int i = 0;
CBotVar* ppVars[1000];
CBotInstr* p = m_Parameters;
- // évalue les paramètres
+ // �value les param�tres
// et place les valeurs sur la pile
- // pour pouvoir être interrompu n'importe quand
+ // pour pouvoir �tre interrompu n'importe quand
if ( p != NULL) while ( TRUE )
{
- pile = pile->RestoreStack(); // de la place sur la pile pour les résultats
+ pile = pile->RestoreStack(); // de la place sur la pile pour les r�sultats
if ( pile == NULL ) return;
if ( pile->GivState() == 0 )
{
p->RestoreState(pile, bMain); // interrompu ici !
return;
}
- ppVars[i++] = pile->GivVar(); // construit la liste des paramètres
+ ppVars[i++] = pile->GivVar(); // construit la liste des param�tres
p = p->GivNext();
if ( p == NULL) break;
}
@@ -1337,10 +1349,10 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain) }
//////////////////////////////////////////////////////////////////////////////
-// déclaration des classes par l'utilisateur
+// d�claration des classes par l'utilisateur
-// pré-compile une nouvelle class
-// l'analyse est complète à l'execption du corps des routines
+// pr�-compile une nouvelle class
+// l'analyse est compl�te � l'execption du corps des routines
CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
{
@@ -1361,7 +1373,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack) return NULL;
}
- // un nom pour la classe est-il là ?
+ // un nom pour la classe est-il l� ?
if (IsOfType(p, TokenTypVar))
{
CBotClass* pPapa = NULL;
@@ -1379,8 +1391,8 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack) }
#endif
CBotClass* classe = (pOld == NULL) ? new CBotClass(name, pPapa) : pOld;
- classe->Purge(); // vide les anciennes définitions
- classe->m_IsDef = FALSE; // définition en cours
+ classe->Purge(); // vide les anciennes d�finitions
+ classe->m_IsDef = FALSE; // d�finition en cours
if ( !IsOfType( p, ID_OPBLK) )
{
@@ -1419,7 +1431,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) if ( IsOfType(p, ID_STATIC) ) bStatic = TRUE;
// CBotClass* pClass = NULL;
- type = TypeParam(p, pStack); // type du résultat
+ type = TypeParam(p, pStack); // type du r�sultat
if ( type.Eq(-1) )
{
@@ -1430,7 +1442,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) while (pStack->IsOk())
{
CBotToken* pp = p;
- IsOfType(p, ID_NOT); // saute le ~ éventuel (destructeur)
+ IsOfType(p, ID_NOT); // saute le ~ �ventuel (destructeur)
if (IsOfType(p, TokenTypVar))
{
@@ -1442,7 +1454,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) if ( p->GivType() != ID_CLBRK )
i = CBotExpression::Compile( p, pStack ); // expression pour la valeur
else
- i = new CBotEmpty(); // spécial si pas de formule
+ i = new CBotEmpty(); // sp�cial si pas de formule
type = CBotTypResult(CBotTypArrayPointer, type);
@@ -1478,7 +1490,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) }
else
{
- // retrouve la méthode précompilée en passe 1
+ // retrouve la m�thode pr�compil�e en passe 1
CBotFunction* pf = m_pMethod;
CBotFunction* prev = NULL;
while ( pf != NULL )
@@ -1523,7 +1535,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) my = my->m_pParent;
}
- // compile une méthode
+ // compile une m�thode
p = pBase;
CBotFunction* f =
CBotFunction::Compile(p, pile, NULL/*, FALSE*/);
@@ -1532,7 +1544,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) {
f->m_pProg = pStack->GivBotCall();
f->m_bSynchro = bSynchro;
- // remplace l'élément dans la chaîne
+ // remplace l'�l�ment dans la cha�ne
f->m_next = pf->m_next;
pf->m_next = NULL;
delete pf;
@@ -1545,7 +1557,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) return pStack->IsOk();
}
- // définition d'un élément
+ // d�finition d'un �l�ment
if (type.Eq(0))
{
pStack->SetError(TX_ENDOF, p);
@@ -1561,7 +1573,7 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) }
else
{
- // il y a une assignation à calculer
+ // il y a une assignation � calculer
i = CBotTwoOpExpr::Compile(p, pStack);
}
if ( !pStack->IsOk() ) return FALSE;
@@ -1582,8 +1594,8 @@ BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond) if ( pv->IsStatic() && pv->m_InitExpr != NULL )
{
- CBotStack* pile = CBotStack::FirstStack(); // une pile indépendante
- while(pile->IsOk() && !pv->m_InitExpr->Execute(pile)); // évalue l'expression sans timer
+ CBotStack* pile = CBotStack::FirstStack(); // une pile ind�pendante
+ while(pile->IsOk() && !pv->m_InitExpr->Execute(pile)); // �value l'expression sans timer
pv->SetVal( pile->GivVar() ) ;
pile->Delete();
}
@@ -1607,26 +1619,26 @@ CBotClass* CBotClass::Compile(CBotToken* &p, CBotCStack* pStack) CBotString name = p->GivString();
- // un nom pour la classe est-il là ?
+ // un nom pour la classe est-il l� ?
if (IsOfType(p, TokenTypVar))
{
- // la classe à été créée par Compile1
+ // la classe � �t� cr��e par Compile1
CBotClass* pOld = CBotClass::Find(name);
#if EXTENDS
if ( IsOfType( p, ID_EXTENDS ) )
{
- IsOfType(p, TokenTypVar); // forcément
+ IsOfType(p, TokenTypVar); // forc�ment
}
#endif
- IsOfType( p, ID_OPBLK); // forcément
+ IsOfType( p, ID_OPBLK); // forc�ment
while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )
{
pOld->CompileDefItem(p, pStack, TRUE);
}
- pOld->m_IsDef = TRUE; // définition terminée
+ pOld->m_IsDef = TRUE; // d�finition termin�e
if (pStack->IsOk()) return pOld;
}
pStack->SetError(TX_ENDOF, p);
diff --git a/src/CBot/CBotIf.cpp b/src/CBot/CBotIf.cpp index c0f561a..1a53aeb 100644 --- a/src/CBot/CBotIf.cpp +++ b/src/CBot/CBotIf.cpp @@ -1,5 +1,18 @@ -///////////////////////////////////////////////////////////////////////
-// instruction if (condition) opération1 else opération2;
+// * 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"
@@ -14,23 +27,23 @@ CBotIf::CBotIf() CBotIf::~CBotIf()
{
- delete m_Condition; // libère la condition
- delete m_Block; // libère le bloc d'instruction1
- delete m_BlockElse; // libère le bloc d'instruction2
+ delete m_Condition; // lib�re la condition
+ delete m_Block; // lib�re le bloc d'instruction1
+ delete m_BlockElse; // lib�re le bloc d'instruction2
}
// compilation (routine statique)
-// appelé lorsque le token "if" a été trouvé
+// appel� lorsque le token "if" a �t� trouv�
CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack)
{
- CBotToken* pp = p; // conserve le ^au token (début instruction)
+ CBotToken* pp = p; // conserve le ^au token (d�but instruction)
if (!IsOfType(p, ID_IF)) return NULL; // ne doit jamais arriver
CBotCStack* pStk = pStack->TokenStack(pp); // un petit bout de pile svp
- CBotIf* inst = new CBotIf(); // crée l'object
+ CBotIf* inst = new CBotIf(); // cr�e l'object
inst->SetToken( pp );
if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )
@@ -40,7 +53,7 @@ CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
if ( pStk->IsOk() )
{
- // le bloc d'instruction est ok (peut être vide)
+ // le bloc d'instruction est ok (peut �tre vide)
// regarde si l'instruction suivante est le token "else"
if (IsOfType(p, ID_ELSE))
@@ -49,57 +62,57 @@ CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack) inst->m_BlockElse = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );
if (!pStk->IsOk())
{
- // il n'y a pas de bloc correct après le else
- // libère l'objet, et transmet l'erreur qui est sur la pile
+ // il n'y a pas de bloc correct apr�s le else
+ // lib�re l'objet, et transmet l'erreur qui est sur la pile
delete inst;
return pStack->Return(NULL, pStk);
}
}
- // rend l'object correct à qui le demande.
+ // rend l'object correct � qui le demande.
return pStack->Return(inst, pStk);
}
}
- // erreur, libère l'objet
+ // erreur, lib�re l'objet
delete inst;
// et transmet l'erreur qui se trouve sur la pile.
return pStack->Return(NULL, pStk);
}
-// exécution de l'instruction
+// ex�cution de l'instruction
BOOL CBotIf :: 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;
- // 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( pile->GivState() == 0 )
{
- // évalue la condition
+ // �value la condition
if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ?
// 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
}
- // passe dans le second état
- if (!pile->SetState(1)) return FALSE; // prêt pour la suite
+ // passe dans le second �tat
+ if (!pile->SetState(1)) return FALSE; // pr�t pour la suite
}
- // second état, évalue les instructions associées
- // le résultat de la condition est sur la pile
+ // second �tat, �value les instructions associ�es
+ // le r�sultat de la condition est sur la pile
- if ( pile->GivVal() == TRUE ) // condition était vraie ?
+ if ( pile->GivVal() == TRUE ) // condition �tait vraie ?
{
- if ( m_Block != NULL && // bloc peut être absent
+ if ( m_Block != NULL && // bloc peut �tre absent
!m_Block->Execute(pile) ) return FALSE; // interrompu ici ?
}
else
@@ -108,7 +121,7 @@ BOOL CBotIf :: Execute(CBotStack* &pj) !m_BlockElse->Execute(pile) ) return FALSE; // interrompu ici
}
- // transmet le résultat et libère la pile
+ // transmet le r�sultat et lib�re la pile
return pj->Return(pile);
}
@@ -117,23 +130,23 @@ void CBotIf :: 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;
- // 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( pile->GivState() == 0 )
{
- // évalue la condition
+ // �value la condition
m_Condition->RestoreState(pile, bMain); // interrompu ici !
return;
}
- // second état, évalue les instructions associées
- // le résultat de la condition est sur la pile
+ // second �tat, �value les instructions associ�es
+ // le r�sultat de la condition est sur la pile
- if ( pile->GivVal() == TRUE ) // condition était vraie ?
+ if ( pile->GivVal() == TRUE ) // condition �tait vraie ?
{
- if ( m_Block != NULL ) // bloc peut être absent
+ if ( m_Block != NULL ) // bloc peut �tre absent
m_Block->RestoreState(pile, bMain); // interrompu ici !
}
else
diff --git a/src/CBot/CBotProgram.cpp b/src/CBot/CBotProgram.cpp index ba14f89..1b770e8 100644 --- a/src/CBot/CBotProgram.cpp +++ b/src/CBot/CBotProgram.cpp @@ -1,5 +1,18 @@ -//////////////////////////////////////////////////////////////////////
-// gestion de base d'un programme CBot
+// * 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"
#include <stdio.h>
@@ -54,8 +67,8 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, Stop();
// delete m_pClass;
- m_pClass->Purge(); // purge les anciennes définitions des classes
- // mais sans détruire l'object
+ m_pClass->Purge(); // purge les anciennes d�finitions des classes
+ // mais sans d�truire l'object
m_pClass = NULL;
delete m_Prog; m_Prog= NULL;
@@ -71,12 +84,12 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, CBotCStack* pStack = new CBotCStack(NULL);
- CBotToken* p = pBaseToken->GivNext(); // saute le 1er token (séparateur)
+ CBotToken* p = pBaseToken->GivNext(); // saute le 1er token (s�parateur)
- pStack->SetBotCall(this); // défini les routines utilisables
+ pStack->SetBotCall(this); // d�fini les routines utilisables
CBotCall::SetPUser(pUser);
- // fait une première passe rapide juste pour prendre les entêtes de routines et de classes
+ // fait une premi�re passe rapide juste pour prendre les ent�tes de routines et de classes
while ( pStack->IsOk() && p != NULL && p->GivType() != 0)
{
if ( IsOfType(p, ID_SEP) ) continue; // des point-virgules qui trainent
@@ -107,7 +120,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, // CBotFunction* temp = NULL;
CBotFunction* next = m_Prog; // reprend la liste
- p = pBaseToken->GivNext(); // revient au début
+ p = pBaseToken->GivNext(); // revient au d�but
while ( pStack->IsOk() && p != NULL && p->GivType() != 0 )
{
@@ -117,7 +130,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))
{
m_bCompileClass = TRUE;
- CBotClass::Compile(p, pStack); // complète la définition de la classe
+ CBotClass::Compile(p, pStack); // compl�te la d�finition de la classe
}
else
{
@@ -129,7 +142,7 @@ BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, }
}
-// delete m_Prog; // la liste de la 1ère passe
+// delete m_Prog; // la liste de la 1�re passe
// m_Prog = temp; // la liste de la seconde passe
if ( !pStack->IsOk() )
@@ -171,12 +184,12 @@ BOOL CBotProgram::Start(const char* name) #if STACKMEM
m_pStack = CBotStack::FirstStack();
#else
- m_pStack = new CBotStack(NULL); // crée une pile d'exécution
+ m_pStack = new CBotStack(NULL); // cr�e une pile d'ex�cution
#endif
m_pStack->SetBotCall(this); // bases pour les routines
- return TRUE; // on est prêt pour un Run()
+ return TRUE; // on est pr�t pour un Run()
}
BOOL CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet modestart, CBotGet modestop)
@@ -204,13 +217,13 @@ BOOL CBotProgram::Run(void* pUser, int timer) if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL)
pUser = m_pInstance->m_pUserPtr;
- m_pStack->Reset(pUser); // vide l'éventuelle erreur précédente, et remet le timer
+ m_pStack->Reset(pUser); // vide l'�ventuelle erreur pr�c�dente, et remet le timer
if ( timer >= 0 ) m_pStack->SetTimer(timer);
m_pStack->SetBotCall(this); // bases pour les routines
#if STACKRUN
- // reprend l'exécution sur le haut de la pile
+ // reprend l'ex�cution sur le haut de la pile
ok = m_pStack->Execute();
if ( ok )
{
@@ -221,7 +234,7 @@ BOOL CBotProgram::Run(void* pUser, int timer) ppVar[2] = NULL;
ok = m_pRun->Execute(ppVar, m_pStack, m_pInstance);
#else
- // revient sur l'exécution normale
+ // revient sur l'ex�cution normale
ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);
#endif
}
@@ -229,7 +242,7 @@ BOOL CBotProgram::Run(void* pUser, int timer) ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);
#endif
- // terminé sur une erreur ?
+ // termin� sur une erreur ?
if (!ok && !m_pStack->IsOk())
{
m_ErrorCode = m_pStack->GivError(m_ErrorStart, m_ErrorEnd);
@@ -239,10 +252,10 @@ BOOL CBotProgram::Run(void* pUser, int timer) delete m_pStack;
#endif
m_pStack = NULL;
- return TRUE; // exécution terminée !!
+ return TRUE; // ex�cution termin�e !!
}
- if ( ok ) m_pRun = NULL; // plus de fonction en exécution
+ if ( ok ) m_pRun = NULL; // plus de fonction en ex�cution
return ok;
error:
@@ -332,7 +345,7 @@ CBotString CBotProgram::GivErrorText(int code) if (TextError.IsEmpty())
{
char buf[100];
- sprintf(buf, "Exception numéro %d.", code);
+ sprintf(buf, "Exception num�ro %d.", code);
TextError = buf;
}
return TextError;
@@ -348,7 +361,7 @@ BOOL CBotProgram::AddFunction(const char* name, BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
{
- // mémorise les pointeurs aux deux fonctions
+ // m�morise les pointeurs aux deux fonctions
return CBotCall::AddFunction(name, rExec, rCompile);
}
@@ -531,12 +544,12 @@ BOOL CBotProgram::RestoreState(FILE* pf) #endif
m_pStack = NULL;
- // récupère la pile depuis l'enregistrement
- // utilise un pointeur NULL (m_pStack) mais c'est ok comme ça
+ // r�cup�re la pile depuis l'enregistrement
+ // utilise un pointeur NULL (m_pStack) mais c'est ok comme �a
if (!m_pStack->RestoreState(pf, m_pStack)) return FALSE;
m_pStack->SetBotCall(this); // bases pour les routines
- // rétabli certains états dans la pile selon la structure
+ // r�tabli certains �tats dans la pile selon la structure
m_pRun->RestoreState(NULL, m_pStack, m_pInstance);
return TRUE;
}
@@ -584,16 +597,16 @@ BOOL CBotCall::AddFunction(const char* name, {
if ( p->GivName() == name )
{
- // libère une fonction qu'on redéfini
+ // lib�re une fonction qu'on red�fini
if ( pp ) pp->m_next = p->m_next;
else m_ListCalls = p->m_next;
pp = p;
p = p->m_next;
- pp->m_next = NULL; // ne pas détruire la suite de la liste
+ pp->m_next = NULL; // ne pas d�truire la suite de la liste
delete pp;
continue;
}
- pp = p; // pointeur précédent
+ pp = p; // pointeur pr�c�dent
p = p->m_next;
}
@@ -607,7 +620,7 @@ BOOL CBotCall::AddFunction(const char* name, // transforme le tableau de pointeurs aux variables
-// en une liste de variables chaînées
+// en une liste de variables cha�n�es
CBotVar* MakeListVars(CBotVar** ppVars, BOOL bSetVal=FALSE)
{
int i = 0;
@@ -631,8 +644,8 @@ CBotVar* MakeListVars(CBotVar** ppVars, BOOL bSetVal=FALSE) return pVar;
}
-// trouve un appel acceptable selon le nom de la procédure
-// et les paramètres donnés
+// trouve un appel acceptable selon le nom de la proc�dure
+// et les param�tres donn�s
CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack* pStack, long& nIdent)
{
@@ -649,7 +662,7 @@ CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack* CBotTypResult r = pt->m_rComp(pVar2, m_pUser);
int ret = r.GivType();
- // si une classe est retournée, c'est en fait un pointeur
+ // si une classe est retourn�e, c'est en fait un pointeur
if ( ret == CBotTypClass ) r.SetType( ret = CBotTypPointer );
if ( ret > 20 )
@@ -730,19 +743,19 @@ int CBotCall::DoCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* fund:
#if !STACKRUN
- // fait la liste des paramètres selon le contenu de la pile (pStackVar)
+ // fait la liste des param�tres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVar, TRUE);
CBotVar* pVarToDelete = pVar;
- // crée une variable pour le résultat
+ // cr�e une variable pour le r�sultat
CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);
CBotVar* pRes = pResult;
int Exception = 0;
int res = pt->m_rExec(pVar, pResult, Exception, pStack->GivPUser());
- if ( pResult != pRes ) delete pRes; // si résultat différent rendu
+ if ( pResult != pRes ) delete pRes; // si r�sultat diff�rent rendu
delete pVarToDelete;
if (res == FALSE)
@@ -768,12 +781,12 @@ fund: CBotStack* pile = pStack->AddStackEOX(pt);
if ( pile == EOX ) return TRUE;
- // fait la liste des paramètres selon le contenu de la pile (pStackVar)
+ // fait la liste des param�tres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVar, TRUE);
CBotVar* pVarToDelete = pVar;
- // crée une variable pour le résultat
+ // cr�e une variable pour le r�sultat
CBotVar* pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);
pile->SetVar( pVar );
@@ -834,12 +847,12 @@ BOOL CBotCall::Run(CBotStack* pStack) {
pStack->SetError(Exception);
}
- if ( pResult != pRes ) delete pResult; // si résultat différent rendu
+ if ( pResult != pRes ) delete pResult; // si r�sultat diff�rent rendu
return FALSE;
}
if ( pResult != NULL ) pStack->SetCopyVar( pResult );
- if ( pResult != pRes ) delete pResult; // si résultat différent rendu
+ if ( pResult != pRes ) delete pResult; // si r�sultat diff�rent rendu
return TRUE;
}
@@ -865,8 +878,8 @@ CBotCallMethode::~CBotCallMethode() m_next = NULL;
}
-// trouve un appel acceptable selon le nom de la procédure
-// et les paramètres donnés
+// trouve un appel acceptable selon le nom de la proc�dure
+// et les param�tres donn�s
CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis,
CBotVar** ppVar, CBotCStack* pStack,
@@ -926,7 +939,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot {
if ( pt->m_nFuncIdent == nIdent )
{
- // fait la liste des paramètres selon le contenu de la pile (pStackVar)
+ // fait la liste des param�tres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVars, TRUE);
CBotVar* pVarToDelete = pVar;
@@ -959,7 +972,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot {
if ( pt->m_name == name )
{
- // fait la liste des paramètres selon le contenu de la pile (pStackVar)
+ // fait la liste des param�tres selon le contenu de la pile (pStackVar)
CBotVar* pVar = MakeListVars(ppVars, TRUE);
CBotVar* pVarToDelete = pVar;
@@ -1025,10 +1038,10 @@ BOOL rCBotDebug( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser )
{
- // pas de paramètre
+ // pas de param�tre
if ( pVar != NULL ) return CBotTypResult( TX_OVERPARAM );
- // la fonction retourne un résultat "string"
+ // la fonction retourne un r�sultat "string"
return CBotTypResult( CBotTypString );
}
@@ -1037,10 +1050,10 @@ CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser ) void CBotProgram::Init()
{
- CBotToken::DefineNum( "CBotErrOpenPar", 5000) ; // manque la parenthèse ouvrante
- CBotToken::DefineNum( "CBotErrClosePar", 5001) ; // manque la parenthèse fermante
- CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ; // l'expression doit être un boolean
- CBotToken::DefineNum( "CBotErrUndefVar", 5003) ; // variable non déclarée
+ CBotToken::DefineNum( "CBotErrOpenPar", 5000) ; // manque la parenth�se ouvrante
+ CBotToken::DefineNum( "CBotErrClosePar", 5001) ; // manque la parenth�se fermante
+ CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ; // l'expression doit �tre un boolean
+ CBotToken::DefineNum( "CBotErrUndefVar", 5003) ; // variable non d�clar�e
CBotToken::DefineNum( "CBotErrBadLeft", 5004) ; // assignation impossible ( 5 = ... )
CBotToken::DefineNum( "CBotErrNoTerminator", 5005) ;// point-virgule attendu
CBotToken::DefineNum( "CBotErrCaseOut", 5006) ; // case en dehors d'un switch
@@ -1048,8 +1061,8 @@ void CBotProgram::Init() CBotToken::DefineNum( "CBotErrElseWhitoutIf", 5009) ;// else sans if correspondant
CBotToken::DefineNum( "CBotErrOpenBlock", 5010) ; // manque " { "
CBotToken::DefineNum( "CBotErrBadType1", 5011) ; // mauvais type pour l'assignation
- CBotToken::DefineNum( "CBotErrRedefVar", 5012) ; // redéfinition de la variable
- CBotToken::DefineNum( "CBotErrBadType2", 5013) ; // 2 opérandes de type incompatibles
+ CBotToken::DefineNum( "CBotErrRedefVar", 5012) ; // red�finition de la variable
+ CBotToken::DefineNum( "CBotErrBadType2", 5013) ; // 2 op�randes de type incompatibles
CBotToken::DefineNum( "CBotErrUndefCall", 5014) ; // routine inconnue
CBotToken::DefineNum( "CBotErrNoDoubleDots", 5015) ;// " : " attendu
CBotToken::DefineNum( "CBotErrBreakOutside", 5017) ;// break en dehors d'une boucle
@@ -1058,28 +1071,28 @@ void CBotProgram::Init() CBotToken::DefineNum( "CBotErrNoCase", 5020) ; // manque " case "
CBotToken::DefineNum( "CBotErrBadNum", 5021) ; // nombre attendu
CBotToken::DefineNum( "CBotErrVoid", 5022) ; // " void " pas possible ici
- CBotToken::DefineNum( "CBotErrNoType", 5023) ; // déclaration de type attendue
+ CBotToken::DefineNum( "CBotErrNoType", 5023) ; // d�claration de type attendue
CBotToken::DefineNum( "CBotErrNoVar", 5024) ; // nom de variable attendu
CBotToken::DefineNum( "CBotErrNoFunc", 5025) ; // nom de fonction attendu
- CBotToken::DefineNum( "CBotErrOverParam", 5026) ; // trop de paramètres
- CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ; // cette fonction existe déjà
- CBotToken::DefineNum( "CBotErrLowParam", 5028) ; // pas assez de paramètres
- CBotToken::DefineNum( "CBotErrBadParam", 5029) ; // mauvais types de paramètres
- CBotToken::DefineNum( "CBotErrNbParam", 5030) ; // mauvais nombre de paramètres
- CBotToken::DefineNum( "CBotErrUndefItem", 5031) ; // élément n'existe pas dans la classe
+ CBotToken::DefineNum( "CBotErrOverParam", 5026) ; // trop de param�tres
+ CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ; // cette fonction existe d�j�
+ CBotToken::DefineNum( "CBotErrLowParam", 5028) ; // pas assez de param�tres
+ CBotToken::DefineNum( "CBotErrBadParam", 5029) ; // mauvais types de param�tres
+ CBotToken::DefineNum( "CBotErrNbParam", 5030) ; // mauvais nombre de param�tres
+ CBotToken::DefineNum( "CBotErrUndefItem", 5031) ; // �l�ment n'existe pas dans la classe
CBotToken::DefineNum( "CBotErrUndefClass", 5032) ; // variable n'est pas une classe
- CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ; // pas de constructeur approprié
- CBotToken::DefineNum( "CBotErrRedefClass", 5034) ; // classe existe déjà
+ CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ; // pas de constructeur appropri�
+ CBotToken::DefineNum( "CBotErrRedefClass", 5034) ; // classe existe d�j�
CBotToken::DefineNum( "CBotErrCloseIndex", 5035) ; // " ] " attendu
- CBotToken::DefineNum( "CBotErrReserved", 5036) ; // mot réservé (par un DefineNum)
+ CBotToken::DefineNum( "CBotErrReserved", 5036) ; // mot r�serv� (par un DefineNum)
-// voici la liste des erreurs pouvant être retournées par le module
-// pour l'exécution
+// voici la liste des erreurs pouvant �tre retourn�es par le module
+// pour l'ex�cution
- CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ; // division par zéro
- CBotToken::DefineNum( "CBotErrNotInit", 6001) ; // variable non initialisée
- CBotToken::DefineNum( "CBotErrBadThrow", 6002) ; // throw d'une valeur négative
- CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ; // fonction n'a pas retourné de résultat
+ CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ; // division par z�ro
+ CBotToken::DefineNum( "CBotErrNotInit", 6001) ; // variable non initialis�e
+ CBotToken::DefineNum( "CBotErrBadThrow", 6002) ; // throw d'une valeur n�gative
+ CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ; // fonction n'a pas retourn� de r�sultat
CBotToken::DefineNum( "CBotErrNoRun", 6004) ; // Run() sans fonction active
CBotToken::DefineNum( "CBotErrUndefFunc", 6005) ; // appel d'une fonction qui n'existe plus
diff --git a/src/CBot/CBotStack.cpp b/src/CBot/CBotStack.cpp index c313a8b..4809f66 100644 --- a/src/CBot/CBotStack.cpp +++ b/src/CBot/CBotStack.cpp @@ -1,5 +1,18 @@ -//////////////////////////////////////////////////////////////////////
-// gestion de la pile (stack)
+// * 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"
@@ -7,7 +20,7 @@ #define ITIMER 100
////////////////////////////////////////////////////////////////////////////
-// gestion de la pile d'exécution
+// gestion de la pile d'ex�cution
////////////////////////////////////////////////////////////////////////////
int CBotStack::m_initimer = ITIMER; // init la variable statique
@@ -28,14 +41,14 @@ CBotStack* CBotStack::FirstStack() long size = sizeof(CBotStack);
size *= (MAXSTACK+10);
- // demande une tranche mémoire pour la pile
+ // demande une tranche m�moire pour la pile
p = (CBotStack*)malloc(size);
// la vide totalement
memset(p, 0, size);
p-> m_bBlock = TRUE;
- m_timer = m_initimer; // met le timer au début
+ m_timer = m_initimer; // met le timer au d�but
CBotStack* pp = p;
pp += MAXSTACK;
@@ -54,19 +67,19 @@ CBotStack* CBotStack::FirstStack() }
#endif
- m_error = 0; // évite des blocages car m_error est static
+ m_error = 0; // �vite des blocages car m_error est static
return p;
}
CBotStack::CBotStack(CBotStack* ppapa)
{
- // constructeur doit exister, sinon le destructeur n'est jamais appelé !
+ // constructeur doit exister, sinon le destructeur n'est jamais appel� !
__asm int 3;
}
CBotStack::~CBotStack()
{
- __asm int 3; // utiliser Delete() à la place
+ __asm int 3; // utiliser Delete() � la place
}
void CBotStack::Delete()
@@ -79,10 +92,10 @@ void CBotStack::Delete() if (m_prev != NULL)
{
if ( m_prev->m_next == this )
- m_prev->m_next = NULL; // enlève de la chaîne
+ m_prev->m_next = NULL; // enl�ve de la cha�ne
if ( m_prev->m_next2 == this )
- m_prev->m_next2 = NULL; // enlève de la chaîne
+ m_prev->m_next2 = NULL; // enl�ve de la cha�ne
}
delete m_var;
@@ -94,7 +107,7 @@ void CBotStack::Delete() int n = m_index;
#endif
- // efface le bloc libéré
+ // efface le bloc lib�r�
memset(this, 0, sizeof(CBotStack));
m_bOver = bOver;
#ifdef _DEBUG
@@ -106,7 +119,7 @@ void CBotStack::Delete() }
-// routine optimisée
+// routine optimis�e
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
{
if (m_next != NULL)
@@ -127,7 +140,7 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock) }
while ( p->m_prev != NULL );
- m_next = p; // chaîne l'élément
+ m_next = p; // cha�ne l'�l�ment
p->m_bBlock = bBlock;
p->m_instr = instr;
p->m_prog = m_prog;
@@ -152,7 +165,7 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock) }
CBotStack* p = AddStack(NULL, bBlock);
p->m_call = instr;
- p->m_bFunc = 2; // spécial
+ p->m_bFunc = 2; // sp�cial
return p;
}
@@ -160,7 +173,7 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) {
if (m_next2 != NULL)
{
- m_next2->m_prog = m_prog; // spécial évite un RestoreStack2
+ m_next2->m_prog = m_prog; // sp�cial �vite un RestoreStack2
return m_next2; // reprise dans une pile existante
}
@@ -171,7 +184,7 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) }
while ( p->m_prev != NULL );
- m_next2 = p; // chaîne l'élément
+ m_next2 = p; // cha�ne l'�l�ment
p->m_prev = this;
p->m_bBlock = bBlock;
p->m_prog = m_prog;
@@ -186,13 +199,13 @@ BOOL CBotStack::GivBlock() BOOL CBotStack::Return(CBotStack* pfils)
{
- if ( pfils == this ) return TRUE; // spécial
+ if ( pfils == this ) return TRUE; // sp�cial
- if (m_var != NULL) delete m_var; // valeur remplacée ?
- m_var = pfils->m_var; // résultat transmis
- pfils->m_var = NULL; // ne pas détruire la variable
+ if (m_var != NULL) delete m_var; // valeur remplac�e ?
+ m_var = pfils->m_var; // r�sultat transmis
+ pfils->m_var = NULL; // ne pas d�truire la variable
- m_next->Delete();m_next = NULL; // libère la pile au dessus
+ m_next->Delete();m_next = NULL; // lib�re la pile au dessus
m_next2->Delete();m_next2 = NULL; // aussi la seconde pile (catch)
return (m_error == 0); // interrompu si erreur
@@ -200,11 +213,11 @@ BOOL CBotStack::Return(CBotStack* pfils) BOOL CBotStack::ReturnKeep(CBotStack* pfils)
{
- if ( pfils == this ) return TRUE; // spécial
+ if ( pfils == this ) return TRUE; // sp�cial
- if (m_var != NULL) delete m_var; // valeur remplacée ?
- m_var = pfils->m_var; // résultat transmis
- pfils->m_var = NULL; // ne pas détruire la variable
+ if (m_var != NULL) delete m_var; // valeur remplac�e ?
+ m_var = pfils->m_var; // r�sultat transmis
+ pfils->m_var = NULL; // ne pas d�truire la variable
return (m_error == 0); // interrompu si erreur
}
@@ -229,7 +242,7 @@ CBotStack::CBotStack(CBotStack* ppapa) m_state = 0;
m_step = 1;
- if (ppapa == NULL) m_timer = m_initimer; // met le timer au début
+ if (ppapa == NULL) m_timer = m_initimer; // met le timer au d�but
m_listVar = NULL;
m_bDontDelete = FALSE;
@@ -247,13 +260,13 @@ CBotStack::~CBotStack() if ( m_next != EOX) delete m_next;
delete m_next2;
if (m_prev != NULL && m_prev->m_next == this )
- m_prev->m_next = NULL; // enlève de la chaîne
+ m_prev->m_next = NULL; // enl�ve de la cha�ne
delete m_var;
if ( !m_bDontDelete ) delete m_listVar;
}
-// routine à optimiser
+// routine � optimiser
CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)
{
if (m_next != NULL)
@@ -261,7 +274,7 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock) return m_next; // reprise dans une pile existante
}
CBotStack* p = new CBotStack(this);
- m_next = p; // chaîne l'élément
+ m_next = p; // cha�ne l'�l�ment
p->m_bBlock = bBlock;
p->m_instr = instr;
p->m_prog = m_prog;
@@ -281,12 +294,12 @@ CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock) return m_next; // reprise dans une pile existante
}
CBotStack* p = new CBotStack(this);
- m_next = p; // chaîne l'élément
+ m_next = p; // cha�ne l'�l�ment
p->m_bBlock = bBlock;
p->m_call = instr;
p->m_prog = m_prog;
p->m_step = 0;
- p->m_bFunc = 2; // spécial
+ p->m_bFunc = 2; // sp�cial
return p;
}
@@ -294,12 +307,12 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) {
if (m_next2 != NULL)
{
- m_next2->m_prog = m_prog; // spécial évite un RestoreStack2
+ m_next2->m_prog = m_prog; // sp�cial �vite un RestoreStack2
return m_next2; // reprise dans une pile existante
}
CBotStack* p = new CBotStack(this);
- m_next2 = p; // chaîne l'élément
+ m_next2 = p; // cha�ne l'�l�ment
p->m_bBlock = bBlock;
p->m_prog = m_prog;
p->m_step = 0;
@@ -309,13 +322,13 @@ CBotStack* CBotStack::AddStack2(BOOL bBlock) BOOL CBotStack::Return(CBotStack* pfils)
{
- if ( pfils == this ) return TRUE; // spécial
+ if ( pfils == this ) return TRUE; // sp�cial
- if (m_var != NULL) delete m_var; // valeur remplacée ?
- m_var = pfils->m_var; // résultat transmis
- pfils->m_var = NULL; // ne pas détruite la variable
+ if (m_var != NULL) delete m_var; // valeur remplac�e ?
+ m_var = pfils->m_var; // r�sultat transmis
+ pfils->m_var = NULL; // ne pas d�truite la variable
- if ( m_next != EOX ) delete m_next; // libère la pile au dessus
+ if ( m_next != EOX ) delete m_next; // lib�re la pile au dessus
delete m_next2;m_next2 = NULL; // aussi la seconde pile (catch)
return (m_error == 0); // interrompu si erreur
@@ -323,7 +336,7 @@ BOOL CBotStack::Return(CBotStack* pfils) BOOL CBotStack::StackOver()
{
- return FALSE; // pas de test de débordement dans cette version
+ return FALSE; // pas de test de d�bordement dans cette version
}
#endif
@@ -345,7 +358,7 @@ CBotStack* CBotStack::RestoreStack(CBotInstr* instr) {
if (m_next != NULL)
{
- m_next->m_instr = instr; // réinit (si reprise après restitution)
+ m_next->m_instr = instr; // r�init (si reprise apr�s restitution)
m_next->m_prog = m_prog;
return m_next; // reprise dans une pile existante
}
@@ -361,7 +374,7 @@ CBotStack* CBotStack::RestoreStackEOX(CBotCall* instr) -// routine pour l'exécution pas à pas
+// routine pour l'ex�cution pas � pas
BOOL CBotStack::IfStep()
{
if ( m_initimer > 0 || m_step++ > 0 ) return FALSE;
@@ -389,7 +402,7 @@ BOOL CBotStack::IfContinue(int state, const char* name) if (!m_labelBreak.IsEmpty() && (name == NULL || m_labelBreak != name))
return FALSE; // c'est pas pour moi
- m_state = state; // où reprendre ?
+ m_state = state; // o� reprendre ?
m_error = 0;
m_labelBreak.Empty();
if ( m_next != EOX ) m_next->Delete(); // purge la pile au dessus
@@ -398,7 +411,7 @@ BOOL CBotStack::IfContinue(int state, const char* name) void CBotStack::SetBreak(int val, const char* name)
{
- m_error = -val; // réagit comme une Exception
+ m_error = -val; // r�agit comme une Exception
m_labelBreak = name;
if (val == 3) // pour un return
{
@@ -407,7 +420,7 @@ void CBotStack::SetBreak(int val, const char* name) }
}
-// remet sur la pile la valeur calculée par le dernier CBotReturn
+// remet sur la pile la valeur calcul�e par le dernier CBotReturn
BOOL CBotStack::GivRetVar(BOOL bRet)
{
@@ -453,7 +466,7 @@ void CBotStack::SetType(CBotTypResult& type) // trouve une variable par son token
-// ce peut être une variable composée avec un point
+// ce peut �tre une variable compos�e avec un point
CBotVar* CBotStack::FindVar(CBotToken* &pToken, BOOL bUpdate, BOOL bModif)
{
CBotStack* p = this;
@@ -497,7 +510,7 @@ CBotVar* CBotStack::FindVar(const char* name) return NULL;
}
-// retrouve une variable sur la pile selon son numéro d'identification
+// retrouve une variable sur la pile selon son num�ro d'identification
// ce qui va plus vite que de comparer les noms.
CBotVar* CBotStack::FindVar(long ident, BOOL bUpdate, BOOL bModif)
@@ -546,22 +559,22 @@ BOOL CBotStack::SetState(int n, int limite) {
m_state = n;
- m_timer--; // décompte les opérations
- return ( m_timer > limite ); // interrompu si timer passé
+ m_timer--; // d�compte les op�rations
+ return ( m_timer > limite ); // interrompu si timer pass�
}
BOOL CBotStack::IncState(int limite)
{
m_state++;
- m_timer--; // décompte les opérations
- return ( m_timer > limite ); // interrompu si timer passé
+ m_timer--; // d�compte les op�rations
+ return ( m_timer > limite ); // interrompu si timer pass�
}
void CBotStack::SetError(int n, CBotToken* token)
{
- if ( n!= 0 && m_error != 0) return; // ne change pas une erreur déjà existante
+ if ( n!= 0 && m_error != 0) return; // ne change pas une erreur d�j� existante
m_error = n;
if (token != NULL)
{
@@ -590,7 +603,7 @@ void CBotStack::SetTimer(int n) BOOL CBotStack::Execute()
{
- CBotCall* instr = NULL; // instruction la plus élevée
+ CBotCall* instr = NULL; // instruction la plus �lev�e
CBotStack* pile;
CBotStack* p = this;
@@ -606,9 +619,9 @@ BOOL CBotStack::Execute() p = p->m_next;
}
- if ( instr == NULL ) return TRUE; // exécution normale demandée
+ if ( instr == NULL ) return TRUE; // ex�cution normale demand�e
- if (!instr->Run(pile)) return FALSE; // exécution à partir de là
+ if (!instr->Run(pile)) return FALSE; // ex�cution � partir de l�
#if STACKMEM
pile->m_next->Delete();
@@ -616,11 +629,11 @@ BOOL CBotStack::Execute() delete pile->m_next;
#endif
- pile->m_next = EOX; // spécial pour reprise
+ pile->m_next = EOX; // sp�cial pour reprise
return TRUE;
}
-// met sur le stack le pointeur à une variable
+// met sur le stack le pointeur � une variable
void CBotStack::SetVar( CBotVar* var )
{
if (m_var) delete m_var; // remplacement d'une variable
@@ -644,7 +657,7 @@ CBotVar* CBotStack::GivVar() CBotVar* CBotStack::GivPtVar()
{
CBotVar* p = m_var;
- m_var = NULL; // ne sera pas détruit donc
+ m_var = NULL; // ne sera pas d�truit donc
return p;
}
@@ -669,7 +682,7 @@ void CBotStack::AddVar(CBotVar* pVar) {
CBotStack* p = this;
- // revient sur l'élement père
+ // revient sur l'�lement p�re
while (p != NULL && p->m_bBlock == 0) p = p->m_prev;
if ( p == NULL ) return;
@@ -679,7 +692,7 @@ void CBotStack::AddVar(CBotVar* pVar) CBotVar** pp = &p->m_listVar;
while ( *pp != NULL ) pp = &(*pp)->m_next;
- *pp = pVar; // ajoute à la suite
+ *pp = pVar; // ajoute � la suite
#ifdef _DEBUG
if ( pVar->GivUniqNum() == 0 ) __asm int 3;
@@ -725,7 +738,7 @@ BOOL CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBo res = m_prog->GivFunctions()->DoCall(nIdent, NULL, ppVar, this, token );
if (res.GivType() >= 0) return res.GivType();
- // si pas trouvé (recompilé ?) cherche selon le nom
+ // si pas trouv� (recompil� ?) cherche selon le nom
nIdent = 0;
res = CBotCall::DoCall(nIdent, token, ppVar, this, rettype );
@@ -756,7 +769,7 @@ BOOL SaveVar(FILE* pf, CBotVar* pVar) return WriteWord(pf, 0); // met un terminateur
}
- if ( !pVar->Save0State(pf)) return FALSE; // entête commune
+ if ( !pVar->Save0State(pf)) return FALSE; // ent�te commune
if ( !pVar->Save1State(pf) ) return FALSE; // sauve selon la classe fille
pVar = pVar->GivNext();
@@ -767,8 +780,8 @@ void CBotStack::GetRunPos(const char* &FunctionName, int &start, int &end) {
CBotProgram* prog = m_prog; // programme courrant
- CBotInstr* funct = NULL; // fonction trouvée
- CBotInstr* instr = NULL; // instruction la plus élevée
+ CBotInstr* funct = NULL; // fonction trouv�e
+ CBotInstr* instr = NULL; // instruction la plus �lev�e
CBotStack* p = this;
@@ -814,7 +827,7 @@ CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level) }
- // descend sur les éléments de block
+ // descend sur les �l�ments de block
while ( p != NULL && !p->m_bBlock ) p = p->m_prev;
while ( p != NULL && level++ < 0 )
@@ -858,12 +871,12 @@ BOOL CBotStack::SaveState(FILE* pf) if (!WriteWord(pf, 1)) return FALSE; // une marque de poursuite
}
if (!WriteWord(pf, m_bBlock)) return FALSE; // est-ce un bloc local
- if (!WriteWord(pf, m_state)) return FALSE; // dans quel état
- if (!WriteWord(pf, 0)) return FALSE; // par compatibilité m_bDontDelete
- if (!WriteWord(pf, m_step)) return FALSE; // dans quel état
+ if (!WriteWord(pf, m_state)) return FALSE; // dans quel �tat
+ if (!WriteWord(pf, 0)) return FALSE; // par compatibilit� m_bDontDelete
+ if (!WriteWord(pf, m_step)) return FALSE; // dans quel �tat
- if (!SaveVar(pf, m_var)) return FALSE; // le résultat courant
+ if (!SaveVar(pf, m_var)) return FALSE; // le r�sultat courant
if (!SaveVar(pf, m_listVar)) return FALSE; // les variables locales
return m_next->SaveState(pf); // enregistre la suite
@@ -893,13 +906,13 @@ BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack) if (!ReadWord(pf, w)) return FALSE; // est-ce un bloc local
pStack->m_bBlock = w;
- if (!ReadWord(pf, w)) return FALSE; // dans quel état j'ère ?
- pStack->SetState((short)w); // dans le bon état
+ if (!ReadWord(pf, w)) return FALSE; // dans quel �tat j'�re ?
+ pStack->SetState((short)w); // dans le bon �tat
if (!ReadWord(pf, w)) return FALSE; // dont delete ?
- // plus utilisé
+ // plus utilis�
- if (!ReadWord(pf, w)) return FALSE; // pas à pas
+ if (!ReadWord(pf, w)) return FALSE; // pas � pas
pStack->m_step = w;
if (!CBotVar::RestoreState(pf, pStack->m_var)) return FALSE; // la variable temp
@@ -911,10 +924,10 @@ BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack) BOOL CBotVar::Save0State(FILE* pf)
{
- if (!WriteWord(pf, 100+m_mPrivate))return FALSE; // variable privée ?
+ if (!WriteWord(pf, 100+m_mPrivate))return FALSE; // variable priv�e ?
if (!WriteWord(pf, m_bStatic))return FALSE; // variable static ?
if (!WriteWord(pf, m_type.GivType()))return FALSE; // enregiste le type (toujours non nul)
- if (!WriteWord(pf, m_binit))return FALSE; // variable définie ?
+ if (!WriteWord(pf, m_binit))return FALSE; // variable d�finie ?
return WriteString(pf, m_token->GivString()); // et le nom de la variable
}
@@ -922,7 +935,7 @@ BOOL CBotVarInt::Save0State(FILE* pf) {
if ( !m_defnum.IsEmpty() )
{
- if(!WriteWord(pf, 200 )) return FALSE; // marqueur spécial
+ if(!WriteWord(pf, 200 )) return FALSE; // marqueur sp�cial
if(!WriteString(pf, m_defnum)) return FALSE; // nom de la valeur
}
@@ -971,9 +984,9 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) CBotVar* pNew = NULL;
CBotVar* pPrev = NULL;
- while ( TRUE ) // recupère toute une liste
+ while ( TRUE ) // recup�re toute une liste
{
- if (!ReadWord(pf, w)) return FALSE; // privé ou type ?
+ if (!ReadWord(pf, w)) return FALSE; // priv� ou type ?
if ( w == 0 ) return TRUE;
CBotString defnum;
@@ -991,7 +1004,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) if (!ReadWord(pf, w)) return FALSE; // type
}
- if ( w == CBotTypClass ) w = CBotTypIntrinsic; // forcément intrinsèque
+ if ( w == CBotTypClass ) w = CBotTypIntrinsic; // forc�ment intrins�que
if (!ReadWord(pf, wi)) return FALSE; // init ?
@@ -1003,22 +1016,22 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) {
case CBotTypInt:
case CBotTypBoolean:
- pNew = CBotVar::Create(&token, w); // crée une variable
+ pNew = CBotVar::Create(&token, w); // cr�e une variable
if (!ReadWord(pf, w)) return FALSE;
pNew->SetValInt((short)w, defnum);
break;
case CBotTypFloat:
- pNew = CBotVar::Create(&token, w); // crée une variable
+ pNew = CBotVar::Create(&token, w); // cr�e une variable
if (!ReadFloat(pf, ww)) return FALSE;
pNew->SetValFloat(ww);
break;
case CBotTypString:
- pNew = CBotVar::Create(&token, w); // crée une variable
+ pNew = CBotVar::Create(&token, w); // cr�e une variable
if (!ReadString(pf, s)) return FALSE;
pNew->SetValString(s);
break;
- // restitue un objet intrinsic ou un élément d'un array
+ // restitue un objet intrinsic ou un �l�ment d'un array
case CBotTypIntrinsic:
case CBotTypArrayBody:
{
@@ -1032,7 +1045,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) CBotVar* p = NULL;
if ( id ) p = CBotVarClass::Find(id) ;
- pNew = new CBotVarClass(&token, r); // crée directement une instance
+ pNew = new CBotVarClass(&token, r); // cr�e directement une instance
// attention cptuse = 0
if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return FALSE;
pNew->SetIdent(id);
@@ -1040,7 +1053,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) if ( p != NULL )
{
delete pNew;
- pNew = p; // reprend l'élément connu
+ pNew = p; // reprend l'�l�ment connu
}
}
}
@@ -1050,7 +1063,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) case CBotTypNullPointer:
if (!ReadString(pf, s)) return FALSE;
{
- pNew = CBotVar::Create(&token, CBotTypResult(w, s));// crée une variable
+ pNew = CBotVar::Create(&token, CBotTypResult(w, s));// cr�e une variable
CBotVarClass* p = NULL;
long id;
ReadLong(pf, id);
@@ -1061,7 +1074,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) if ( !CBotVar::RestoreState( pf, pInstance ) ) return FALSE;
((CBotVarPointer*)pNew)->SetPointer( pInstance ); // et pointe dessus
-// if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p ); // plutôt celui-ci !
+// if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p ); // plut�t celui-ci !
}
break;
@@ -1071,7 +1084,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) CBotTypResult r;
if (!ReadType(pf, r)) return FALSE;
- pNew = CBotVar::Create(&token, r); // crée une variable
+ pNew = CBotVar::Create(&token, r); // cr�e une variable
// restitue une copie de l'instance d'origine
CBotVar* pInstance = NULL;
@@ -1098,7 +1111,7 @@ BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar) ////////////////////////////////////////////////////////////////////////////
-// gestion de la pile à la compilation
+// gestion de la pile � la compilation
////////////////////////////////////////////////////////////////////////////
CBotProgram* CBotCStack::m_prog = NULL; // init la variable statique
@@ -1134,19 +1147,19 @@ CBotCStack::CBotCStack(CBotCStack* ppapa) CBotCStack::~CBotCStack()
{
if (m_next != NULL) delete m_next;
- if (m_prev != NULL) m_prev->m_next = NULL; // enlève de la chaîne
+ if (m_prev != NULL) m_prev->m_next = NULL; // enl�ve de la cha�ne
delete m_var;
delete m_listVar;
}
-// utilisé uniquement à la compilation
+// utilis� uniquement � la compilation
CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, BOOL bBlock)
{
if (m_next != NULL) return m_next; // reprise dans une pile existante
CBotCStack* p = new CBotCStack(this);
- m_next = p; // chaîne l'élément
+ m_next = p; // cha�ne l'�l�ment
p->m_bBlock = bBlock;
if (pToken != NULL) p->SetStartError(pToken->GivStart());
@@ -1159,13 +1172,13 @@ CBotInstr* CBotCStack::Return(CBotInstr* inst, CBotCStack* pfils) {
if ( pfils == this ) return inst;
- if (m_var != NULL) delete m_var; // valeur remplacée ?
- m_var = pfils->m_var; // résultat transmis
- pfils->m_var = NULL; // ne pas détruire la variable
+ if (m_var != NULL) delete m_var; // valeur remplac�e ?
+ m_var = pfils->m_var; // r�sultat transmis
+ pfils->m_var = NULL; // ne pas d�truire la variable
if (m_error)
{
- m_start = pfils->m_start; // récupère la position de l'erreur
+ m_start = pfils->m_start; // r�cup�re la position de l'erreur
m_end = pfils->m_end;
}
@@ -1175,13 +1188,13 @@ CBotInstr* CBotCStack::Return(CBotInstr* inst, CBotCStack* pfils) CBotFunction* CBotCStack::ReturnFunc(CBotFunction* inst, CBotCStack* pfils)
{
- if (m_var != NULL) delete m_var; // valeur remplacée ?
- m_var = pfils->m_var; // résultat transmis
- pfils->m_var = NULL; // ne pas détruire la variable
+ if (m_var != NULL) delete m_var; // valeur remplac�e ?
+ m_var = pfils->m_var; // r�sultat transmis
+ pfils->m_var = NULL; // ne pas d�truire la variable
if (m_error)
{
- m_start = pfils->m_start; // récupère la position de l'erreur
+ m_start = pfils->m_start; // r�cup�re la position de l'erreur
m_end = pfils->m_end;
}
@@ -1235,7 +1248,7 @@ void CBotCStack::SetType(CBotTypResult& type) }
// cherche une variable sur la pile
-// le token peut être une suite de TokenTypVar (objet d'une classe)
+// le token peut �tre une suite de TokenTypVar (objet d'une classe)
// ou un pointeur dans le source
CBotVar* CBotCStack::FindVar(CBotToken* &pToken)
@@ -1284,20 +1297,20 @@ BOOL CBotCStack::IsOk() void CBotCStack::SetStartError( int pos )
{
- if ( m_error != 0) return; // ne change pas une erreur déjà existante
+ if ( m_error != 0) return; // ne change pas une erreur d�j� existante
m_start = pos;
}
void CBotCStack::SetError(int n, int pos)
{
- if ( n!= 0 && m_error != 0) return; // ne change pas une erreur déjà existante
+ if ( n!= 0 && m_error != 0) return; // ne change pas une erreur d�j� existante
m_error = n;
m_end = pos;
}
void CBotCStack::SetError(int n, CBotToken* p)
{
- if (m_error) return; // ne change pas une erreur déjà existante
+ if (m_error) return; // ne change pas une erreur d�j� existante
m_error = n;
m_start = p->GivStart();
m_end = p->GivEnd();
@@ -1366,7 +1379,7 @@ void CBotCStack::AddVar(CBotVar* pVar) {
CBotCStack* p = this;
- // revient sur l'élement père
+ // revient sur l'�lement p�re
while (p != NULL && p->m_bBlock == 0) p = p->m_prev;
if ( p == NULL ) return;
@@ -1374,14 +1387,14 @@ void CBotCStack::AddVar(CBotVar* pVar) CBotVar** pp = &p->m_listVar;
while ( *pp != NULL ) pp = &(*pp)->m_next;
- *pp = pVar; // ajoute à la suite
+ *pp = pVar; // ajoute � la suite
#ifdef _DEBUG
if ( pVar->GivUniqNum() == 0 ) __asm int 3;
#endif
}
-// test si une variable est déjà définie localement
+// test si une variable est d�j� d�finie localement
BOOL CBotCStack::CheckVarLocal(CBotToken* &pToken)
{
@@ -1414,7 +1427,7 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId val = m_prog->GivFunctions()->CompileCall(p->GivString(), ppVars, nIdent);
if ( val.GivType() < 0 )
{
- // pVar = NULL; // l'erreur n'est pas sur un paramètre en particulier
+ // pVar = NULL; // l'erreur n'est pas sur un param�tre en particulier
SetError( -val.GivType(), p );
val.SetType(-val.GivType());
return val;
@@ -1423,7 +1436,7 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId return val;
}
-// test si un nom de procédure est déjà défini quelque part
+// test si un nom de proc�dure est d�j� d�fini quelque part
BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
@@ -1436,7 +1449,7 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) {
if ( pToken->GivString() == pp->GivName() )
{
- // les paramètres sont-ils exactement les mêmes ?
+ // les param�tres sont-ils exactement les m�mes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
}
@@ -1448,7 +1461,7 @@ BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam) {
if ( pToken->GivString() == pp->GivName() )
{
- // les paramètres sont-ils exactement les mêmes ?
+ // les param�tres sont-ils exactement les m�mes ?
if ( pp->CheckParam( pParam ) )
return TRUE;
}
diff --git a/src/CBot/CBotString.cpp b/src/CBot/CBotString.cpp index bcbe399..09c45fb 100644 --- a/src/CBot/CBotString.cpp +++ b/src/CBot/CBotString.cpp @@ -1,13 +1,24 @@ -/////////////////////////////////////////////////////
-// gestion de chaine
-// basé sur le CString de MFC
-// mais moins complet
+// * 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"
#include <string.h>
-HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("Cbot.dll"); // comment le récupérer autrement ??
+HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("Cbot.dll"); // comment le r�cup�rer autrement ??
CBotString::CBotString()
@@ -438,7 +449,7 @@ CBotStringArray::CBotStringArray() CBotStringArray::~CBotStringArray()
{
- SetSize(0); // détruit les données !
+ SetSize(0); // d�truit les donn�es !
}
@@ -503,7 +514,7 @@ static void CopyElements(CBotString* pDest, CBotString* pSrc, int nCount) -// sélect la taille du tableau
+// s�lect la taille du tableau
void CBotStringArray::SetSize(int nNewSize)
{
diff --git a/src/CBot/CBotToken.cpp b/src/CBot/CBotToken.cpp index 4e99cf9..6fd9e33 100644 --- a/src/CBot/CBotToken.cpp +++ b/src/CBot/CBotToken.cpp @@ -1,10 +1,21 @@ -//////////////////////////////////////////////////////////////////
-// Gestion des Tokens
-// le texte d'un programme est d'abord transformé
-// en une suite de tokens pour facilité l'interprétation
+// * 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 .
// il faudra traiter le seul cas d'erreur possible
-// qui est un caractère illégal dans une string
+// qui est un caract�re ill�gal dans une string
#include "CBot.h"
@@ -20,7 +31,7 @@ CBotToken::CBotToken() m_next = NULL;
m_prev = NULL;
- m_type = TokenTypVar; // à priori un nom d'une variable
+ m_type = TokenTypVar; // � priori un nom d'une variable
m_IdKeyWord = -1;
}
@@ -53,14 +64,14 @@ CBotToken::CBotToken(const CBotToken* pSrc) CBotToken::CBotToken(CBotString& mot, CBotString& sep, int start, int end)
{
- m_Text = mot; // mot trouvé comme token
- m_Sep = sep; // séparateurs qui suivent
+ m_Text = mot; // mot trouv� comme token
+ m_Sep = sep; // s�parateurs qui suivent
m_next = NULL;
m_prev = NULL;
m_start = start;
m_end = end;
- m_type = TokenTypVar; // à priori un nom d'une variable
+ m_type = TokenTypVar; // � priori un nom d'une variable
m_IdKeyWord = -1;
}
@@ -71,13 +82,13 @@ CBotToken::CBotToken(const char* mot, const char* sep) m_next = NULL;
m_prev = NULL;
- m_type = TokenTypVar; // à priori un nom d'une variable
+ m_type = TokenTypVar; // � priori un nom d'une variable
m_IdKeyWord = -1;
}
CBotToken::~CBotToken()
{
- delete m_next; // récursif
+ delete m_next; // r�cursif
m_next = NULL;
}
@@ -199,54 +210,54 @@ BOOL Char2InList(const char c, const char cc, const char* list) }
static char* sep1 = " \r\n\t,:()[]{}-+*/=;><!~^|&%.";
-static char* sep2 = " \r\n\t"; // séparateurs pures
-static char* sep3 = ",:()[]{}-+*/=;<>!~^|&%."; // séparateurs opérationnels
-static char* num = "0123456789"; // le point (unique) est testé séparément
+static char* sep2 = " \r\n\t"; // s�parateurs pures
+static char* sep3 = ",:()[]{}-+*/=;<>!~^|&%."; // s�parateurs op�rationnels
+static char* num = "0123456789"; // le point (unique) est test� s�par�ment
static char* hexnum = "0123456789ABCDEFabcdef";
-static char* nch = "\"\r\n\t"; // refusé dans les chaines
+static char* nch = "\"\r\n\t"; // refus� dans les chaines
-//static char* duo = "+=-=*=/===!=<=>=++--///**/||&&";// les opérateurs doubles
+//static char* duo = "+=-=*=/===!=<=>=++--///**/||&&";// les op�rateurs doubles
// cherche le prochain token dans une phrase
-// ne doit pas commencer par des séparateurs
-// qui sont pris avec le token précédent
+// ne doit pas commencer par des s�parateurs
+// qui sont pris avec le token pr�c�dent
CBotToken* CBotToken::NextToken(char* &program, int& error, BOOL first)
{
- CBotString mot; // le mot trouvé
- CBotString sep; // les séparateurs qui le suivent
+ CBotString mot; // le mot trouv�
+ CBotString sep; // les s�parateurs qui le suivent
char c;
BOOL stop = first;
if (*program == 0) return NULL;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
if (!first)
{
mot = c; // construit le mot
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
- // cas particulier pour les chaînes de caractères
+ // cas particulier pour les cha�nes de caract�res
if ( mot[0] == '\"' )
{
while (c != 0 && !CharInList(c, nch))
{
mot += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
if ( c == '\\' )
{
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
if ( c == 'n' ) c = '\n';
if ( c == 'r' ) c = '\r';
if ( c == 't' ) c = '\t';
mot += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
}
}
if ( c == '\"' )
{
- mot += c; // chaîne complète
- c = *(program++); // prochain caractère
+ mot += c; // cha�ne compl�te
+ c = *(program++); // prochain caract�re
}
stop = TRUE;
}
@@ -254,30 +265,30 @@ CBotToken* CBotToken::NextToken(char* &program, int& error, BOOL first) // cas particulier pour les nombres
if ( CharInList(mot[0], num ))
{
- BOOL bdot = FALSE; // trouvé un point ?
- BOOL bexp = FALSE; // trouvé un exposant ?
+ BOOL bdot = FALSE; // trouv� un point ?
+ BOOL bexp = FALSE; // trouv� un exposant ?
char* liste = num;
- if (mot[0] == '0' && c == 'x') // valeur hexadécimale ?
+ if (mot[0] == '0' && c == 'x') // valeur hexad�cimale ?
{
mot += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
liste = hexnum;
}
cw:
while (c != 0 && CharInList(c, liste))
{
cc: mot += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
}
- if ( liste == num ) // pas pour les exadécimaux
+ if ( liste == num ) // pas pour les exad�cimaux
{
if ( !bdot && c == '.' ) { bdot = TRUE; goto cc; }
if ( !bexp && ( c == 'e' || c == 'E' ) )
{
bexp = TRUE;
mot += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
if ( c == '-' ||
c == '+' ) goto cc;
goto cw;
@@ -287,13 +298,13 @@ cc: mot += c; stop = TRUE;
}
- if (CharInList(mot[0], sep3)) // un séparateur opérationnel ?
+ if (CharInList(mot[0], sep3)) // un s�parateur op�rationnel ?
{
CBotString motc = mot;
- while (motc += c, c != 0 && GivKeyWords(motc)>0) // cherche l'opérande le plus long possible
+ while (motc += c, c != 0 && GivKeyWords(motc)>0) // cherche l'op�rande le plus long possible
{
mot += c; // construit le mot
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
}
stop = TRUE;
@@ -310,7 +321,7 @@ cc: mot += c; bis:
while (CharInList(c, sep2))
{
- sep += c; // tous les séparateurs qui suivent
+ sep += c; // tous les s�parateurs qui suivent
c = *(program++);
}
if (c == '/' && *program == '/') // un commentaire dans le tas ?
@@ -318,7 +329,7 @@ bis: while( c != '\n' && c != 0 )
{
sep += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
}
goto bis;
}
@@ -328,14 +339,14 @@ bis: while( c != 0 && (c != '*' || *program != '/'))
{
sep += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
}
if ( c != 0 )
{
sep += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
sep += c;
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
}
goto bis;
}
@@ -356,7 +367,7 @@ bis: }
mot += c; // construit le mot
- c = *(program++); // prochain caractère
+ c = *(program++); // prochain caract�re
}
}
@@ -379,12 +390,12 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error) char* pp = p;
while (NULL != (nxt = NextToken(p, error)))
{
- prv->m_next = nxt; // ajoute à la suite
+ prv->m_next = nxt; // ajoute � la suite
nxt->m_prev = prv;
prv = nxt; // avance
nxt->m_start = pos;
-/* pos += nxt->m_Text.GivLength(); // la chaîne peut être plus courte (BOA supprimés)
+/* pos += nxt->m_Text.GivLength(); // la cha�ne peut �tre plus courte (BOA supprim�s)
nxt->m_end = pos;
pos += nxt->m_Sep.GivLength();*/
pos += (p - pp); // taille totale
@@ -393,10 +404,10 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error) }
// ajoute un token comme terminateur
- // ( utile pour avoir le précédent )
+ // ( utile pour avoir le pr�c�dent )
nxt = new CBotToken();
nxt->m_type = 0;
- prv->m_next = nxt; // ajoute à la suite
+ prv->m_next = nxt; // ajoute � la suite
nxt->m_prev = prv;
return tokenbase;
@@ -417,7 +428,7 @@ int CBotToken::GivKeyWords(const char* w) if (l == 0)
{
- LoadKeyWords(); // prend la liste la première fois
+ LoadKeyWords(); // prend la liste la premi�re fois
l = m_ListKeyWords.GivSize();
}
@@ -511,8 +522,8 @@ BOOL IsOfType(CBotToken* &p, int type1, int type2) return FALSE;
}
-// idem avec un nombre indéfini d'arguments
-// il faut mettre un zéro comme dernier argument
+// idem avec un nombre ind�fini d'arguments
+// il faut mettre un z�ro comme dernier argument
BOOL IsOfTypeList(CBotToken* &p, int type1, ...)
{
int i = type1;
diff --git a/src/CBot/CBotToken.h b/src/CBot/CBotToken.h index 2715dd5..5c54c55 100644 --- a/src/CBot/CBotToken.h +++ b/src/CBot/CBotToken.h @@ -1,12 +1,25 @@ -////////////////////////////////////////////////////////////////////
-// interpréteur pour le language CBot du jeu COLOBOT
+// * 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 .
-// un programme écrit est tout d'abord transformé en une liste de tokens
+// un programme �crit est tout d'abord transform� en une liste de tokens
// avant d'aborder le compilateur proprement dit
// par exemple
// int var = 3 * ( pos.y + x )
-// est décomposé en (chaque ligne est un token)
+// est d�compos� en (chaque ligne est un token)
// int
// var
// =
diff --git a/src/CBot/CBotTwoOpExpr ordre inversé.cpp b/src/CBot/CBotTwoOpExpr ordre inversé.cpp index 65adcba..7ef646e 100644 --- a/src/CBot/CBotTwoOpExpr ordre inversé.cpp +++ b/src/CBot/CBotTwoOpExpr ordre inversé.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"
@@ -19,14 +31,14 @@ CBotTwoOpExpr::~CBotTwoOpExpr() delete m_rightop;
}
-// type d'opérandes acceptés par les opérations
+// type d'op�randes accept�s par les op�rations
#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
#define BOOLEEN (1<<CBotTypBoolean)
#define CHAINE (1<<CBotTypString)
#define CLASSE (1<<CBotTypClass)
-// liste des opérations (précéance)
+// liste des op�rations (pr�c�ance)
static int ListOp[] =
{
BOOLEEN, ID_LOG_OR, 0,
@@ -82,40 +94,40 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
- // cherche des instructions qui peuvent convenir à gauche de l'opération
- CBotInstr* left = CBotParExpr::Compile( p, pStk ) ; // expression (...) à gauche
+ // cherche des instructions qui peuvent convenir � gauche de l'op�ration
+ CBotInstr* left = CBotParExpr::Compile( p, pStk ) ; // expression (...) � gauche
if (left == NULL) return pStack->Return(NULL, pStk); // si erreur, la transmet
CBotToken* pp = p;
- int TypeOp = pp->GetType(); // type d'opération
- p = p->Next(); // saute le token de l'opération
+ int TypeOp = pp->GetType(); // type d'op�ration
+ p = p->Next(); // saute le token de l'op�ration
- // cherche des instructions qui peuvent convenir à droite
+ // cherche des instructions qui peuvent convenir � droite
CBotInstr* right = (*pOp == 0) ?
- CBotParExpr::Compile( p, pStk ) : // expression (...) à droite
- CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A op B à droite
+ CBotParExpr::Compile( p, pStk ) : // expression (...) � droite
+ CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A op B � droite
- if (right == NULL) return pStack->Return(left, pStk); // pas d'opérande à droite ?
+ if (right == NULL) return pStack->Return(left, pStk); // pas d'op�rande � droite ?
- // est-ce qu'on a l'opération prévue entre les deux ?
+ // est-ce qu'on a l'op�ration pr�vue entre les deux ?
if ( IsInList( TypeOp, pOperations, typemasque ) )
{
- CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // élément pour opération
- inst->SetToken(pp); // mémorise l'opération
+ CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // �l�ment pour op�ration
+ inst->SetToken(pp); // m�morise l'op�ration
int type1, type2;
- type1 = pStk->GetType(); // de quel type le premier opérande ?
+ type1 = pStk->GetType(); // de quel type le premier op�rande ?
inst->m_rightop = right;
{
- // il y a un second opérande acceptable
+ // il y a un second op�rande acceptable
- type2 = pStk->GetType(); // de quel type le résultat ?
+ type2 = pStk->GetType(); // de quel type le r�sultat ?
- // quel est le type du résultat ?
+ // quel est le type du r�sultat ?
int TypeRes = MAX( type1, type2 );
if (!TypeOk( TypeRes, typemasque )) type1 = 99; // erreur de type
@@ -131,83 +143,83 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera case ID_LS:
TypeRes = CBotTypBoolean;
}
- if ( TypeCompatible (type1, type2) || // les résultats sont-ils compatibles
- // cas particulier pour les concaténation de chaînes
+ if ( TypeCompatible (type1, type2) || // les r�sultats sont-ils compatibles
+ // cas particulier pour les concat�nation de cha�nes
(TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString)))
{
- // si ok, enregistre l'opérande dans l'objet
+ // si ok, enregistre l'op�rande dans l'objet
inst->m_leftop = left;
- // met une variable sur la pile pour avoir le type de résultat
+ // met une variable sur la pile pour avoir le type de r�sultat
pStk->SetVar(new CBotVar(NULL, TypeRes));
- // et rend l'object à qui l'a demandé
+ // 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);
}
-// fait l'opération d'addition ou de soustraction
+// fait l'op�ration d'addition ou de soustraction
BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile
+ CBotStack* pStk1 = pStack->AddStack(); // ajoute un �l�ment � la pile
// ou le retrouve en cas de reprise
// if ( pStk1 == EOX ) return TRUE;
- // selon la reprise, on peut être dans l'un des 2 états
+ // selon la reprise, on peut �tre dans l'un des 2 �tats
- if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
+ 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
+ // passe � l'�tape suivante
+ pStk1->SetState(1); // pr�t pour la suite
- // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
+ // pour les OU et ET logique, n'�value pas la seconde expression si pas n�cessaire
if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE )
{
CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
res->SetValInt(FALSE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
+ return pStack->Return(pStk1); // transmet le r�sultat
}
if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE )
{
CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
res->SetValInt(TRUE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
+ return pStack->Return(pStk1); // transmet le r�sultat
}
- // 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 ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
- int type1 = pStk1->GetType(); // de quels types les résultats ?
+ int type1 = pStk1->GetType(); // de quels types les r�sultats ?
int type2 = pStk2->GetType();
- // crée une variable temporaire pour y mettre le résultat
- // quel est le type du résultat ?
+ // cr�e une variable temporaire pour y mettre le r�sultat
+ // quel est le type du r�sultat ?
int TypeRes = MAX(type1, type2);
switch ( GetTokenType() )
{
@@ -225,7 +237,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) );
int err = 0;
- // fait l'opération selon la demande
+ // fait l'op�ration selon la demande
switch (GetTokenType())
{
case ID_ADD:
@@ -244,28 +256,28 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division
break;
case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_LOG_AND:
case ID_AND:
@@ -292,11 +304,11 @@ 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(pStk1); // transmet le résultat
+ pStk1->Return(pStk2); // lib�re la pile
+ return pStack->Return(pStk1); // transmet le r�sultat
}
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<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
#define BOOLEEN (1<<CBotTypBoolean)
@@ -43,9 +55,9 @@ CBotLogicExpr::~CBotLogicExpr() #define POINTER (1<<CBotTypPointer)
#define INSTANCE (1<<CBotTypClass)
-// liste des opérations (précéance)
-// type acceptable, opérande
-// le zéro termine un niveau de précéance
+// liste des op�rations (pr�c�ance)
+// type acceptable, op�rande
+// le z�ro termine un niveau de pr�c�ance
static int ListOp[] =
{
@@ -112,21 +124,21 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera CBotCStack* pStk = pStack->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
diff --git a/src/CBot/CBotVar.cpp b/src/CBot/CBotVar.cpp index bd5e889..bd6fe31 100644 --- a/src/CBot/CBotVar.cpp +++ b/src/CBot/CBotVar.cpp @@ -1,8 +1,20 @@ -////////////////////////////////////////////////////////////////////
-// Définition pour la classe CBotVar
-// gestion des variables du langage CBot
-
-// on ne crée jamais d'instance de la class mère CBotVar
+// * 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 .
+
+// on ne cr�e jamais d'instance de la class m�re CBotVar
#include "CBot.h"
@@ -106,7 +118,7 @@ CBotVarClass::CBotVarClass( const CBotToken* name, CBotTypResult& type) //, int void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type ) //, int &nIdent )
{*/
if ( !type.Eq(CBotTypClass) &&
- !type.Eq(CBotTypIntrinsic) && // par comodité accepte ces types
+ !type.Eq(CBotTypIntrinsic) && // par comodit� accepte ces types
!type.Eq(CBotTypPointer) &&
!type.Eq(CBotTypArrayPointer) &&
!type.Eq(CBotTypArrayBody)) __asm int 3;
@@ -142,7 +154,7 @@ void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type CBotClass* pClass2 = pClass->GivParent();
if ( pClass2 != NULL )
{
- // crée également une instance dans la classe père
+ // cr�e �galement une instance dans la classe p�re
m_pParent = new CBotVarClass(name, CBotTypResult(type.GivType(),pClass2) ); //, nIdent);
}
@@ -158,7 +170,7 @@ CBotVarClass::~CBotVarClass( ) if ( m_pParent ) delete m_pParent;
m_pParent = NULL;
- // libère l'objet indirect s'il y a lieu
+ // lib�re l'objet indirect s'il y a lieu
// if ( m_Indirect != NULL )
// m_Indirect->DecrementUse();
@@ -248,7 +260,7 @@ void* CBotVar::GivUserPtr() BOOL CBotVar::Save1State(FILE* pf)
{
- // cette routine "virtual" ne doit jamais être appellée,
+ // cette routine "virtual" ne doit jamais �tre appell�e,
// il doit y avoir une routine pour chaque classe fille (CBotVarInt, CBotVarFloat, etc)
// ( voir le type dans m_type )
__asm int 3;
@@ -262,7 +274,7 @@ void CBotVar::Maj(void* pUser, BOOL bContinu) }
-// crée une variable selon son type
+// cr�e une variable selon son type
CBotVar* CBotVar::Create(const CBotToken* name, int type )
{
@@ -290,7 +302,7 @@ CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type) return new CBotVarClass(name, type);
case CBotTypClass:
- // crée une nouvelle instance d'une classe
+ // cr�e une nouvelle instance d'une classe
// et retourne le POINTER sur cette instance
{
CBotVarClass* instance = new CBotVarClass(name, type);
@@ -312,7 +324,7 @@ CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type) while (type.Eq(CBotTypArrayBody))
{
type = type.GivTypElem();
- pv = ((CBotVarArray*)pv)->GivItem(0, TRUE); // crée au moins l'élément [0]
+ pv = ((CBotVarArray*)pv)->GivItem(0, TRUE); // cr�e au moins l'�l�ment [0]
}
return array;
@@ -360,7 +372,7 @@ CBotVar* CBotVar::Create( const char* n, CBotTypResult type) }
case CBotTypClass:
- // crée une nouvelle instance d'une classe
+ // cr�e une nouvelle instance d'une classe
// et retourne le POINTER sur cette instance
{
CBotVarClass* instance = new CBotVarClass(&name, type);
@@ -383,7 +395,7 @@ CBotVar* CBotVar::Create( const char* n, CBotTypResult type) while (type.Eq(CBotTypArrayBody))
{
type = type.GivTypElem();
- pv = ((CBotVarArray*)pv)->GivItem(0, TRUE); // crée au moins l'élément [0]
+ pv = ((CBotVarArray*)pv)->GivItem(0, TRUE); // cr�e au moins l'�l�ment [0]
}
return array;
@@ -452,7 +464,7 @@ void CBotVar::SetType(CBotTypResult& type) int CBotVar::GivInit()
{
- if ( m_type.Eq(CBotTypClass) ) return IS_DEF; // toujours défini !
+ if ( m_type.Eq(CBotTypClass) ) return IS_DEF; // toujours d�fini !
return m_binit;
}
@@ -460,7 +472,7 @@ int CBotVar::GivInit() void CBotVar::SetInit(BOOL bInit)
{
m_binit = bInit;
- if ( bInit == 2 ) m_binit = IS_DEF; // cas spécial
+ if ( bInit == 2 ) m_binit = IS_DEF; // cas sp�cial
if ( m_type.Eq(CBotTypPointer) && bInit == 2 )
{
@@ -525,7 +537,7 @@ CBotVar* CBotVar::GivItem(int row, BOOL bGrow) return NULL;
}
-// dit si une variable appartient à une classe donnée
+// dit si une variable appartient � une classe donn�e
BOOL CBotVar::IsElemOfClass(const char* name)
{
CBotClass* pc = NULL;
@@ -551,7 +563,7 @@ BOOL CBotVar::IsElemOfClass(const char* name) CBotVar* CBotVar::GivStaticVar()
{
- // rend le pointeur à la variable si elle est statique
+ // rend le pointeur � la variable si elle est statique
if ( m_bStatic == 0 || m_pMyThis == NULL ) return this;
CBotClass* pClass = m_pMyThis->GivClass();
@@ -604,7 +616,7 @@ void CBotVar::SetVal(CBotVar* var) __asm int 3;
}
- m_binit = var->m_binit; // copie l'état nan s'il y a
+ m_binit = var->m_binit; // copie l'�tat nan s'il y a
}
void CBotVar::SetStatic(BOOL bStatic)
@@ -644,8 +656,8 @@ CBotVarClass* CBotVar::GivPointer() return NULL;
}
-// toutes ces fonctions doivent être définies dans les classes filles
-// dérivées de la classe CBotVar
+// toutes ces fonctions doivent �tre d�finies dans les classes filles
+// d�riv�es de la classe CBotVar
int CBotVar::GivValInt()
{
@@ -834,7 +846,7 @@ void CBotVarInt::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;
m_pUserPtr = p->m_pUserPtr;
- // garde le même idendificateur (par défaut)
+ // garde le m�me idendificateur (par d�faut)
if (m_ident == 0 ) m_ident = p->m_ident;
m_defnum = p->m_defnum;
@@ -1047,7 +1059,7 @@ void CBotVarFloat::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le même idendificateur (par défaut)
+ // garde le m�me idendificateur (par d�faut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -1208,7 +1220,7 @@ void CBotVarBoolean::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le même idendificateur (par défaut)
+ // garde le m�me idendificateur (par d�faut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -1306,7 +1318,7 @@ void CBotVarString::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le même idendificateur (par défaut)
+ // garde le m�me idendificateur (par d�faut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -1379,7 +1391,7 @@ BOOL CBotVarString::Hs(CBotVar* left, CBotVar* right) // copie une variable dans une autre
void CBotVarClass::Copy(CBotVar* pSrc, BOOL bName)
{
- pSrc = pSrc->GivPointer(); // si source donné par un pointeur
+ pSrc = pSrc->GivPointer(); // si source donn� par un pointeur
if ( pSrc->GivType() != CBotTypClass )
__asm int 3;
@@ -1402,7 +1414,7 @@ __asm int 3; "que faire du pParent"; m_pMyThis = NULL;//p->m_pMyThis;
m_ItemIdent = p->m_ItemIdent;
- // garde le même idendificateur (par défaut)
+ // garde le m�me idendificateur (par d�faut)
if (m_ident == 0 ) m_ident = p->m_ident;
delete m_pVar;
@@ -1439,7 +1451,7 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent) m_pClass = pClass;
- // initialise les variables associées à cette classe
+ // initialise les variables associ�es � cette classe
delete m_pVar;
m_pVar = NULL;
@@ -1449,24 +1461,24 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent) while ( pv != NULL )
{
// cherche les dimensions max du tableau
- CBotInstr* p = pv->m_LimExpr; // les différentes formules
+ CBotInstr* p = pv->m_LimExpr; // les diff�rentes formules
if ( p != NULL )
{
- CBotStack* pile = CBotStack::FirstStack(); // une pile indépendante
+ CBotStack* pile = CBotStack::FirstStack(); // une pile ind�pendante
int n = 0;
int max[100];
while (p != NULL)
{
while( pile->IsOk() && !p->Execute(pile) ) ; // calcul de la taille sans interruptions
- CBotVar* v = pile->GivVar(); // résultat
+ CBotVar* v = pile->GivVar(); // r�sultat
max[n] = v->GivValInt(); // valeur
n++;
p = p->GivNext3();
}
while (n<100) max[n++] = 0;
- pv->m_type.SetArray( max ); // mémorise les limitations
+ pv->m_type.SetArray( max ); // m�morise les limitations
pile->Delete();
}
@@ -1477,20 +1489,20 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent) if ( pv->m_InitExpr != NULL ) // expression pour l'initialisation ?
{
#if STACKMEM
- CBotStack* pile = CBotStack::FirstStack(); // une pile indépendante
+ CBotStack* pile = CBotStack::FirstStack(); // une pile ind�pendante
- while(pile->IsOk() && !pv->m_InitExpr->Execute(pile, pn)); // évalue l'expression sans timer
+ while(pile->IsOk() && !pv->m_InitExpr->Execute(pile, pn)); // �value l'expression sans timer
pile->Delete();
#else
- CBotStack* pile = new CBotStack(NULL); // une pile indépendante
- while(!pv->m_InitExpr->Execute(pile)); // évalue l'expression sans timer
+ CBotStack* pile = new CBotStack(NULL); // une pile ind�pendante
+ while(!pv->m_InitExpr->Execute(pile)); // �value l'expression sans timer
pn->SetVal( pile->GivVar() ) ;
delete pile;
#endif
}
-// pn->SetUniqNum(CBotVar::NextUniqNum()); // numérote les éléments
+// pn->SetUniqNum(CBotVar::NextUniqNum()); // num�rote les �l�ments
pn->SetUniqNum(pv->GivUniqNum()); //++nIdent
pn->m_pMyThis = this;
@@ -1511,12 +1523,12 @@ void CBotVarClass::Maj(void* pUser, BOOL bContinu) /* if (!bContinu && m_pMyThis != NULL)
m_pMyThis->Maj(pUser, TRUE);*/
- // une routine de mise à jour existe-elle ?
+ // une routine de mise � jour existe-elle ?
if ( m_pClass->m_rMaj == NULL ) return;
- // récupère le pointeur user selon la classe
- // ou selon le paramètre passé au CBotProgram::Run()
+ // r�cup�re le pointeur user selon la classe
+ // ou selon le param�tre pass� au CBotProgram::Run()
if ( m_pUserPtr != NULL) pUser = m_pUserPtr;
if ( pUser == OBJECTDELETED ||
@@ -1553,7 +1565,7 @@ CBotVar* CBotVarClass::GivItemRef(int nIdent) }
// pour la gestion d'un tableau
-// bExtend permet d'agrandir le tableau, mais pas au dela de la taille fixée par SetArray()
+// bExtend permet d'agrandir le tableau, mais pas au dela de la taille fix�e par SetArray()
CBotVar* CBotVarClass::GivItem(int n, BOOL bExtend)
{
@@ -1597,7 +1609,7 @@ CBotString CBotVarClass::GivValString() CBotString res;
- if ( m_pClass != NULL ) // pas utilisé pour un array
+ if ( m_pClass != NULL ) // pas utilis� pour un array
{
res = m_pClass->GivName() + "( ";
@@ -1658,7 +1670,7 @@ void CBotVarClass::DecrementUse() if ( m_CptUse == 0 )
{
// s'il y en a un, appel le destructeur
- // mais seulement si un constructeur avait été appelé.
+ // mais seulement si un constructeur avait �t� appel�.
if ( m_bConstructor )
{
m_CptUse++; // ne revient pas dans le destructeur
@@ -1667,7 +1679,7 @@ void CBotVarClass::DecrementUse() // sauve la valeur pour la remettre ensuite
int err, start, end;
CBotStack* pile = NULL;
- err = pile->GivError(start,end); // pile == NULL ça ne derange pas !!
+ err = pile->GivError(start,end); // pile == NULL �a ne derange pas !!
pile = CBotStack::FirstStack(); // efface l'erreur
CBotVar* ppVars[1];
@@ -1689,7 +1701,7 @@ void CBotVarClass::DecrementUse() m_CptUse--;
}
- delete this; // s'auto-détruit !!
+ delete this; // s'auto-d�truit !!
}
}
@@ -1699,7 +1711,7 @@ CBotVarClass* CBotVarClass::GivPointer() }
-// trouve une instance selon son numéro unique
+// trouve une instance selon son num�ro unique
CBotVarClass* CBotVarClass::Find(long id)
{
@@ -1726,7 +1738,7 @@ BOOL CBotVarClass::Eq(CBotVar* left, CBotVar* right) r = r->GivNext();
}
- // devrait toujours arrivé simultanément au bout (mêmes classes)
+ // devrait toujours arriv� simultan�ment au bout (m�mes classes)
return l == r;
}
@@ -1742,7 +1754,7 @@ BOOL CBotVarClass::Ne(CBotVar* left, CBotVar* right) r = r->GivNext();
}
- // devrait toujours arrivé simultanément au bout (mêmes classes)
+ // devrait toujours arriv� simultan�ment au bout (m�mes classes)
return l != r;
}
@@ -1763,12 +1775,12 @@ CBotVarArray::CBotVarArray(const CBotToken* name, CBotTypResult& type ) m_type.SetType(CBotTypArrayPointer);
m_binit = FALSE;
- m_pInstance = NULL; // la liste des éléments du tableau
+ m_pInstance = NULL; // la liste des �l�ments du tableau
}
CBotVarArray::~CBotVarArray()
{
- if ( m_pInstance != NULL ) m_pInstance->DecrementUse(); // une référence en moins
+ if ( m_pInstance != NULL ) m_pInstance->DecrementUse(); // une r�f�rence en moins
}
// copie une variable dans une autre
@@ -1784,34 +1796,34 @@ void CBotVarArray::Copy(CBotVar* pSrc, BOOL bName) m_pInstance = p->GivPointer();
if ( m_pInstance != NULL )
- m_pInstance->IncrementUse(); // une référence en plus
+ m_pInstance->IncrementUse(); // une r�f�rence en plus
m_binit = p->m_binit;
//- m_bStatic = p->m_bStatic;
m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le même idendificateur (par défaut)
+ // garde le m�me idendificateur (par d�faut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
void CBotVarArray::SetPointer(CBotVar* pVarClass)
{
- m_binit = TRUE; // init, même sur un pointeur null
+ m_binit = TRUE; // init, m�me sur un pointeur null
- if ( m_pInstance == pVarClass) return; // spécial, ne pas décrémenter et réincrémenter
- // car le décrément peut détruire l'object
+ if ( m_pInstance == pVarClass) return; // sp�cial, ne pas d�cr�menter et r�incr�menter
+ // car le d�cr�ment peut d�truire l'object
if ( pVarClass != NULL )
{
if ( pVarClass->GivType() == CBotTypArrayPointer )
- pVarClass = pVarClass->GivPointer(); // le vrai pointeur à l'objet
+ pVarClass = pVarClass->GivPointer(); // le vrai pointeur � l'objet
if ( !pVarClass->m_type.Eq(CBotTypClass) &&
!pVarClass->m_type.Eq(CBotTypArrayBody))
__asm int 3;
- ((CBotVarClass*)pVarClass)->IncrementUse(); // une référence en plus
+ ((CBotVarClass*)pVarClass)->IncrementUse(); // une r�f�rence en plus
}
if ( m_pInstance != NULL ) m_pInstance->DecrementUse();
@@ -1830,7 +1842,7 @@ CBotVar* CBotVarArray::GivItem(int n, BOOL bExtend) if ( m_pInstance == NULL )
{
if ( !bExtend ) return NULL;
- // crée une instance pour le tableau
+ // cr�e une instance pour le tableau
CBotVarClass* instance = new CBotVarClass(NULL, m_type);
SetPointer( instance );
@@ -1853,18 +1865,18 @@ CBotString CBotVarArray::GivValString() BOOL CBotVarArray::Save1State(FILE* pf)
{
if ( !WriteType(pf, m_type) ) return FALSE;
- return SaveVar(pf, m_pInstance); // sauve l'instance qui gère le tableau
+ return SaveVar(pf, m_pInstance); // sauve l'instance qui g�re le tableau
}
/////////////////////////////////////////////////////////////////////////////
-// gestion des pointeurs à une instance donnée
+// gestion des pointeurs � une instance donn�e
CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type )
{
if ( !type.Eq(CBotTypPointer) &&
!type.Eq(CBotTypNullPointer) &&
- !type.Eq(CBotTypClass) && // par commodité accepte Class et Intrinsic
+ !type.Eq(CBotTypClass) && // par commodit� accepte Class et Intrinsic
!type.Eq(CBotTypIntrinsic) ) __asm int 3;
m_token = new CBotToken(name);
@@ -1877,14 +1889,14 @@ CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type ) m_type.SetType(CBotTypPointer); // quoi qu'il en soit, c'est un pointeur
m_binit = FALSE;
m_pClass = NULL;
- m_pVarClass = NULL; // sera défini par un SetPointer()
+ m_pVarClass = NULL; // sera d�fini par un SetPointer()
SetClass(type.GivClass() );
}
CBotVarPointer::~CBotVarPointer()
{
- if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse(); // une référence en moins
+ if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse(); // une r�f�rence en moins
}
@@ -1899,7 +1911,7 @@ void CBotVarPointer::Maj(void* pUser, BOOL bContinu) CBotVar* CBotVarPointer::GivItem(const char* name)
{
if ( m_pVarClass == NULL) // pas d'instance existant ?
- return m_pClass->GivItem(name); // rend le pointeur dans la classe elle-même
+ return m_pClass->GivItem(name); // rend le pointeur dans la classe elle-m�me
return m_pVarClass->GivItem(name);
}
@@ -1907,7 +1919,7 @@ CBotVar* CBotVarPointer::GivItem(const char* name) CBotVar* CBotVarPointer::GivItemRef(int nIdent)
{
if ( m_pVarClass == NULL) // pas d'instance existant ?
- return m_pClass->GivItemRef(nIdent);// rend le pointeur dans la classe elle-même
+ return m_pClass->GivItemRef(nIdent);// rend le pointeur dans la classe elle-m�me
return m_pVarClass->GivItemRef(nIdent);
}
@@ -1936,21 +1948,21 @@ void CBotVarPointer::ConstructorSet() void CBotVarPointer::SetPointer(CBotVar* pVarClass)
{
- m_binit = TRUE; // init, même sur un pointeur null
+ m_binit = TRUE; // init, m�me sur un pointeur null
- if ( m_pVarClass == pVarClass) return; // spécial, ne pas décrémenter et réincrémenter
- // car le décrément peut détruire l'object
+ if ( m_pVarClass == pVarClass) return; // sp�cial, ne pas d�cr�menter et r�incr�menter
+ // car le d�cr�ment peut d�truire l'object
if ( pVarClass != NULL )
{
if ( pVarClass->GivType() == CBotTypPointer )
- pVarClass = pVarClass->GivPointer(); // le vrai pointeur à l'objet
+ pVarClass = pVarClass->GivPointer(); // le vrai pointeur � l'objet
// if ( pVarClass->GivType() != CBotTypClass )
if ( !pVarClass->m_type.Eq(CBotTypClass) )
__asm int 3;
- ((CBotVarClass*)pVarClass)->IncrementUse(); // une référence en plus
+ ((CBotVarClass*)pVarClass)->IncrementUse(); // une r�f�rence en plus
m_pClass = ((CBotVarClass*)pVarClass)->m_pClass;
m_pUserPtr = pVarClass->m_pUserPtr; // pas vraiment indispensable
m_type = CBotTypResult(CBotTypPointer, m_pClass); // un pointeur de quel genre
@@ -2006,7 +2018,7 @@ BOOL CBotVarPointer::Save1State(FILE* pf) if (!WriteString(pf, "")) return FALSE;
}
- if (!WriteLong(pf, GivIdent())) return FALSE; // la référence unique
+ if (!WriteLong(pf, GivIdent())) return FALSE; // la r�f�rence unique
// sauve aussi une copie de l'instance
return SaveVar(pf, GivPointer());
@@ -2027,7 +2039,7 @@ void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName) m_pVarClass = p->GivPointer();
if ( m_pVarClass != NULL )
- m_pVarClass->IncrementUse(); // une référence en plus
+ m_pVarClass->IncrementUse(); // une r�f�rence en plus
m_pClass = p->m_pClass;
m_binit = p->m_binit;
@@ -2036,7 +2048,7 @@ void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName) m_pMyThis = NULL;//p->m_pMyThis;
m_pUserPtr = p->m_pUserPtr;
- // garde le même idendificateur (par défaut)
+ // garde le m�me idendificateur (par d�faut)
if (m_ident == 0 ) m_ident = p->m_ident;
}
@@ -2065,7 +2077,7 @@ BOOL CBotVarPointer::Ne(CBotVar* left, CBotVar* right) ///////////////////////////////////////////////////////
-// gestion des types de résultats
+// gestion des types de r�sultats
CBotTypResult::CBotTypResult(int type)
@@ -2185,7 +2197,7 @@ void CBotTypResult::SetArray( int* max ) m_limite = *max;
if (m_limite < 1) m_limite = -1;
- if ( m_pNext != NULL ) // dernière dimension ?
+ if ( m_pNext != NULL ) // derni�re dimension ?
{
m_pNext->SetArray( max+1 );
}
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)
{
diff --git a/src/CBot/ClassFILE.cpp b/src/CBot/ClassFILE.cpp index 21bd39e..cfde47f 100644 --- a/src/CBot/ClassFILE.cpp +++ b/src/CBot/ClassFILE.cpp @@ -1,6 +1,18 @@ -// ClassFile.cpp
-//
-// définition des méthodes pour la classe FILE
+// * 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 .
@@ -12,7 +24,7 @@ static int m_CompteurFileOpen = 0; -// Prépare un nom de fichier.
+// Pr�pare un nom de fichier.
void PrepareFilename(CBotString &filename) //DD!
{
@@ -21,7 +33,7 @@ void PrepareFilename(CBotString &filename) //DD! pos = filename.ReverseFind('\\');
if ( pos > 0 )
{
- filename = filename.Mid(pos+1); // enlève les dossiers
+ filename = filename.Mid(pos+1); // enl�ve les dossiers
}
pos = filename.ReverseFind('/');
@@ -33,7 +45,7 @@ void PrepareFilename(CBotString &filename) //DD! pos = filename.ReverseFind(':');
if ( pos > 0 )
{
- filename = filename.Mid(pos+1); // enlève aussi la lettre d'unité C:
+ filename = filename.Mid(pos+1); // enl�ve aussi la lettre d'unit� C:
}
filename = CBotString("files\\") + filename;
@@ -41,31 +53,31 @@ void PrepareFilename(CBotString &filename) //DD! // constructeur de la classe
-// reçois le nom du fichier en paramètre
+// re�ois le nom du fichier en param�tre
-// exécution
+// ex�cution
BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
CBotString mode;
- // accepte sans paramètre
+ // accepte sans param�tre
if ( pVar == NULL ) return TRUE;
- // qui doit être une chaîne de caractères
+ // qui doit �tre une cha�ne de caract�res
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }
CBotString filename = pVar->GivValString();
PrepareFilename(filename); //DR
- // il peut y avoir un second paramètre
+ // il peut y avoir un second param�tre
pVar = pVar->GivNext();
if ( pVar != NULL )
{
- // récupère le mode
+ // r�cup�re le mode
mode = pVar->GivValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return FALSE; }
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return FALSE; }
}
@@ -75,7 +87,7 @@ BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio if ( ! mode.IsEmpty() )
{
- // ouvre le ficher demandé
+ // ouvre le ficher demand�
FILE* pFile = fopen( filename, mode );
if ( pFile == NULL ) { Exception = CBotErrFileOpen; return FALSE; }
@@ -92,38 +104,38 @@ BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio // compilation
CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
{
- // accepte sans paramètre
+ // accepte sans param�tre
if ( pVar == NULL ) return CBotTypResult( 0 );
- // qui doit être une chaine
+ // qui doit �tre une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // il peut y avoir un second paramètre
+ // il peut y avoir un second param�tre
pVar = pVar->GivNext();
if ( pVar != NULL )
{
- // qui doit être une chaine
+ // qui doit �tre une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
- // le résultat est de type void (constructeur)
+ // le r�sultat est de type void (constructeur)
return CBotTypResult( 0 );
}
// destructeur de la classe
-// exécution
+// ex�cution
BOOL rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // récupère l'élément "handle"
+ // r�cup�re l'�l�ment "handle"
pVar = pThis->GivItem("handle");
- // pas ouvert ? pas de problème
+ // pas ouvert ? pas de probl�me
if ( pVar->GivInit() != IS_DEF) return TRUE;
FILE* pFile= (FILE*)pVar->GivValInt();
@@ -136,22 +148,22 @@ BOOL rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception }
-// méthode FILE :: open
-// reçois le mode r/w en paramètre
+// m�thode FILE :: open
+// re�ois le mode r/w en param�tre
-// exécution
+// ex�cution
BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il doit y avoir un paramètre
+ // il doit y avoir un param�tre
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
- // qui doit être une chaîne de caractères
+ // qui doit �tre une cha�ne de caract�res
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }
- // il peut y avoir un second paramètre
+ // il peut y avoir un second param�tre
if ( pVar->GivNext() != NULL )
{
- // dans ce cas le premier paramètre est le nom du fichier
+ // dans ce cas le premier param�tre est le nom du fichier
CBotString filename = pVar->GivValString();
PrepareFilename(filename); //DR
@@ -159,29 +171,29 @@ BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) CBotVar* pVar2 = pThis->GivItem("filename");
pVar2->SetValString(filename);
- // paramètre suivant est le mode
+ // param�tre suivant est le mode
pVar = pVar -> GivNext();
}
CBotString mode = pVar->GivValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return FALSE; }
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return FALSE; }
- // récupère l'élément "handle"
+ // r�cup�re l'�l�ment "handle"
pVar = pThis->GivItem("handle");
- // qui doit pas être initialisé
+ // qui doit pas �tre initialis�
if ( pVar->GivInit() == IS_DEF) { Exception = CBotErrFileOpen; return FALSE; }
// reprend le nom du fichier
pVar = pThis->GivItem("filename");
CBotString filename = pVar->GivValString();
- PrepareFilename(filename); //DD! (si le nom a été attribué par h.filename = "...";
+ PrepareFilename(filename); //DD! (si le nom a �t� attribu� par h.filename = "...";
- // ouvre le ficher demandé
+ // ouvre le ficher demand�
FILE* pFile = fopen( filename, mode );
if ( pFile == NULL ) //DR
{
@@ -202,39 +214,39 @@ BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)
{
- // il doit y avoir un paramètre
+ // il doit y avoir un param�tre
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
- // qui doit être une chaine
+ // qui doit �tre une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // il peut y avoir un second paramètre
+ // il peut y avoir un second param�tre
pVar = pVar->GivNext();
if ( pVar != NULL )
{
- // qui doit être une chaine
+ // qui doit �tre une chaine
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
- // le résultat est de type bool
+ // le r�sultat est de type bool
return CBotTypResult(CBotTypBoolean); //DR
}
-// méthode FILE :: close
+// m�thode FILE :: close
-// exécution
+// ex�cution
BOOL rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il ne doit pas y avoir de paramètre
+ // il ne doit pas y avoir de param�tre
if ( pVar != NULL ) return CBotErrOverParam;
- // récupère l'élément "handle"
+ // r�cup�re l'�l�ment "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -251,27 +263,27 @@ BOOL rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfclose (CBotVar* pThis, CBotVar* &pVar)
{
- // il ne doit pas y avoir de paramètre
+ // il ne doit pas y avoir de param�tre
if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un résultat "void"
+ // la fonction retourne un r�sultat "void"
return CBotTypResult( 0 );
}
-// méthode FILE :: writeln
+// m�thode FILE :: writeln
-// exécution
+// ex�cution
BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il doit y avoir un paramètre
+ // il doit y avoir un param�tre
if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }
- // qui doit être une chaîne de caractères
+ // qui doit �tre une cha�ne de caract�res
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }
CBotString param = pVar->GivValString();
- // récupère l'élément "handle"
+ // r�cup�re l'�l�ment "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -280,7 +292,7 @@ BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) int res = fputs(param+"\n", pFile);
- // en cas d'erreur génère une exception
+ // en cas d'erreur g�n�re une exception
if ( res < 0 ) { Exception = CBotErrWrite; return FALSE; }
return TRUE;
@@ -289,28 +301,28 @@ BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)
{
- // il doit y avoir un paramètre
+ // il doit y avoir un param�tre
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
- // qui doit être une chaîne de caractères
+ // qui doit �tre une cha�ne de caract�res
if ( pVar->GivType() != CBotTypString ) return CBotTypResult( CBotErrBadString );
- // pas d'autre paramètre
+ // pas d'autre param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un résultat void
+ // la fonction retourne un r�sultat void
return CBotTypResult( 0 );
}
-// méthode FILE :: readln
+// m�thode FILE :: readln
-// exécution
+// ex�cution
BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il ne doit pas y avoir de paramètre
+ // il ne doit pas y avoir de param�tre
if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }
- // récupère l'élément "handle"
+ // r�cup�re l'�l�ment "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -325,7 +337,7 @@ BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) for ( i = 0 ; i < 2000 ; i++ ) if (chaine[i] == '\n') chaine[i] = 0;
- // en cas d'erreur génère une exception
+ // en cas d'erreur g�n�re une exception
if ( ferror(pFile) ) { Exception = CBotErrRead; return FALSE; }
pResult->SetValString( chaine );
@@ -336,22 +348,22 @@ BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfread (CBotVar* pThis, CBotVar* &pVar)
{
- // il ne doit pas y avoir de paramètre
+ // il ne doit pas y avoir de param�tre
if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un résultat "string"
+ // la fonction retourne un r�sultat "string"
return CBotTypResult( CBotTypString );
}
-// méthode FILE :: readln
+// m�thode FILE :: readln
-// exécution
+// ex�cution
BOOL rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
- // il ne doit pas y avoir de paramètre
+ // il ne doit pas y avoir de param�tre
if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }
- // récupère l'élément "handle"
+ // r�cup�re l'�l�ment "handle"
pVar = pThis->GivItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }
@@ -366,10 +378,10 @@ BOOL rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) // compilation
CBotTypResult cfeof (CBotVar* pThis, CBotVar* &pVar)
{
- // il ne doit pas y avoir de paramètre
+ // il ne doit pas y avoir de param�tre
if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
- // la fonction retourne un résultat booleen
+ // la fonction retourne un r�sultat booleen
return CBotTypResult( CBotTypBoolean );
}
@@ -379,25 +391,25 @@ CBotTypResult cfeof (CBotVar* pThis, CBotVar* &pVar) void InitClassFILE()
{
-// crée une classe pour la gestion des fichiers
+// cr�e une classe pour la gestion des fichiers
// l'utilisation en est la suivante:
// file canal( "NomFichier.txt" )
// canal.open( "r" ); // ouvre en lecture
// s = canal.readln( ); // lit une ligne
// canal.close(); // referme le fichier
- // crée la classe FILE
+ // cr�e la classe FILE
m_pClassFILE = new CBotClass("file", NULL);
// ajoute le composant ".filename"
m_pClassFILE->AddItem("filename", CBotTypString);
// ajoute le composant ".handle"
m_pClassFILE->AddItem("handle", CBotTypInt, PR_PRIVATE);
- // défini un constructeur et un destructeur
+ // d�fini un constructeur et un destructeur
m_pClassFILE->AddFunction("file", rfconstruct, cfconstruct );
m_pClassFILE->AddFunction("~file", rfdestruct, NULL );
- // défini les méthodes associées
+ // d�fini les m�thodes associ�es
m_pClassFILE->AddFunction("open", rfopen, cfopen );
m_pClassFILE->AddFunction("close", rfclose, cfclose );
m_pClassFILE->AddFunction("writeln", rfwrite, cfwrite );
@@ -407,6 +419,6 @@ void InitClassFILE() m_pFuncFile = new CBotProgram( );
CBotStringArray ListFonctions;
m_pFuncFile->Compile( "public file openfile(string name, string mode) {return new file(name, mode);}", ListFonctions);
- m_pFuncFile->SetIdent(-2); // identificateur spécial pour RestoreState dans cette fonction
+ m_pFuncFile->SetIdent(-2); // identificateur sp�cial pour RestoreState dans cette fonction
}
diff --git a/src/CBot/Copie de CBotTwoOpExpr.cpp b/src/CBot/Copie de CBotTwoOpExpr.cpp index 7a95b55..54db4c4 100644 --- a/src/CBot/Copie de CBotTwoOpExpr.cpp +++ b/src/CBot/Copie de 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"
@@ -19,14 +31,14 @@ CBotTwoOpExpr::~CBotTwoOpExpr() delete m_rightop;
}
-// type d'opérandes acceptés par les opérations
+// type d'op�randes accept�s par les op�rations
#define ENTIER ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
#define FLOTANT ((1<<CBotTypFloat)|(1<<CBotTypDouble))
#define BOOLEEN (1<<CBotTypBoolean)
#define CHAINE (1<<CBotTypString)
#define CLASSE (1<<CBotTypClass)
-// liste des opérations (précéance)
+// liste des op�rations (pr�c�ance)
static int ListOp[] =
{
BOOLEEN, ID_LOG_OR, 0,
@@ -82,35 +94,35 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera CBotCStack* pStk = pStack->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->GetType();
if ( IsInList( TypeOp, pOperations, typemasque ) )
{
- 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
int type1, type2;
- type1 = pStk->GetType(); // de quel type le premier opérande ?
+ type1 = pStk->GetType(); // de quel type le premier op�rande ?
- p = p->Next(); // saute le token de l'opération
+ p = p->Next(); // 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, pOperations )) )
- // expression (...) à droite
+ // expression (...) � droite
{
- // il y a un second opérande acceptable
+ // il y a un second op�rande acceptable
- type2 = pStk->GetType(); // de quel type le résultat ?
+ type2 = pStk->GetType(); // de quel type le r�sultat ?
- // quel est le type du résultat ?
+ // quel est le type du r�sultat ?
int TypeRes = MAX( type1, type2 );
if (!TypeOk( TypeRes, typemasque )) type1 = 99; // erreur de type
@@ -126,81 +138,81 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera case ID_LS:
TypeRes = CBotTypBoolean;
}
- if ( TypeCompatible (type1, type2) || // les résultats sont-ils compatibles
- // cas particulier pour les concaténation de chaînes
+ if ( TypeCompatible (type1, type2) || // les r�sultats sont-ils compatibles
+ // cas particulier pour les concat�nation de cha�nes
(TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString)))
{
- // si ok, enregistre l'opérande dans l'objet
+ // si ok, enregistre l'op�rande dans l'objet
inst->m_leftop = left;
- // met une variable sur la pile pour avoir le type de résultat
+ // met une variable sur la pile pour avoir le type de r�sultat
pStk->SetVar(new CBotVar(NULL, TypeRes));
- // et rend l'object à qui l'a demandé
+ // 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);
}
-// fait l'opération d'addition ou de soustraction
+// fait l'op�ration d'addition ou de soustraction
BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile
+ CBotStack* pStk1 = pStack->AddStack(); // ajoute un �l�ment � la pile
// ou le retrouve en cas de reprise
- // selon la reprise, on peut être dans l'un des 2 états
+ // selon la reprise, on peut �tre dans l'un des 2 �tats
- if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
+ 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
+ // passe � l'�tape suivante
+ pStk1->SetState(1); // pr�t pour la suite
- // pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire
+ // pour les OU et ET logique, n'�value pas la seconde expression si pas n�cessaire
if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE )
{
CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
res->SetValInt(FALSE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
+ return pStack->Return(pStk1); // transmet le r�sultat
}
if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE )
{
CBotVar* res = CBotVar::Create( NULL, CBotTypBoolean);
res->SetValInt(TRUE);
pStk1->SetVar(res);
- return pStack->Return(pStk1); // transmet le résultat
+ return pStack->Return(pStk1); // transmet le r�sultat
}
- // 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 ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
- int type1 = pStk1->GetType(); // de quels types les résultats ?
+ int type1 = pStk1->GetType(); // de quels types les r�sultats ?
int type2 = pStk2->GetType();
- // crée une variable temporaire pour y mettre le résultat
- // quel est le type du résultat ?
+ // cr�e une variable temporaire pour y mettre le r�sultat
+ // quel est le type du r�sultat ?
int TypeRes = MAX(type1, type2);
switch ( GetTokenType() )
{
@@ -218,7 +230,7 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) CBotVar* temp = CBotVar::Create( NULL, MAX(type1, type2) );
int err = 0;
- // fait l'opération selon la demande
+ // fait l'op�ration selon la demande
switch (GetTokenType())
{
case ID_ADD:
@@ -237,28 +249,28 @@ BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack) err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division
break;
case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
break;
case ID_LOG_AND:
case ID_AND:
@@ -285,11 +297,11 @@ 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(pStk1); // transmet le résultat
+ pStk1->Return(pStk2); // lib�re la pile
+ return pStack->Return(pStk1); // transmet le r�sultat
}
diff --git a/src/CBot/StringFunctions.cpp b/src/CBot/StringFunctions.cpp index 803ffd9..88a41fd 100644 --- a/src/CBot/StringFunctions.cpp +++ b/src/CBot/StringFunctions.cpp @@ -1,21 +1,35 @@ -// définition des fonctions sur les chaînes
-
-
-// donne la longueur d'une chaîne
-// exécution
+// * 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 .
+
+
+// donne la longueur d'une cha�ne
+// ex�cution
BOOL rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // pas de second paramètre
+ // pas de second param�tre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
// met la longueur sur la pile
@@ -28,49 +42,49 @@ BOOL rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cIntStr( CBotVar* &pVar, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADPARAM );
- // pas de second paramètre
+ // pas de second param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le résultat final est un nombre entier
+ // le r�sultat final est un nombre entier
return CBotTypResult( CBotTypInt );
}
-// donne la partie gauche d'une chaîne
-// exécution
+// donne la partie gauche d'une cha�ne
+// ex�cution
BOOL rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second paramètre
+ // il faut un second param�tre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être un nombre
+ // qui doit �tre un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // récupère ce nombre
+ // r�cup�re ce nombre
int n = pVar->GivValInt();
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // prend la partie intéressante
+ // prend la partie int�ressante
s = s.Left( n );
// la met sur la pile
@@ -83,56 +97,56 @@ BOOL rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cStrStrInt( CBotVar* &pVar, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // il faut un second paramètre
+ // il faut un second param�tre
pVar = pVar->GivNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être un nombre
+ // qui doit �tre un nombre
if ( pVar->GivType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le résultat final est une string
+ // le r�sultat final est une string
return CBotTypResult( CBotTypString );
}
-// donne la partie droite d'une chaîne
-// exécution
+// donne la partie droite d'une cha�ne
+// ex�cution
BOOL rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second paramètre
+ // il faut un second param�tre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être un nombre
+ // qui doit �tre un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // récupère ce nombre
+ // r�cup�re ce nombre
int n = pVar->GivValInt();
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // prend la partie intéressante
+ // prend la partie int�ressante
s = s.Right( n );
// la met sur la pile
@@ -140,50 +154,50 @@ BOOL rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) return TRUE;
}
-// donne la partie centrale d'une chaîne
-// exécution
+// donne la partie centrale d'une cha�ne
+// ex�cution
BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second paramètre
+ // il faut un second param�tre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être un nombre
+ // qui doit �tre un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // récupère ce nombre
+ // r�cup�re ce nombre
int n = pVar->GivValInt();
- // 3e paramètre optionnel
+ // 3e param�tre optionnel
if ( pVar->GivNext() != NULL )
{
pVar = pVar->GivNext();
- // qui doit être un nombre
+ // qui doit �tre un nombre
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }
- // récupère ce nombre
+ // r�cup�re ce nombre
int l = pVar->GivValInt();
- // mais pas de 4e paramètre
+ // mais pas de 4e param�tre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
- // prend la partie intéressante
+ // prend la partie int�ressante
s = s.Mid( n, l );
}
else
{
- // prend la partie intéressante
+ // prend la partie int�ressante
s = s.Mid( n );
}
@@ -192,59 +206,59 @@ BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) return TRUE;
}
-// donne la partie centrale d'une chaîne
+// donne la partie centrale d'une cha�ne
// compilation
CBotTypResult cStrStrIntInt( CBotVar* &pVar, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // il faut un second paramètre
+ // il faut un second param�tre
pVar = pVar->GivNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être un nombre
+ // qui doit �tre un nombre
if ( pVar->GivType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
- // 3e paramètre optionnel
+ // 3e param�tre optionnel
if ( pVar->GivNext() != NULL )
{
pVar = pVar->GivNext();
- // qui doit être un nombre
+ // qui doit �tre un nombre
if ( pVar->GivType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
- // pas de 4e paramètre
+ // pas de 4e param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
}
- // le résultat final est une string
+ // le r�sultat final est une string
return CBotTypResult( CBotTypString );
}
-// donne le nombre contenu dans une chaîne
-// exécution
+// donne le nombre contenu dans une cha�ne
+// ex�cution
BOOL rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
- // mais pas de 2e paramètre
+ // mais pas de 2e param�tre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
float val = GivNumFloat(s);
@@ -259,49 +273,49 @@ BOOL rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cFloatStr( CBotVar* &pVar, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // pas de 2e paramètre
+ // pas de 2e param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le résultat final est un nombre
+ // le r�sultat final est un nombre
return CBotTypResult( CBotTypFloat );
}
// trouve une chaine dans une autre
-// exécution
+// ex�cution
BOOL rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
- // il faut un second paramètre
+ // il faut un second param�tre
pVar = pVar->GivNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // récupère ce nombre
+ // r�cup�re ce nombre
CBotString s2 = pVar->GivValString();
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }
- // met le résultat sur la pile
+ // met le r�sultat sur la pile
int res = s.Find(s2);
pResult->SetValInt( res );
if ( res < 0 ) pResult->SetInit( IS_NAN );
@@ -313,43 +327,43 @@ BOOL rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cIntStrStr( CBotVar* &pVar, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // il faut un second paramètre
+ // il faut un second param�tre
pVar = pVar->GivNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // pas de 3e paramètre
+ // pas de 3e param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le résultat final est un nombre
+ // le r�sultat final est un nombre
return CBotTypResult( CBotTypInt );
}
// donne une chaine en majuscule
-// exécution
+// ex�cution
BOOL rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
- // mais pas de 2e paramètre
+ // mais pas de 2e param�tre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
@@ -361,20 +375,20 @@ BOOL rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) }
// donne une chaine en minuscules
-// exécution
+// ex�cution
BOOL rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }
- // recupére le contenu de la string
+ // recup�re le contenu de la string
CBotString s = pVar->GivValString();
- // mais pas de 2e paramètre
+ // mais pas de 2e param�tre
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }
@@ -390,17 +404,17 @@ BOOL rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser ) CBotTypResult cStrStr( CBotVar* &pVar, void* pUser )
{
- // il faut un paramètre
+ // il faut un param�tre
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
- // qui doit être une string
+ // qui doit �tre une string
if ( pVar->GivType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
- // pas de 2e paramètre
+ // pas de 2e param�tre
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
- // le résultat final est une string
+ // le r�sultat final est une string
return CBotTypResult( CBotTypString );
}
diff --git a/src/CBot/TestCBot/CBotConsoleDlg.cpp b/src/CBot/TestCBot/CBotConsoleDlg.cpp index 5f29e86..dfd4ec4 100644 --- a/src/CBot/TestCBot/CBotConsoleDlg.cpp +++ b/src/CBot/TestCBot/CBotConsoleDlg.cpp @@ -1,5 +1,18 @@ -// CBotConsoleDlg.cpp : implementation file
-//
+// * 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 "stdafx.h"
#include "TestCBot.h"
@@ -104,7 +117,7 @@ UINT ThreadProc(ThreadInfo *info) CTimeSpan ts = t - t0;
char buffer[200];
- sprintf( buffer, "\r\nExécution terminée en %d secondes.\r\nInterrompue %d fois.\r\n",
+ sprintf( buffer, "\r\nEx�cution termin�e en %d secondes.\r\nInterrompue %d fois.\r\n",
ts.GetTotalSeconds(), Cpt);
info->m_pEdit1->ReplaceSel(buffer);
@@ -168,7 +181,7 @@ void CBotConsoleDlg::OnOK() m_Edit2.EnableWindow(FALSE);
m_cOK.EnableWindow(FALSE);
- // lance un processus paralèle pour l'exécution
+ // lance un processus paral�le pour l'ex�cution
m_threadinfo.m_pWndMessage = this ;
m_threadinfo.m_pEdit1 = &m_Edit1;
diff --git a/src/CBot/TestCBot/CBotConsoleDlg.h b/src/CBot/TestCBot/CBotConsoleDlg.h index bae9793..88d04dc 100644 --- a/src/CBot/TestCBot/CBotConsoleDlg.h +++ b/src/CBot/TestCBot/CBotConsoleDlg.h @@ -1,3 +1,18 @@ +// * 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 .
#if !defined(AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_)
#define AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/ChildFrm.cpp b/src/CBot/TestCBot/ChildFrm.cpp index 9005c72..0d21e5f 100644 --- a/src/CBot/TestCBot/ChildFrm.cpp +++ b/src/CBot/TestCBot/ChildFrm.cpp @@ -1,5 +1,18 @@ -// ChildFrm.cpp : implementation of the CChildFrame class
-//
+// * 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 "stdafx.h"
#include "TestCBot.h"
diff --git a/src/CBot/TestCBot/ChildFrm.h b/src/CBot/TestCBot/ChildFrm.h index ebcbeb2..cacbc4a 100644 --- a/src/CBot/TestCBot/ChildFrm.h +++ b/src/CBot/TestCBot/ChildFrm.h @@ -1,6 +1,18 @@ -// ChildFrm.h : interface of the CChildFrame class
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_CHILDFRM_H__4D1BB909_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_CHILDFRM_H__4D1BB909_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/MainFrm.cpp b/src/CBot/TestCBot/MainFrm.cpp index e151cce..2870f93 100644 --- a/src/CBot/TestCBot/MainFrm.cpp +++ b/src/CBot/TestCBot/MainFrm.cpp @@ -1,5 +1,18 @@ -// MainFrm.cpp : implementation of the CMainFrame class
-//
+// * 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 "stdafx.h"
#include "TestCBot.h"
diff --git a/src/CBot/TestCBot/MainFrm.h b/src/CBot/TestCBot/MainFrm.h index b9d68db..5b33df5 100644 --- a/src/CBot/TestCBot/MainFrm.h +++ b/src/CBot/TestCBot/MainFrm.h @@ -1,6 +1,18 @@ -// MainFrm.h : interface of the CMainFrame class
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_MAINFRM_H__4D1BB907_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_MAINFRM_H__4D1BB907_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/PerformDlg.cpp b/src/CBot/TestCBot/PerformDlg.cpp index a541f0b..f027f66 100644 --- a/src/CBot/TestCBot/PerformDlg.cpp +++ b/src/CBot/TestCBot/PerformDlg.cpp @@ -1,5 +1,18 @@ -// PerformDlg.cpp : implementation file
-//
+// * 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 "stdafx.h"
#include "testcbot.h"
@@ -122,7 +135,7 @@ BOOL CPerformDlg::OnInitDialog() CBotStringArray liste;
- // crée les scripts pour les tests
+ // cr�e les scripts pour les tests
for ( int i = 0; i < 100; i++ )
{
m_pProg[i] = new CBotProgram();
@@ -130,7 +143,7 @@ BOOL CPerformDlg::OnInitDialog() m_pProg[i]->Start(liste[0]);
}
- // lance un processus paralèle pour l'exécution
+ // lance un processus paral�le pour l'ex�cution
// m_threadinfo2.m_pWndMessage = this ;
m_threadinfo2.m_pEdit = &m_Edit1;
diff --git a/src/CBot/TestCBot/PerformDlg.h b/src/CBot/TestCBot/PerformDlg.h index 77ca71a..18ba1ea 100644 --- a/src/CBot/TestCBot/PerformDlg.h +++ b/src/CBot/TestCBot/PerformDlg.h @@ -1,3 +1,18 @@ +// * 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 .
#if !defined(AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_)
#define AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/Routines.cpp b/src/CBot/TestCBot/Routines.cpp index cd3a32b..4f037d1 100644 --- a/src/CBot/TestCBot/Routines.cpp +++ b/src/CBot/TestCBot/Routines.cpp @@ -1,10 +1,25 @@ +// * 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 .
////////////////////////////////////////////////////////////////////
// routine show()
-// utilisable depuis le programme écrit en CBot
+// utilisable depuis le programme �crit en CBot
-// exécution
+// ex�cution
BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
CString s;
@@ -32,15 +47,15 @@ BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser ) CBotTypResult cShow( CBotVar* &pVar, void* pUser)
{
if ( pVar == NULL ) return CBotTypResult(5028);
- return CBotTypResult(0); // tous paramètres acceptés, void en retour
+ return CBotTypResult(0); // tous param�tres accept�s, void en retour
}
////////////////////////////////////////////////////////////////////
// routine print()
-// utilisable depuis le programme écrit en CBot
+// utilisable depuis le programme �crit en CBot
-// exécution
+// ex�cution
BOOL rPrintLn( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
CString s;
@@ -90,19 +105,19 @@ BOOL rPrint( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser ) CBotTypResult cPrint( CBotVar* &pVar, void* pUser)
{
- return CBotTypResult(0); // tous paramètres acceptés, un entier en retour
+ return CBotTypResult(0); // tous param�tres accept�s, un entier en retour
}
//////////////////////////////////////////////////////////////////
// class CPoint pour essayer
-// exécution
+// ex�cution
BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
- if ( pVar == NULL )return TRUE; // constructeur sans paramètres est ok
+ if ( pVar == NULL )return TRUE; // constructeur sans param�tres est ok
CBotVar* pX = pThis->GivItem("x");
pX->SetValFloat( pVar->GivValFloat() );
@@ -117,20 +132,20 @@ BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception ) CBotTypResult cCPoint( CBotVar* pThis, CBotVar* &pVar)
{
- // ok si aucun paramètres !
+ // ok si aucun param�tres !
if ( pVar == NULL ) return CBotTypResult(0);
- // paramètre de type numérique svp
+ // param�tre de type num�rique svp
if ( pVar->GivType() > CBotTypDouble ) return CBotTypResult(5011);
pVar = pVar->GivNext();
- // il doit y avoir un second paramètre
+ // il doit y avoir un second param�tre
if ( pVar == NULL ) return 5028;
- // également de type numérique
+ // �galement de type num�rique
if ( pVar->GivType() > CBotTypDouble )return CBotTypResult(5011);
pVar = pVar->GivNext();
- // et pas plus de 2 paramètres svp
+ // et pas plus de 2 param�tres svp
if ( pVar != NULL ) return CBotTypResult(5026);
return CBotTypResult(0); // cette fonction retourne void
diff --git a/src/CBot/TestCBot/StdAfx.cpp b/src/CBot/TestCBot/StdAfx.cpp index b1dde8d..7a91baa 100644 --- a/src/CBot/TestCBot/StdAfx.cpp +++ b/src/CBot/TestCBot/StdAfx.cpp @@ -1,6 +1,18 @@ -// stdafx.cpp : source file that includes just the standard includes
-// TestCBot.pch will be the pre-compiled header
-// stdafx.obj will contain the pre-compiled type information
+// * 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 "stdafx.h"
diff --git a/src/CBot/TestCBot/StdAfx.h b/src/CBot/TestCBot/StdAfx.h index 7be8c40..9a7d859 100644 --- a/src/CBot/TestCBot/StdAfx.h +++ b/src/CBot/TestCBot/StdAfx.h @@ -1,7 +1,18 @@ -// stdafx.h : include file for standard system include files,
-// or project specific include files that are used frequently, but
-// are changed infrequently
-//
+// * 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 .
#if !defined(AFX_STDAFX_H__4D1BB905_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_STDAFX_H__4D1BB905_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/TestCBot.cpp b/src/CBot/TestCBot/TestCBot.cpp index 7e2aabb..50c1e72 100644 --- a/src/CBot/TestCBot/TestCBot.cpp +++ b/src/CBot/TestCBot/TestCBot.cpp @@ -1,5 +1,18 @@ -// TestCBot.cpp : Defines the class behaviors for the application.
-//
+// * 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 "stdafx.h"
#include "TestCBot.h"
@@ -55,7 +68,7 @@ static char BASED_CODE szFilename[] = "File1"; #include "../ClassFILE.cpp"
-// routine pour mettre à jour l'instance de la classe Bot courante
+// routine pour mettre � jour l'instance de la classe Bot courante
void rMajObject( CBotVar* pThis, void* pUser )
{
if (!pThis->IsElemOfClass("object"))
@@ -76,7 +89,7 @@ void rMajObject( CBotVar* pThis, void* pUser ) // pX = pThis->GivItem( "xx" );
// pX->SetValFloat( (float)22 );
- // crée une instance sur une classe object
+ // cr�e une instance sur une classe object
// CBotVar* pAutre = CBotVar::Create("autre", CBotTypClass, "object");
// pAutre->SetUserPtr( (void*)3 );
// pPt->SetPointer( pAutre );
@@ -88,13 +101,13 @@ void rMajObject( CBotVar* pThis, void* pUser ) BOOL CTestCBotApp::InitInstance()
{
//////////////////////////////////////////////
-// défini les mots clefs supplémentaires
+// d�fini les mots clefs suppl�mentaires
// -------------------------------------------
CBotProgram::Init();
//////////////////////////////////////////////
-// défini les fonctions "show()" et "print()"
+// d�fini les fonctions "show()" et "print()"
// -------------------------------------------
CBotProgram::AddFunction("show", rShow, cShow);
@@ -103,7 +116,7 @@ BOOL CTestCBotApp::InitInstance() ///////////////////////////////////
-// définie la classe globale CPoint
+// d�finie la classe globale CPoint
// --------------------------------
m_pClassPoint = new CBotClass("CPoint", NULL);
@@ -126,7 +139,7 @@ BOOL CTestCBotApp::InitInstance() // ajoute le constructeur pour cette classe
m_pClassPointIntr->AddFunction("point", rCPoint, cCPoint);
- // défini la classe "object"
+ // d�fini la classe "object"
CBotClass* pClassObject = new CBotClass( "object", NULL ) ;
pClassObject->AddItem( "xx", CBotTypFloat );
pClassObject->AddItem( "position", CBotTypResult( CBotTypIntrinsic, "point" ) );
diff --git a/src/CBot/TestCBot/TestCBot.h b/src/CBot/TestCBot/TestCBot.h index f101fd1..0fe04ec 100644 --- a/src/CBot/TestCBot/TestCBot.h +++ b/src/CBot/TestCBot/TestCBot.h @@ -1,5 +1,18 @@ -// TestCBot.h : main header file for the TESTCBOT application
-//
+// * 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 .
#if !defined(AFX_TESTCBOT_H__4D1BB903_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOT_H__4D1BB903_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/TestCBotDoc.cpp b/src/CBot/TestCBot/TestCBotDoc.cpp index e033dd5..5238b19 100644 --- a/src/CBot/TestCBot/TestCBotDoc.cpp +++ b/src/CBot/TestCBot/TestCBotDoc.cpp @@ -1,5 +1,18 @@ -// TestCBotDoc.cpp : implementation of the CTestCBotDoc class
-//
+// * 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 "stdafx.h"
#include "TestCBot.h"
@@ -125,7 +138,7 @@ void CTestCBotDoc::OnRun() m_pProg = NULL;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
@@ -136,7 +149,7 @@ void CTestCBotDoc::OnRun() if( m_Liste.GivSize() == 0 )
{
- AfxMessageBox("Aucune fonction marquée \"extern\" !");
+ AfxMessageBox("Aucune fonction marqu�e \"extern\" !");
return;
}
@@ -160,7 +173,7 @@ void CTestCBotDoc::OnRun() TextError = m_pProg->GivErrorText( dlg.m_code );
m_pEdit->SetSel( dlg.m_start, dlg.m_end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
AfxMessageBox(TextError);
}
@@ -187,7 +200,7 @@ BOOL CTestCBotDoc::Compile() if ( m_pProg == NULL ) m_pProg = new CBotProgram();
char buffer[100];
- strcpy(buffer, "le pointeur à passer pour voir");
+ strcpy(buffer, "le pointeur � passer pour voir");
if (m_bModified && !m_pProg->Compile(m_DocText, m_Liste, (void*)buffer))
{
@@ -196,7 +209,7 @@ BOOL CTestCBotDoc::Compile() m_pProg = NULL;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
@@ -209,7 +222,7 @@ BOOL CTestCBotDoc::Compile() if ( m_pProg->GetPosition( "TheTest", start, end) )
{
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
}
m_bModified = FALSE;
@@ -219,7 +232,7 @@ BOOL CTestCBotDoc::Compile() static int compt = 0;
-// routine retournant le "pointeur" à un autre object
+// routine retournant le "pointeur" � un autre object
BOOL rRetObject( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
pResult->SetPointer( NULL );
@@ -318,7 +331,7 @@ CBotTypResult cRadar( CBotVar* &pVar, void* pUser ) return CBotTypResult( CBotTypPointer, "object");
}
-// routine retournant le "pointeur" à un autre object
+// routine retournant le "pointeur" � un autre object
BOOL rTEST( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
test = 1 ;
@@ -338,7 +351,7 @@ CBotTypResult cTEST( CBotVar* &pVar, void* pUser ) return CBotTypResult( 0 );
}
-// routine retournant le "pointeur" à un autre object
+// routine retournant le "pointeur" � un autre object
BOOL rF( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
if ( pResult == NULL ) return TRUE;
@@ -353,7 +366,7 @@ CBotTypResult cF( CBotVar* &pVar, void* pUser ) /////////////////////////////////////////////////////////////////
-// Compilation d'une procédure avec un "point".
+// Compilation d'une proc�dure avec un "point".
CBotTypResult cPoint(CBotVar* &var, void* user)
{
@@ -381,7 +394,7 @@ CBotTypResult cPoint(CBotVar* &var, void* user) return CBotTypResult( CBotErrBadParam );
}
-// Donne un paramètre de type "point".
+// Donne un param�tre de type "point".
#define UNIT 1
@@ -495,13 +508,13 @@ void CTestCBotDoc::OnTest() // dlg.m_Script = m_DocText;
// dlg.DoModal();
- // défini la routine RetObject
+ // d�fini la routine RetObject
CBotProgram::AddFunction( "Radar", rRetObject, cRetObject );
// ajoute une routine pour cette classe
CBotProgram::AddFunction("Space", rSpace, cSpace);
- // défini la routine Test
+ // d�fini la routine Test
CBotProgram::AddFunction( "TEST", rTEST, cTEST );
CBotProgram::AddFunction( "F", rF, cF );
@@ -509,13 +522,13 @@ void CTestCBotDoc::OnTest() CBotProgram::AddFunction( "fire", rTurn, cTurn );
CBotProgram::AddFunction( "radar", rRadar, cRadar );
- // crée une instance de la classe "Bot" pour ce robot
+ // cr�e une instance de la classe "Bot" pour ce robot
CBotVar* pThisRobot = CBotVar::Create( "", CBotTypResult(CBotTypClass, "object") );
pThisRobot->SetUserPtr( (void*)1 );
pThisRobot->SetIdent( 1234 );
delete m_pProg;
- // crée un objet programme associé à cette instance
+ // cr�e un objet programme associ� � cette instance
m_pProg = new CBotProgram(pThisRobot);
// compile le programme
@@ -532,7 +545,7 @@ void CTestCBotDoc::OnTest() delete pThisRobot;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
@@ -541,14 +554,14 @@ void CTestCBotDoc::OnTest() return;
}
- // exécute pour voir
+ // ex�cute pour voir
m_pProg->Start(m_Liste[0]);
int mode = -1;
if ( mode >= 0 ) {
- // sauve et restore à chaque pas possible
+ // sauve et restore � chaque pas possible
while (!m_pProg->Run(NULL, 1))
{
const char* FunctionName;
@@ -575,7 +588,7 @@ if ( mode == 2 ) if (!m_pProg->Compile(m_DocText, m_Liste, (void*) 44)) delete pThisRobot;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
diff --git a/src/CBot/TestCBot/TestCBotDoc.h b/src/CBot/TestCBot/TestCBotDoc.h index d8275b5..d3a2748 100644 --- a/src/CBot/TestCBot/TestCBotDoc.h +++ b/src/CBot/TestCBot/TestCBotDoc.h @@ -1,6 +1,18 @@ -// TestCBotDoc.h : interface of the CTestCBotDoc class
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_TESTCBOTDOC_H__4D1BB90B_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOTDOC_H__4D1BB90B_8E74_11D4_A439_00D059085115__INCLUDED_
@@ -18,8 +30,8 @@ protected: // create from serialization only // Attributes
public:
- CEdit* m_pEdit; // pour mémoriser le texte, et l'afficher
- CBotProgram* m_pProg; // le programme compilé
+ CEdit* m_pEdit; // pour m�moriser le texte, et l'afficher
+ CBotProgram* m_pProg; // le programme compil�
CString m_DocText;
CBotStringArray m_Liste;
BOOL m_bModified;
diff --git a/src/CBot/TestCBot/TestCBotView.cpp b/src/CBot/TestCBot/TestCBotView.cpp index 052e756..21ddbaa 100644 --- a/src/CBot/TestCBot/TestCBotView.cpp +++ b/src/CBot/TestCBot/TestCBotView.cpp @@ -1,5 +1,18 @@ -// TestCBotView.cpp : implementation of the CTestCBotView class
-//
+// * 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 "stdafx.h"
#include "TestCBot.h"
@@ -93,7 +106,7 @@ void CTestCBotView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* if ( !bActivate && !pDoc->Compile() )
{
-// comment faire pour réactiver l'ancien document
+// comment faire pour r�activer l'ancien document
}
CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
diff --git a/src/CBot/TestCBot/TestCBotView.h b/src/CBot/TestCBot/TestCBotView.h index bca156f..1932993 100644 --- a/src/CBot/TestCBot/TestCBotView.h +++ b/src/CBot/TestCBot/TestCBotView.h @@ -1,6 +1,18 @@ -// TestCBotView.h : interface of the CTestCBotView class
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_TESTCBOTVIEW_H__4D1BB90D_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOTVIEW_H__4D1BB90D_8E74_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/TestCBot/resource.h b/src/CBot/TestCBot/resource.h index bed36ca..d549244 100644 --- a/src/CBot/TestCBot/resource.h +++ b/src/CBot/TestCBot/resource.h @@ -1,7 +1,18 @@ -//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by TestCBot.rc
-//
+// * 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 .
#define IDD_ABOUTBOX 100
#define IDR_MAINFRAME 128
#define IDR_TESTCBTYPE 129
diff --git a/src/CBot/old CBotAddExpr.cpp b/src/CBot/old CBotAddExpr.cpp index 85b7588..4a1d91a 100644 --- a/src/CBot/old CBotAddExpr.cpp +++ b/src/CBot/old CBotAddExpr.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"
@@ -26,9 +38,9 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotCStack* pStk = pStack->TokenStack(); // un bout de pile svp
- // cherche des instructions qui peuvent convenir à gauche de l'opération + ou -
+ // cherche des instructions qui peuvent convenir � gauche de l'op�ration + ou -
- CBotInstr* left = CBotMulExpr::Compile( p, pStk ); // expression A * B à gauche
+ 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 ?
@@ -36,82 +48,82 @@ CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotCStack* pStack) 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
+ CBotAddExpr* inst = new CBotAddExpr(); // �l�ment pour op�ration
+ inst->SetToken(p); // m�morise l'op�ration
int type1, type2;
- type1 = pStk->GetType(CBotTypChar); // de quel type le premier opérande ?
+ type1 = pStk->GetType(CBotTypChar); // de quel type le premier op�rande ?
- p = p->Next(); // saute le token de l'opération
+ p = p->Next(); // 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 = CBotAddExpr::Compile( p, pStk )) ) // expression (...) à droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression (...) � droite
{
- // il y a un second opérande acceptable
+ // il y a un second op�rande acceptable
- type2 = pStk->GetType(CBotTypChar); // de quel type le résultat ?
+ type2 = pStk->GetType(CBotTypChar); // de quel type le r�sultat ?
- if ( type1 == type2 && // les résultats sont-ils compatibles
+ if ( type1 == type2 && // les r�sultats sont-ils compatibles
type1 != CBotTypBoolean &&
(inst->m_token.GetType() != ID_SUB ||
- type1 < CBotTypBoolean )) // pas de soustraction de chaînes !
+ type1 < CBotTypBoolean )) // pas de soustraction de cha�nes !
{
- // si ok, enregistre l'opérande dans l'objet
+ // si ok, enregistre l'op�rande dans l'objet
inst->m_leftop = left;
- // 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);
}
-// fait l'opération d'addition ou de soustraction
+// fait l'op�ration d'addition ou de soustraction
BOOL CBotAddExpr::Execute(CBotStack* &pStack)
{
- CBotStack* pStk1 = pStack->AddStack(); // ajoute un élément à la pile
+ CBotStack* pStk1 = pStack->AddStack(); // ajoute un �l�ment � la pile
// ou le retrouve en cas de reprise
- // selon la reprise, on peut être dans l'un des 2 états
+ // selon la reprise, on peut �tre dans l'un des 2 �tats
- if ( pStk1->GetState() == 0 && // 1er état, évalue l'opérande de gauche
+ 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
+ // 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 ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
- int type1 = pStk1->GetType(); // de quels types les résultats ?
+ 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
+ // cr�e une variable temporaire pour y mettre le r�sultat
CBotVar* result = CBotVar::Create( NULL, MAX(type1, type2));
- // fait l'opération selon la demande
+ // fait l'op�ration selon la demande
switch (GetTokenType())
{
case ID_ADD:
@@ -121,10 +133,10 @@ BOOL CBotAddExpr::Execute(CBotStack* &pStack) result->Sub(pStk1->GetVar(), pStk2->GetVar()); // soustrait
break;
}
- pStk2->SetVar(result); // met le résultat sur la pile
+ 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
+ pStk1->Return(pStk2); // lib�re la pile
+ return pStack->Return(pStk1); // transmet le r�sultat
}
diff --git a/src/CBot/old CBotCompExpr.cpp b/src/CBot/old CBotCompExpr.cpp index e7439b7..c9f81d9 100644 --- a/src/CBot/old CBotCompExpr.cpp +++ b/src/CBot/old CBotCompExpr.cpp @@ -1,7 +1,18 @@ -///////////////////////////////////////////////////
-// expression du genre Opérande1 > Opérande2
-// Opérande1 != Opérande2
-// etc.
+// * 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,7 +38,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) {
CBotCStack* pStk = pStack->TokenStack();
- CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B à gauche
+ CBotInstr* left = CBotAddExpr::Compile( p, pStk ); // expression A + B � gauche
if (left == NULL) return pStack->Return(NULL, pStk); // erreur
if ( p->GetType() == ID_HI ||
@@ -37,22 +48,22 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) p->GetType() == ID_EQ ||
p->GetType() == ID_NE) // les diverses comparaisons
{
- CBotCompExpr* inst = new CBotCompExpr(); // élément pour opération
- inst->SetToken(p); // mémorise l'opération
+ CBotCompExpr* inst = new CBotCompExpr(); // �l�ment pour op�ration
+ inst->SetToken(p); // m�morise l'op�ration
int type1, type2;
type1 = pStk->GetType(CBotTypChar);
p = p->Next();
- if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B à droite
+ if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) ) // expression A + B � droite
{
type2 = pStk->GetType(CBotTypChar);
- // les résultats sont-ils compatibles
+ // les r�sultats sont-ils compatibles
if ( type1 == type2 && type1 != CBotTypBoolean && type1 != CBotTypClass)
{
inst->m_leftop = left;
pStk->SetVar(new CBotVar(NULL, CBotTypBoolean));
- // le résultat est un boolean
+ // le r�sultat est un boolean
return pStack->Return(inst, pStk);
}
pStk->SetError(TX_BAD2TYPE, &inst->m_token);
@@ -67,7 +78,7 @@ CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack) }
-// fait l'opération
+// fait l'op�ration
BOOL CBotCompExpr::Execute(CBotStack* &pStack)
{
@@ -75,9 +86,9 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) if ( pStk1->GetState() == 0 && !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?
- pStk1->SetState(1); // opération terminée
+ pStk1->SetState(1); // op�ration termin�e
- // 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
CBotStack* pStk2 = pStk1->AddStack();
if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?
@@ -91,30 +102,30 @@ BOOL CBotCompExpr::Execute(CBotStack* &pStack) switch (GetTokenType())
{
case ID_LO:
- temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inférieur
+ temp->Lo(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur
break;
case ID_HI:
- temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // supérieur
+ temp->Hi(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur
break;
case ID_LS:
- temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inférieur ou égal
+ temp->Ls(pStk1->GetVar(), pStk2->GetVar()); // inf�rieur ou �gal
break;
case ID_HS:
- temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // supérieur ou égal
+ temp->Hs(pStk1->GetVar(), pStk2->GetVar()); // sup�rieur ou �gal
break;
case ID_EQ:
- temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // égal
+ temp->Eq(pStk1->GetVar(), pStk2->GetVar()); // �gal
break;
case ID_NE:
- temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // différent
+ temp->Ne(pStk1->GetVar(), pStk2->GetVar()); // diff�rent
break;
}
- result->SetValInt(temp->GetValInt()); // converti le résultat
+ result->SetValInt(temp->GetValInt()); // converti le r�sultat
delete temp;
- pStk2->SetVar(result); // met le résultat sur la pile
+ 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
+ pStk1->Return(pStk2); // lib�re la pile
+ return pStack->Return(pStk1); // transmet le r�sultat
}
diff --git a/src/CBot/old TstCBot/BotConsoleDlg.cpp b/src/CBot/old TstCBot/BotConsoleDlg.cpp index 077f080..b7348ed 100644 --- a/src/CBot/old TstCBot/BotConsoleDlg.cpp +++ b/src/CBot/old TstCBot/BotConsoleDlg.cpp @@ -1,5 +1,18 @@ -// BotConsoleDlg.cpp : implementation file
-//
+// * 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 "stdafx.h"
#include "TstCBot.h"
@@ -68,7 +81,7 @@ UINT ThreadProc(ThreadInfo *info) CTimeSpan ts = t - t0;
char buffer[200];
- sprintf( buffer, "\r\nExécution terminée en %d secondes.\r\nInterrompue %d fois.\r\n",
+ sprintf( buffer, "\r\nEx�cution termin�e en %d secondes.\r\nInterrompue %d fois.\r\n",
ts.GetTotalSeconds(), Cpt);
info->m_pEdit1->ReplaceSel(buffer);
@@ -126,7 +139,7 @@ void CBotConsoleDlg::OnOK() m_Edit2.EnableWindow(FALSE);
m_cOK.EnableWindow(FALSE);
- // lance un processus paralèle pour l'exécution
+ // lance un processus paral�le pour l'ex�cution
m_threadinfo.m_pWndMessage = this ;
m_threadinfo.m_pEdit1 = &m_Edit1;
diff --git a/src/CBot/old TstCBot/BotConsoleDlg.h b/src/CBot/old TstCBot/BotConsoleDlg.h index 9b54ff2..6a483da 100644 --- a/src/CBot/old TstCBot/BotConsoleDlg.h +++ b/src/CBot/old TstCBot/BotConsoleDlg.h @@ -1,3 +1,18 @@ +// * 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 .
#if !defined(AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_)
#define AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/old TstCBot/BotErrorDlg.cpp b/src/CBot/old TstCBot/BotErrorDlg.cpp index 87d56f0..8dc9b37 100644 --- a/src/CBot/old TstCBot/BotErrorDlg.cpp +++ b/src/CBot/old TstCBot/BotErrorDlg.cpp @@ -1,5 +1,18 @@ -// BotErrorDlg.cpp : implementation file
-//
+// * 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 "stdafx.h"
#include "TstCBot.h"
diff --git a/src/CBot/old TstCBot/BotErrorDlg.h b/src/CBot/old TstCBot/BotErrorDlg.h index 522afad..9d87848 100644 --- a/src/CBot/old TstCBot/BotErrorDlg.h +++ b/src/CBot/old TstCBot/BotErrorDlg.h @@ -1,3 +1,18 @@ +// * 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 .
#if !defined(AFX_BOTERRORDLG_H__80E73D20_7454_11D4_A439_00D059085115__INCLUDED_)
#define AFX_BOTERRORDLG_H__80E73D20_7454_11D4_A439_00D059085115__INCLUDED_
diff --git a/src/CBot/old TstCBot/CMyThread.cpp b/src/CBot/old TstCBot/CMyThread.cpp index ca92c77..ab54ab4 100644 --- a/src/CBot/old TstCBot/CMyThread.cpp +++ b/src/CBot/old TstCBot/CMyThread.cpp @@ -1,5 +1,18 @@ -// CMyThread.cpp : pour créer un processus pour la console
-//
+// * 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 "stdafx.h"
#include "TstCBot.h"
@@ -38,7 +51,7 @@ BOOL CMyThread::InitInstance() CTstCBotApp* pApp = (CTstCBotApp*)AfxGetApp();
- // ouvre une fenêtre pour afficher les sorties
+ // ouvre une fen�tre pour afficher les sorties
CRect rect;
AfxGetMainWnd()->GetClientRect( rect );
rect += CPoint(30,30);
diff --git a/src/CBot/old TstCBot/CMyThread.h b/src/CBot/old TstCBot/CMyThread.h index 1134077..6d5d866 100644 --- a/src/CBot/old TstCBot/CMyThread.h +++ b/src/CBot/old TstCBot/CMyThread.h @@ -1,6 +1,18 @@ -// CMyThread.h : pour créer un processus pour la console
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_MAINFRM_H__20B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_MAINFRM_H__20B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/MainFrm.cpp b/src/CBot/old TstCBot/MainFrm.cpp index 6c0962c..6550a89 100644 --- a/src/CBot/old TstCBot/MainFrm.cpp +++ b/src/CBot/old TstCBot/MainFrm.cpp @@ -1,5 +1,18 @@ -// MainFrm.cpp : implementation of the CMainFrame class
-//
+// * 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 "stdafx.h"
#include "TstCBot.h"
diff --git a/src/CBot/old TstCBot/MainFrm.h b/src/CBot/old TstCBot/MainFrm.h index 56b9c41..fe86ee6 100644 --- a/src/CBot/old TstCBot/MainFrm.h +++ b/src/CBot/old TstCBot/MainFrm.h @@ -1,6 +1,18 @@ -// MainFrm.h : interface of the CMainFrame class
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_MAINFRM_H__70B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_MAINFRM_H__70B3756C_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/Resource.h b/src/CBot/old TstCBot/Resource.h index 6863fd8..f131d7c 100644 --- a/src/CBot/old TstCBot/Resource.h +++ b/src/CBot/old TstCBot/Resource.h @@ -1,7 +1,18 @@ -//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by TstCBot.rc
-//
+// * 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 .
#define IDD_ABOUTBOX 100
#define IDR_MAINFRAME 128
#define IDR_TSTCBOTYPE 129
diff --git a/src/CBot/old TstCBot/StdAfx.cpp b/src/CBot/old TstCBot/StdAfx.cpp index ae0ec93..7a91baa 100644 --- a/src/CBot/old TstCBot/StdAfx.cpp +++ b/src/CBot/old TstCBot/StdAfx.cpp @@ -1,6 +1,18 @@ -// stdafx.cpp : source file that includes just the standard includes
-// TstCBot.pch will be the pre-compiled header
-// stdafx.obj will contain the pre-compiled type information
+// * 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 "stdafx.h"
diff --git a/src/CBot/old TstCBot/StdAfx.h b/src/CBot/old TstCBot/StdAfx.h index 7d46ace..eea8584 100644 --- a/src/CBot/old TstCBot/StdAfx.h +++ b/src/CBot/old TstCBot/StdAfx.h @@ -1,7 +1,18 @@ -// stdafx.h : include file for standard system include files,
-// or project specific include files that are used frequently, but
-// are changed infrequently
-//
+// * 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 .
#if !defined(AFX_STDAFX_H__70B3756A_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_STDAFX_H__70B3756A_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/TstCBot.cpp b/src/CBot/old TstCBot/TstCBot.cpp index 8ac4557..5b831e3 100644 --- a/src/CBot/old TstCBot/TstCBot.cpp +++ b/src/CBot/old TstCBot/TstCBot.cpp @@ -1,5 +1,18 @@ -// TstCBot.cpp : Defines the class behaviors for the application.
-//
+// * 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 "stdafx.h"
#include "TstCBot.h"
@@ -19,9 +32,9 @@ static char THIS_FILE[] = __FILE__; ////////////////////////////////////////////////////////////////////
// routine show()
-// utilisable depuis le programme écrit en CBot
+// utilisable depuis le programme �crit en CBot
-// exécution
+// ex�cution
BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
@@ -56,7 +69,7 @@ BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception ) int cShow( CBotVar* &pVar, CBotString& RetClass)
{
if ( pVar == NULL ) return 22;
- return CBotTypInt; // tous paramètres acceptés, un entier en retour
+ return CBotTypInt; // tous param�tres accept�s, un entier en retour
}
int cErr( CBotVar* &pVar, CBotString& RetClass)
@@ -67,9 +80,9 @@ int cErr( CBotVar* &pVar, CBotString& RetClass) ////////////////////////////////////////////////////////////////////
// routine print()
-// utilisable depuis le programme écrit en CBot
+// utilisable depuis le programme �crit en CBot
-// exécution
+// ex�cution
BOOL rPrintLn( CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
@@ -118,19 +131,19 @@ BOOL rPrint( CBotVar* pVar, CBotVar* pResult, int& Exception ) int cPrint( CBotVar* &pVar, CBotString& RetClass)
{
- return 0; // tous paramètres acceptés, un entier en retour
+ return 0; // tous param�tres accept�s, un entier en retour
}
//////////////////////////////////////////////////////////////////
// class CPoint pour essayer
-// exécution
+// ex�cution
BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
- if ( pVar == NULL )return TRUE; // constructeur sans paramètres est ok
+ if ( pVar == NULL )return TRUE; // constructeur sans param�tres est ok
if ( pVar->RetType() > CBotTypDouble )
{
@@ -175,41 +188,41 @@ BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception ) int cCPoint( CBotVar* pThis, CBotVar* &pVar, CBotString& RetClass)
{
- // l'objet doit être de la classe CPoint
+ // l'objet doit �tre de la classe CPoint
if ( !pThis->IsElemOfClass("CPoint") ) return 6021;
- // ok si aucun paramètres !
+ // ok si aucun param�tres !
if ( pVar == NULL ) return 0;
- // paramètre de type numérique svp
+ // param�tre de type num�rique svp
if ( pVar->RetType() > CBotTypDouble ) return 6023;
pVar = pVar->RetNext();
- // il doit y avoir un second paramètre
+ // il doit y avoir un second param�tre
if ( pVar == NULL ) return 6022;
- // également de type numérique
+ // �galement de type num�rique
if ( pVar->RetType() > CBotTypDouble )return 6023;
pVar = pVar->RetNext();
- // et pas plus de 2 paramètres svp
+ // et pas plus de 2 param�tres svp
if ( pVar != NULL ) return 6025;
return 0; // cette fonction retourne void
}
-// méthode déterminant l'opposé
+// m�thode d�terminant l'oppos�
BOOL rOppose( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
- if ( pVar != NULL ) // pas de paramètre
+ if ( pVar != NULL ) // pas de param�tre
{
Exception = 6025; return FALSE;
}
- CBotVar* pvar = pThis->RetItemList(); // demande la chaîne des items
+ CBotVar* pvar = pThis->RetItemList(); // demande la cha�ne des items
- // tous les paramètres sont des nombres
+ // tous les param�tres sont des nombres
while (pvar != NULL)
{
pvar->SetValFloat( -pvar->RetValFloat() );
@@ -222,15 +235,15 @@ BOOL rOppose( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception ) int cOppose( CBotVar* pThis, CBotVar* &pVar, CBotString& RetClass)
{
- // l'objet doit être de la classe CPoint
+ // l'objet doit �tre de la classe CPoint
if ( !pThis->IsElemOfClass("CPoint") ) return 6021;
RetClass = "CPoint"; // l'objet rendu est de cette class
- // ok si aucun paramètres !
- if ( pVar == NULL ) return CBotTypClass; // le paramètre retourné est une instance de la classe
+ // ok si aucun param�tres !
+ if ( pVar == NULL ) return CBotTypClass; // le param�tre retourn� est une instance de la classe
- return TX_OVERPARAM; // ça va pas
+ return TX_OVERPARAM; // �a va pas
}
@@ -313,7 +326,7 @@ BOOL CTstCBotApp::InitInstance() ///////////////////////////////////
-// défini la fonction "show()"
+// d�fini la fonction "show()"
// --------------------------------
CBotProgram::AddFunction("show", rShow, cShow);
@@ -323,7 +336,7 @@ BOOL CTstCBotApp::InitInstance() ///////////////////////////////////
-// définie la classe globale CPoint
+// d�finie la classe globale CPoint
// --------------------------------
CBotClass* m_pClassPoint;
@@ -336,8 +349,8 @@ BOOL CTstCBotApp::InitInstance() // ajoute le constructeur pour cette classe
m_pClassPoint->AddFunction("CPoint", rCPoint, cCPoint);
- // ajoute la méthode Opposé
- m_pClassPoint->AddFunction("Opposé", rOppose, cOppose);
+ // ajoute la m�thode Oppos�
+ m_pClassPoint->AddFunction("Oppos�", rOppose, cOppose);
//////////////////////////////////////////////////////////////////
@@ -348,7 +361,7 @@ BOOL CTstCBotApp::InitInstance() CBotStringArray Liste;
p->Compile(" public void MonProgram( ) { show (\"mon programme\") ;}", Liste );
- // l'objet n'est pas détruit et plus référencé
+ // l'objet n'est pas d�truit et plus r�f�renc�
// je sais c'est pas bien
diff --git a/src/CBot/old TstCBot/TstCBot.h b/src/CBot/old TstCBot/TstCBot.h index 616db43..a351344 100644 --- a/src/CBot/old TstCBot/TstCBot.h +++ b/src/CBot/old TstCBot/TstCBot.h @@ -1,5 +1,18 @@ -// TstCBot.h : main header file for the TSTCBOT application
-//
+// * 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 .
#if !defined(AFX_TSTCBOT_H__70B37568_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_TSTCBOT_H__70B37568_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/TstCBotDoc.cpp b/src/CBot/old TstCBot/TstCBotDoc.cpp index 7d7e2ef..6c14f11 100644 --- a/src/CBot/old TstCBot/TstCBotDoc.cpp +++ b/src/CBot/old TstCBot/TstCBotDoc.cpp @@ -1,5 +1,18 @@ -// TstCBotDoc.cpp : implementation of the CTstCBotDoc class
-//
+// * 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 "stdafx.h"
#include "TstCBot.h"
diff --git a/src/CBot/old TstCBot/TstCBotDoc.h b/src/CBot/old TstCBot/TstCBotDoc.h index ae1d0f7..dd71389 100644 --- a/src/CBot/old TstCBot/TstCBotDoc.h +++ b/src/CBot/old TstCBot/TstCBotDoc.h @@ -1,6 +1,18 @@ -// TstCBotDoc.h : interface of the CTstCBotDoc class
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_TSTCBOTDOC_H__70B3756E_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_TSTCBOTDOC_H__70B3756E_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
diff --git a/src/CBot/old TstCBot/TstCBotView.cpp b/src/CBot/old TstCBot/TstCBotView.cpp index 3ee9094..33777a6 100644 --- a/src/CBot/old TstCBot/TstCBotView.cpp +++ b/src/CBot/old TstCBot/TstCBotView.cpp @@ -1,5 +1,18 @@ -// TstCBotView.cpp : implementation of the CTstCBotView class
-//
+// * 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 "stdafx.h"
#include "TstCBot.h"
@@ -189,13 +202,13 @@ void CTstCBotView::OnCp1() m_pProg = NULL;
m_pEdit->SetSel( start, end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
TextError.LoadString( code );
if (TextError.IsEmpty())
{
char buf[100];
- sprintf(buf, "Erreur numéro %d.", code);
+ sprintf(buf, "Erreur num�ro %d.", code);
TextError = buf;
}
AfxMessageBox( TextError );
@@ -214,13 +227,13 @@ void CTstCBotView::OnExe() if( m_pProg == NULL)
{
- AfxMessageBox("Pas de programme compilé !");
+ AfxMessageBox("Pas de programme compil� !");
return;
}
if( pApp->m_Liste.RetSize() == 0 )
{
- AfxMessageBox("Aucune fonction marquée \"extern\" !");
+ AfxMessageBox("Aucune fonction marqu�e \"extern\" !");
return;
}
@@ -234,13 +247,13 @@ void CTstCBotView::OnExe() CString TextError;
m_pEdit->SetSel( dlg.m_start, dlg.m_end );
- m_pEdit->SetFocus(); // met en évidence la partie avec problème
+ m_pEdit->SetFocus(); // met en �vidence la partie avec probl�me
TextError.LoadString( dlg.m_code );
if (TextError.IsEmpty())
{
char buf[100];
- sprintf(buf, "Erreur numéro %d.", dlg.m_code);
+ sprintf(buf, "Erreur num�ro %d.", dlg.m_code);
TextError = buf;
}
// AfxMessageBox( TextError );
diff --git a/src/CBot/old TstCBot/TstCBotView.h b/src/CBot/old TstCBot/TstCBotView.h index d5aede5..12f779d 100644 --- a/src/CBot/old TstCBot/TstCBotView.h +++ b/src/CBot/old TstCBot/TstCBotView.h @@ -1,6 +1,18 @@ -// TstCBotView.h : interface of the CTstCBotView class
-//
-/////////////////////////////////////////////////////////////////////////////
+// * 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 .
#if !defined(AFX_TSTCBOTVIEW_H__70B37570_5DFD_11D4_A15E_00E0189013DF__INCLUDED_)
#define AFX_TSTCBOTVIEW_H__70B37570_5DFD_11D4_A15E_00E0189013DF__INCLUDED_
@@ -20,9 +32,9 @@ protected: // create from serialization only CTstCBotView();
DECLARE_DYNCREATE(CTstCBotView)
- CEdit* m_pEdit; // texte en édition
+ CEdit* m_pEdit; // texte en �dition
CWnd* m_pWnd;
- CBotProgram* m_pProg; // programme compilé
+ CBotProgram* m_pProg; // programme compil�
// Attributes
public:
diff --git a/src/CBot/resource.h b/src/CBot/resource.h index 659ee69..0cc2ea5 100644 --- a/src/CBot/resource.h +++ b/src/CBot/resource.h @@ -1,7 +1,18 @@ -//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by CBot.rc
-//
+// * 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 .
#define ID_KEYWORDS 2000
#define ID_IF 2000
#define ID_ELSE 2001
|