Unneeded files deleted.

1 files changed, 0 insertions, 295 deletions

diff --git a/src/CBot/Copie de CBotTwoOpExpr.cpp b/src/CBot/Copie de CBotTwoOpExpr.cpp
deleted file mode 100644
index 7a95b55..0000000
--- a/src/CBot/Copie de CBotTwoOpExpr.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-///////////////////////////////////////////////////

-// expression du genre Opérande1 + Opérande2

-//					   Opérande1 > Opérande2

-

-#include "CBot.h"

-

-// divers constructeurs

-

-CBotTwoOpExpr::CBotTwoOpExpr()

-{

-	m_leftop	=

-	m_rightop	= NULL;			// NULL pour pouvoir faire delete sans autre

-	name = "CBotTwoOpExpr";		// debug

-}

-

-CBotTwoOpExpr::~CBotTwoOpExpr()

-{

-	delete	m_leftop;

-	delete	m_rightop;

-}

-

-// type d'opérandes acceptés par les opérations

-#define		ENTIER		((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))

-#define		FLOTANT		((1<<CBotTypFloat)|(1<<CBotTypDouble))

-#define		BOOLEEN		(1<<CBotTypBoolean)

-#define		CHAINE		(1<<CBotTypString)

-#define		CLASSE		(1<<CBotTypClass)

-

-// liste des opérations (précéance)

-static int	ListOp[] = 

-{

-	BOOLEEN,				ID_LOG_OR, 0,

-	BOOLEEN,				ID_LOG_AND, 0,

-	BOOLEEN|ENTIER,			ID_OR, 0,

-	ENTIER,					ID_XOR, 0,

-	BOOLEEN|ENTIER,			ID_AND, 0,

-	BOOLEEN|ENTIER|FLOTANT,	ID_EQ, 

-	BOOLEEN|ENTIER|FLOTANT,	ID_NE, 0,

-	ENTIER|FLOTANT,			ID_HI,

-	ENTIER|FLOTANT,			ID_LO,

-	ENTIER|FLOTANT,			ID_HS,

-	ENTIER|FLOTANT,			ID_LS, 0,

-	ENTIER,					ID_SR,

-	ENTIER,					ID_SL,

-	ENTIER,					ID_ASR, 0,

-	ENTIER|FLOTANT|CHAINE,	ID_ADD,

-	ENTIER|FLOTANT,			ID_SUB, 0,

-	ENTIER|FLOTANT,			ID_MUL, 

-	ENTIER|FLOTANT,			ID_DIV, 

-	ENTIER|FLOTANT,			ID_MODULO, 0,

-	0,

-};

-

-BOOL IsInList( int val, int* list, int& typemasque )

-{

-	while (TRUE)

-	{

-		if ( *list == 0 ) return FALSE;

-		typemasque = *list++;

-		if ( *list++ == val ) return TRUE;

-	}

-}

-

-BOOL TypeOk( int type, int test )

-{

-	while (TRUE)

-	{

-		if ( type == 0 ) return (test & 1);

-		type--; test /= 2;

-	}

-}

-

-// compile une instruction de type A op B

-

-CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations)

-{

-	int	typemasque;

-

-	if ( pOperations == NULL ) pOperations = ListOp;

-	int* pOp = pOperations;

-	while ( *pOp++ != 0 );				// suite de la table

-

-	CBotCStack* pStk = pStack->TokenStack();					// un bout de pile svp

-

-	// cherche des instructions qui peuvent convenir à gauche de l'opération

-	CBotInstr*	left = (*pOp == 0) ?

-						CBotParExpr::Compile( p, pStk ) :		// expression (...) à gauche

-						CBotTwoOpExpr::Compile( p, pStk, pOp );	// expression A * B à gauche

-

-	if (left == NULL) return pStack->Return(NULL, pStk);		// si erreur, la transmet

-

-	// est-ce qu'on a l'opérande prévu ensuite ?

-	int	TypeOp = p->GetType();

-	if ( IsInList( TypeOp, pOperations, typemasque ) )

-	{

-		CBotTwoOpExpr* inst = new CBotTwoOpExpr();				// élément pour opération

-		inst->SetToken(p);										// mémorise l'opération

-

-		int			 type1, type2;

-		type1 = pStk->GetType();								// de quel type le premier opérande ?

-

-		p = p->Next();											// saute le token de l'opération 

-

-		// cherche des instructions qui peuvent convenir à droite

-

-		if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOperations )) )

