/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Created on: 20 mai 2010
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#include "AvmCommunicationPrimitive.h"

#include <builder/Builder.h>

#include <computer/EvaluationEnvironment.h>
#include <computer/ExecutionDataFactory.h>
#include <computer/ExecutionEnvironment.h>
#include <computer/PathConditionProcessor.h>

#include <computer/primitive/AvmCommunicationFactory.h>
#include <computer/primitive/AvmAssignPrimitive.h>

#include <fml/expression/AvmCode.h>
#include <fml/expression/ExpressionConstant.h>
#include <fml/expression/ExpressionSimplifier.h>
#include <fml/expression/StatementConstructor.h>

#include <fml/runtime/ExecutionConfiguration.h>
#include <fml/runtime/ExecutionData.h>
#include <fml/runtime/RuntimeLib.h>
#include <fml/runtime/RuntimeID.h>


namespace sep
{


/**
 ***************************************************************************
 * execution of an INPUT program
 ***************************************************************************
 */

bool AvmPrimitive_Input::run(ExecutionEnvironment & ENV)
{
AVM_IF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )
	AVM_OS_TRACE << TAB << "Input Message to receive: "
			<< ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )

	if( not AvmCommunicationFactory::popMessage(ENV,
			ENV.mARG->at(0).to_ptr< InstanceOfPort >()) )
	{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << TAB << "THROW UNSATISFIED << INPUT >> :> "
			<< ENV.mARG->outED->mRID.strUniqId()
			<< " |=> " << ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
	}

	return( true );
}


bool AvmPrimitive_InputVar::run(ExecutionEnvironment & ENV)
{
	InstanceOfData * anInstance = ENV.mARG->at(0).to_ptr< InstanceOfData >();

	BFList paramList;
	BF aNewSymbolicConstant( ENV.createNewFreshParam(ENV.mARG->outED->mRID,
			anInstance, paramList) );

	ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
			BF( new ExecutionConfiguration(ENV.mARG->outED->mRID,
					BFCode(OperatorManager::OPERATOR_INPUT,
								ENV.mARG->at(0), aNewSymbolicConstant)) ) );

	if( ENV.setRvalue(ENV.mARG->outED, anInstance, aNewSymbolicConstant) )
	{
		ENV.mARG->outED.appendParameters( paramList );

		ENV.appendOutput( ENV.mARG->outED );

		return( true );
	}

	return( false );
}


bool AvmPrimitive_InputEnv::run(ExecutionEnvironment & ENV)
{
	BFCode aTraceInput(OperatorManager::OPERATOR_INPUT_ENV, ENV.mARG->at(0));

	bool allSuccess = true;

	if( ENV.inCODE->populated() )
	{
		ENV.mARG->outED.makeModifiableParamTable();

		InstanceOfPort * aPort = ENV.mARG->at(0).to_ptr< InstanceOfPort >();
		avm_size_t offset = 0;

		InstanceOfData * aVar = NULL;
		BF aNewSymbolicConstant;
		BFList paramList;

		for( ENV.mARG->begin(1) ; ENV.mARG->hasNext() ;
				ENV.mARG->next() , ++offset )
		{
			paramList.clear();

			aVar = ENV.mARG->current().to_ptr< InstanceOfData >();

			aNewSymbolicConstant = ENV.createNewFreshParam(
					ENV.mARG->outED->mRID, aPort->getParameterType(offset),
					aVar, paramList);

			if( not ENV.setRvalue(ENV.mARG->outED, aVar, aNewSymbolicConstant) )
			{
				allSuccess = false;

				break;
			}

			ENV.mARG->outED.appendParameters( paramList );

			aTraceInput->append( aNewSymbolicConstant );
		}
	}

	if( allSuccess )
	{
		ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
				BF( new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceInput) ) );

		ENV.outEDS.append( ENV.mARG->outED );

		return( true );
	}
	else
	{
		return( false );
	}
}


