org.eclipse.efm.symbex/src/fam/coverage/AvmCoverageDirectiveTraceBuilder.h - efm/org.eclipse.efm-symbex - Git at Google

 /*******************************************************************************
  * 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: 17 janv. 2015
  *
  * Contributors:
  *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
  *   - Initial API and implementation
  ******************************************************************************/

 #ifndef AVM_PROCESS_COVERAGE_AVMCOVERAGEDIRECTIVETRACEBUILDER_H_
 #define AVM_PROCESS_COVERAGE_AVMCOVERAGEDIRECTIVETRACEBUILDER_H_

 #include <collection/List.h>
 #include <collection/Typedef.h>

 #include <fml/buffer/LifoBuffer.h>

 #include <fml/executable/AvmTransition.h>
 #include <fml/executable/InstanceOfBuffer.h>

 #include <fml/runtime/ExecutionData.h>
 #include <fml/runtime/RuntimeID.h>

 #include <fml/trace/TracePoint.h>
 #include <fml/trace/TraceSequence.h>

 #include <fam/coverage/AvmCoverageHeuristicProperty.h>


 namespace sep
 {

 class AvmCoverageTransitionView;
 class OutStream;

 class ExecutableForm;
 class ExecutionContext;
 class APExecutionData;

 class InstanceOfMachine;
 class InstanceOfPort;

 class RuntimeForm;


 class AvmTraceProperty  :  public TraceSequence
 {

 public:
 	/**
 	 * ATTRIBUTE
 	 */
 	AvmCoverageTransitionView * mTransitionCoverage;

 	avm_size_t mSize;

 	avm_size_t mUncoveredCount;

 	avm_size_t mGuardCount;

 	avm_size_t mUnconditionalCount;

 	avm_size_t mUnstableCount;


 	/**
 	 * CONSTRUCTOR
 	 * Default
 	 */
 	AvmTraceProperty(AvmCoverageTransitionView * aTransitionCoverage)
 	: TraceSequence( CLASS_KIND_T( AvmTraceProperty ) ),
 	mTransitionCoverage( aTransitionCoverage ),
 	mSize( 0 ),
 	mUncoveredCount( 0 ),
 	mGuardCount( 0 ),
 	mUnconditionalCount( 0 ),
 	mUnstableCount( 0 )
 	{
 		//!! NOTHING
 	}

 	AvmTraceProperty(ExecutionContext * anEC = NULL)
 	: TraceSequence( anEC ),
 	mTransitionCoverage( NULL ),
 	mSize( 0 ),
 	mUncoveredCount( 0 ),
 	mGuardCount( 0 ),
 	mUnconditionalCount( 0 ),
 	mUnstableCount( 0 )
 	{
 		//!! NOTHING
 	}

 	/**
 	 * CONSTRUCTOR
 	 * Copy
 	 */
 	AvmTraceProperty(const TraceSequence & aTrace)
 	: TraceSequence( aTrace ),
 	mTransitionCoverage( NULL ),
 	mSize( 0 ),
 	mUncoveredCount( 0 ),
 	mGuardCount( 0 ),
 	mUnconditionalCount( 0 ),
 	mUnstableCount( 0 )
 	{
 		updadeSize();
 	}

 	AvmTraceProperty(const AvmTraceProperty & aTraceProperty)
 	: TraceSequence( aTraceProperty ),
 	mTransitionCoverage( aTraceProperty.mTransitionCoverage ),
 	mSize( aTraceProperty.mSize ),
 	mUncoveredCount( aTraceProperty.mUncoveredCount ),
 	mGuardCount( aTraceProperty.mGuardCount ),
 	mUnconditionalCount( aTraceProperty.mUnconditionalCount ),
 	mUnstableCount( aTraceProperty.mUnstableCount )
 	{
 		//!! NOTHING
 	}

 	/**
 	 * DESTRUCTOR
 	 */
 	virtual ~AvmTraceProperty()
 	{
 		//!! NOTHING
 	}


 	/**
 	 * Configure
 	 */
 	inline bool configure(AvmTraceProperty & aTraceElement)
 	{
 		clear();

 		mTransitionCoverage = aTraceElement.mTransitionCoverage;

 		return( true );
 	}


 	/**
 	 * Utils for TraceSequence
 	 */
 	void checkDecrementation(AvmTransition * aTransition);

 	void checkIncrementation(AvmTransition * aTransition);


 	inline void append(const RuntimeID & aRID, AvmTransition * aTransition)
 	{
 		points.push_back( BF( new TracePoint(
 				ENUM_TRACE_POINT::TRACE_TRANSITION_NATURE,
 				AVM_OPCODE_INVOKE_TRANSITION, aRID, aTransition) ) );

 		++mSize;
 		checkIncrementation( aTransition );
 	}

 	inline void clear()
 	{
 		points.clear();
 		mSize = 0;
 		mUncoveredCount = 0;
 		mGuardCount = 0;
 		mUnconditionalCount = 0;
 		mUnstableCount = 0;
 	}

 	inline void copyTrace(AvmTraceProperty & aTraceElement)
 	{
 		TraceSequence::copyTrace( aTraceElement );

 		mTransitionCoverage = aTraceElement.mTransitionCoverage;

 		mSize = aTraceElement.mSize;
 		mUncoveredCount = aTraceElement.mUncoveredCount;
 		mGuardCount = aTraceElement.mGuardCount;
 		mUnconditionalCount = aTraceElement.mUnconditionalCount;
 		mUnstableCount = aTraceElement.mUnstableCount;
 	}


 	inline bool empty() const
 	{
 		return( mSize == 0 );
 	}


 	inline void pop_back(avm_size_t ptsCount)
 	{
 		mSize = mSize - ptsCount;
 		for( ; ptsCount > 0 ; --ptsCount )
 		{
 			checkDecrementation( backTransition() );

 			points.pop_back();
 		}
 	}

 	inline void pop_front(avm_size_t ptsCount)
 	{
 		mSize = mSize - ptsCount;
 		for( ; ptsCount > 0 ; --ptsCount )
 		{
 			checkDecrementation( frontTransition() );

 			points.pop_front();
 		}
 	}

 	inline void resize(avm_size_t newSize)
 	{
 		if( newSize == 0 )
 		{
 			clear();
 		}
 		else for( ; mSize > newSize ; --mSize )
 		{
 			checkDecrementation( backTransition() );

 			points.pop_back();
 		}
 	}


 	/**
 	 * mSize
 	 * mUnconditionalCount
 	 * mUnstableCount
 	 */
 	void updadeSize();


 	inline avm_size_t xSize() const
 	{
 //		return( mSize );
 //		return( mSize - mUnconditionalCount );
 //		return( mSize - mUnconditionalCount - mUnstableCount );

 //		if( backTransition()->isUnstableTarget() )
 //		{
 //			return( 2 * mSize + mGuardCount -
 //					mUncoveredCount - mUnconditionalCount - mUnstableCount );
 //		}
 //		else
 		{
 			return( mSize + mGuardCount -
 					mUncoveredCount - mUnconditionalCount - mUnstableCount );
 		}
 	}


 	bool compare( bool (* isComp)(avm_size_t, avm_size_t),
 			const AvmTraceProperty & aTraceElement );

 	template< class Compare >
 	bool isInf(Compare isComp, const AvmTraceProperty & aTraceElement)
 	{
 		return( isComp(xSize(), aTraceElement.xSize()) );
 	}

 	template< class Compare >
 	bool isSup(Compare isComp, const AvmTraceProperty & aTraceElement)
 	{
 		return( isComp(xSize(), aTraceElement.xSize()) );
 	}


 	inline bool sizeEQ(const AvmTraceProperty & aTraceElement) const
 	{
 		return( xSize() == aTraceElement.xSize() );
 	}

 	inline bool sizeGT(const AvmTraceProperty & aTraceElement) const
 	{
 		return( xSize() > aTraceElement.xSize() );
 	}

 	inline bool sizeGTE(const AvmTraceProperty & aTraceElement) const
 	{
 		return( xSize() >= aTraceElement.xSize() );
 	}

 	inline bool sizeLT(const AvmTraceProperty & aTraceElement) const
 	{
 		return( xSize() < aTraceElement.xSize() );
 	}

 	inline bool sizeLTE(const AvmTraceProperty & aTraceElement) const
 	{
 		return( xSize() <= aTraceElement.xSize() );
 	}


 	/**
 	 * back / front;
 	 * AvmTransition
 	 */
 	inline AvmTransition * backTransition() const
 	{
 		return( points.back().to_ptr< TracePoint >()->
 				object->to< AvmTransition >() );
 	}

 	inline AvmTransition * frontTransition() const
 	{
 		return( points.front().to_ptr< TracePoint >()->
 				object->to< AvmTransition >() );
 	}

 	/**
 	 * Serialization
 	 */
 	virtual void toStream(OutStream & os, bool verbose = false) const;

 };


 DEFINE_LIST_REF( AvmTraceProperty )


 class AvmCoverageDirectiveTraceBuilder  :  public IHeuristicClass
 {

 protected:
 	/**
 	 * TYPEDEF
 	 */
 	typedef List< ListOfAvmTransition > ListOfListOfAvmTransition;


 	/**
 	 * ATTRIBUTE
 	 */
 	const ExecutionContext * mEC;
 	APExecutionData mED;
 	RuntimeID mRID;
 	AvmTransition * mTransition;

 	TracePoint * mTransitionPoint;
 	AvmTraceProperty mTraceElement;

 	avm_size_t mComputingPathCountLimit;
 	avm_size_t mComputingPathSizeLimit;

 	bool mGoalAchievedFlag;

 //	ListOfAvmTransition mTransitionPath;
 //	ListOfInstanceOfPort mExpectedInput;
 	InstanceOfBuffer mVirtualBuffer;
 	LifoBuffer mEmitOutput;

 	TableOfRuntimeFormState mTableOfRuntimeStatus;


 	// computing variable for method << computePathToTransition >>
 	ListOfListOfAvmTransition anyTransitionPaths;
 	ListOfListOfAvmTransition prefixLoopTransitionPaths;

 	ListOfAvmTransition outgoingTransitions;
 	ListOfAvmTransition aTransitionPath;
 	ListOfAvmTransition::const_iterator itTrans;
 	ListOfAvmTransition::const_iterator endTrans;

 	InstanceOfMachine * tgtInstance;
 	ExecutableForm * fwdMachine;
 	ExecutableForm * tgtMachine;


 public:
 	/**
 	 * CONSTRUCTOR
 	 * Default
 	 */
 	AvmCoverageDirectiveTraceBuilder(
 			ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
 			avm_size_t pathCountLimit = 32, avm_size_t pathSizeLimit = 32)
 	: IHeuristicClass( anHeuristicClass ),
 	mEC( NULL ),
 	mED( ),
 	mRID( ),

 	mTransition( NULL ),
 	mTransitionPoint( NULL ),

 	mTraceElement( ),

 	mComputingPathCountLimit( pathCountLimit ),
 	mComputingPathSizeLimit( pathSizeLimit ),

 	mGoalAchievedFlag( false ),

 	//mTransitionPath( ),
 	//mExpectedInput( ),
 	mVirtualBuffer(NULL, NULL, 0, TYPE_MULTI_LIFO_SPECIFIER, -1),
 	mEmitOutput( & mVirtualBuffer ),

 	mTableOfRuntimeStatus( 0 ),

 	// computing variable for method << computePathToTransition >>
 	anyTransitionPaths( ),
 	prefixLoopTransitionPaths( ),

 	outgoingTransitions( ),
 	aTransitionPath( ),
 	itTrans( ),
 	endTrans( ),

 	tgtInstance( NULL ),
 	fwdMachine( NULL ),
 	tgtMachine( NULL )
 	{
 		//!! NOTHING
 	}


 	/**
 	 * CONSTRUCTOR
 	 * Other
 	 */
 	AvmCoverageDirectiveTraceBuilder(
 			const ExecutionContext * anEC, TracePoint * tpTransition,
 			ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
 			avm_size_t pathCountLimit = 64, avm_size_t pathSizeLimit = 64);

 	AvmCoverageDirectiveTraceBuilder(const ExecutionContext * anEC,
 			const RuntimeID & aRID, AvmTransition * aTransition,
 			ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
 			avm_size_t pathCountLimit = 16, avm_size_t pathSizeLimit = 16);


 	/**
 	 * mComputingPathCountLimit
 	 * mComputingPathSizeLimit
 	 */
 	void setComputingLimit(avm_size_t pathCountLimit, avm_size_t pathSizeLimit)
 	{
 		mComputingPathCountLimit = pathCountLimit;
 		mComputingPathSizeLimit  = pathSizeLimit;
 	}


 	////////////////////////////////////////////////////////////////////////////
 	// Configure
 	////////////////////////////////////////////////////////////////////////////

 	bool configure(AvmTraceProperty & aTraceElement,
 			const ExecutionContext * anEC, TracePoint * tpTransition,
 			ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
 			avm_size_t pathCountLimit = 64, avm_size_t pathSizeLimit = 64);

 	bool configure(AvmTraceProperty & aTraceElement,
 			const ExecutionContext * anEC,
 			const RuntimeID & aRID, AvmTransition * aTransition,
 			ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
 			avm_size_t pathCountLimit = 16, avm_size_t pathSizeLimit = 16);


 	////////////////////////////////////////////////////////////////////////////
 	// API
 	////////////////////////////////////////////////////////////////////////////

 	bool initialize();

 	bool computePath();

 	bool computePath(AvmTraceProperty & aTraceElement);

 	bool computePath(AvmTraceProperty & aTraceElement, ExecutionContext * anEC,
 			const RuntimeID & aRID, AvmTransition * aTransition,
 			ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
 			avm_size_t pathCountLimit = 16, avm_size_t pathSizeLimit = 16);

 	void report(OutStream & os);


 	bool computePath(const RuntimeID & aRID, AvmTransition * aTransition);

 	bool fireTransition(const RuntimeID & aRID, AvmTransition * aTransition);

 	void traceTransition(const RuntimeID & aRID, AvmTransition * aTransition);

 	bool computePathToTransition(
 			const RuntimeID & aRID, AvmTransition * aTransition);


 	inline bool computePathFromRunnable(
 			const RuntimeID & aRID, AvmTransition * aTransition)
 	{
 		switch( mHeuristicClass )
 		{
 			case IHeuristicClass::HEURISTIC_BASIC_CLASS:
 			{
 				return( computeBasicPathFromRunnable(aRID, aTransition) );
 			}

 			case IHeuristicClass::HEURISTIC_NAIVE_CLASS:
 			case IHeuristicClass::HEURISTIC_SMART_CLASS:
 			case IHeuristicClass::HEURISTIC_AGRESSIVE_CLASS:
 			case IHeuristicClass::HEURISTIC_NOTHING_ELSE_CLASS:
 			default:
 			{
 				return( computeSmartPathFromRunnable(aRID, aTransition) );
 			}
 		}
 	}

 	bool computeBasicPathFromRunnable(
 			const RuntimeID & aRID, AvmTransition * aTransition);

 	bool computeSmartPathFromRunnable(
 			const RuntimeID & aRID, AvmTransition * aTransition);


 	bool computePathToInput(
 			const RuntimeID & aRID, InstanceOfPort * anInputTrace);


 	bool computePathToTransition(
 			const RuntimeID & aRID, AvmTransition * aTransition,
 			ListOfAvmTransition & oneTransitionPath);

 	bool computePathToTransition(
 			const RuntimeID & aRID, AvmTransition * aTransition,
 			ListOfListOfAvmTransition & allTransitionPaths);

 	void computeTargetMachine(RuntimeID & aRID, AvmCode * aCode);

 };


 } /* namespace sep */

 #endif /* AVM_PROCESS_COVERAGE_AVMCOVERAGEDIRECTIVETRACEBUILDER_H_ */
	/*******************************************************************************
	* 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: 17 janv. 2015
	*
	* Contributors:
	* Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
	* - Initial API and implementation
	******************************************************************************/

	#ifndef AVM_PROCESS_COVERAGE_AVMCOVERAGEDIRECTIVETRACEBUILDER_H_
	#define AVM_PROCESS_COVERAGE_AVMCOVERAGEDIRECTIVETRACEBUILDER_H_

	#include <collection/List.h>
	#include <collection/Typedef.h>

	#include <fml/buffer/LifoBuffer.h>

	#include <fml/executable/AvmTransition.h>
	#include <fml/executable/InstanceOfBuffer.h>

	#include <fml/runtime/ExecutionData.h>
	#include <fml/runtime/RuntimeID.h>

	#include <fml/trace/TracePoint.h>
	#include <fml/trace/TraceSequence.h>

	#include <fam/coverage/AvmCoverageHeuristicProperty.h>


	namespace sep
	{

	class AvmCoverageTransitionView;
	class OutStream;

	class ExecutableForm;
	class ExecutionContext;
	class APExecutionData;

	class InstanceOfMachine;
	class InstanceOfPort;

	class RuntimeForm;


	class AvmTraceProperty : public TraceSequence
	{

	public:
	/**
	* ATTRIBUTE
	*/
	AvmCoverageTransitionView * mTransitionCoverage;

	avm_size_t mSize;

	avm_size_t mUncoveredCount;

	avm_size_t mGuardCount;

	avm_size_t mUnconditionalCount;

	avm_size_t mUnstableCount;


	/**
	* CONSTRUCTOR
	* Default
	*/
	AvmTraceProperty(AvmCoverageTransitionView * aTransitionCoverage)
	: TraceSequence( CLASS_KIND_T( AvmTraceProperty ) ),
	mTransitionCoverage( aTransitionCoverage ),
	mSize( 0 ),
	mUncoveredCount( 0 ),
	mGuardCount( 0 ),
	mUnconditionalCount( 0 ),
	mUnstableCount( 0 )
	{
	//!! NOTHING
	}

	AvmTraceProperty(ExecutionContext * anEC = NULL)
	: TraceSequence( anEC ),
	mTransitionCoverage( NULL ),
	mSize( 0 ),
	mUncoveredCount( 0 ),
	mGuardCount( 0 ),
	mUnconditionalCount( 0 ),
	mUnstableCount( 0 )
	{
	//!! NOTHING
	}

	/**
	* CONSTRUCTOR
	* Copy
	*/
	AvmTraceProperty(const TraceSequence & aTrace)
	: TraceSequence( aTrace ),
	mTransitionCoverage( NULL ),
	mSize( 0 ),
	mUncoveredCount( 0 ),
	mGuardCount( 0 ),
	mUnconditionalCount( 0 ),
	mUnstableCount( 0 )
	{
	updadeSize();
	}

	AvmTraceProperty(const AvmTraceProperty & aTraceProperty)
	: TraceSequence( aTraceProperty ),
	mTransitionCoverage( aTraceProperty.mTransitionCoverage ),
	mSize( aTraceProperty.mSize ),
	mUncoveredCount( aTraceProperty.mUncoveredCount ),
	mGuardCount( aTraceProperty.mGuardCount ),
	mUnconditionalCount( aTraceProperty.mUnconditionalCount ),
	mUnstableCount( aTraceProperty.mUnstableCount )
	{
	//!! NOTHING
	}

	/**
	* DESTRUCTOR
	*/
	virtual ~AvmTraceProperty()
	{
	//!! NOTHING
	}


	/**
	* Configure
	*/
	inline bool configure(AvmTraceProperty & aTraceElement)
	{
	clear();

	mTransitionCoverage = aTraceElement.mTransitionCoverage;

	return( true );
	}


	/**
	* Utils for TraceSequence
	*/
	void checkDecrementation(AvmTransition * aTransition);

	void checkIncrementation(AvmTransition * aTransition);


	inline void append(const RuntimeID & aRID, AvmTransition * aTransition)
	{
	points.push_back( BF( new TracePoint(
	ENUM_TRACE_POINT::TRACE_TRANSITION_NATURE,
	AVM_OPCODE_INVOKE_TRANSITION, aRID, aTransition) ) );

	++mSize;
	checkIncrementation( aTransition );
	}

	inline void clear()
	{
	points.clear();
	mSize = 0;
	mUncoveredCount = 0;
	mGuardCount = 0;
	mUnconditionalCount = 0;
	mUnstableCount = 0;
	}

	inline void copyTrace(AvmTraceProperty & aTraceElement)
	{
	TraceSequence::copyTrace( aTraceElement );

	mTransitionCoverage = aTraceElement.mTransitionCoverage;

	mSize = aTraceElement.mSize;
	mUncoveredCount = aTraceElement.mUncoveredCount;
	mGuardCount = aTraceElement.mGuardCount;
	mUnconditionalCount = aTraceElement.mUnconditionalCount;
	mUnstableCount = aTraceElement.mUnstableCount;
	}


	inline bool empty() const
	{
	return( mSize == 0 );
	}


	inline void pop_back(avm_size_t ptsCount)
	{
	mSize = mSize - ptsCount;
	for( ; ptsCount > 0 ; --ptsCount )
	{
	checkDecrementation( backTransition() );

	points.pop_back();
	}
	}

	inline void pop_front(avm_size_t ptsCount)
	{
	mSize = mSize - ptsCount;
	for( ; ptsCount > 0 ; --ptsCount )
	{
	checkDecrementation( frontTransition() );

	points.pop_front();
	}
	}

	inline void resize(avm_size_t newSize)
	{
	if( newSize == 0 )
	{
	clear();
	}
	else for( ; mSize > newSize ; --mSize )
	{
	checkDecrementation( backTransition() );

	points.pop_back();
	}
	}


	/**
	* mSize
	* mUnconditionalCount
	* mUnstableCount
	*/
	void updadeSize();


	inline avm_size_t xSize() const
	{
	// return( mSize );
	// return( mSize - mUnconditionalCount );
	// return( mSize - mUnconditionalCount - mUnstableCount );

	// if( backTransition()->isUnstableTarget() )
	// {
	// return( 2 * mSize + mGuardCount -
	// mUncoveredCount - mUnconditionalCount - mUnstableCount );
	// }
	// else
	{
	return( mSize + mGuardCount -
	mUncoveredCount - mUnconditionalCount - mUnstableCount );
	}
	}


	bool compare( bool (* isComp)(avm_size_t, avm_size_t),
	const AvmTraceProperty & aTraceElement );

	template< class Compare >
	bool isInf(Compare isComp, const AvmTraceProperty & aTraceElement)
	{
	return( isComp(xSize(), aTraceElement.xSize()) );
	}

	template< class Compare >
	bool isSup(Compare isComp, const AvmTraceProperty & aTraceElement)
	{
	return( isComp(xSize(), aTraceElement.xSize()) );
	}


	inline bool sizeEQ(const AvmTraceProperty & aTraceElement) const
	{
	return( xSize() == aTraceElement.xSize() );
	}

	inline bool sizeGT(const AvmTraceProperty & aTraceElement) const
	{
	return( xSize() > aTraceElement.xSize() );
	}

	inline bool sizeGTE(const AvmTraceProperty & aTraceElement) const
	{
	return( xSize() >= aTraceElement.xSize() );
	}

	inline bool sizeLT(const AvmTraceProperty & aTraceElement) const
	{
	return( xSize() < aTraceElement.xSize() );
	}

	inline bool sizeLTE(const AvmTraceProperty & aTraceElement) const
	{
	return( xSize() <= aTraceElement.xSize() );
	}


	/**
	* back / front;
	* AvmTransition
	*/
	inline AvmTransition * backTransition() const
	{
	return( points.back().to_ptr< TracePoint >()->
	object->to< AvmTransition >() );
	}

	inline AvmTransition * frontTransition() const
	{
	return( points.front().to_ptr< TracePoint >()->
	object->to< AvmTransition >() );
	}

	/**
	* Serialization
	*/
	virtual void toStream(OutStream & os, bool verbose = false) const;

	};


	DEFINE_LIST_REF( AvmTraceProperty )



	class AvmCoverageDirectiveTraceBuilder : public IHeuristicClass
	{

	protected:
	/**
	* TYPEDEF
	*/
	typedef List< ListOfAvmTransition > ListOfListOfAvmTransition;


	/**
	* ATTRIBUTE
	*/
	const ExecutionContext * mEC;
	APExecutionData mED;
	RuntimeID mRID;
	AvmTransition * mTransition;

	TracePoint * mTransitionPoint;
	AvmTraceProperty mTraceElement;

	avm_size_t mComputingPathCountLimit;
	avm_size_t mComputingPathSizeLimit;

	bool mGoalAchievedFlag;

	// ListOfAvmTransition mTransitionPath;
	// ListOfInstanceOfPort mExpectedInput;
	InstanceOfBuffer mVirtualBuffer;
	LifoBuffer mEmitOutput;

	TableOfRuntimeFormState mTableOfRuntimeStatus;


	// computing variable for method << computePathToTransition >>
	ListOfListOfAvmTransition anyTransitionPaths;
	ListOfListOfAvmTransition prefixLoopTransitionPaths;

	ListOfAvmTransition outgoingTransitions;
	ListOfAvmTransition aTransitionPath;
	ListOfAvmTransition::const_iterator itTrans;
	ListOfAvmTransition::const_iterator endTrans;

	InstanceOfMachine * tgtInstance;
	ExecutableForm * fwdMachine;
	ExecutableForm * tgtMachine;


	public:
	/**
	* CONSTRUCTOR
	* Default
	*/
	AvmCoverageDirectiveTraceBuilder(
	ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
	avm_size_t pathCountLimit = 32, avm_size_t pathSizeLimit = 32)
	: IHeuristicClass( anHeuristicClass ),
	mEC( NULL ),
	mED( ),
	mRID( ),

	mTransition( NULL ),
	mTransitionPoint( NULL ),

	mTraceElement( ),

	mComputingPathCountLimit( pathCountLimit ),
	mComputingPathSizeLimit( pathSizeLimit ),

	mGoalAchievedFlag( false ),

	//mTransitionPath( ),
	//mExpectedInput( ),
	mVirtualBuffer(NULL, NULL, 0, TYPE_MULTI_LIFO_SPECIFIER, -1),
	mEmitOutput( & mVirtualBuffer ),

	mTableOfRuntimeStatus( 0 ),

	// computing variable for method << computePathToTransition >>
	anyTransitionPaths( ),
	prefixLoopTransitionPaths( ),

	outgoingTransitions( ),
	aTransitionPath( ),
	itTrans( ),
	endTrans( ),

	tgtInstance( NULL ),
	fwdMachine( NULL ),
	tgtMachine( NULL )
	{
	//!! NOTHING
	}


	/**
	* CONSTRUCTOR
	* Other
	*/
	AvmCoverageDirectiveTraceBuilder(
	const ExecutionContext * anEC, TracePoint * tpTransition,
	ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
	avm_size_t pathCountLimit = 64, avm_size_t pathSizeLimit = 64);

	AvmCoverageDirectiveTraceBuilder(const ExecutionContext * anEC,
	const RuntimeID & aRID, AvmTransition * aTransition,
	ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
	avm_size_t pathCountLimit = 16, avm_size_t pathSizeLimit = 16);


	/**
	* mComputingPathCountLimit
	* mComputingPathSizeLimit
	*/
	void setComputingLimit(avm_size_t pathCountLimit, avm_size_t pathSizeLimit)
	{
	mComputingPathCountLimit = pathCountLimit;
	mComputingPathSizeLimit = pathSizeLimit;
	}


	////////////////////////////////////////////////////////////////////////////
	// Configure
	////////////////////////////////////////////////////////////////////////////

	bool configure(AvmTraceProperty & aTraceElement,
	const ExecutionContext * anEC, TracePoint * tpTransition,
	ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
	avm_size_t pathCountLimit = 64, avm_size_t pathSizeLimit = 64);

	bool configure(AvmTraceProperty & aTraceElement,
	const ExecutionContext * anEC,
	const RuntimeID & aRID, AvmTransition * aTransition,
	ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
	avm_size_t pathCountLimit = 16, avm_size_t pathSizeLimit = 16);


	////////////////////////////////////////////////////////////////////////////
	// API
	////////////////////////////////////////////////////////////////////////////

	bool initialize();

	bool computePath();

	bool computePath(AvmTraceProperty & aTraceElement);

	bool computePath(AvmTraceProperty & aTraceElement, ExecutionContext * anEC,
	const RuntimeID & aRID, AvmTransition * aTransition,
	ENUM_HEURISTIC_CLASS anHeuristicClass = HEURISTIC_SMART_CLASS,
	avm_size_t pathCountLimit = 16, avm_size_t pathSizeLimit = 16);

	void report(OutStream & os);


	bool computePath(const RuntimeID & aRID, AvmTransition * aTransition);

	bool fireTransition(const RuntimeID & aRID, AvmTransition * aTransition);

	void traceTransition(const RuntimeID & aRID, AvmTransition * aTransition);

	bool computePathToTransition(
	const RuntimeID & aRID, AvmTransition * aTransition);


	inline bool computePathFromRunnable(
	const RuntimeID & aRID, AvmTransition * aTransition)
	{
	switch( mHeuristicClass )
	{
	case IHeuristicClass::HEURISTIC_BASIC_CLASS:
	{
	return( computeBasicPathFromRunnable(aRID, aTransition) );
	}

	case IHeuristicClass::HEURISTIC_NAIVE_CLASS:
	case IHeuristicClass::HEURISTIC_SMART_CLASS:
	case IHeuristicClass::HEURISTIC_AGRESSIVE_CLASS:
	case IHeuristicClass::HEURISTIC_NOTHING_ELSE_CLASS:
	default:
	{
	return( computeSmartPathFromRunnable(aRID, aTransition) );
	}
	}
	}

	bool computeBasicPathFromRunnable(
	const RuntimeID & aRID, AvmTransition * aTransition);

	bool computeSmartPathFromRunnable(
	const RuntimeID & aRID, AvmTransition * aTransition);


	bool computePathToInput(
	const RuntimeID & aRID, InstanceOfPort * anInputTrace);


	bool computePathToTransition(
	const RuntimeID & aRID, AvmTransition * aTransition,
	ListOfAvmTransition & oneTransitionPath);

	bool computePathToTransition(
	const RuntimeID & aRID, AvmTransition * aTransition,
	ListOfListOfAvmTransition & allTransitionPaths);

	void computeTargetMachine(RuntimeID & aRID, AvmCode * aCode);

	};


	} /* namespace sep */

	#endif /* AVM_PROCESS_COVERAGE_AVMCOVERAGEDIRECTIVETRACEBUILDER_H_ */