Added license info using a small program SrcHead.

1 files changed, 123 insertions, 110 deletions

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;

 		}