bool AvmPrimitive_InputBuffer::run(ExecutionEnvironment & ENV)
{
AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin AvmPrimitive_InputBuffer::run" << std::endl;

	ENV.mARG->outED->getRuntime(1).toStreamData(
			ENV.mARG->outED, AVM_OS_TRACE << INCR2_INDENT_TAB);
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )


	const RoutingData & aRoutingData =
			ENV.mARG->at(0).to_ptr< InstanceOfPort >()->getInputRoutingData();

	const RuntimeID & aRoutingRID = aRoutingData.getRuntimeRID();

	RuntimeID bufferDeclRID = aRoutingRID;

	InstanceOfBuffer * aBuffer = aRoutingData.getBufferInstance().first();

	bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
			ENV.mARG->outED->mRID, aBuffer);
	if( bufferDeclRID.valid() )
	{
		BaseBufferForm & bbf =
				ENV.mARG->outED.getWritableRuntime(
						bufferDeclRID ).getWritableBuffer( aBuffer );

		Message popMsg;
/*!!INPUT#ENABLED!!
		if( ENV.mARG->outED->getRuntime(ENV.mARG->outED->mRID).isInputEnabled()
			|| ENV.mARG->outED->getRuntime(aRoutingRID).isInputEnabled()
			|| aRoutingData.isInputEnabled() || bbf->isInputEnabled() )
		{
			popMsg = bbf->popUntil(aRoutingData.getMID());
		}
		else*/
		{
			popMsg = bbf.pop(aRoutingData.getMID(), ENV.mARG->outED->mRID);
		}

		if( popMsg.valid() )
		{
			BFCode aTraceInput(OperatorManager::OPERATOR_INPUT, ENV.mARG->at(0));

			Message::const_iterator itVal = popMsg.beginParameters();
			Message::const_iterator endVal = popMsg.endParameters();

			// We have to ignore the << Port >> InstanceOfPort
			for( ENV.mARG->begin(1) ; (itVal != endVal) && ENV.mARG->hasNext() ;
					ENV.mARG->next() , ++itVal )
			{
				if( ENV.setRvalue(ENV.mARG->outED,
						ENV.mARG->current().to_ptr< InstanceOfData >(), *itVal) )
				{
					aTraceInput->append( *itVal );

				}
				else
				{
					return( false );
				}
			}

			ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
					BF( new ExecutionConfiguration(
							ENV.mARG->outED->mRID, aTraceInput, popMsg) ) );

			ENV.outEDS.append( ENV.mARG->outED );

AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(1).toStreamData(
			ENV.mARG->outED, AVM_OS_TRACE << INCR2_INDENT_TAB);

	AVM_OS_TRACE << DECR2_INDENT_TAB
			<< "end AvmPrimitive_InputBuffer::run"
			<< std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

			return( true );
		}
	}

	return( false );
}


bool AvmPrimitive_InputRdv::run(ExecutionEnvironment & ENV)
{
	const BF & aPort = ENV.mARG->at(0);

	const RoutingData & aRoutingData =
			aPort.to_ptr< InstanceOfPort >()->getInputRoutingData();

	const RuntimeID & aRoutingRID = aRoutingData.getRuntimeRID();

	Message inMsg( aRoutingData.getMID(),
			RuntimeID::REF_NULL, ENV.mARG->outED->mRID, aPort );

	// We have to ignore the << Port >> InstanceOfPort
	for( ENV.mARG->begin(1) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
	{
		inMsg.appendParameter( ENV.mARG->current() );
	}

	ENV.mARG->outED.pushExecSyncPoint( new ExecutionSynchronizationPoint(
			AWAITING_POINT_INPUT_NATURE, aRoutingRID, aRoutingData, inMsg) );

	ENV.appendSync_mwsetAEES(ENV.mARG->outED, AEES_WAITING_INCOM_RDV);

	return( true );
}



/**
 ***************************************************************************
 * execution of an INPUT_FROM program
 ***************************************************************************
 */
bool AvmPrimitive_InputFrom::run(ExecutionEnvironment & ENV)
{
AVM_IF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )
	AVM_OS_TRACE << TAB << "Input Message to receive: "
			<< ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )

	if( (RuntimeLib::RID_ENVIRONMENT == ENV.mARG->at(1))
		|| (RuntimeLib::RID_NIL == ENV.mARG->at(1)) )
	{
		AvmCommunicationFactory::popMessage_environment(ENV,
				ENV.mARG->at(1).bfRID(), RoutingData::_NULL_, 2);
	}
	else if( not AvmCommunicationFactory::popMessageFrom(ENV) )
	{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << TAB << "THROW UNSATISFIED << INPUT#FROM >> :> ?!? |=> "
			<< ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
	}

	return( true );
}


