colobot/src/CBot/CBotAddExpr.cpp

///////////////////////////////////////////////////
// expression du genre Op<4F>rande1 + Op<4F>rande2
//					   Op<4F>rande1 - Op<4F>rande2

#include "CBot.h"

// divers constructeurs

CBotAddExpr::CBotAddExpr()
{
	m_leftop	=
	m_rightop	= NULL;			// NULL pour pouvoir faire delete sans autre
	name = "CBotAddExpr";		// debug
}

CBotAddExpr::~CBotAddExpr()
{
	delete	m_leftop;
	delete	m_rightop;
}


// compile une instruction de type A + B

CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack)
{
	CBotStack* pStk = pStack->TokenStack();					// un bout de pile svp

	// cherche des instructions qui peuvent convenir <20> gauche de l'op<6F>ration + ou -

	CBotInstr*	left = CBotMulExpr::Compile( p, pStk );		// expression A * B <20> gauche
	if (left == NULL) return pStack->Return(NULL, pStk);	// si erreur, la transmet

	// est-ce qu'on a le token + ou - ensuite ?

	if ( p->GetType() == ID_ADD ||
		 p->GetType() == ID_SUB)							// plus ou moins
	{
		CBotAddExpr* inst = new CBotAddExpr();				// <20>l<EFBFBD>ment pour op<6F>ration
		inst->SetToken(p);									// m<>morise l'op<6F>ration

		int			 type1, type2;
		type1 = pStack->GetType();							// de quel type le premier op<6F>rande ?

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

		// cherche des instructions qui peuvent convenir <20> droite

		if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) )	// expression (...) <20> droite
		{
			// il y a un second op<6F>rande acceptable

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

			if ( type1 == type2 )							// les r<>sultats sont-ils compatibles
			{
				// si ok, enregistre l'op<6F>rande dans l'objet
				inst->m_leftop = left;
				// et rend l'object <20> qui l'a demand<6E>
				return pStack->Return(inst, pStk);
			}
		}

		// en cas d'erreur, lib<69>re les <20>l<EFBFBD>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 <20> une op<6F>ration + ou -
	// rend <20> qui l'a demand<6E>, l'op<6F>rande (de gauche) trouv<75>
	// <20> la place de l'objet "addition"
	return pStack->Return(left, pStk);
}




// fait l'op<6F>ration d'addition ou de soustraction

BOOL CBotAddExpr::Execute(CBotStack* &pStack)
{
	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un <20>l<EFBFBD>ment <20> la pile
												// ou le retrouve en cas de reprise
//	if ( pSk1 == EOX ) return TRUE;


	// selon la reprise, on peut <20>tre dans l'un des 2 <20>tats

	if ( pStk1->GetState() == 0 &&				// 1er <20>tat, <20>value l'op<6F>rande de gauche
		!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?

	// passe <20> l'<27>tape suivante
	pStk1->SetState(1);							// pr<70>t pour la suite

	// 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 <20>l<EFBFBD>ment <20> la pile
												// ou le retrouve en cas de reprise

	// 2e <20>tat, <20>value l'op<6F>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<63>e une variable temporaire pour y mettre le r<>sultat
	CBotVar*	result = new CBotVar( NULL, MAX(type1, type2));

	// fait l'op<6F>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;
	}
	pStk2->SetVar(result);						// met le r<>sultat sur la pile

	pStk1->Return(pStk2);						// lib<69>re la pile
	return pStack->Return(pStk1);				// transmet le r<>sultat
}