| /******************************************************************************* |
| * 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: 10 nov. 2014 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "TransitionReachability.h" |
| |
| |
| #include <computer/primitive/AvmCommunicationFactory.h> |
| |
| #include <fml/executable/AvmTransition.h> |
| #include <fml/executable/ExecutableLib.h> |
| |
| #include <fml/expression/StatementTypeChecker.h> |
| |
| #include <fml/runtime/ExecutionContext.h> |
| #include <fml/runtime/ExecutionData.h> |
| #include <fml/runtime/Message.h> |
| #include <fml/runtime/RuntimeForm.h> |
| #include <fml/runtime/RuntimeID.h> |
| |
| #include <fml/trace/TracePoint.h> |
| #include <fml/trace/TraceSequence.h> |
| |
| |
| namespace sep |
| { |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| TransitionReachability::TransitionReachability(const ExecutionContext & anEC, |
| const RuntimeID & aRID, AvmTransition * aTransition) |
| : theEC( anEC ), |
| theED( anEC.refExecutionData() ), |
| theRID( aRID ), |
| theTransition( aTransition ), |
| theTransitionPoint( NULL ), |
| theTraceElement( ), |
| |
| theRuntimePathComputingCountLimit( 16 ), |
| |
| theGoalAchievedFlag( false ), |
| |
| theVirtualBuffer(theTransition, NULL, 0, TYPE_LIFO_SPECIFIER, -1), |
| theEmitOutput( & theVirtualBuffer ), |
| |
| theTableOfRuntimeStatus( *( theED.getRuntimeFormStateTable() ) ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * UTILS |
| */ |
| bool TransitionReachability::initialize() |
| { |
| theGoalAchievedFlag = false; |
| |
| if( theRID.invalid() ) |
| { |
| if( theED.mRID.getExecutable()->getTransition().contains(theTransition) ) |
| { |
| theRID = theED.mRID; |
| } |
| |
| if( theRID.invalid() ) |
| { |
| if( theTransitionPoint != NULL ) |
| { |
| theTransitionPoint->updateRID( theED ); |
| |
| theRID = theTransitionPoint->RID; |
| } |
| else |
| { |
| theRID = theED.getRuntimeID( theTransition->getExecutable() ); |
| } |
| } |
| } |
| |
| return( theRID.valid() ); |
| } |
| |
| |
| bool TransitionReachability::computePath() |
| { |
| if( initialize() ) |
| { |
| AvmCommunicationFactory::collectBufferMessage(theED, theEmitOutput); |
| |
| return( theGoalAchievedFlag = computePath(theRID, theTransition) ); |
| } |
| |
| return( false ); |
| } |
| |
| |
| bool TransitionReachability::computePath(TraceSequence & aTraceElement) |
| { |
| if( initialize() ) |
| { |
| AvmCommunicationFactory::collectBufferMessage(theED, theEmitOutput); |
| |
| if( computePath(theRID, theTransition) ) |
| { |
| aTraceElement.copyTrace( theTraceElement ); |
| |
| theGoalAchievedFlag = true; |
| |
| return( true ); |
| } |
| } |
| |
| return( false ); |
| } |
| |
| |
| |
| void TransitionReachability::report(OutStream & os) |
| { |
| os << "Trace to reach :> " << theTransition->strTransitionHeader(); |
| theTraceElement.toStream(os); |
| |
| // os << TAB << "Emit Output :>" << to_stream( theEmitOutput ); |
| |
| os << ( theGoalAchievedFlag ? "NEW" : "NO" ) << " OBJECTIVE !!!" << std::endl; |
| } |
| |
| |
| |
| bool TransitionReachability::computePath( |
| const RuntimeID & aRID, AvmTransition * aTransition) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << TAB << "computePath from :> "; |
| theEC.traceMinimum(AVM_OS_COUT); |
| AVM_OS_COUT << TAB2 << aRID.strUniqId() << " |==> "; |
| aTransition->toStreamHeader(AVM_OS_COUT); AVM_OS_COUT << std::endl; |
| if( aTransition->hasInternalCommunicationCode() ) |
| { |
| AVM_OS_COUT << TAB2 << "com |==> "; |
| BaseCompiledForm::toStreamStaticCom(AVM_OS_COUT, |
| aTransition->getInternalCommunicationCode()); |
| } |
| AVM_OS_COUT << TAB2 << "Emit Output :>" << to_stream( theEmitOutput ) |
| << TAB << "end //computePath" << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| |
| if( theED.isIdleOrRunning(aRID) ) |
| { |
| return( fireTransition(aRID, aTransition) ); |
| } |
| else |
| { |
| return( computePathToTransition(aRID, aTransition) ); |
| } |
| |
| return( false ); |
| } |
| |
| |
| bool TransitionReachability::fireTransition( |
| const RuntimeID & aRID, AvmTransition * aTransition) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << std::endl |
| << TAB << "fireTransition :> " << aRID.strUniqId() |
| << " |==> " << aTransition->strTransitionHeader() << std::endl |
| << TAB2 << "Emit Output :>" << to_stream( theEmitOutput ) |
| << TAB << "end //fireTransition" << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| |
| theTableOfRuntimeStatus.stateSet(aRID.getOffset(), PROCESS_SUSPENDED_STATE); |
| |
| if( aTransition->hasInputCom() ) |
| { |
| ListOfInstanceOfPort anInputTrace( aTransition->getInputCom() ); |
| if( theEmitOutput.uncontains( anInputTrace ) ) |
| { |
| // trouver des émetteurs pour les INPUT attendu au regard de ED< SC > |
| while( anInputTrace.nonempty() ) |
| { |
| if( computePathToInput(aRID, anInputTrace.front()) ) |
| { |
| anInputTrace.pop_front(); |
| } |
| else |
| { |
| break; |
| } |
| } |
| |
| if( anInputTrace.empty() ) |
| { |
| traceTransition(aRID, aTransition); |
| |
| return( true ); |
| } |
| return( false ); |
| } |
| else |
| { |
| traceTransition(aRID, aTransition); |
| } |
| } |
| else |
| { |
| traceTransition(aRID, aTransition); |
| } |
| |
| return( true ); |
| } |
| |
| |
| void TransitionReachability::traceTransition( |
| const RuntimeID & aRID, AvmTransition * aTransition) |
| { |
| TracePoint * tmpTP = new TracePoint( |
| ENUM_TRACE_POINT::TRACE_TRANSITION_NATURE, |
| AVM_OPCODE_INVOKE_TRANSITION, aRID, aTransition); |
| |
| theTraceElement.points.append( BF(tmpTP) ); |
| |
| // Virtual Eval Of aTransition |
| if( aTransition->hasOutputCom() ) |
| { |
| ListOfInstanceOfPort::const_iterator itOutput = |
| aTransition->getOutputCom().begin(); |
| ListOfInstanceOfPort::const_iterator endOutput = |
| aTransition->getOutputCom().end(); |
| for( ; itOutput != endOutput ; ++itOutput ) |
| { |
| theEmitOutput.push( Message(aRID, INCR_BF(*itOutput)) ); |
| } |
| } |
| } |
| |
| |
| bool TransitionReachability::computePathToTransition( |
| const RuntimeID & aRID, AvmTransition * aTransition) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << std::endl |
| << TAB << "computePathToTransition using :> " << aRID.strUniqId() |
| << " |==> " << aTransition->strTransitionHeader() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| |
| RuntimeID tmpRID = aRID.getPRID(); |
| for( ; tmpRID.valid() ; tmpRID = tmpRID.getPRID() ) |
| { |
| // AVM_OS_COUT << tmpRID.strUniqId() << " : " |
| // << tmpRID.getInstance()->getFullyQualifiedNameID() << std::endl; |
| |
| if( theED.isIdleOrRunning(tmpRID) ) |
| { |
| break; |
| } |
| } |
| |
| AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( tmpRID ) |
| << "Runnable Ancestor Statemachine for " |
| << aRID.strUniqId() << " in the context of " |
| << aTransition->getFullyQualifiedNameID() << " !!!" |
| << SEND_EXIT; |
| |
| const RuntimeForm & tmpRF = theED.getRuntime(tmpRID); |
| |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << TAB2 << "Runnable Ancestor Statemachine :> " |
| << tmpRID.str() << std::endl |
| << TAB2 << "Runnable Ancestor State Scheduler :> {"; |
| tmpRF.getOnSchedule()->toStreamRoutine( AVM_OS_COUT ) |
| << TAB2 << "}" << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| |
| if( tmpRF.getOnSchedule()->isOpCode( AVM_OPCODE_RUN ) && |
| tmpRF.getOnSchedule()->first().is< RuntimeID >() ) |
| { |
| return( computePathFromRunnable( |
| tmpRF.getOnSchedule()->first().bfRID(), aTransition) ); |
| } |
| |
| return( false ); |
| } |
| |
| |
| bool TransitionReachability::computePathFromRunnable( |
| const RuntimeID & aRID, AvmTransition * aTransition) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << std::endl |
| << TAB << "computePathFromRunnable using :> " << aRID.strUniqId() |
| << " |==> " << aTransition->strTransitionHeader() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| if( not aRID.getExecutable()-> |
| containsForwardReachableTransition(aTransition) ) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << TAB2 << "Unreachable transition :> " |
| << theTransition->strTransitionHeader() << std::endl |
| << TAB2 << "from : " << aRID.str() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| return( false ); |
| } |
| |
| |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << TAB << "Looking for a path to :> " << aRID.str() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| |
| ListOfAvmTransition oneTransitionPath; |
| |
| if( computePathToTransition(aRID, aTransition, oneTransitionPath) ) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << INCR_INDENT; |
| AvmTransition::toStream(AVM_OS_COUT, oneTransitionPath); |
| AVM_OS_COUT << DECR_INDENT << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| // All found path |
| // ListOfListOfAvmTransition allTransitionPaths; |
| // computePathToTransition(aRID, aTransition, allTransitionPaths); |
| |
| RuntimeID tmpRID = aRID; |
| do |
| { |
| aTransition = oneTransitionPath.front(); |
| |
| if( fireTransition(tmpRID, aTransition) ) |
| { |
| oneTransitionPath.pop_front(); |
| |
| if( not computeTargetMachine(tmpRID, aTransition->getCode()) ) |
| { |
| return( false ); |
| } |
| } |
| else |
| { |
| break; |
| } |
| } |
| while( oneTransitionPath.nonempty() ); |
| |
| return( oneTransitionPath.empty() ); |
| } |
| |
| return( false ); |
| } |
| |
| |
| |
| //bool TransitionReachability::computePathFromRunnable( |
| // const RuntimeID & aRID, AvmTransition * aTransition) |
| //{ |
| //AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // AVM_OS_COUT << std::endl |
| // << TAB << "computePathFromRunnable using :> " << aRID.strUniqId() |
| // << " |==> " << aTransition->strTransitionHeader() << std::endl; |
| //AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // |
| // if( not aRID.getExecutable()-> |
| // containsForwardReachableTransition(aTransition) ) |
| // { |
| //AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // AVM_OS_COUT << TAB2 << "Unreachable transition :> " |
| // << theTransition->strTransitionHeader() << std::endl |
| // << TAB2 << "from : " << aRID.str() << std::endl; |
| //AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // |
| // return( false ); |
| // } |
| // |
| // |
| //AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // AVM_OS_COUT << TAB << "Looking for a path to :> " << aRID.str() << std::endl; |
| //AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // |
| // |
| // // All found path |
| // ListOfListOfAvmTransition allTransitionPaths; |
| // computePathToTransition(aRID, aTransition, allTransitionPaths); |
| // |
| // BFList saveTracePoints( theTraceElement.points ); |
| // |
| // ListOfAvmTransition oneTransitionPath; |
| // RuntimeID tmpRID; |
| // |
| //// if( computePathToTransition(aRID, aTransition, oneTransitionPath) ) |
| // while( allTransitionPaths.nonempty() ) |
| // { |
| // oneTransitionPath.clear(); |
| // oneTransitionPath.splice( allTransitionPaths.front() ); |
| // allTransitionPaths.pop_front(); |
| // |
| //AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // AVM_OS_COUT << TAB << "Found Path --> " |
| // << aTransition->getFullyQualifiedNameID() << std::endl << INCR_INDENT; |
| // AvmTransition::toStream(AVM_OS_COUT, oneTransitionPath); |
| // AVM_OS_COUT << DECR_INDENT << std::endl; |
| //AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| // |
| // tmpRID = aRID; |
| // do |
| // { |
| // aTransition = oneTransitionPath.front(); |
| // |
| // if( fireTransition(tmpRID, aTransition) ) |
| // { |
| // oneTransitionPath.pop_front(); |
| // |
| // computeTargetMachine(tmpRID, aTransition->getCode()); |
| // } |
| // else |
| // { |
| // break; |
| // } |
| // } |
| // while( oneTransitionPath.nonempty() ); |
| // |
| // if( oneTransitionPath.empty() ) |
| // { |
| // return( true ); |
| // } |
| // else if( allTransitionPaths.empty() ) |
| // { |
| // return( false ); |
| // } |
| // |
| // // BACKTRACK |
| // else if( saveTracePoints.empty() ) |
| // { |
| // theTraceElement.points.clear(); |
| // } |
| // else |
| // { |
| // while( theTraceElement.points.back().isNTEQ( saveTracePoints.back() ) ) |
| // { |
| // theTraceElement.points.pop_back(); |
| // } |
| // } |
| // } |
| // |
| // return( false ); |
| //} |
| |
| |
| bool TransitionReachability::computePathToInput( |
| const RuntimeID & aRID, InstanceOfPort * anInputTrace) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << TAB << "computePathToInput :> " << std::endl |
| << TAB2 << "Expected Input :> " |
| << anInputTrace->getFullyQualifiedNameID() << std::endl |
| << TAB2 << "Emit Output :>" << to_stream( theEmitOutput ) |
| << TAB << "end //computePathToInput" << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| |
| ExecutableForm * tmpExecutable = NULL; |
| RuntimeID srcRID; |
| |
| // Parcourir tous les états et repérer ceux contenant les bons output/outputTo |
| TableOfRuntimeT::const_iterator itRF = theED.getTableOfRuntime().begin(); |
| TableOfRuntimeT::const_iterator endRF = theED.getTableOfRuntime().end(); |
| for( ; itRF != endRF ; ++itRF ) |
| { |
| srcRID = (*itRF)->getRID(); |
| tmpExecutable = srcRID.getExecutable(); |
| |
| if( theTableOfRuntimeStatus.isSuspended(srcRID.getOffset()) ) |
| { |
| //!! Exclude machine |
| } |
| else if( theED.isIdleOrRunning( srcRID ) && |
| tmpExecutable->getForwardReachableTransition().nonempty() ) |
| { |
| ListOfAvmTransition::const_iterator itTrans = |
| tmpExecutable->getForwardReachableTransition().begin(); |
| ListOfAvmTransition::const_iterator endTrans = |
| tmpExecutable->getForwardReachableTransition().end(); |
| for( ; itTrans != endTrans ; ++itTrans ) |
| { |
| if( (*itTrans)->getOutputCom().contains(anInputTrace) ) |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << TAB << "found Output in :> " << srcRID.strUniqId() << " |==> " |
| << (*itTrans)->strTransitionHeader() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| if( tmpExecutable != (*itTrans)->getExecutable() ) |
| { |
| if( computePathFromRunnable(srcRID, (*itTrans)) ) |
| { |
| return( true ); |
| } |
| } |
| else if( fireTransition(srcRID, (*itTrans)) ) |
| { |
| return( true ); |
| } |
| } |
| } |
| } |
| } |
| |
| AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| AVM_OS_COUT << TAB << "Unfound Input :> " |
| << anInputTrace->getFullyQualifiedNameID() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION ) |
| |
| return( false ); |
| } |
| |
| |
| bool TransitionReachability::computePathToTransition(const RuntimeID & aRID, |
| AvmTransition * aTransition, ListOfAvmTransition & oneTransitionPath) |
| { |
| ListOfListOfAvmTransition anyTransitionPaths; |
| |
| ListOfAvmTransition listOfOutgoingTransition; |
| InstanceOfMachine * tgtInstance; |
| |
| // Initialization step |
| ExecutableForm * fwdMachine = aRID.getExecutable(); |
| fwdMachine->getOutgoingTransition( listOfOutgoingTransition ); |
| |
| ExecutableForm * tgtMachine = fwdMachine; |
| |
| ListOfAvmTransition::const_iterator itTrans = listOfOutgoingTransition.begin(); |
| ListOfAvmTransition::const_iterator endTrans = listOfOutgoingTransition.end(); |
| for( ; itTrans != endTrans ; ++itTrans ) |
| { |
| if( (tgtInstance = (*itTrans)->getTransitionTarget()) != NULL ) |
| { |
| tgtMachine = tgtInstance->getExecutable(); |
| } |
| if( tgtMachine->containsForwardReachableTransition(aTransition) ) |
| { |
| anyTransitionPaths.append( ListOfAvmTransition(*itTrans) ); |
| } |
| } |
| |
| |
| ListOfAvmTransition aTransitionPath; |
| |
| // Iterative step |
| while( anyTransitionPaths.nonempty() ) |
| { |
| aTransitionPath.clear(); |
| aTransitionPath.splice( anyTransitionPaths.front() ); |
| anyTransitionPaths.pop_front(); |
| |
| if( (tgtInstance = aTransitionPath.back()->getTransitionTarget()) != NULL ) |
| { |
| fwdMachine = tgtInstance->getExecutable(); |
| } |
| if( fwdMachine->getTransition().contains(aTransition) ) |
| { |
| oneTransitionPath.splice( aTransitionPath ); |
| oneTransitionPath.push_back( aTransition ); |
| |
| return( true ); |
| } |
| else |
| { |
| listOfOutgoingTransition.clear(); |
| fwdMachine->getOutgoingTransition( listOfOutgoingTransition ); |
| |
| itTrans = listOfOutgoingTransition.begin(); |
| endTrans = listOfOutgoingTransition.end(); |
| for( ; itTrans != endTrans ; ++itTrans ) |
| { |
| if( not aTransitionPath.contains( *itTrans ) ) |
| { |
| if( (tgtInstance = (*itTrans)->getTransitionTarget()) != NULL ) |
| { |
| tgtMachine = tgtInstance->getExecutable(); |
| } |
| if( tgtMachine->containsForwardReachableTransition(aTransition) ) |
| { |
| if( anyTransitionPaths.size() < |
| theRuntimePathComputingCountLimit ) |
| { |
| anyTransitionPaths.push_back( aTransitionPath ); |
| anyTransitionPaths.back().push_back( *itTrans ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return( false ); |
| } |
| |
| |
| bool TransitionReachability::computePathToTransition(const RuntimeID & aRID, |
| AvmTransition * aTransition, ListOfListOfAvmTransition & allTransitionPaths) |
| { |
| ListOfListOfAvmTransition anyTransitionPaths; |
| ListOfListOfAvmTransition prefixLoopTransitionPaths; |
| |
| ListOfAvmTransition aTransitionPath; |
| |
| ListOfAvmTransition listOfOutgoingTransition; |
| InstanceOfMachine * tgtInstance; |
| |
| // Initialization step |
| ExecutableForm * fwdMachine = aRID.getExecutable(); |
| fwdMachine->getOutgoingTransition( listOfOutgoingTransition ); |
| |
| ExecutableForm * tgtMachine = fwdMachine; |
| |
| ListOfAvmTransition::const_iterator itTrans = listOfOutgoingTransition.begin(); |
| ListOfAvmTransition::const_iterator endTrans = listOfOutgoingTransition.end(); |
| for( ; itTrans != endTrans ; ++itTrans ) |
| { |
| if( (tgtInstance = (*itTrans)->getTransitionTarget()) != NULL ) |
| { |
| tgtMachine = tgtInstance->getExecutable(); |
| } |
| if( tgtMachine->containsForwardReachableTransition(aTransition) ) |
| { |
| anyTransitionPaths.append( ListOfAvmTransition(*itTrans) ); |
| } |
| } |
| |
| // Iterative step |
| while( anyTransitionPaths.nonempty() ) |
| { |
| // AVM_OS_COUT << TAB << "TMP found paths :> " << std::endl; |
| // ListOfListOfAvmTransition::const_iterator itList = allTransitionPaths.begin(); |
| // ListOfListOfAvmTransition::const_iterator endList = allTransitionPaths.end(); |
| // for( avm_size_t number = 0 ; itList != endList ; ++itList , ++number ) |
| // { |
| // AVM_OS_COUT << TAB << "Path number :" << number << ">" |
| // << std::endl << INCR_INDENT; |
| // AvmTransition::toStream(AVM_OS_COUT, *itList); |
| // AVM_OS_COUT << std::endl << DECR_INDENT; |
| // } |
| // |
| // AVM_OS_COUT << TAB << "TMP Computing paths :> " << std::endl; |
| // itList = anyTransitionPaths.begin(); |
| // endList = anyTransitionPaths.end(); |
| // for( avm_size_t number = 0 ; itList != endList ; ++itList , ++number ) |
| // { |
| // AVM_OS_COUT << TAB << "Path number :" << number << ">" |
| // << std::endl << INCR_INDENT; |
| // AvmTransition::toStream(AVM_OS_COUT, *itList); |
| // AVM_OS_COUT << DECR_INDENT; |
| // } |
| // AVM_OS_COUT << std::endl; |
| |
| aTransitionPath.clear(); |
| aTransitionPath.splice( anyTransitionPaths.front() ); |
| anyTransitionPaths.pop_front(); |
| |
| if( (tgtInstance = aTransitionPath.back()->getTransitionTarget()) != NULL ) |
| { |
| fwdMachine = tgtInstance->getExecutable(); |
| } |
| if( fwdMachine->getTransition().contains(aTransition) ) |
| { |
| allTransitionPaths.push_back( aTransitionPath ); |
| allTransitionPaths.back().push_back( aTransition ); |
| } |
| else |
| { |
| listOfOutgoingTransition.clear(); |
| fwdMachine->getOutgoingTransition( listOfOutgoingTransition ); |
| |
| itTrans = listOfOutgoingTransition.begin(); |
| endTrans = listOfOutgoingTransition.end(); |
| for( ; itTrans != endTrans ; ++itTrans ) |
| { |
| if( aTransitionPath.contains( *itTrans ) ) |
| { |
| prefixLoopTransitionPaths.push_back( aTransitionPath ); |
| prefixLoopTransitionPaths.back().push_back( *itTrans ); |
| } |
| else |
| { |
| if( (tgtInstance = (*itTrans)->getTransitionTarget()) != NULL ) |
| { |
| tgtMachine = tgtInstance->getExecutable(); |
| } |
| if( tgtMachine->containsForwardReachableTransition(aTransition) ) |
| { |
| anyTransitionPaths.push_back( aTransitionPath ); |
| anyTransitionPaths.back().push_back( *itTrans ); |
| } |
| } |
| } |
| } |
| } |
| |
| AVM_OS_COUT << TAB << "List of found paths :> " << std::endl; |
| ListOfListOfAvmTransition::const_iterator itList = allTransitionPaths.begin(); |
| ListOfListOfAvmTransition::const_iterator endList = allTransitionPaths.end(); |
| for( avm_size_t number = 0 ; itList != endList ; ++itList , ++number ) |
| { |
| AVM_OS_COUT << TAB << "Path number :" << number << " --> " |
| << aTransition->getFullyQualifiedNameID() << std::endl << INCR_INDENT; |
| AvmTransition::toStream(AVM_OS_COUT, *itList); |
| AVM_OS_COUT << std::endl << DECR_INDENT; |
| } |
| |
| // AVM_OS_COUT << TAB << "List of found prefix-paths :> " << std::endl; |
| // itList = prefixLoopTransitionPaths.begin(); |
| // endList = prefixLoopTransitionPaths.end(); |
| // for( avm_size_t number = 0 ; itList != endList ; ++itList , ++number ) |
| // { |
| // AVM_OS_COUT << TAB << "Prefix number :" << number << ">" |
| // << std::endl << INCR_INDENT; |
| // AvmTransition::toStream(AVM_OS_COUT, *itList); |
| // AVM_OS_COUT << std::endl << DECR_INDENT; |
| // } |
| |
| return( allTransitionPaths.nonempty() ); |
| } |
| |
| |
| bool TransitionReachability::computeTargetMachine( |
| RuntimeID & aRID, AvmCode * aCode) |
| { |
| switch( aCode->getAvmOpCode() ) |
| { |
| case AVM_OPCODE_ENABLE_INVOKE: |
| case AVM_OPCODE_ENABLE_SET: |
| { |
| const BF & targetMachine = aCode->first(); |
| |
| if( targetMachine.is< InstanceOfMachine >() ) |
| { |
| if( (targetMachine.to_ptr< InstanceOfMachine >() |
| != aRID.getInstance()) |
| && theED.getRuntime(aRID).hasChild() ) |
| { |
| aRID = theED.getRuntimeFormChild(aRID, |
| targetMachine.to_ptr< InstanceOfMachine >() ); |
| } |
| } |
| else if( targetMachine.is< RuntimeID >() ) |
| { |
| aRID = targetMachine.bfRID(); |
| } |
| |
| return( true ); |
| } |
| case AVM_OPCODE_DISABLE_SELF: |
| { |
| aRID = aRID.getPRID(); |
| |
| return( true ); |
| } |
| case AVM_OPCODE_DISABLE_INVOKE: |
| { |
| if( (aCode->first() == ExecutableLib::MACHINE_SELF) |
| || (aRID == aCode->first()) ) |
| { |
| aRID = aRID.getPRID(); |
| |
| return( true ); |
| } |
| else |
| { |
| return( false ); |
| } |
| } |
| case AVM_OPCODE_DISABLE_SELVES: |
| { |
| if( aCode->first().isInteger() ) |
| { |
| for( avm_uinteger_t level = aCode->first().toInteger() ; |
| level > 0 ; --level ) |
| { |
| aRID = aRID.getPRID(); |
| } |
| } |
| else |
| { |
| aRID = aRID.getPRID(); |
| } |
| |
| return( true ); |
| } |
| default: |
| { |
| if( StatementTypeChecker::isSchedule(aCode) ) |
| { |
| AvmCode::const_iterator it = aCode->begin(); |
| AvmCode::const_iterator endIt = aCode->end(); |
| for( ; it != endIt ; ++it ) |
| { |
| if( (*it).is< AvmCode >() ) |
| { |
| if( not computeTargetMachine(aRID, |
| (*it).to_ptr< AvmCode >()) ) |
| { |
| return( false ); |
| } |
| } |
| } |
| } |
| |
| return( true ); |
| } |
| } |
| } |
| |
| |
| } /* namespace sep */ |