/**
 ***************************************************************************
 * execution of an OUTPUT program
 ***************************************************************************
 */

bool AvmPrimitive_Output::run(ExecutionEnvironment & ENV)
{
AVM_IF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )
	AVM_OS_TRACE << INCR_INDENT_TAB
			<< "<!?!" << ENV.inED->mRID.strUniqId()
			<< " |=> " << ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )

	Message anOutputMsg(ENV.mARG->outED->mRID, ENV.mARG->at(0) );

AVM_IF_DEBUG_LEVEL_FLAG( MEDIUM , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "Output Message to build" << std::endl;
	anOutputMsg.toStream(AVM_OS_TRACE);
AVM_ENDIF_DEBUG_LEVEL_FLAG( MEDIUM , STATEMENT_COMMUNICATION )


	for( ENV.mARG->begin(1) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
	{
		anOutputMsg.appendParameter( ENV.mARG->current() );
	}


AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "Output Message to push" << std::endl;
	anOutputMsg.toStream(AVM_OS_TRACE);
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )


	if( not AvmCommunicationFactory::pushMessage(ENV,
			anOutputMsg, ENV.mARG->outED->mRID) )
	{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << TAB << "THROW UNSATISFIED << OUTPUT >> : <<< "
			<< ENV.mARG->outED->mRID.strUniqId()
			<< " |=> " << ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
	}


AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB_DECR_INDENT
			<< "!?!> " << ENV.inED->mRID.strUniqId()
			<< " |=> " <<  ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

	return( true );
}


bool AvmPrimitive_OutputVar::run(ExecutionEnvironment & ENV)
{
	ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
			BF( new ExecutionConfiguration(ENV.mARG->outED->mRID,
					BFCode(OperatorManager::OPERATOR_OUTPUT,
							ENV.mARG->at(0), ENV.mARG->at(1))) ) );

	ENV.appendOutput( ENV.mARG->outED );

	return( true );
}


bool AvmPrimitive_OutputEnv::run(ExecutionEnvironment & ENV)
{
	BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT_ENV, ENV.mARG->at(0));

	for( ENV.mARG->begin(1) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
	{
		aTraceOutput->append( ENV.mARG->current() );
	}

	ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
			BF( new ExecutionConfiguration(
					ENV.mARG->outED->mRID, aTraceOutput) ) );

	ENV.outEDS.append( ENV.mARG->outED );

	return( true );
}


bool AvmPrimitive_OutputBuffer::run(ExecutionEnvironment & ENV)
{
AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin AvmPrimitive_OutputBuffer::run" << std::endl;

	ENV.mARG->outED->getRuntime(1).toStream(
			AVM_OS_TRACE << INCR2_INDENT_TAB);
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	const BF & aPort = ENV.mARG->at(0);

	const RoutingData & aRoutingData =
			aPort.to_ptr< InstanceOfPort >()->getOutputRoutingData();

	const RuntimeID & aRoutingRID = aRoutingData.getRuntimeRID();

	RuntimeID bufferDeclRID = aRoutingRID;

	InstanceOfBuffer * aBuffer = aRoutingData.getBufferInstance().first();

	bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
			ENV.mARG->outED->mRID, aBuffer);

	if( bufferDeclRID.valid() )
	{
		BaseBufferForm & bbf =
				ENV.mARG->outED.getWritableRuntime(
						bufferDeclRID ).getWritableBuffer( aBuffer );

		Message outMsg( aRoutingData.getMID(),
				ENV.mARG->outED->mRID, ENV.mARG->outED->mRID, aPort );

		// We have to ignore the << Port >> InstanceOfPort
		for( ENV.mARG->begin(1) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
		{
			outMsg.appendParameter( ENV.mARG->current() );
		}

		if( bbf.push( outMsg ) )
		{
			BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT, aPort);

			aTraceOutput->append( outMsg.getParameters() );

			ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
					BF( new ExecutionConfiguration(
							ENV.mARG->outED->mRID, aTraceOutput, outMsg) ) );

			ENV.outEDS.append( ENV.mARG->outED );


AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(1).toStream(
			AVM_OS_TRACE << INCR2_INDENT_TAB);

	AVM_OS_TRACE << DECR2_INDENT_TAB
			<< "end AvmPrimitive_OutputBuffer::run"
			<< std::endl;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

			return( true );
		}
	}

	return( false );
}