-																// expression (...) à droite

-		{

-			// il y a un second opérande acceptable

-

-			type2 = pStk->GetType();							// de quel type le résultat ?

-

-			// quel est le type du résultat ?

-			int	TypeRes = MAX( type1, type2 );

-			if (!TypeOk( TypeRes, typemasque )) type1 = 99;		// erreur de type

-

-			switch ( TypeOp )

-			{

-			case ID_LOG_OR:

-			case ID_LOG_AND:

-			case ID_EQ:

-			case ID_NE:

-			case ID_HI:

-			case ID_LO:

-			case ID_HS:

-			case ID_LS:

-				TypeRes = CBotTypBoolean;

-			}

-			if ( TypeCompatible (type1, type2) ||				// les résultats sont-ils compatibles

-			// cas particulier pour les concaténation de chaînes

-				 (TypeOp == ID_ADD && (type1 == CBotTypString || type2 == CBotTypString)))

-			{

-				// si ok, enregistre l'opérande dans l'objet

-				inst->m_leftop = left;

-				// met une variable sur la pile pour avoir le type de résultat

-				pStk->SetVar(new CBotVar(NULL, TypeRes));

-				// et rend l'object à qui l'a demandé

-				return pStack->Return(inst, pStk);

-			}

-			pStk->SetError(TX_BAD2TYPE, &inst->m_token);

-		}

-

-		// en cas d'erreur, libère les éléments

-		delete left;

-		delete inst;

-		// et transmet l'erreur qui se trouve sur la pile

-		return pStack->Return(NULL, pStk);

-	}

-

-	// si on n'a pas affaire à une opération + ou -

-	// rend à qui l'a demandé, l'opérande (de gauche) trouvé

-	// à la place de l'objet "addition"

-	return pStack->Return(left, pStk);

-}

-

-

-

-

-// fait l'opération d'addition ou de soustraction

-

-BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)

