Last coding fix ;)

1 files changed, 225 insertions, 222 deletions

diff --git a/src/CBot/CBotDll.h b/src/CBot/CBotDll.h
index afb9c1c..ea67f2c 100644
--- a/src/CBot/CBotDll.h
+++ b/src/CBot/CBotDll.h
@@ -1,4 +1,4 @@
-// * This file is part of the COLOBOT source code

+// * 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

@@ -12,7 +12,10 @@
 // * GNU General Public License for more details.

 // *

 // * You should have received a copy of the GNU General Public License

-// * along with this program. If not, see  http://www.gnu.org/licenses/.

+// * along with this program. If not, see  http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////////

+// Librairie pour l'interprétation du language CBOT

+// pour le jeu COLOBOT

+//

 

 //#include "stdafx.h"

 

@@ -24,26 +27,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

@@ -51,24 +54,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)

@@ -76,13 +79,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;	

@@ -91,13 +94,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

@@ -107,20 +110,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();

@@ -135,7 +138,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);

@@ -151,7 +154,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 );

@@ -168,16 +171,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

@@ -186,8 +189,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

@@ -197,63 +200,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;

@@ -360,9 +363,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

@@ -382,7 +385,7 @@ public:
 	CBotString&		ElementAt(int nIndex);

 };

 

-// diff�rents mode pour GetPosition

+// différents mode pour GetPosition

 enum CBotGet

 {

 	GetPosExtern	= 1,

@@ -392,16 +395,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;

 

@@ -409,12 +412,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;

 

@@ -422,12 +425,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

@@ -444,11 +447,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);

@@ -465,10 +468,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);

@@ -476,42 +479,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

@@ -519,7 +522,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

@@ -528,20 +531,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

 

 

@@ -564,21 +567,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 )

 	{

@@ -586,7 +589,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 !

 }

 

 

@@ -602,7 +605,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

@@ -610,20 +613,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

 {

@@ -638,11 +641,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

@@ -662,12 +665,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

@@ -688,16 +691,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

@@ -716,10 +719,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);

@@ -740,9 +743,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

@@ -750,18 +753,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

@@ -771,27 +774,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);

@@ -850,16 +853,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 !

 */

 

 

@@ -868,41 +871,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

@@ -911,41 +914,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

@@ -961,7 +964,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

@@ -1003,9 +1006,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

@@ -1017,19 +1020,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

@@ -1054,20 +1057,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

@@ -1075,7 +1078,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

@@ -1102,10 +1105,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"

@@ -1115,17 +1118,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

@@ -1133,9 +1136,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 );

@@ -1143,49 +1146,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();

 

@@ -1193,4 +1196,4 @@ BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
 										// rend FALSE s'il faut patienter encore

 }

 

-#endif

+#endif
\ No newline at end of file