bool AvmPrimitive_OutputRdv::run(ExecutionEnvironment & ENV)
{
	const BF & aPort = ENV.mARG->at(0);

	const RoutingData & aRoutingData =
			aPort.to_ptr< InstanceOfPort >()->getOutputRoutingData();

	const RuntimeID & aRoutingRID = aRoutingData.getRuntimeRID();

	Message outMsg( aRoutingData.getMID(),
			ENV.mARG->outED->mRID, ENV.mARG->outED->mRID, aPort );

	// We have to ignore the << Port >> InstanceOfPort
	for( ENV.mARG->begin(1) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
	{
		outMsg.appendParameter( ENV.mARG->current() );
	}

	ENV.mARG->outED.pushExecSyncPoint(new ExecutionSynchronizationPoint(
			AWAITING_POINT_OUTPUT_NATURE, aRoutingRID, aRoutingData, outMsg) );

	ENV.appendSync_mwsetAEES(ENV.mARG->outED, AEES_WAITING_OUTCOM_RDV);

	return( true );
}


/**
 ***************************************************************************
 * execution of an OUTPUT_TO program
 ***************************************************************************
 */
bool AvmPrimitive_OutputTo::run(ExecutionEnvironment & ENV)
{
AVM_IF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )
	AVM_OS_TRACE << INCR_INDENT_TAB
			<< "<!?!" << ENV.inED->mRID.strUniqId()
			<< " |=> " << ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG_AND_NOT_FLAG( COMMUNICATION , STATEMENT )

	Message anOutputMsg( ENV.mARG->outED->mRID,
			ENV.mARG->at(1).bfRID(), ENV.mARG->at(0) );

AVM_IF_DEBUG_LEVEL_FLAG( MEDIUM , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "Output Message to build" << std::endl;
	anOutputMsg.toStream(AVM_OS_TRACE);
AVM_ENDIF_DEBUG_LEVEL_FLAG( MEDIUM , STATEMENT_COMMUNICATION )


	for( ENV.mARG->begin(2) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
	{
		anOutputMsg.appendParameter( ENV.mARG->current() );
	}


AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "Output Message to push" << std::endl;
	anOutputMsg.toStream(AVM_OS_TRACE);
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )


	if( ENV.mARG->at(0).to_ptr< InstanceOfPort >()->isPort() )
	{
		if( not AvmCommunicationFactory::pushMessageTo(ENV, anOutputMsg) )
		{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << TAB << "THROW UNSATISFIED << OUTPUT >> : <<< "
			<< ENV.mARG->outED->mRID.strUniqId()
			<< " |=> " << ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
		}
	}
	else// if( ENV.mARG->at(0).to_ptr< InstanceOfPort >()->isSignal() )
	{
		if( ENV.mARG->at(1).bfRID().valid() )
		{
			if( (RuntimeLib::RID_ENVIRONMENT == ENV.mARG->at(1))
				|| (RuntimeLib::RID_NIL == ENV.mARG->at(1)) )
			{
				AvmCommunicationFactory::pushMessage_environment(ENV,
					ENV.mARG->at(1).bfRID(), RoutingData::_NULL_, anOutputMsg);
			}
			else if( not AvmCommunicationFactory::pushMessage(ENV,
					anOutputMsg, ENV.mARG->at(1).bfRID()) )
			{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << TAB << "THROW UNSATISFIED << OUTPUT#TO<"
			<< ENV.mARG->at(1).bfRID().getFullyQualifiedNameID() << "> >> : <<< "
			<< ENV.mARG->outED->mRID.strUniqId()
			<< " |=> " << ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
			}
		}
		else
		{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << TAB << "THROW UNKNOWN RECEIVER << OUTPUT#TO<"
			<< ENV.mARG->at(1).bfRID().getFullyQualifiedNameID() << "?> >> : <<< "
			<< ENV.mARG->outED->mRID.strUniqId()
			<< " |=> " << ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)

			return( false );
		}
	}

AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB_DECR_INDENT
			<< "!?!> " << ENV.inED->mRID.strUniqId()
			<< " |=> " <<  ENV.inCODE->str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

	return( true );
}


