Added license info using a small program SrcHead.

1 files changed, 159 insertions, 146 deletions

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;