-{

-	CBotStack* pStk1 = pStack->AddStack();			// ajoute un élément à la pile

-													// ou le retrouve en cas de reprise

-

-	// selon la reprise, on peut être dans l'un des 2 états

-

-	if ( pStk1->GetState() == 0 &&					// 1er état, évalue l'opérande de gauche

-		!m_leftop->Execute(pStk1) ) return FALSE;	// interrompu ici ?

-

-	// passe à l'étape suivante

-	pStk1->SetState(1);								// prêt pour la suite

-

-	// pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire

-	if ( GetTokenType() == ID_LOG_AND && pStk1->GetVal() == FALSE )

-	{

-		CBotVar*	res = CBotVar::Create( NULL, CBotTypBoolean);

-		res->SetValInt(FALSE);

-		pStk1->SetVar(res);

-		return pStack->Return(pStk1);				// transmet le résultat

-	}

-	if ( GetTokenType() == ID_LOG_OR && pStk1->GetVal() == TRUE )

-	{

-		CBotVar*	res = CBotVar::Create( NULL, CBotTypBoolean);

-		res->SetValInt(TRUE);

-		pStk1->SetVar(res);

-		return pStack->Return(pStk1);				// transmet le résultat

-	}

-

-	// demande un peu plus de stack pour ne pas toucher le résultat de gauche

-	// qui se trouve sur la pile, justement.

-

-	CBotStack* pStk2 = pStk1->AddStack();			// ajoute un élément à la pile

-													// ou le retrouve en cas de reprise

-

-	// 2e état, évalue l'opérande de droite

-	if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?

-

-	int		type1 = pStk1->GetType();				// de quels types les résultats ?

-	int		type2 = pStk2->GetType();

-

-	// crée une variable temporaire pour y mettre le résultat

-	// quel est le type du résultat ?

-	int	TypeRes = MAX(type1, type2);

-	switch ( GetTokenType() )

-	{

-	case ID_LOG_OR:

-	case ID_LOG_AND:

-	case ID_EQ:

-	case ID_NE:

-	case ID_HI:

-	case ID_LO:

-	case ID_HS:

-	case ID_LS:

-		TypeRes = CBotTypBoolean;

-	}

-	CBotVar*	result = CBotVar::Create( NULL, TypeRes);

-	CBotVar*	temp   = CBotVar::Create( NULL, MAX(type1, type2) );

-

-	int	err = 0;

-	// fait l'opération selon la demande

-	switch (GetTokenType())

-	{

-	case ID_ADD:

-		result->Add(pStk1->GetVar(), pStk2->GetVar());		// additionne

-		break;

-	case ID_SUB:

-		result->Sub(pStk1->GetVar(), pStk2->GetVar());		// soustrait

-		break;

-	case ID_MUL:

-		result->Mul(pStk1->GetVar(), pStk2->GetVar());		// multiplie

-		break;

-	case ID_DIV:

-		err = result->Div(pStk1->GetVar(), pStk2->GetVar());// divise

-		break;

-	case ID_MODULO:

-		err = result->Modulo(pStk1->GetVar(), pStk2->GetVar());// reste de division

-		break;

-	case ID_LO:

-		temp->Lo(pStk1->GetVar(), pStk2->GetVar());			// inférieur

-		result->SetValInt(temp->GetValInt());				// converti le résultat

-		break;

-	case ID_HI:

-		temp->Hi(pStk1->GetVar(), pStk2->GetVar());			// supérieur

-		result->SetValInt(temp->GetValInt());				// converti le résultat

-		break;

-	case ID_LS:

-		temp->Ls(pStk1->GetVar(), pStk2->GetVar());			// inférieur ou égal

-		result->SetValInt(temp->GetValInt());				// converti le résultat

-		break;

-	case ID_HS:

-		temp->Hs(pStk1->GetVar(), pStk2->GetVar());			// supérieur ou égal

-		result->SetValInt(temp->GetValInt());				// converti le résultat

-		break;

-	case ID_EQ:

-		temp->Eq(pStk1->GetVar(), pStk2->GetVar());			// égal

-		result->SetValInt(temp->GetValInt());				// converti le résultat

-		break;

-	case ID_NE:

-		temp->Ne(pStk1->GetVar(), pStk2->GetVar());			// différent

-		result->SetValInt(temp->GetValInt());				// converti le résultat

-		break;

-	case ID_LOG_AND:

-	case ID_AND:

-		result->And(pStk1->GetVar(), pStk2->GetVar());		// ET

-		break;

-	case ID_LOG_OR:

-	case ID_OR:

-		result->Or(pStk1->GetVar(), pStk2->GetVar());		// OU

-		break;

-	case ID_XOR:

-		result->XOr(pStk1->GetVar(), pStk2->GetVar());		// OU exclusif

-		break;

-	case ID_ASR:

-		result->ASR(pStk1->GetVar(), pStk2->GetVar());

-		break;

-	case ID_SR:

-		result->SR(pStk1->GetVar(), pStk2->GetVar());

-		break;

-	case ID_SL:

-		result->SL(pStk1->GetVar(), pStk2->GetVar());

-		break;

-	default:

-		__asm int 3;

-	}

-	delete temp;

-

-	pStk2->SetVar(result);						// met le résultat sur la pile

-	if ( err ) pStk2->SetError(err, &m_token);	// et l'erreur éventuelle (division par zéro)

-

-	pStk1->Return(pStk2);						// libère la pile

-	return pStack->Return(pStk1);				// transmet le résultat

-}

-

-