/**
 ***************************************************************************
 * execution of a PRESENT program
 ***************************************************************************
 */
bool AvmPrimitive_Present::run(ExecutionEnvironment & ENV)
{
	if( AvmCommunicationFactory::computePresence(ENV.mARG->outED,
			ENV.mARG->at(0).to_ptr< InstanceOfPort >()) )
	{
		ENV.outEDS.append( ENV.mARG->outED );
	}
	else
	{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << "THROW UNSATISFIED << PRESENCE >> :> ?!? < "
			<< ENV.inCODE->str() << " >|=> "
			<< ENV.mARG->at(0).str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
	}

	return( true );
}


bool AvmPrimitive_Present::seval(EvaluationEnvironment & ENV)
{
	ENV.outVAL = ExpressionConstructor::newBoolean(
			AvmCommunicationFactory::computePresence(ENV.mARG->outED,
					ENV.mARG->at(0).to_ptr< InstanceOfPort >()) );

	return( true );
}



/**
 ***************************************************************************
 * execution of an ABSENT program
 ***************************************************************************
 */
bool AvmPrimitive_Absent::run(ExecutionEnvironment & ENV)
{
	if( AvmCommunicationFactory::computeAbsence(ENV.mARG->outED,
			ENV.mARG->at(0).to_ptr< InstanceOfPort >()) )
	{
		ENV.outEDS.append( ENV.mARG->outED );
	}
	else
	{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << "THROW UNSATISFIED << ABSENCE >> :> ?!? < "
			<< ENV.inCODE->str() << " >|=> "
			<< ENV.mARG->at(0).str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
	}

	return( true );
}


bool AvmPrimitive_Absent::seval(EvaluationEnvironment & ENV)
{
	ENV.outVAL = ExpressionConstructor::newBoolean(
			AvmCommunicationFactory::computeAbsence(ENV.mARG->outED,
					ENV.mARG->at(0).to_ptr< InstanceOfPort >()) );

	return( true );
}



/**
 ***************************************************************************
 * execution of a UPDATE BUFFER program
 ***************************************************************************
 */
bool AvmPrimitive_UpdateBuffer::run(ExecutionEnvironment & ENV)
{
	if( ENV.inCODE->size() == 1 )
	{
		switch( ENV.inCODE->first().classKind() )
		{
			case FORM_AVMCODE_KIND:
			{
				ExecutionEnvironment tmpENV(ENV, ENV.inCODE->first());
				if( tmpENV.run() )
				{
					APExecutionData tmpED;
					while( tmpENV.outEDS.nonempty() )
					{
						tmpENV.outEDS.pop_first_to( tmpED );

						if( AvmCommunicationFactory::updateBuffer(tmpED) )
						{
							ENV.outEDS.append( tmpED );
						}
					}

					ENV.spliceOutput(tmpENV);

					return( true );
				}

				break;
			}

			default:
			{
				AVM_OS_WARNING_ALERT
						<< "Unexpected argument KIND for an SYNCHRONIZE program\n"
						<< ENV.inCODE->toString( AVM_TAB1_INDENT )
						<< SEND_ALERT;

				return( false );
			}
		}
	}
	else
	{
		APExecutionData anOutputED = ENV.inED;
		if( AvmCommunicationFactory::updateBuffer(anOutputED) )
		{
			ENV.outEDS.append( anOutputED );

			return( true );
		}
	}

	return( false );
}



////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///// MATH MIN
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

