org.eclipse.efm.symbex/src/fml/runtime/ExecutionContextFlags.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: 26 avr. 2016
  *
  * Contributors:
  *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
  *   - Initial API and Implementation
  ******************************************************************************/

 #ifndef FML_RUNTIME_EXECUTIONCONTEXTFLAGS_H_
 #define FML_RUNTIME_EXECUTIONCONTEXTFLAGS_H_

 #include <util/avm_string.h>


 namespace sep
 {

 struct ExecutionContextFlags
 {

 	/**
 	 * REACHED_LIMIT
 	 * 4 bits
 	 */
 	enum REACHED_LIMIT
 	{
 		REACHED_UNDEFINED_LIMIT          = 0x00,

 		REACHED_NODE_HEIGHT_LIMIT        = 0x01,

 		REACHED_NODE_WIDTH_LIMIT         = 0x02,

 		REACHED_NODE_COUNT_LIMIT         = 0x04,

 		REACHED_SYMBEX_STEP_LIMIT        = 0x08,

 	};

 	/**
 	 * INTERRUPT_REQUEST
 	 * 2 bits
 	 */
 	enum INTERRUPT_REQUEST
 	{
 		INTERRUPT_UNDEFINED_REQUEST      = 0x00,

 		INTERRUPT_FAM_REQUEST            = 0x01,

 		INTERRUPT_USER_REQUEST           = 0x02,

 	};

 	/**
 	 * EXECUTION_TRACE
 	 * 4 bits
 	 */
 	enum EXECUTION_TRACE
 	{
 		EXECUTION_UNDEFINED_TRACE         = 0x00,

 		EXECUTION_DEADLOCK_TRACE          = 0x01,

 		EXECUTION_TRIVIAL_LOOP_TRACE      = 0x02,

 		EXECUTION_LIVELOCK_TRACE          = 0x03,

 		EXECUTION_REDUNDANCY_TRACE        = 0x04,

 		EXECUTION_REDUNDANCY_TARGET_TRACE = 0x05,

 		EXECUTION_STATEMENT_EXIT_TRACE    = 0x06,

 		EXECUTION_FATAL_ERROR_TRACE       = 0x07,

 		EXECUTION_SYMBEX_LIMIT_TRACE      = 0x08,

 		EXECUTION_EXCEPTION_TRACE         = 0x09,

 		EXECUTION_STEP_MARK_TRACE         = 0x0A

 	};

 	/**
 	 * FORMAL ANALYSIS MODULE as FAM_TRACE
 	 * 3 bits
 	 */
 	enum FAM_TRACE
 	{
 		FAM_UNDEFINED_TRACE              = 0x00,

 		FAM_COVERAGE_ELEMENT_TRACE       = 0x01,

 		FAM_OBJECTIVE_ACHIEVED_TRACE     = 0x02,

 		FAM_OBJECTIVE_FAILED_TRACE       = 0x04,

 		FAM_OBJECTIVE_ABORTED_TRACE      = 0x08,

 	};


 	/**
 	 * TYPEDEF
 	 */
 	typedef unsigned short  bit_field_t;

 	/**
 	 * BIT FIELDS
 	 */
 	bit_field_t limit          : 4;

 	bit_field_t interrupt      : 2;

 	bit_field_t execution      : 4;

 	bit_field_t analysis       : 4;


 	/**
 	 * CONSTRUCTORS
 	 */
 	ExecutionContextFlags()
 	: limit( REACHED_UNDEFINED_LIMIT ),
 	interrupt( INTERRUPT_UNDEFINED_REQUEST ),
 	execution( EXECUTION_UNDEFINED_TRACE ),
 	analysis( FAM_UNDEFINED_TRACE )
 	{
 		//!! NOTHING
 	}

 	/**
 	 * DESTRUCTOR
 	 */
 	~ExecutionContextFlags()
 	{
 		//!! NOTHING
 	}


 	/**
 	 * TESTER - SETTER
 	 */
 	inline bool isDefined() const
 	{
 		return(    (limit     != REACHED_UNDEFINED_LIMIT  )
 				|| (interrupt != EXECUTION_UNDEFINED_TRACE)
 				|| (execution != EXECUTION_UNDEFINED_TRACE)
 				|| (analysis != EXECUTION_UNDEFINED_TRACE ) );
 	}

 	inline bool hasReachedLimitOrExecutionTrace() const
 	{
 		return(    (limit     != REACHED_UNDEFINED_LIMIT  )
 				|| (execution != EXECUTION_UNDEFINED_TRACE) );
 	}

 	inline bool isUndefined() const
 	{
 		return(    (limit     == REACHED_UNDEFINED_LIMIT  )
 				&& (interrupt == EXECUTION_UNDEFINED_TRACE)
 				&& (execution == EXECUTION_UNDEFINED_TRACE)
 				&& (analysis == EXECUTION_UNDEFINED_TRACE ) );
 	}


 	////////////////////////////////////////////////////////////////////////////
 	// REACHED LIMIT
 	////////////////////////////////////////////////////////////////////////////

 	/**
 	 * GETTER - SETTER
 	 * limit
 	 */
 	inline REACHED_LIMIT getReachedLimit() const
 	{
 		return( static_cast< REACHED_LIMIT >( limit ) );
 	}

 	inline bool hasReachedLimit() const
 	{
 		return( limit != REACHED_UNDEFINED_LIMIT );
 	}

 	inline bool noneReachedLimit() const
 	{
 		return( limit == REACHED_UNDEFINED_LIMIT );
 	}

 	inline bool isReachedLimit(REACHED_LIMIT reachedLimit) const
 	{
 		return( limit == reachedLimit );
 	}

 	inline ExecutionContextFlags & addReachedLimit(REACHED_LIMIT reachedLimit)
 	{
 		limit |= reachedLimit;

 		return( *this );
 	}

 	inline ExecutionContextFlags & remReachedLimit(REACHED_LIMIT reachedLimit)
 	{
 		limit &= (~ reachedLimit);

 		return( *this );
 	}

 	inline ExecutionContextFlags & setReachedLimit(REACHED_LIMIT reachedLimit)
 	{
 		limit = reachedLimit;

 		return( *this );
 	}

 	inline ExecutionContextFlags & unsetReachedLimit()
 	{
 		limit = REACHED_UNDEFINED_LIMIT;

 		return( *this );
 	}


 	/**
 	 * GETTER - SETTER
 	 * "node height" limit
 	 */
 	inline bool isReachedNodeHeightLimit() const
 	{
 		return( limit == REACHED_NODE_HEIGHT_LIMIT );
 	}

 	inline bool hasReachedNodeHeightLimit() const
 	{
 		return( (limit & REACHED_NODE_HEIGHT_LIMIT) != 0 );
 	}

 	inline ExecutionContextFlags & addReachedNodeHeightLimit()
 	{
 		limit |= REACHED_NODE_HEIGHT_LIMIT;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setReachedNodeHeightLimit()
 	{
 		limit = REACHED_NODE_HEIGHT_LIMIT;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "node width" limit
 	 */
 	inline bool isReachedNodeWidthLimit() const
 	{
 		return( limit == REACHED_NODE_WIDTH_LIMIT );
 	}

 	inline bool hasReachedNodeWidthLimit() const
 	{
 		return( (limit & REACHED_NODE_WIDTH_LIMIT) != 0 );
 	}

 	inline ExecutionContextFlags & addReachedNodeWidthLimit()
 	{
 		limit |= REACHED_NODE_WIDTH_LIMIT;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setReachedNodeWidthLimit()
 	{
 		limit = REACHED_NODE_WIDTH_LIMIT;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "node count" limit
 	 */
 	inline bool isReachedNodeCountLimit() const
 	{
 		return( limit == REACHED_NODE_COUNT_LIMIT );
 	}

 	inline bool hasReachedNodeCountLimit() const
 	{
 		return( (limit & REACHED_NODE_COUNT_LIMIT) != 0 );
 	}

 	inline ExecutionContextFlags & addReachedNodeCountLimit()
 	{
 		limit |= REACHED_NODE_COUNT_LIMIT;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setReachedNodeCountLimit()
 	{
 		limit = REACHED_NODE_COUNT_LIMIT;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "execution step" limit
 	 */
 	inline bool isReachedSymbexStepLimit() const
 	{
 		return( limit == REACHED_SYMBEX_STEP_LIMIT );
 	}

 	inline bool hasReachedSymbexStepLimit() const
 	{
 		return( (limit & REACHED_SYMBEX_STEP_LIMIT) != 0 );
 	}


 	inline ExecutionContextFlags & addReachedSymbexStepLimit()
 	{
 		limit |= REACHED_SYMBEX_STEP_LIMIT;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setReachedSymbexStepLimit()
 	{
 		limit = REACHED_SYMBEX_STEP_LIMIT;

 		return( *this );
 	}


 	////////////////////////////////////////////////////////////////////////////
 	// REACHED LIMIT
 	////////////////////////////////////////////////////////////////////////////

 	/**
 	 * GETTER - SETTER
 	 * interrupt
 	 */
 	inline INTERRUPT_REQUEST getInterruptRequest() const
 	{
 		return( static_cast< INTERRUPT_REQUEST >( interrupt ) );
 	}

 	inline bool hasInterruptRequest() const
 	{
 		return( interrupt != REACHED_UNDEFINED_LIMIT );
 	}

 	inline bool noneInterruptRequest() const
 	{
 		return( interrupt == REACHED_UNDEFINED_LIMIT );
 	}

 	inline bool isInterruptRequest(INTERRUPT_REQUEST interruptRequest) const
 	{
 		return( interrupt == interruptRequest );
 	}

 	inline ExecutionContextFlags & setInterruptRequest(
 			INTERRUPT_REQUEST interruptRequest)
 	{
 		interrupt = interruptRequest;

 		return( *this );
 	}

 	inline ExecutionContextFlags & unsetInterruptRequest()
 	{
 		interrupt = REACHED_UNDEFINED_LIMIT;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "formal analysis module" as "fam" request
 	 */
 	inline bool isInterruptModuleRequest() const
 	{
 		return( interrupt == INTERRUPT_FAM_REQUEST );
 	}

 	inline ExecutionContextFlags & setInterruptModuleRequest()
 	{
 		interrupt = INTERRUPT_FAM_REQUEST;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "fam" request
 	 */
 	inline bool isInterruptUserRequest() const
 	{
 		return( interrupt == INTERRUPT_USER_REQUEST );
 	}

 	inline ExecutionContextFlags & setInterruptUserRequest()
 	{
 		interrupt = INTERRUPT_USER_REQUEST;

 		return( *this );
 	}


 	////////////////////////////////////////////////////////////////////////////
 	// EXECUTION TRACE
 	////////////////////////////////////////////////////////////////////////////

 	/**
 	 * GETTER - SETTER
 	 * execution
 	 */
 	inline EXECUTION_TRACE getExecutionTrace() const
 	{
 		return( static_cast< EXECUTION_TRACE >( execution ) );
 	}

 	inline bool hasExecutionTrace() const
 	{
 		return( execution != EXECUTION_UNDEFINED_TRACE );
 	}

 	inline bool noneExecutionTrace() const
 	{
 		return( execution == EXECUTION_UNDEFINED_TRACE );
 	}

 	inline bool isExecutionTrace(EXECUTION_TRACE reachedLimit) const
 	{
 		return( execution == reachedLimit );
 	}

 	inline ExecutionContextFlags & addExecutionTrace(EXECUTION_TRACE reachedLimit)
 	{
 		execution |= reachedLimit;

 		return( *this );
 	}

 	inline ExecutionContextFlags & remExecutionTrace(EXECUTION_TRACE reachedLimit)
 	{
 		execution &= (~ reachedLimit);

 		return( *this );
 	}

 	inline ExecutionContextFlags & setExecutionTrace(EXECUTION_TRACE reachedLimit)
 	{
 		execution = reachedLimit;

 		return( *this );
 	}

 	inline ExecutionContextFlags & unsetExecutionTrace()
 	{
 		execution = EXECUTION_UNDEFINED_TRACE;

 		return( *this );
 	}


 	/**
 	 * GETTER - SETTER
 	 * "deadlock" execution
 	 */
 	inline bool isExecutionDeadlockTrace() const
 	{
 		return( execution == EXECUTION_DEADLOCK_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionDeadlockTrace()
 	{
 		execution = EXECUTION_DEADLOCK_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "trivial_loop" execution
 	 */
 	inline bool isExecutionTrivialLoopTrace() const
 	{
 		return( execution == EXECUTION_TRIVIAL_LOOP_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionTrivialLoopTrace()
 	{
 		execution = EXECUTION_TRIVIAL_LOOP_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "livelock" execution
 	 */
 	inline bool isExecutionLivelockTrace() const
 	{
 		return( execution == EXECUTION_LIVELOCK_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionLivelockTrace()
 	{
 		execution = EXECUTION_LIVELOCK_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "redundancy" execution
 	 */
 	inline bool isExecutionRedundancyTrace() const
 	{
 		return( execution == EXECUTION_REDUNDANCY_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionRedundancyTrace()
 	{
 		execution = EXECUTION_REDUNDANCY_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "redundancy target" execution
 	 */
 	inline bool isExecutionRedundancyTargetTrace() const
 	{
 		return( execution == EXECUTION_REDUNDANCY_TARGET_TRACE );
 	}

 	inline bool noneExecutionRedundancyTargetTrace() const
 	{
 		return( execution != EXECUTION_REDUNDANCY_TARGET_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionRedundancyTargetTrace()
 	{
 		execution = EXECUTION_REDUNDANCY_TARGET_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "statement_exit" execution
 	 */
 	inline bool isExecutionStatementExitTrace() const
 	{
 		return( execution == EXECUTION_STATEMENT_EXIT_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionStatementExitTrace()
 	{
 		execution = EXECUTION_STATEMENT_EXIT_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "fatal_error" execution
 	 */
 	inline bool isExecutionFatalErrorTrace() const
 	{
 		return( execution == EXECUTION_FATAL_ERROR_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionFatalErrorTrace()
 	{
 		execution = EXECUTION_FATAL_ERROR_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "boundary" execution
 	 */
 	inline bool isExecutionSymbexLimitationTrace() const
 	{
 		return( execution == EXECUTION_SYMBEX_LIMIT_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionSymbexLimitationTrace()
 	{
 		execution = EXECUTION_SYMBEX_LIMIT_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "exception" execution
 	 */
 	inline bool isExecutionExceptionTrace() const
 	{
 		return( execution == EXECUTION_EXCEPTION_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionExceptionTrace()
 	{
 		execution = EXECUTION_EXCEPTION_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "step_mark" execution
 	 */
 	inline bool isExecutionStepMarkTrace() const
 	{
 		return( execution == EXECUTION_STEP_MARK_TRACE );
 	}

 	inline ExecutionContextFlags & setExecutionStepMarkTrace()
 	{
 		execution = EXECUTION_STEP_MARK_TRACE;

 		return( *this );
 	}


 	////////////////////////////////////////////////////////////////////////////
 	// ANALYSIS TRACE
 	////////////////////////////////////////////////////////////////////////////

 	/**
 	 * GETTER - SETTER
 	 * analysis
 	 */
 	inline FAM_TRACE getAnalysisTrace() const
 	{
 		return( static_cast< FAM_TRACE >( analysis ) );
 	}

 	inline bool hasAnalysisTrace() const
 	{
 		return( analysis != REACHED_UNDEFINED_LIMIT );
 	}

 	inline bool noneAnalysisTrace() const
 	{
 		return( analysis == REACHED_UNDEFINED_LIMIT );
 	}

 	inline bool hasAnalysisTrace(FAM_TRACE analysisTrace) const
 	{
 		return( (analysis & analysisTrace) != 0 );
 	}

 	inline bool isAnalysisTrace(FAM_TRACE analysisTrace) const
 	{
 		return( analysis == analysisTrace );
 	}

 	inline ExecutionContextFlags & setAnalysisTrace(FAM_TRACE analysisTrace)
 	{
 		analysis = analysisTrace;

 		return( *this );
 	}

 	inline ExecutionContextFlags & unsetAnalysisTrace()
 	{
 		analysis = FAM_UNDEFINED_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "coverage" analysis
 	 */
 	inline bool hasCoverageElementTrace() const
 	{
 		return( (analysis & FAM_COVERAGE_ELEMENT_TRACE) != 0 );
 	}

 	inline bool isCoverageElementTrace() const
 	{
 		return( analysis == FAM_COVERAGE_ELEMENT_TRACE );
 	}

 	inline bool noneCoverageElementTrace() const
 	{
 		return( (analysis & FAM_COVERAGE_ELEMENT_TRACE) == 0 );
 	}

 	inline ExecutionContextFlags & addCoverageElementTrace()
 	{
 		analysis |= FAM_COVERAGE_ELEMENT_TRACE;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setCoverageElementTrace()
 	{
 		analysis = FAM_COVERAGE_ELEMENT_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "coverage" analysis
 	 */
 	inline bool hasObjectiveAchievedTrace() const
 	{
 		return( (analysis & FAM_OBJECTIVE_ACHIEVED_TRACE) != 0 );
 	}

 	inline bool isObjectiveAchievedTrace() const
 	{
 		return( analysis == FAM_OBJECTIVE_ACHIEVED_TRACE );
 	}

 	inline bool noneObjectiveAchievedTrace() const
 	{
 		return( (analysis & FAM_OBJECTIVE_ACHIEVED_TRACE) == 0 );
 	}

 	inline ExecutionContextFlags & addObjectiveAchievedTrace()
 	{
 		analysis |= FAM_OBJECTIVE_ACHIEVED_TRACE;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setObjectiveAchievedTrace()
 	{
 		analysis = FAM_OBJECTIVE_ACHIEVED_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "coverage" analysis
 	 */
 	inline bool hasObjectiveFailedTrace() const
 	{
 		return( (analysis & FAM_OBJECTIVE_FAILED_TRACE) != 0 );
 	}

 	inline bool isObjectiveFailedTrace() const
 	{
 		return( analysis == FAM_OBJECTIVE_FAILED_TRACE );
 	}

 	inline ExecutionContextFlags & addObjectiveFailedTrace()
 	{
 		analysis |= FAM_OBJECTIVE_FAILED_TRACE;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setObjectiveFailedTrace()
 	{
 		analysis = FAM_OBJECTIVE_FAILED_TRACE;

 		return( *this );
 	}

 	/**
 	 * GETTER - SETTER
 	 * "coverage" analysis
 	 */
 	inline bool hasObjectiveAbortedTrace() const
 	{
 		return( (analysis & FAM_OBJECTIVE_ABORTED_TRACE) != 0 );
 	}

 	inline bool isObjectiveAbortedTrace() const
 	{
 		return( analysis == FAM_OBJECTIVE_ABORTED_TRACE );
 	}

 	inline ExecutionContextFlags & addObjectiveAbortedTrace()
 	{
 		analysis |= FAM_OBJECTIVE_ABORTED_TRACE;

 		return( *this );
 	}

 	inline ExecutionContextFlags & setObjectiveAbortedTrace()
 	{
 		analysis = FAM_OBJECTIVE_ABORTED_TRACE;

 		return( *this );
 	}


 	/**
 	 * REEXECUTABILITY
 	 */
 	inline bool isReexecutable() const
 	{
 		return( noneExecutionTrace() );
 	}

 	inline ExecutionContextFlags & setReexecutable()
 	{
 		limit = REACHED_UNDEFINED_LIMIT;

 		interrupt = INTERRUPT_UNDEFINED_REQUEST;

 		return( *this );
 	}


 	/**
 	 * CATEGORY TEST
 	 */
 	inline bool hasError() const
 	{
 		return( isExecutionFatalErrorTrace()
 				|| isExecutionSymbexLimitationTrace() );
 	}

 	inline bool hasAlert() const
 	{
 		return( isExecutionDeadlockTrace()
 				|| isExecutionLivelockTrace()
 				|| isExecutionStatementExitTrace() );
 	}

 	inline bool hasWarning() const
 	{
 		return( hasReachedLimit() );
 	}

 	inline bool hasCoverageElement() const
 	{
 		return( hasCoverageElementTrace() );
 	}

 	inline bool hasObjectiveAchieved() const
 	{
 		return( hasObjectiveAchievedTrace() );
 	}

 	inline bool hasObjectiveFailed() const
 	{
 		return( hasObjectiveFailedTrace() );
 	}

 	inline bool hasObjectiveAborted() const
 	{
 		return( hasObjectiveAbortedTrace() );
 	}

 	inline bool hasRedundancy() const
 	{
 		return( isExecutionTrivialLoopTrace()
 				|| isExecutionRedundancyTrace() );
 	}

 	inline bool hasRedundancyTarget() const
 	{
 		return( isExecutionRedundancyTargetTrace() );
 	}


 	/**
 	 * Default Separator
 	 */
 	static std::string SEPARATOR;

 	/**
 	 * REACHED LIMIT to STRING
 	 */
 	inline std::string strReachedLimit(
 			const std::string & separator = " & ") const
 	{
 		return( ExecutionContextFlags::strReachedLimit(
 				limit , separator ) );
 	}

 	static std::string strReachedLimit(bit_field_t reachedLimit,
 			const std::string & separator = SEPARATOR);

 	/**
 	 * INTERRUPT REQUEST to STRING
 	 */
 	inline std::string strInterruptRequest(
 			const std::string & separator = " & ") const
 	{
 		return( ExecutionContextFlags::strInterruptRequest(
 				interrupt , separator ) );
 	}

 	static std::string strInterruptRequest(bit_field_t interruptRequest,
 			const std::string & separator = SEPARATOR);


 	/**
 	 * EXECUTION TRACE to STRING
 	 */
 	inline std::string strExecutionTrace(
 			const std::string & separator = " ") const
 	{
 		return( ExecutionContextFlags::strExecutionTrace(
 				execution , separator ) );
 	}

 	static std::string strExecutionTrace(bit_field_t executionTrace,
 			const std::string & separator = SEPARATOR);

 	/**
 	 * ANALYSIS TRACE to STRING
 	 */
 	inline std::string strAnalysisTrace(
 			const std::string & separator = " ") const
 	{
 		return( ExecutionContextFlags::strAnalysisTrace(
 				analysis , separator ) );
 	}

 	static std::string strAnalysisTrace(bit_field_t analysisTrace,
 			const std::string & separator = SEPARATOR);

 	/**
 	 * Serialization
 	 */
 	inline std::string str(const std::string & separator = SEPARATOR) const
 	{
 		return( StringTools::removeLastIfEndsWith(
 				toString( separator ), separator) );
 	}

 	inline std::string toString(
 			const std::string & separator = SEPARATOR) const
 	{
 		return( ExecutionContextFlags::strReachedLimit(
 						limit , separator ) +
 				ExecutionContextFlags::strInterruptRequest(
 						interrupt , separator ) +
 				ExecutionContextFlags::strExecutionTrace(
 						execution , separator ) +
 				ExecutionContextFlags::strAnalysisTrace(
 						analysis , separator ) );
 	}


 };


 class ExecutionContextFlagsImpl
 {

 protected:
 	/**
 	 * ATTRIBUTES
 	 */
 	ExecutionContextFlags mFlags;


 public:
 	/**
 	 * CONSTRUCTOR
 	 */
 	ExecutionContextFlagsImpl()
 	: mFlags( )
 	{
 		//!! NOTHING
 	}


 	/**
 	 * DESTRUCTOR
 	 */
 	~ExecutionContextFlagsImpl()
 	{
 		//!! NOTHING
 	}

 	/**
 	 * GETTER
 	 * mFlags
 	 */
 	inline const ExecutionContextFlags & getFlags() const
 	{
 		return( mFlags );
 	}

 	inline ExecutionContextFlags & getwFlags()
 	{
 		return( mFlags );
 	}

 	inline bool hasFlags() const
 	{
 		return( mFlags.isDefined() );
 	}

 	inline void setFlags(const ExecutionContextFlags & flags)
 	{
 		mFlags = flags;
 	}

 };


 } /* namespace sep */

 #endif /* FML_RUNTIME_EXECUTIONCONTEXTFLAGS_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: 26 avr. 2016
	*
	* Contributors:
	* Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
	* - Initial API and Implementation
	******************************************************************************/

	#ifndef FML_RUNTIME_EXECUTIONCONTEXTFLAGS_H_
	#define FML_RUNTIME_EXECUTIONCONTEXTFLAGS_H_

	#include <util/avm_string.h>


	namespace sep
	{

	struct ExecutionContextFlags
	{

	/**
	* REACHED_LIMIT
	* 4 bits
	*/
	enum REACHED_LIMIT
	{
	REACHED_UNDEFINED_LIMIT = 0x00,

	REACHED_NODE_HEIGHT_LIMIT = 0x01,

	REACHED_NODE_WIDTH_LIMIT = 0x02,

	REACHED_NODE_COUNT_LIMIT = 0x04,

	REACHED_SYMBEX_STEP_LIMIT = 0x08,

	};

	/**
	* INTERRUPT_REQUEST
	* 2 bits
	*/
	enum INTERRUPT_REQUEST
	{
	INTERRUPT_UNDEFINED_REQUEST = 0x00,

	INTERRUPT_FAM_REQUEST = 0x01,

	INTERRUPT_USER_REQUEST = 0x02,

	};

	/**
	* EXECUTION_TRACE
	* 4 bits
	*/
	enum EXECUTION_TRACE
	{
	EXECUTION_UNDEFINED_TRACE = 0x00,

	EXECUTION_DEADLOCK_TRACE = 0x01,

	EXECUTION_TRIVIAL_LOOP_TRACE = 0x02,

	EXECUTION_LIVELOCK_TRACE = 0x03,

	EXECUTION_REDUNDANCY_TRACE = 0x04,

	EXECUTION_REDUNDANCY_TARGET_TRACE = 0x05,

	EXECUTION_STATEMENT_EXIT_TRACE = 0x06,

	EXECUTION_FATAL_ERROR_TRACE = 0x07,

	EXECUTION_SYMBEX_LIMIT_TRACE = 0x08,

	EXECUTION_EXCEPTION_TRACE = 0x09,

	EXECUTION_STEP_MARK_TRACE = 0x0A

	};

	/**
	* FORMAL ANALYSIS MODULE as FAM_TRACE
	* 3 bits
	*/
	enum FAM_TRACE
	{
	FAM_UNDEFINED_TRACE = 0x00,

	FAM_COVERAGE_ELEMENT_TRACE = 0x01,

	FAM_OBJECTIVE_ACHIEVED_TRACE = 0x02,

	FAM_OBJECTIVE_FAILED_TRACE = 0x04,

	FAM_OBJECTIVE_ABORTED_TRACE = 0x08,

	};



	/**
	* TYPEDEF
	*/
	typedef unsigned short bit_field_t;

	/**
	* BIT FIELDS
	*/
	bit_field_t limit : 4;

	bit_field_t interrupt : 2;

	bit_field_t execution : 4;

	bit_field_t analysis : 4;



	/**
	* CONSTRUCTORS
	*/
	ExecutionContextFlags()
	: limit( REACHED_UNDEFINED_LIMIT ),
	interrupt( INTERRUPT_UNDEFINED_REQUEST ),
	execution( EXECUTION_UNDEFINED_TRACE ),
	analysis( FAM_UNDEFINED_TRACE )
	{
	//!! NOTHING
	}

	/**
	* DESTRUCTOR
	*/
	~ExecutionContextFlags()
	{
	//!! NOTHING
	}



	/**
	* TESTER - SETTER
	*/
	inline bool isDefined() const
	{
	return( (limit != REACHED_UNDEFINED_LIMIT )
	\|\| (interrupt != EXECUTION_UNDEFINED_TRACE)
	\|\| (execution != EXECUTION_UNDEFINED_TRACE)
	\|\| (analysis != EXECUTION_UNDEFINED_TRACE ) );
	}

	inline bool hasReachedLimitOrExecutionTrace() const
	{
	return( (limit != REACHED_UNDEFINED_LIMIT )
	\|\| (execution != EXECUTION_UNDEFINED_TRACE) );
	}

	inline bool isUndefined() const
	{
	return( (limit == REACHED_UNDEFINED_LIMIT )
	&& (interrupt == EXECUTION_UNDEFINED_TRACE)
	&& (execution == EXECUTION_UNDEFINED_TRACE)
	&& (analysis == EXECUTION_UNDEFINED_TRACE ) );
	}


	////////////////////////////////////////////////////////////////////////////
	// REACHED LIMIT
	////////////////////////////////////////////////////////////////////////////

	/**
	* GETTER - SETTER
	* limit
	*/
	inline REACHED_LIMIT getReachedLimit() const
	{
	return( static_cast< REACHED_LIMIT >( limit ) );
	}

	inline bool hasReachedLimit() const
	{
	return( limit != REACHED_UNDEFINED_LIMIT );
	}

	inline bool noneReachedLimit() const
	{
	return( limit == REACHED_UNDEFINED_LIMIT );
	}

	inline bool isReachedLimit(REACHED_LIMIT reachedLimit) const
	{
	return( limit == reachedLimit );
	}

	inline ExecutionContextFlags & addReachedLimit(REACHED_LIMIT reachedLimit)
	{
	limit \|= reachedLimit;

	return( *this );
	}

	inline ExecutionContextFlags & remReachedLimit(REACHED_LIMIT reachedLimit)
	{
	limit &= (~ reachedLimit);

	return( *this );
	}

	inline ExecutionContextFlags & setReachedLimit(REACHED_LIMIT reachedLimit)
	{
	limit = reachedLimit;

	return( *this );
	}

	inline ExecutionContextFlags & unsetReachedLimit()
	{
	limit = REACHED_UNDEFINED_LIMIT;

	return( *this );
	}


	/**
	* GETTER - SETTER
	* "node height" limit
	*/
	inline bool isReachedNodeHeightLimit() const
	{
	return( limit == REACHED_NODE_HEIGHT_LIMIT );
	}

	inline bool hasReachedNodeHeightLimit() const
	{
	return( (limit & REACHED_NODE_HEIGHT_LIMIT) != 0 );
	}

	inline ExecutionContextFlags & addReachedNodeHeightLimit()
	{
	limit \|= REACHED_NODE_HEIGHT_LIMIT;

	return( *this );
	}

	inline ExecutionContextFlags & setReachedNodeHeightLimit()
	{
	limit = REACHED_NODE_HEIGHT_LIMIT;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "node width" limit
	*/
	inline bool isReachedNodeWidthLimit() const
	{
	return( limit == REACHED_NODE_WIDTH_LIMIT );
	}

	inline bool hasReachedNodeWidthLimit() const
	{
	return( (limit & REACHED_NODE_WIDTH_LIMIT) != 0 );
	}

	inline ExecutionContextFlags & addReachedNodeWidthLimit()
	{
	limit \|= REACHED_NODE_WIDTH_LIMIT;

	return( *this );
	}

	inline ExecutionContextFlags & setReachedNodeWidthLimit()
	{
	limit = REACHED_NODE_WIDTH_LIMIT;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "node count" limit
	*/
	inline bool isReachedNodeCountLimit() const
	{
	return( limit == REACHED_NODE_COUNT_LIMIT );
	}

	inline bool hasReachedNodeCountLimit() const
	{
	return( (limit & REACHED_NODE_COUNT_LIMIT) != 0 );
	}

	inline ExecutionContextFlags & addReachedNodeCountLimit()
	{
	limit \|= REACHED_NODE_COUNT_LIMIT;

	return( *this );
	}

	inline ExecutionContextFlags & setReachedNodeCountLimit()
	{
	limit = REACHED_NODE_COUNT_LIMIT;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "execution step" limit
	*/
	inline bool isReachedSymbexStepLimit() const
	{
	return( limit == REACHED_SYMBEX_STEP_LIMIT );
	}

	inline bool hasReachedSymbexStepLimit() const
	{
	return( (limit & REACHED_SYMBEX_STEP_LIMIT) != 0 );
	}


	inline ExecutionContextFlags & addReachedSymbexStepLimit()
	{
	limit \|= REACHED_SYMBEX_STEP_LIMIT;

	return( *this );
	}

	inline ExecutionContextFlags & setReachedSymbexStepLimit()
	{
	limit = REACHED_SYMBEX_STEP_LIMIT;

	return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// REACHED LIMIT
	////////////////////////////////////////////////////////////////////////////

	/**
	* GETTER - SETTER
	* interrupt
	*/
	inline INTERRUPT_REQUEST getInterruptRequest() const
	{
	return( static_cast< INTERRUPT_REQUEST >( interrupt ) );
	}

	inline bool hasInterruptRequest() const
	{
	return( interrupt != REACHED_UNDEFINED_LIMIT );
	}

	inline bool noneInterruptRequest() const
	{
	return( interrupt == REACHED_UNDEFINED_LIMIT );
	}

	inline bool isInterruptRequest(INTERRUPT_REQUEST interruptRequest) const
	{
	return( interrupt == interruptRequest );
	}

	inline ExecutionContextFlags & setInterruptRequest(
	INTERRUPT_REQUEST interruptRequest)
	{
	interrupt = interruptRequest;

	return( *this );
	}

	inline ExecutionContextFlags & unsetInterruptRequest()
	{
	interrupt = REACHED_UNDEFINED_LIMIT;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "formal analysis module" as "fam" request
	*/
	inline bool isInterruptModuleRequest() const
	{
	return( interrupt == INTERRUPT_FAM_REQUEST );
	}

	inline ExecutionContextFlags & setInterruptModuleRequest()
	{
	interrupt = INTERRUPT_FAM_REQUEST;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "fam" request
	*/
	inline bool isInterruptUserRequest() const
	{
	return( interrupt == INTERRUPT_USER_REQUEST );
	}

	inline ExecutionContextFlags & setInterruptUserRequest()
	{
	interrupt = INTERRUPT_USER_REQUEST;

	return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// EXECUTION TRACE
	////////////////////////////////////////////////////////////////////////////

	/**
	* GETTER - SETTER
	* execution
	*/
	inline EXECUTION_TRACE getExecutionTrace() const
	{
	return( static_cast< EXECUTION_TRACE >( execution ) );
	}

	inline bool hasExecutionTrace() const
	{
	return( execution != EXECUTION_UNDEFINED_TRACE );
	}

	inline bool noneExecutionTrace() const
	{
	return( execution == EXECUTION_UNDEFINED_TRACE );
	}

	inline bool isExecutionTrace(EXECUTION_TRACE reachedLimit) const
	{
	return( execution == reachedLimit );
	}

	inline ExecutionContextFlags & addExecutionTrace(EXECUTION_TRACE reachedLimit)
	{
	execution \|= reachedLimit;

	return( *this );
	}

	inline ExecutionContextFlags & remExecutionTrace(EXECUTION_TRACE reachedLimit)
	{
	execution &= (~ reachedLimit);

	return( *this );
	}

	inline ExecutionContextFlags & setExecutionTrace(EXECUTION_TRACE reachedLimit)
	{
	execution = reachedLimit;

	return( *this );
	}

	inline ExecutionContextFlags & unsetExecutionTrace()
	{
	execution = EXECUTION_UNDEFINED_TRACE;

	return( *this );
	}


	/**
	* GETTER - SETTER
	* "deadlock" execution
	*/
	inline bool isExecutionDeadlockTrace() const
	{
	return( execution == EXECUTION_DEADLOCK_TRACE );
	}

	inline ExecutionContextFlags & setExecutionDeadlockTrace()
	{
	execution = EXECUTION_DEADLOCK_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "trivial_loop" execution
	*/
	inline bool isExecutionTrivialLoopTrace() const
	{
	return( execution == EXECUTION_TRIVIAL_LOOP_TRACE );
	}

	inline ExecutionContextFlags & setExecutionTrivialLoopTrace()
	{
	execution = EXECUTION_TRIVIAL_LOOP_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "livelock" execution
	*/
	inline bool isExecutionLivelockTrace() const
	{
	return( execution == EXECUTION_LIVELOCK_TRACE );
	}

	inline ExecutionContextFlags & setExecutionLivelockTrace()
	{
	execution = EXECUTION_LIVELOCK_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "redundancy" execution
	*/
	inline bool isExecutionRedundancyTrace() const
	{
	return( execution == EXECUTION_REDUNDANCY_TRACE );
	}

	inline ExecutionContextFlags & setExecutionRedundancyTrace()
	{
	execution = EXECUTION_REDUNDANCY_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "redundancy target" execution
	*/
	inline bool isExecutionRedundancyTargetTrace() const
	{
	return( execution == EXECUTION_REDUNDANCY_TARGET_TRACE );
	}

	inline bool noneExecutionRedundancyTargetTrace() const
	{
	return( execution != EXECUTION_REDUNDANCY_TARGET_TRACE );
	}

	inline ExecutionContextFlags & setExecutionRedundancyTargetTrace()
	{
	execution = EXECUTION_REDUNDANCY_TARGET_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "statement_exit" execution
	*/
	inline bool isExecutionStatementExitTrace() const
	{
	return( execution == EXECUTION_STATEMENT_EXIT_TRACE );
	}

	inline ExecutionContextFlags & setExecutionStatementExitTrace()
	{
	execution = EXECUTION_STATEMENT_EXIT_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "fatal_error" execution
	*/
	inline bool isExecutionFatalErrorTrace() const
	{
	return( execution == EXECUTION_FATAL_ERROR_TRACE );
	}

	inline ExecutionContextFlags & setExecutionFatalErrorTrace()
	{
	execution = EXECUTION_FATAL_ERROR_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "boundary" execution
	*/
	inline bool isExecutionSymbexLimitationTrace() const
	{
	return( execution == EXECUTION_SYMBEX_LIMIT_TRACE );
	}

	inline ExecutionContextFlags & setExecutionSymbexLimitationTrace()
	{
	execution = EXECUTION_SYMBEX_LIMIT_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "exception" execution
	*/
	inline bool isExecutionExceptionTrace() const
	{
	return( execution == EXECUTION_EXCEPTION_TRACE );
	}

	inline ExecutionContextFlags & setExecutionExceptionTrace()
	{
	execution = EXECUTION_EXCEPTION_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "step_mark" execution
	*/
	inline bool isExecutionStepMarkTrace() const
	{
	return( execution == EXECUTION_STEP_MARK_TRACE );
	}

	inline ExecutionContextFlags & setExecutionStepMarkTrace()
	{
	execution = EXECUTION_STEP_MARK_TRACE;

	return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// ANALYSIS TRACE
	////////////////////////////////////////////////////////////////////////////

	/**
	* GETTER - SETTER
	* analysis
	*/
	inline FAM_TRACE getAnalysisTrace() const
	{
	return( static_cast< FAM_TRACE >( analysis ) );
	}

	inline bool hasAnalysisTrace() const
	{
	return( analysis != REACHED_UNDEFINED_LIMIT );
	}

	inline bool noneAnalysisTrace() const
	{
	return( analysis == REACHED_UNDEFINED_LIMIT );
	}

	inline bool hasAnalysisTrace(FAM_TRACE analysisTrace) const
	{
	return( (analysis & analysisTrace) != 0 );
	}

	inline bool isAnalysisTrace(FAM_TRACE analysisTrace) const
	{
	return( analysis == analysisTrace );
	}

	inline ExecutionContextFlags & setAnalysisTrace(FAM_TRACE analysisTrace)
	{
	analysis = analysisTrace;

	return( *this );
	}

	inline ExecutionContextFlags & unsetAnalysisTrace()
	{
	analysis = FAM_UNDEFINED_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "coverage" analysis
	*/
	inline bool hasCoverageElementTrace() const
	{
	return( (analysis & FAM_COVERAGE_ELEMENT_TRACE) != 0 );
	}

	inline bool isCoverageElementTrace() const
	{
	return( analysis == FAM_COVERAGE_ELEMENT_TRACE );
	}

	inline bool noneCoverageElementTrace() const
	{
	return( (analysis & FAM_COVERAGE_ELEMENT_TRACE) == 0 );
	}

	inline ExecutionContextFlags & addCoverageElementTrace()
	{
	analysis \|= FAM_COVERAGE_ELEMENT_TRACE;

	return( *this );
	}

	inline ExecutionContextFlags & setCoverageElementTrace()
	{
	analysis = FAM_COVERAGE_ELEMENT_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "coverage" analysis
	*/
	inline bool hasObjectiveAchievedTrace() const
	{
	return( (analysis & FAM_OBJECTIVE_ACHIEVED_TRACE) != 0 );
	}

	inline bool isObjectiveAchievedTrace() const
	{
	return( analysis == FAM_OBJECTIVE_ACHIEVED_TRACE );
	}

	inline bool noneObjectiveAchievedTrace() const
	{
	return( (analysis & FAM_OBJECTIVE_ACHIEVED_TRACE) == 0 );
	}

	inline ExecutionContextFlags & addObjectiveAchievedTrace()
	{
	analysis \|= FAM_OBJECTIVE_ACHIEVED_TRACE;

	return( *this );
	}

	inline ExecutionContextFlags & setObjectiveAchievedTrace()
	{
	analysis = FAM_OBJECTIVE_ACHIEVED_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "coverage" analysis
	*/
	inline bool hasObjectiveFailedTrace() const
	{
	return( (analysis & FAM_OBJECTIVE_FAILED_TRACE) != 0 );
	}

	inline bool isObjectiveFailedTrace() const
	{
	return( analysis == FAM_OBJECTIVE_FAILED_TRACE );
	}

	inline ExecutionContextFlags & addObjectiveFailedTrace()
	{
	analysis \|= FAM_OBJECTIVE_FAILED_TRACE;

	return( *this );
	}

	inline ExecutionContextFlags & setObjectiveFailedTrace()
	{
	analysis = FAM_OBJECTIVE_FAILED_TRACE;

	return( *this );
	}

	/**
	* GETTER - SETTER
	* "coverage" analysis
	*/
	inline bool hasObjectiveAbortedTrace() const
	{
	return( (analysis & FAM_OBJECTIVE_ABORTED_TRACE) != 0 );
	}

	inline bool isObjectiveAbortedTrace() const
	{
	return( analysis == FAM_OBJECTIVE_ABORTED_TRACE );
	}

	inline ExecutionContextFlags & addObjectiveAbortedTrace()
	{
	analysis \|= FAM_OBJECTIVE_ABORTED_TRACE;

	return( *this );
	}

	inline ExecutionContextFlags & setObjectiveAbortedTrace()
	{
	analysis = FAM_OBJECTIVE_ABORTED_TRACE;

	return( *this );
	}


	/**
	* REEXECUTABILITY
	*/
	inline bool isReexecutable() const
	{
	return( noneExecutionTrace() );
	}

	inline ExecutionContextFlags & setReexecutable()
	{
	limit = REACHED_UNDEFINED_LIMIT;

	interrupt = INTERRUPT_UNDEFINED_REQUEST;

	return( *this );
	}


	/**
	* CATEGORY TEST
	*/
	inline bool hasError() const
	{
	return( isExecutionFatalErrorTrace()
	\|\| isExecutionSymbexLimitationTrace() );
	}

	inline bool hasAlert() const
	{
	return( isExecutionDeadlockTrace()
	\|\| isExecutionLivelockTrace()
	\|\| isExecutionStatementExitTrace() );
	}

	inline bool hasWarning() const
	{
	return( hasReachedLimit() );
	}

	inline bool hasCoverageElement() const
	{
	return( hasCoverageElementTrace() );
	}

	inline bool hasObjectiveAchieved() const
	{
	return( hasObjectiveAchievedTrace() );
	}

	inline bool hasObjectiveFailed() const
	{
	return( hasObjectiveFailedTrace() );
	}

	inline bool hasObjectiveAborted() const
	{
	return( hasObjectiveAbortedTrace() );
	}

	inline bool hasRedundancy() const
	{
	return( isExecutionTrivialLoopTrace()
	\|\| isExecutionRedundancyTrace() );
	}

	inline bool hasRedundancyTarget() const
	{
	return( isExecutionRedundancyTargetTrace() );
	}


	/**
	* Default Separator
	*/
	static std::string SEPARATOR;

	/**
	* REACHED LIMIT to STRING
	*/
	inline std::string strReachedLimit(
	const std::string & separator = " & ") const
	{
	return( ExecutionContextFlags::strReachedLimit(
	limit , separator ) );
	}

	static std::string strReachedLimit(bit_field_t reachedLimit,
	const std::string & separator = SEPARATOR);

	/**
	* INTERRUPT REQUEST to STRING
	*/
	inline std::string strInterruptRequest(
	const std::string & separator = " & ") const
	{
	return( ExecutionContextFlags::strInterruptRequest(
	interrupt , separator ) );
	}

	static std::string strInterruptRequest(bit_field_t interruptRequest,
	const std::string & separator = SEPARATOR);


	/**
	* EXECUTION TRACE to STRING
	*/
	inline std::string strExecutionTrace(
	const std::string & separator = " ") const
	{
	return( ExecutionContextFlags::strExecutionTrace(
	execution , separator ) );
	}

	static std::string strExecutionTrace(bit_field_t executionTrace,
	const std::string & separator = SEPARATOR);

	/**
	* ANALYSIS TRACE to STRING
	*/
	inline std::string strAnalysisTrace(
	const std::string & separator = " ") const
	{
	return( ExecutionContextFlags::strAnalysisTrace(
	analysis , separator ) );
	}

	static std::string strAnalysisTrace(bit_field_t analysisTrace,
	const std::string & separator = SEPARATOR);

	/**
	* Serialization
	*/
	inline std::string str(const std::string & separator = SEPARATOR) const
	{
	return( StringTools::removeLastIfEndsWith(
	toString( separator ), separator) );
	}

	inline std::string toString(
	const std::string & separator = SEPARATOR) const
	{
	return( ExecutionContextFlags::strReachedLimit(
	limit , separator ) +
	ExecutionContextFlags::strInterruptRequest(
	interrupt , separator ) +
	ExecutionContextFlags::strExecutionTrace(
	execution , separator ) +
	ExecutionContextFlags::strAnalysisTrace(
	analysis , separator ) );
	}


	};


	class ExecutionContextFlagsImpl
	{

	protected:
	/**
	* ATTRIBUTES
	*/
	ExecutionContextFlags mFlags;


	public:
	/**
	* CONSTRUCTOR
	*/
	ExecutionContextFlagsImpl()
	: mFlags( )
	{
	//!! NOTHING
	}


	/**
	* DESTRUCTOR
	*/
	~ExecutionContextFlagsImpl()
	{
	//!! NOTHING
	}

	/**
	* GETTER
	* mFlags
	*/
	inline const ExecutionContextFlags & getFlags() const
	{
	return( mFlags );
	}

	inline ExecutionContextFlags & getwFlags()
	{
	return( mFlags );
	}

	inline bool hasFlags() const
	{
	return( mFlags.isDefined() );
	}

	inline void setFlags(const ExecutionContextFlags & flags)
	{
	mFlags = flags;
	}

	};


	} /* namespace sep */

	#endif /* FML_RUNTIME_EXECUTIONCONTEXTFLAGS_H_ */