bool AvmPrimitive_OBS::run(ExecutionEnvironment & ENV)
{
	if( ENV.mARG->at(2).isEqualTrue()  )
	{
		//!! NO NEED PATH CONDITION UPDATE
		ENV.appendOutput( ENV.mARG->outED );
	}

	else if( ENV.mARG->at(2).isEqualFalse()  )
	{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << "THROW UNSATISFIED << OBS >> : "
			<< ENV.mARG->outED->mRID.strUniqId() << " |=> "
			<< ENV.inCODE->str() << std::endl;
//	AVM_OS_TRACE << "THROW UNSATISFIED << GUARD >> : "
//			<< ENV.mARG->outED->mRID.strUniqId() << " , ";
//	AVM_OS_TRACE << ENV.inCODE->str()  << " |=> "
//			<< ENV.mARG->at(2).str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
	}

	else
	{
		AVM_OS_TRACE << "OBS :> " << ENV.mARG->at(2).str() << std::endl;

		if( not PathConditionProcessor::appendPathCondition(
				ENV, ENV.mARG->outED, ENV.mARG->at(2)) )
		{
AVM_IF_DEBUG_FLAG( STATEMENT)
	AVM_OS_TRACE << "THROW UNSATISFIED << OBS >> : "
			<< ENV.mARG->outED->mRID.strUniqId() << " |=> "
			<< ENV.inCODE->str() << std::endl;
//	AVM_OS_TRACE << "THROW UNSATISFIED << GUARD >> : "
//			<< ENV.mARG->outED->mRID.strUniqId() << " , ";
//	AVM_OS_TRACE << ENV.inCODE->str()  << " |=> "
//			<< ENV.mARG->at(2).str() << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT)
		}
	}

	return( true );
}

bool AvmPrimitive_OBS::seval(EvaluationEnvironment & ENV)
{
	if( ENV.mARG->at(0).is< AvmCode >() )
	{
		const BFCode & evtCondition = ENV.mARG->at(0).bfCode();

		switch( evtCondition->getAvmOpCode() )
		{
			case AVM_OPCODE_INPUT:
			case AVM_OPCODE_OUTPUT:
			{
				if( evtCondition->first().is< BaseInstanceForm >() )
				{
					BaseInstanceForm * ioInstance =
							evtCondition->first().to_ptr< BaseInstanceForm >();

					if( ioInstance->is< InstanceOfPort >() )
					{
						AvmCode * ioTrace = NULL;

						ioTrace = ENV.searchTraceIO(
								ENV.outED->getIOElementTrace(), evtCondition);

						if( ioTrace != NULL )
						{
							ENV.outVAL = ENV.ioSubst( ENV.outED,
									ENV.outED->mRID.getExecutable(),
									evtCondition, ioTrace, ENV.mARG->at(1) );
						}
						else
						{
							ENV.outVAL = ExpressionConstant::BOOLEAN_FALSE;
						}

						return( true );
					}
					else if( ioInstance->is< InstanceOfData >() )
					{
						if( ENV.isAssigned(ENV.outED, ENV.outED->mRID,
								ioInstance->to< InstanceOfData >()) )
						{
							if( not ENV.seval(ENV.mARG->at(1)) )
							{
								return( false );
							}
						}
						else
						{
							ENV.outVAL = ExpressionConstant::BOOLEAN_FALSE;
						}

						return( true );
					}
				}

				ENV.outVAL = ExpressionConstant::BOOLEAN_FALSE;

				return( true );
			}

			default:
			{
				BF evtCond = ENV.outVAL;

				if( ENV.seval(ENV.mARG->at(1)) )
				{
					ENV.outVAL = ExpressionSimplifier::AND(
							ENV.mARG->at(0), evtCond);

					return( true );
				}
				break;
			}
		}
	}

	else if( ENV.mARG->at(0).isEqualTrue() )
	{
		return( ENV.seval(ENV.mARG->at(1)) );
	}
	else if( ENV.mARG->at(0).isNotEqualFalse() )
	{
		BF evtCond = ENV.outVAL;
		if( ENV.seval(ENV.mARG->at(1)) )
		{
			ENV.outVAL = ExpressionSimplifier::AND(ENV.mARG->at(0), evtCond);

			return( true );
		}
	}

	return( false );
}



}