| /******************************************************************************* |
| * 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 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| #ifndef EXECUTABLEFORM_H_ |
| #define EXECUTABLEFORM_H_ |
| |
| #include <fml/executable/AvmProgram.h> |
| #include <fml/common/SpecifierElement.h> |
| |
| #include <base/SmartTable.h> |
| |
| #include <collection/Typedef.h> |
| #include <collection/Vector.h> |
| |
| #include <fml/expression/AvmCode.h> |
| |
| #include <fml/executable/AvmTransition.h> |
| #include <fml/executable/BaseInstanceForm.h> |
| #include <fml/executable/InstanceOfBuffer.h> |
| #include <fml/executable/InstanceOfConnect.h> |
| #include <fml/executable/InstanceOfData.h> |
| #include <fml/executable/InstanceOfMachine.h> |
| #include <fml/executable/InstanceOfPort.h> |
| #include <fml/executable/Router.h> |
| |
| #include <fml/symbol/Symbol.h> |
| #include <fml/symbol/TableOfSymbol.h> |
| |
| #include <fml/infrastructure/InstanceSpecifierPart.h> |
| #include <fml/infrastructure/Machine.h> |
| #include <fml/infrastructure/System.h> |
| |
| |
| namespace sep |
| { |
| |
| class AvmCode; |
| class ExecutableSystem; |
| class ObjectElement; |
| class Specifier; |
| |
| |
| // TYPE DEFINITION for TABLE , SMART POINTER and CONTAINER |
| typedef TableOfBF_T< ExecutableForm > TableOfExecutableForm; |
| |
| typedef SmartTable< InstanceOfBuffer , DestroyElementPolicy > TableOfBuffer; |
| typedef SmartTable< InstanceOfConnect , DestroyElementPolicy > TableOfConnectT; |
| typedef SmartTable< InstanceOfData , DestroyElementPolicy > TableOfVariableT; |
| typedef SmartTable< InstanceOfMachine , DestroyElementPolicy > TableOfMachineT; |
| typedef SmartTable< InstanceOfPort , DestroyElementPolicy > TableOfPortT; |
| |
| |
| class ExecutableForm : |
| public AvmProgram , |
| public SpecifierImpl, |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( ExecutableForm ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( ExecutableForm ) |
| |
| |
| protected: |
| /* |
| * ATTRIBUTES |
| */ |
| ExecutableSystem & mExecutableSystem; |
| |
| avm_size_t mInitialInstanceCount; |
| avm_size_t mMaximalInstanceCount; |
| |
| avm_size_t mPossibleStaticInstanciationCount; |
| avm_size_t mPossibleDynamicInstanciationCount; |
| |
| TableOfSymbol mTableOfChannel; |
| |
| TableOfSymbol mTableOfPort; |
| avm_size_t mMessageSignalCount; |
| |
| TableOfSymbol mTableOfBuffer; |
| TableOfSymbol mTableOfConnect; |
| |
| TableOfSymbol mTableOfInstanceModel; |
| |
| TableOfSymbol mTableOfInstanceStatic; |
| InstanceOfMachine * mPrototypeInstance; |
| |
| TableOfSymbol mTableOfInstanceDynamic; |
| |
| TableOfTransition mTableOfTransition; |
| |
| TableOfAvmProgram mTableOfProgram; |
| |
| TableOfAvmProgram mTableOfAnonymousInnerRoutine; |
| |
| TableOfExecutableForm mTableOfExecutable; |
| |
| TableOfSymbol mTableOfAlias; |
| |
| |
| // Predefined routines |
| AvmProgram onCreateRoutine; |
| AvmProgram onInitRoutine; |
| AvmProgram onFinalRoutine; |
| |
| AvmProgram onReturnRoutine; |
| |
| AvmProgram onStartRoutine; |
| AvmProgram onStopRoutine; |
| |
| AvmProgram onIEnableRoutine; |
| AvmProgram onEnableRoutine; |
| |
| AvmProgram onIDisableRoutine; |
| AvmProgram onDisableRoutine; |
| |
| AvmProgram onIAbortRoutine; |
| AvmProgram onAbortRoutine; |
| |
| AvmProgram onIRunRoutine; |
| AvmProgram onRunRoutine; |
| AvmProgram onRtcRoutine; |
| |
| AvmProgram onScheduleRoutine; |
| AvmProgram onConcurrencyRoutine; |
| |
| AvmProgram onSynchronizeRoutine; |
| |
| |
| // Structural decompositon |
| bool mMainComponentFlag; |
| |
| // MOC Attribute for mutable Schedule |
| bool mMutableScheduleFlag; |
| |
| |
| // Communication routing |
| TableOfRouter mTableOfRouter4Instance; |
| |
| TableOfRouter mTableOfRouter4Model; |
| |
| bool mRdvCommunicationFlag; |
| |
| // MOC Attribute for Communication |
| bool mInputEnabledCommunicationFlag; |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Static Analysis Information |
| //////////////////////////////////////////////////////////////////////////// |
| |
| TableOfInstanceOfData mRequiredData; |
| TableOfInstanceOfData mUselessData; |
| |
| |
| // The list of backward reachable machine |
| ListOfInstanceOfMachine mBackwardReachableMachine; |
| |
| // The list of backward reachable transition |
| ListOfAvmTransition mBackwardReachableTransition; |
| |
| |
| // The list of forward reachable machine |
| ListOfInstanceOfMachine mForwardReachableMachine; |
| |
| // The list of forward reachable transition |
| ListOfAvmTransition mForwardReachableTransition; |
| |
| // Default is << true >> |
| bool isReachableStateFlag; |
| |
| |
| public: |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| ExecutableForm(ExecutableSystem & aExecutableSystem, |
| ExecutableForm * aContainer, |
| Machine * astMachine, avm_size_t aDataSize = 0) |
| : AvmProgram(CLASS_KIND_T( ExecutableForm ), |
| Specifier::SCOPE_MACHINE_KIND, aContainer, astMachine, aDataSize), |
| SpecifierImpl( astMachine ), |
| |
| mExecutableSystem( aExecutableSystem ), |
| |
| mInitialInstanceCount( |
| ((astMachine != NULL) && astMachine->hasInstanceSpecifier()) ? |
| astMachine->getInstanceSpecifier()->getInitialInstanceCount() : 1 ), |
| mMaximalInstanceCount( |
| ((astMachine != NULL) && astMachine->hasInstanceSpecifier()) ? |
| astMachine->getInstanceSpecifier()->getMaximalInstanceCount() : 1 ), |
| |
| mPossibleStaticInstanciationCount( 0 ), |
| mPossibleDynamicInstanciationCount( 0 ), |
| |
| mTableOfChannel( ), |
| |
| mTableOfPort( ), |
| mMessageSignalCount( 0 ), |
| |
| mTableOfBuffer( ), |
| mTableOfConnect( ), |
| |
| mTableOfInstanceModel( ), |
| |
| mTableOfInstanceStatic( ), |
| mPrototypeInstance( ), |
| |
| mTableOfInstanceDynamic( ), |
| |
| mTableOfTransition( ), |
| mTableOfProgram( ), |
| mTableOfAnonymousInnerRoutine( ), |
| |
| mTableOfExecutable( ), |
| |
| mTableOfAlias( ), |
| |
| onCreateRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "create" , 0 ), |
| |
| onInitRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "init" , 0 ), |
| onFinalRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "final" , 0 ), |
| |
| onReturnRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "return" , 0 ), |
| |
| onStartRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "start" , 0 ), |
| onStopRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "stop" , 0 ), |
| |
| onIEnableRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "ienable" , 0 ), |
| onEnableRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "enable" , 0 ), |
| |
| onIDisableRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "idisable" , 0 ), |
| onDisableRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "disable" , 0 ), |
| |
| onIAbortRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "iabort" , 0 ), |
| onAbortRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "abort" , 0 ), |
| |
| onIRunRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "irun" , 0 ), |
| onRunRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "run" , 0 ), |
| onRtcRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "rtc" , 0 ), |
| |
| onScheduleRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "schedule" , 0 ), |
| onConcurrencyRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "concurrency" , 0 ), |
| |
| onSynchronizeRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "synchronize" , 0 ), |
| |
| mMainComponentFlag( ( (astMachine == NULL) || |
| astMachine->getModifier().hasFeatureTransient() ) ? false : true ), |
| |
| mMutableScheduleFlag( false ), |
| |
| mTableOfRouter4Instance( ), |
| |
| mTableOfRouter4Model( ), |
| |
| mRdvCommunicationFlag( false ), |
| |
| mInputEnabledCommunicationFlag( false ), |
| |
| mRequiredData( ), |
| mUselessData( ), |
| |
| mBackwardReachableMachine( ), |
| mBackwardReachableTransition( ), |
| |
| mForwardReachableMachine( ), |
| mForwardReachableTransition( ), |
| |
| isReachableStateFlag( true ) |
| { |
| updateFullyQualifiedNameID(); |
| } |
| |
| ExecutableForm(ExecutableSystem & aExecutableSystem, avm_size_t aDataSize) |
| : AvmProgram(CLASS_KIND_T( ExecutableForm ), |
| Specifier::SCOPE_MACHINE_KIND, NULL, NULL, aDataSize), |
| SpecifierImpl( Specifier::COMPONENT_EXECUTABLE_SPECIFIER ), |
| |
| mExecutableSystem( aExecutableSystem ), |
| |
| mInitialInstanceCount( 1 ), |
| mMaximalInstanceCount( 1 ), |
| |
| mPossibleStaticInstanciationCount( 0 ), |
| mPossibleDynamicInstanciationCount( 0 ), |
| |
| mTableOfChannel( ), |
| |
| mTableOfPort( ), |
| mMessageSignalCount( 0 ), |
| |
| mTableOfBuffer( ), |
| mTableOfConnect( ), |
| |
| mTableOfInstanceModel( ), |
| |
| mTableOfInstanceStatic( ), |
| mPrototypeInstance( ), |
| |
| mTableOfInstanceDynamic( ), |
| |
| mTableOfTransition( ), |
| mTableOfProgram( ), |
| mTableOfAnonymousInnerRoutine( ), |
| |
| mTableOfExecutable( ), |
| |
| mTableOfAlias( ), |
| |
| onCreateRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "create" , 0 ), |
| |
| onInitRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "init" , 0 ), |
| onFinalRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "final" , 0 ), |
| |
| onReturnRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "return" , 0 ), |
| |
| onStartRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "start" , 0 ), |
| onStopRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "stop" , 0 ), |
| |
| onIEnableRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "ienable" , 0 ), |
| onEnableRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "enable" , 0 ), |
| |
| onIDisableRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "idisable" , 0 ), |
| onDisableRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "disable" , 0 ), |
| |
| onIAbortRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "iabort" , 0 ), |
| onAbortRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "abort" , 0 ), |
| |
| onIRunRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "irun" , 0 ), |
| onRunRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "run" , 0 ), |
| onRtcRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "rtc" , 0 ), |
| |
| onScheduleRoutine ( Specifier::SCOPE_ROUTINE_KIND , this , "schedule" , 0 ), |
| onConcurrencyRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "concurrency" , 0 ), |
| |
| onSynchronizeRoutine( Specifier::SCOPE_ROUTINE_KIND , this , "synchronize" , 0 ), |
| |
| mMainComponentFlag( false ), |
| |
| mMutableScheduleFlag( false ), |
| |
| mTableOfRouter4Instance( ), |
| |
| mTableOfRouter4Model( ), |
| |
| mRdvCommunicationFlag( false ), |
| |
| mInputEnabledCommunicationFlag( false ), |
| |
| mRequiredData( ), |
| mUselessData( ), |
| |
| mBackwardReachableMachine( ), |
| mBackwardReachableTransition( ), |
| |
| mForwardReachableMachine( ), |
| mForwardReachableTransition( ), |
| |
| isReachableStateFlag( true ) |
| { |
| updateFullyQualifiedNameID(); |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~ExecutableForm() |
| { |
| mRequiredData.clear(); |
| mUselessData.clear(); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * is in SCOPE |
| */ |
| inline bool isAncestorOf(const ExecutableForm * anExecutable) |
| { |
| while( (anExecutable != NULL) && (anExecutable != this) ) |
| { |
| anExecutable = anExecutable->getExecutableContainer(); |
| } |
| return( anExecutable == this ); |
| } |
| |
| |
| /** |
| * SETTER |
| * mFullyQualifiedNameID |
| */ |
| virtual void updateFullyQualifiedNameID( |
| const std::string & aFullyQualifiedNameID); |
| |
| inline virtual void updateFullyQualifiedNameID() |
| { |
| if( hasAstElement() ) |
| { |
| updateFullyQualifiedNameID( getAstFullyQualifiedNameID() ); |
| } |
| else |
| { |
| setAllNameID( "exec#anonym" , "exec#anonym" ); |
| } |
| } |
| |
| |
| /** |
| * LCA -LCRA |
| */ |
| const ExecutableForm * LCA( |
| const ExecutableForm * anExecutable) const; |
| |
| inline const ExecutableForm * LCRA( |
| const ExecutableForm * anExecutable) const |
| { |
| return( (this == anExecutable) ? this : LCA( anExecutable ) ); |
| } |
| |
| |
| /** |
| * GETTER |
| * Compiled ObjectElement as Compiled Machine |
| */ |
| inline const Machine * getAstMachine() const |
| { |
| return( getAstElement()->as< Machine >() ); |
| } |
| |
| inline bool isAstMachine() const |
| { |
| return( hasAstElement() && getAstElement()->is< Machine >() ); |
| } |
| |
| |
| inline const System * getAstSystem() const |
| { |
| return( getAstElement()->as< System >() ); |
| } |
| |
| inline bool isCompiledSystem() const |
| { |
| return( hasAstElement() && getAstElement()->is< System >() ); |
| } |
| |
| |
| |
| /** |
| * Primitive inlining |
| */ |
| bool isInlinableEnable() const |
| { |
| return( hasAstElement() && getAstElement()->is< Machine >() && |
| getAstMachine()->isInlinableEnable() ); |
| } |
| |
| bool isInlinableProcedure() const |
| { |
| return( hasAstElement() && getAstElement()->is< Machine >() && |
| getAstMachine()->isInlinableProcedure() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mInitialInstanceCount |
| */ |
| inline avm_size_t getInitialInstanceCount() const |
| { |
| return( mInitialInstanceCount ); |
| } |
| |
| inline bool hasInitialInstance() const |
| { |
| return( mInitialInstanceCount > 0 ); |
| } |
| |
| inline void setInitialInstanceCount(avm_size_t anInitialInstanceCount) |
| { |
| mInitialInstanceCount = anInitialInstanceCount; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mMaximalInstanceCount |
| */ |
| inline avm_size_t getMaximalInstanceCount() const |
| { |
| return( mMaximalInstanceCount ); |
| } |
| |
| inline bool hasMaximalInstance() const |
| { |
| return( mMaximalInstanceCount != AVM_NUMERIC_MAX_SIZE_T ); |
| } |
| |
| inline bool hasMaximalNewInstance() const |
| { |
| return( (mMaximalInstanceCount > mInitialInstanceCount) && |
| (mMaximalInstanceCount != AVM_NUMERIC_MAX_SIZE_T) ); |
| } |
| |
| inline void setMaximalInstanceCount(avm_size_t aMaximalInstanceCount) |
| { |
| mMaximalInstanceCount = aMaximalInstanceCount; |
| } |
| |
| |
| /** |
| * SETTER |
| * mInitialInstanceCount |
| * mMaximalInstanceCount |
| */ |
| inline void setInstanceCount(avm_size_t anInitialInstanceCount, |
| avm_size_t aMaximalInstanceCount) |
| { |
| mInitialInstanceCount = anInitialInstanceCount; |
| |
| mMaximalInstanceCount = aMaximalInstanceCount; |
| } |
| |
| inline avm_size_t getCreatedInstanceCount() const |
| { |
| return( mInitialInstanceCount ); |
| |
| // return( (mMaximalInstanceCount != AVM_NUMERIC_MAX_SIZE_T) ? |
| // mMaximalInstanceCount : mInitialInstanceCount ); |
| } |
| |
| |
| /* |
| * GETTER - SETTER |
| * mPossibleStaticInstanciationCount |
| * mPossibleDynamicInstanciationCount |
| * Single or Multiple |
| * Instanciation Information |
| * for Data Access optimisation |
| */ |
| inline avm_size_t getPossibleStaticInstanciationCount() const |
| { |
| return( mPossibleStaticInstanciationCount ); |
| } |
| |
| inline bool hasPossibleStaticInstanciation() const |
| { |
| return( mPossibleStaticInstanciationCount > 0 ); |
| } |
| |
| void incrPossibleStaticInstanciationCount(avm_offset_t offset = 1); |
| |
| |
| inline avm_size_t getPossibleDynamicInstanciationCount() const |
| { |
| return( mPossibleDynamicInstanciationCount ); |
| } |
| |
| inline bool hasPossibleDynamicInstanciation() const |
| { |
| return( mPossibleDynamicInstanciationCount > 0 ); |
| } |
| |
| void incrPossibleDynamicInstanciationCount(avm_size_t offset = 1); |
| |
| |
| bool hasSingleRuntimeInstance(); |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfChannel |
| */ |
| inline const Symbol & saveChannel(InstanceOfPort * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "InstanceOfPort !!!" |
| << SEND_EXIT; |
| |
| anInstance->setContainer(this); |
| |
| return( mTableOfChannel.save(anInstance) ); |
| } |
| |
| inline TableOfSymbol & getChannel() |
| { |
| return( mTableOfChannel ); |
| } |
| |
| inline const TableOfSymbol & getChannel() const |
| { |
| return( mTableOfChannel ); |
| } |
| |
| inline bool hasChannel() const |
| { |
| return( mTableOfChannel.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfPort |
| */ |
| inline const Symbol & savePort(InstanceOfPort * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "InstanceOfPort !!!" |
| << SEND_EXIT; |
| |
| anInstance->setContainer(this); |
| |
| return( mTableOfPort.save(anInstance) ); |
| } |
| |
| inline TableOfSymbol & getPort() |
| { |
| return( mTableOfPort ); |
| } |
| |
| inline const TableOfSymbol & getPort() const |
| { |
| return( mTableOfPort ); |
| } |
| |
| |
| inline bool hasPort() const |
| { |
| return( mTableOfPort.nonempty() ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * mMessageSignalCount |
| */ |
| inline avm_size_t getMessageSignalCount() const |
| { |
| return( mMessageSignalCount ); |
| } |
| |
| inline bool hasMessageSignalCount() const |
| { |
| return( mMessageSignalCount > 0 ); |
| } |
| |
| inline void setMessageSignalCount(avm_size_t count) |
| { |
| mMessageSignalCount = count; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfBuffer |
| */ |
| |
| inline const Symbol & saveBuffer(InstanceOfBuffer * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "BaseInstanceForm !!!" |
| << SEND_EXIT; |
| |
| anInstance->setContainer(this); |
| |
| return( mTableOfBuffer.save(anInstance) ); |
| } |
| |
| inline TableOfSymbol & getBuffer() |
| { |
| return( mTableOfBuffer ); |
| } |
| |
| inline const TableOfSymbol & getBuffer() const |
| { |
| return( mTableOfBuffer ); |
| } |
| |
| |
| inline bool hasBuffer() const |
| { |
| return( mTableOfBuffer.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfConnect |
| */ |
| |
| inline const Symbol & saveConnect(InstanceOfConnect * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "BaseInstanceForm !!!" |
| << SEND_EXIT; |
| |
| anInstance->setContainer(this); |
| |
| return( mTableOfConnect.save(anInstance) ); |
| } |
| |
| inline TableOfSymbol & getConnect() |
| { |
| return( mTableOfConnect ); |
| } |
| |
| inline const TableOfSymbol & getConnect() const |
| { |
| return( mTableOfConnect ); |
| } |
| |
| |
| inline bool hasConnect() const |
| { |
| return( mTableOfConnect.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * Communicated or Lifeline |
| */ |
| inline bool isCommunicator() const |
| { |
| return( hasPort() || hasRouter4This() || hasConnect() ); |
| } |
| |
| inline bool isCommunicatorWith(InstanceOfPort * aPort) const |
| { |
| return( mTableOfPort.contains(aPort) |
| || (hasRouter4This() && getRouter4This().hasRouting(aPort)) ); |
| } |
| |
| inline bool isLifeline() const |
| { |
| return( getSpecifier().hasFeatureLifeline() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mDefault instance for using machine model |
| */ |
| inline const Symbol & saveInstanceModel(InstanceOfMachine * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "InstanceOfMachine !!!" |
| << SEND_EXIT; |
| |
| anInstance->setContainer(this); |
| |
| return( mTableOfInstanceModel.save( anInstance ) ); |
| } |
| |
| inline void appendInstanceModel(Symbol & aMachine) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( aMachine ) |
| << "InstanceOfMachine !!!" |
| << SEND_EXIT; |
| |
| aMachine.setContainer(this); |
| |
| mTableOfInstanceModel.append( aMachine ); |
| } |
| |
| |
| inline TableOfSymbol & getInstanceModel() |
| { |
| return( mTableOfInstanceModel ); |
| } |
| |
| inline const TableOfSymbol & getInstanceModel() const |
| { |
| return( mTableOfInstanceModel ); |
| } |
| |
| inline const Symbol & getByAstInstanceModel( |
| const ObjectElement * astElement) const |
| { |
| const Symbol & aModel = |
| mTableOfInstanceModel.getByAstElement(astElement); |
| |
| // To ignore the THIS instance at offset 0 !!! |
| return( ( aModel.invalid() || aModel.isnotThis(this) ) ? |
| aModel : Symbol::REF_NULL ); |
| } |
| |
| inline bool hasInstanceModel() const |
| { |
| return( mTableOfInstanceModel.nonempty() ); |
| } |
| |
| inline bool hasInstanceModelThis() const |
| { |
| return( mTableOfInstanceModel.nonempty() && |
| mTableOfInstanceModel.first().isThis() ); |
| } |
| |
| |
| inline const Symbol & firstInstanceModel() const |
| { |
| return( hasInstanceModelThis() ? |
| mTableOfInstanceModel.second() : |
| mTableOfInstanceModel.first() ); |
| } |
| |
| inline bool hasOneInstanceModel() const |
| { |
| return( hasInstanceStaticThis() |
| && (mTableOfInstanceModel.size() == 2) ); |
| } |
| |
| inline avm_size_t sizeInstanceModel() const |
| { |
| // don't forget the instance THIS at offset 0 !!! |
| return( mTableOfInstanceModel.size() |
| - (hasInstanceStaticThis() ? 1 : 0) ); |
| } |
| |
| |
| |
| /** |
| * GETTER |
| * begin -- end |
| * iterator |
| */ |
| inline TableOfSymbol::const_iterator instance_model_begin() const |
| { |
| // don't forget the instance THIS at offset 0 !!! |
| return( hasInstanceStaticThis() ? |
| ++(mTableOfInstanceModel.begin()) : |
| mTableOfInstanceModel.begin() ); |
| } |
| |
| inline TableOfSymbol::const_iterator instance_model_end() const |
| { |
| return( mTableOfInstanceModel.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfInstanceStatic |
| */ |
| inline const Symbol & saveInstanceStatic(InstanceOfMachine * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "InstanceOfMachine !!!" |
| << SEND_EXIT; |
| |
| anInstance->setContainer(this); |
| |
| return( mTableOfInstanceStatic.save(anInstance) ); |
| } |
| |
| inline TableOfSymbol & getInstanceStatic() |
| { |
| return( mTableOfInstanceStatic ); |
| } |
| |
| inline const TableOfSymbol & getInstanceStatic() const |
| { |
| return( mTableOfInstanceStatic ); |
| } |
| |
| |
| inline const Symbol & getByAstInstanceStatic( |
| const ObjectElement * astElement) const |
| { |
| const Symbol & anInstance = |
| mTableOfInstanceStatic.getByAstElement(astElement); |
| |
| // To ignore the THIS instance at offset 0 !!! |
| return( ( anInstance.invalid() || anInstance.isnotThis(this) ) ? |
| anInstance : Symbol::REF_NULL ); |
| } |
| |
| |
| inline bool hasInstanceStatic() const |
| { |
| return( mTableOfInstanceStatic.nonempty() ); |
| } |
| |
| inline bool hasInstanceStaticThis() const |
| { |
| return( mTableOfInstanceStatic.nonempty() && |
| mTableOfInstanceStatic.first().isThis() ); |
| } |
| |
| inline const Symbol & getInstanceStaticThis() const |
| { |
| return( mTableOfInstanceStatic.first() ); |
| } |
| |
| inline const Symbol & firstInstanceStatic() const |
| { |
| return( hasInstanceStaticThis() ? |
| mTableOfInstanceStatic.second() : |
| mTableOfInstanceStatic.first() ); |
| } |
| |
| |
| inline bool hasOneInstanceStatic() const |
| { |
| return( hasInstanceStaticThis() |
| && (mTableOfInstanceStatic.size() == 2) ); |
| } |
| |
| inline avm_size_t sizeInstanceStatic() const |
| { |
| // don't forget the instance THIS at offset 0 !!! |
| return( mTableOfInstanceStatic.size() |
| - (hasInstanceStaticThis() ? 1 : 0) ); |
| } |
| |
| |
| /** |
| * GETTER |
| * begin -- end |
| * iterator |
| */ |
| inline TableOfSymbol::const_iterator instance_static_begin() const |
| { |
| // don't forget the instance THIS at offset 0 !!! |
| return( hasInstanceStaticThis() ? |
| ++(mTableOfInstanceStatic.begin()) : |
| mTableOfInstanceStatic.begin() ); |
| } |
| |
| |
| inline TableOfSymbol::const_iterator instance_static_end() const |
| { |
| return( mTableOfInstanceStatic.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * Machine Count |
| */ |
| avm_size_t getrecMachineCount() const; |
| |
| |
| /** |
| * GETTER |
| * mPrototypeInstance |
| */ |
| inline InstanceOfMachine * getPrototypeInstance() const |
| { |
| return( mPrototypeInstance ); |
| } |
| |
| inline bool hasPrototypeInstance() const |
| { |
| return( mPrototypeInstance != NULL ); |
| } |
| |
| inline void setPrototypeInstance(InstanceOfMachine * anInstance) |
| { |
| mPrototypeInstance = anInstance; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfInstanceStatic |
| * mTableOfInstanceModel |
| * mTableOfInstanceDynamic |
| */ |
| inline TableOfSymbol & getInstanceByDesign(Specifier::DESIGN_KIND aDesign) |
| { |
| switch( aDesign ) |
| { |
| case Specifier::DESIGN_INSTANCE_KIND: |
| return( mTableOfInstanceStatic ); |
| |
| case Specifier::DESIGN_MODEL_KIND: |
| return( mTableOfInstanceModel ); |
| |
| case Specifier::DESIGN_DYNAMIC_KIND: |
| return( mTableOfInstanceDynamic ); |
| |
| default: |
| { |
| AVM_OS_FATAL_ERROR_EXIT |
| << "Unexpected instance design << " |
| << Specifier::strDesign(aDesign, "") << " >> !!!" |
| << SEND_EXIT; |
| |
| return( mTableOfInstanceStatic ); |
| } |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mDefault instance for using machine model |
| */ |
| inline const Symbol & saveInstanceDynamic(InstanceOfMachine * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "InstanceOfMachine !!!" |
| << SEND_EXIT; |
| |
| anInstance->setContainer(this); |
| |
| return( mTableOfInstanceDynamic.save( anInstance ) ); |
| } |
| |
| inline void appendInstanceDynamic(Symbol & aMachine) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( aMachine ) |
| << "InstanceOfMachine !!!" |
| << SEND_EXIT; |
| |
| aMachine.setContainer(this); |
| |
| mTableOfInstanceDynamic.append( aMachine ); |
| } |
| |
| |
| inline TableOfSymbol & getInstanceDynamic() |
| { |
| return( mTableOfInstanceDynamic ); |
| } |
| |
| inline const TableOfSymbol & getInstanceDynamic() const |
| { |
| return( mTableOfInstanceDynamic ); |
| } |
| |
| inline const Symbol & getByAstInstanceDynamic( |
| const ObjectElement * astElement) const |
| { |
| return( mTableOfInstanceDynamic.getByAstElement(astElement) ); |
| } |
| |
| inline bool hasInstanceDynamic() const |
| { |
| return( mTableOfInstanceDynamic.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * begin -- end |
| * iterator |
| */ |
| inline TableOfSymbol::const_iterator instance_dynamic_begin() const |
| { |
| // don't forget the instance THIS at offset 0 !!! |
| return( mTableOfInstanceDynamic.begin() ); |
| } |
| |
| inline TableOfSymbol::const_iterator instance_dynamic_end() const |
| { |
| return( mTableOfInstanceDynamic.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfTransition |
| */ |
| inline const BF & saveTransition(AvmTransition * aTransition) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aTransition ) |
| << "AvmTransition !!!" |
| << SEND_EXIT; |
| |
| aTransition->setContainer(this); |
| aTransition->setOffset( mTableOfTransition.size() ); |
| |
| return( mTableOfTransition.save(aTransition) ); |
| } |
| |
| inline TableOfTransition & getTransition() |
| { |
| return( mTableOfTransition ); |
| } |
| |
| inline const TableOfTransition & getTransition() const |
| { |
| return( mTableOfTransition ); |
| } |
| |
| inline AvmTransition * rawTransition(avm_offset_t offset) const |
| { |
| return( mTableOfTransition.rawAt(offset) ); |
| } |
| |
| |
| inline const BF & getTransition( |
| const std::string & aFullyQualifiedNameID) const |
| { |
| return( mTableOfTransition.getByFQNameID( aFullyQualifiedNameID ) ); |
| } |
| |
| inline const BF & getTransitionByNameID(const std::string & aNameID) const |
| { |
| return( mTableOfTransition.getByNameID( aNameID ) ); |
| } |
| |
| inline const BF & getTransitionByQualifiedNameID( |
| const std::string & aQualifiedNameID) const |
| { |
| return( mTableOfTransition.getByQualifiedNameID( aQualifiedNameID ) ); |
| } |
| |
| |
| inline const BF & getTransitionByAstElement( |
| const ObjectElement * astElement) const |
| { |
| return( mTableOfTransition.getByAstElement(astElement) ); |
| } |
| |
| |
| inline bool hasTransition() const |
| { |
| return( mTableOfTransition.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfProgram |
| */ |
| inline void appendProgram(const BF & anAvmProgram) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( anAvmProgram ) |
| << "AvmProgram !!!" |
| << SEND_EXIT; |
| |
| anAvmProgram.to_ptr< AvmProgram >()->setContainer(this); |
| anAvmProgram.to_ptr< AvmProgram >()->setOffset( mTableOfProgram.size() ); |
| |
| mTableOfProgram.append(anAvmProgram); |
| } |
| |
| inline const BF & saveProgram(AvmProgram * anAvmProgram) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anAvmProgram ) |
| << "AvmProgram !!!" |
| << SEND_EXIT; |
| |
| anAvmProgram->setContainer(this); |
| anAvmProgram->setOffset( mTableOfProgram.size() ); |
| |
| return( mTableOfProgram.save(anAvmProgram) ); |
| } |
| |
| inline TableOfAvmProgram & getProgram() |
| { |
| return( mTableOfProgram ); |
| } |
| |
| inline const TableOfAvmProgram & getProgram() const |
| { |
| return( mTableOfProgram ); |
| } |
| |
| inline AvmProgram * rawProgram(avm_offset_t offset) const |
| { |
| return( mTableOfProgram.rawAt(offset) ); |
| } |
| |
| |
| inline const BF & getProgram(const std::string & aFullyQualifiedNameID, |
| Specifier::SCOPE_KIND aScope = |
| Specifier::SCOPE_UNDEFINED_KIND) const |
| { |
| return( mTableOfProgram.getByFQNameID(aFullyQualifiedNameID, aScope) ); |
| } |
| |
| inline const BF & getProgramByNameID(const std::string & id, |
| Specifier::SCOPE_KIND aScope = |
| Specifier::SCOPE_UNDEFINED_KIND) const |
| { |
| return( mTableOfProgram.getByNameID(id, aScope) ); |
| } |
| |
| inline const BF & getProgramByQualifiedNameID( |
| const std::string & aQualifiedNameID, |
| Specifier::SCOPE_KIND aScope = |
| Specifier::SCOPE_UNDEFINED_KIND) const |
| { |
| return( mTableOfProgram. |
| getByQualifiedNameID(aQualifiedNameID, aScope) ); |
| } |
| |
| |
| inline const BF & getProgramByAstElement( |
| const ObjectElement * astElement) const |
| { |
| return( mTableOfProgram.getByAstElement(astElement) ); |
| } |
| |
| inline bool hasProgram() const |
| { |
| return( mTableOfProgram.nonempty() ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfAnonymousInnerRoutine |
| * like << variable::on_write >> or << type::constraint >> routines |
| */ |
| inline const BF & saveAnonymousInnerRoutine(AvmProgram * aRoutine) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aRoutine ) |
| << "Anonymous Inner Routine as Program !!!" |
| << SEND_EXIT; |
| |
| aRoutine->setContainer(this); |
| aRoutine->setOffset( mTableOfAnonymousInnerRoutine.size() ); |
| |
| return( mTableOfAnonymousInnerRoutine.save(aRoutine) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfExecutable |
| */ |
| inline const BF & saveExecutable(ExecutableForm * anExecutable) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anExecutable ) |
| << "ExecutableForm !!!" |
| << SEND_EXIT; |
| |
| anExecutable->setContainer(this); |
| anExecutable->setOffset( mTableOfExecutable.size() ); |
| |
| return( mTableOfExecutable.save(anExecutable) ); |
| } |
| |
| inline const TableOfExecutableForm & getExecutables() const |
| { |
| return( mTableOfExecutable ); |
| } |
| |
| inline bool hasExecutable() const |
| { |
| return( mTableOfExecutable.nonempty() ); |
| } |
| |
| |
| /* |
| * contains DATA |
| */ |
| inline bool containsData(InstanceOfData * anInstance) const |
| { |
| return( AvmProgram::containsData(anInstance) /*|| |
| mTableOfAlias.contains(anInstance)*/ ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfAlias |
| */ |
| inline void appendAlias(const Symbol & anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( anInstance ) |
| << "InstanceOfData !!!" |
| << SEND_EXIT; |
| |
| mTableOfAlias.append(anInstance); |
| } |
| |
| inline const Symbol & saveAlias(BaseInstanceForm * anInstance) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance ) |
| << "InstanceOfData !!!" |
| << SEND_EXIT; |
| |
| return( mTableOfAlias.save(anInstance) ); |
| } |
| |
| inline TableOfSymbol & getAlias() |
| { |
| return( mTableOfAlias ); |
| } |
| |
| inline const TableOfSymbol & getAlias() const |
| { |
| return( mTableOfAlias ); |
| } |
| |
| |
| inline bool hasAlias() const |
| { |
| return( mTableOfAlias.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * any SYMBOL filtering by an optional type specifier family |
| */ |
| virtual const BF & getSymbol( |
| const std::string & aFullyQualifiedNameID, |
| avm_type_specifier_kind_t typeFamily) const; |
| |
| virtual const BF & getSymbolByQualifiedNameID( |
| const std::string & aQualifiedNameID, |
| avm_type_specifier_kind_t typeFamily) const; |
| |
| virtual const BF & getSymbolByNameID(const std::string & aNameID, |
| avm_type_specifier_kind_t typeFamily) const; |
| |
| virtual const BF & getSymbolByAstElement(const ObjectElement * astElement, |
| avm_type_specifier_kind_t typeFamily) const; |
| |
| |
| /** |
| * GETTER - SETTER |
| * onCreateRoutine |
| */ |
| inline AvmProgram & getOnCreateRoutine() |
| { |
| return( onCreateRoutine ); |
| } |
| |
| inline BFCode & getOnCreate() |
| { |
| return( onCreateRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnCreate() const |
| { |
| return( onCreateRoutine.getCode() ); |
| } |
| |
| inline bool hasOnCreate() const |
| { |
| return( onCreateRoutine.hasCode() ); |
| } |
| |
| inline void setOnCreate(const BFCode & aProgram) |
| { |
| onCreateRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onInitRoutine |
| */ |
| inline AvmProgram & getOnInitRoutine() |
| { |
| return( onInitRoutine ); |
| } |
| |
| inline BFCode & getOnInit() |
| { |
| return( onInitRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnInit() const |
| { |
| return( onInitRoutine.getCode() ); |
| } |
| |
| inline bool hasOnInit() const |
| { |
| return( onInitRoutine.hasCode() ); |
| } |
| |
| inline void setOnInit(const BFCode & aProgram) |
| { |
| onInitRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onFinalRoutine |
| */ |
| inline AvmProgram & getOnFinalRoutine() |
| { |
| return( onFinalRoutine ); |
| } |
| |
| inline BFCode & getOnFinal() |
| { |
| return( onFinalRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnFinal() const |
| { |
| return( onFinalRoutine.getCode() ); |
| } |
| |
| inline bool hasOnFinal() const |
| { |
| return( onFinalRoutine.hasCode() ); |
| } |
| |
| inline void setOnFinal(const BFCode & aProgram) |
| { |
| onFinalRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onReturnRoutine |
| */ |
| inline AvmProgram & getOnReturnRoutine() |
| { |
| return( onReturnRoutine ); |
| } |
| |
| inline BFCode & getOnReturn() |
| { |
| return( onReturnRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnReturn() const |
| { |
| return( onReturnRoutine.getCode() ); |
| } |
| |
| inline bool hasOnReturn() const |
| { |
| return( onReturnRoutine.hasCode() ); |
| } |
| |
| inline void setOnReturn(const BFCode & aProgram) |
| { |
| onReturnRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onStartRoutine |
| */ |
| inline AvmProgram & getOnStartRoutine() |
| { |
| return( onStartRoutine ); |
| } |
| |
| inline BFCode & getOnStart() |
| { |
| return( onStartRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnStart() const |
| { |
| return( onStartRoutine.getCode() ); |
| } |
| |
| inline bool hasOnStart() const |
| { |
| return( onStartRoutine.hasCode() ); |
| } |
| |
| inline void setOnStart(const BFCode & aProgram) |
| { |
| onStartRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onStopRoutine |
| */ |
| inline AvmProgram & getOnStopRoutine() |
| { |
| return( onStopRoutine ); |
| } |
| |
| inline BFCode & getOnStop() |
| { |
| return( onStopRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnStop() const |
| { |
| return( onStopRoutine.getCode() ); |
| } |
| |
| inline bool hasOnStop() const |
| { |
| return( onStopRoutine.hasCode() ); |
| } |
| |
| inline void setOnStop(const BFCode & aProgram) |
| { |
| onStopRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onIEnableRoutine |
| */ |
| inline AvmProgram & getOnIEnableRoutine() |
| { |
| return( onIEnableRoutine ); |
| } |
| |
| inline BFCode & getOnIEnable() |
| { |
| return( onIEnableRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnIEnable() const |
| { |
| return( onIEnableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIEnable() const |
| { |
| return( onIEnableRoutine.hasCode() ); |
| } |
| |
| inline void setOnIEnable(const BFCode & aProgram) |
| { |
| onIEnableRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onEnableRoutine |
| */ |
| inline AvmProgram & getOnEnableRoutine() |
| { |
| return( onEnableRoutine ); |
| } |
| |
| inline BFCode & getOnEnable() |
| { |
| return( onEnableRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnEnable() const |
| { |
| return( onEnableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnEnable() const |
| { |
| return( onEnableRoutine.hasCode() ); |
| } |
| |
| inline void setOnEnable(const BFCode & aProgram) |
| { |
| onEnableRoutine.setCode( aProgram ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * onIDisableRoutine |
| */ |
| inline AvmProgram & getOnIDisableRoutine() |
| { |
| return( onIDisableRoutine ); |
| } |
| |
| inline BFCode & getOnIDisable() |
| { |
| return( onIDisableRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnIDisable() const |
| { |
| return( onIDisableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIDisable() const |
| { |
| return( onIDisableRoutine.hasCode() ); |
| } |
| |
| inline void setOnIDisable(const BFCode & aProgram) |
| { |
| onIDisableRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onDisableRoutine |
| */ |
| inline AvmProgram & getOnDisableRoutine() |
| { |
| return( onDisableRoutine ); |
| } |
| |
| inline BFCode & getOnDisable() |
| { |
| return( onDisableRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnDisable() const |
| { |
| return( onDisableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnDisable() const |
| { |
| return( onDisableRoutine.hasCode() ); |
| } |
| |
| inline void setOnDisable(const BFCode & aProgram) |
| { |
| onDisableRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onIAbortRoutine |
| */ |
| inline AvmProgram & getOnIAbortRoutine() |
| { |
| return( onIAbortRoutine ); |
| } |
| |
| inline BFCode & getOnIAbort() |
| { |
| return( onIAbortRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnIAbort() const |
| { |
| return( onIAbortRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIAbort() const |
| { |
| return( onIAbortRoutine.hasCode() ); |
| } |
| |
| inline void setOnIAbort(const BFCode & aProgram) |
| { |
| onIAbortRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onAbortRoutine |
| */ |
| inline AvmProgram & getOnAbortRoutine() |
| { |
| return( onAbortRoutine ); |
| } |
| |
| inline BFCode & getOnAbort() |
| { |
| return( onAbortRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnAbort() const |
| { |
| return( onAbortRoutine.getCode() ); |
| } |
| |
| inline bool hasOnAbort() const |
| { |
| return( onAbortRoutine.hasCode() ); |
| } |
| |
| inline void setOnAbort(const BFCode & aProgram) |
| { |
| onAbortRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onIRunRoutine |
| */ |
| inline AvmProgram & getOnIRunRoutine() |
| { |
| return( onIRunRoutine ); |
| } |
| |
| inline BFCode & getOnIRun() |
| { |
| return( onIRunRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnIRun() const |
| { |
| return( onIRunRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIRun() const |
| { |
| return( onIRunRoutine.hasCode() ); |
| } |
| |
| inline void setOnIRun(const BFCode & aProgram) |
| { |
| onIRunRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onRunRoutine |
| */ |
| inline AvmProgram & getOnRunRoutine() |
| { |
| return( onRunRoutine ); |
| } |
| |
| inline BFCode & getOnRun() |
| { |
| return( onRunRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnRun() const |
| { |
| return( onRunRoutine.getCode() ); |
| } |
| |
| inline bool hasOnRun() const |
| { |
| return( onRunRoutine.hasCode() ); |
| } |
| |
| inline void setOnRun(const BFCode & aProgram) |
| { |
| onRunRoutine.setCode( aProgram ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * onRtcRoutine |
| */ |
| inline AvmProgram & getOnRtcRoutine() |
| { |
| return( onRtcRoutine ); |
| } |
| |
| inline BFCode & getOnRtc() |
| { |
| return( onRtcRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnRtc() const |
| { |
| return( onRtcRoutine.getCode() ); |
| } |
| |
| inline bool hasOnRtc() const |
| { |
| return( onRtcRoutine.hasCode() ); |
| } |
| |
| inline void setOnRtc(const BFCode & aProgram) |
| { |
| onRtcRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mSchedule |
| */ |
| inline AvmProgram & getOnScheduleRoutine() |
| { |
| return( onScheduleRoutine ); |
| } |
| |
| inline BFCode & getOnSchedule() |
| { |
| return( onScheduleRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnSchedule() const |
| { |
| return( onScheduleRoutine.getCode() ); |
| } |
| |
| inline bool hasOnSchedule() const |
| { |
| return( onScheduleRoutine.hasCode() ); |
| } |
| |
| inline void setOnSchedule(const BFCode & aProgram) |
| { |
| onScheduleRoutine.setCode( aProgram ); |
| } |
| |
| inline bool hasUserRunningCode() const |
| { |
| return( hasOnRun() || hasOnRtc() || hasOnSchedule() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mInitRoutine |
| * mEnableRoutine |
| * mRunRoutine |
| */ |
| inline bool hasInitOrRun() const |
| { |
| return( hasOnInit() || hasOnRun() ); |
| } |
| |
| inline bool hasOnInitOrEnableOrRun() const |
| { |
| return( hasOnInit() || hasOnEnable() || hasOnRun() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * on activity by opcode |
| */ |
| AvmProgram & getOnActivityRoutine(AVM_OPCODE opCode); |
| |
| const BFCode & getOnActivity(AVM_OPCODE opCode) const; |
| |
| |
| /** |
| * GETTER - SETTER |
| * mComponentFlag |
| * Structural decompositon |
| */ |
| bool isMainComponent() const |
| { |
| return( mMainComponentFlag ); |
| } |
| |
| void setMainComponent(bool isMainComponent = true) |
| { |
| mMainComponentFlag = isMainComponent; |
| } |
| |
| bool isCompositeComponent() const |
| { |
| return( hasOnConcurrency() ); |
| } |
| |
| |
| |
| /** |
| * GETTER - SETTER |
| * mMutableScheduleFlag |
| * MOC Attribute for mutable Schedule |
| */ |
| bool isMutableSchedule() const |
| { |
| return( mMutableScheduleFlag ); |
| } |
| |
| void setMutableSchedule(bool isMutableSchedule = true) |
| { |
| mMutableScheduleFlag = isMutableSchedule; |
| } |
| |
| bool isInlinableSchedule() const; |
| |
| |
| /** |
| * GETTER - SETTER |
| * mConcurrency |
| */ |
| inline AvmProgram & getOnConcurrencyRoutine() |
| { |
| return( onConcurrencyRoutine ); |
| } |
| |
| inline BFCode & getOnConcurrency() |
| { |
| return( onConcurrencyRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnConcurrency() const |
| { |
| return( onConcurrencyRoutine.getCode() ); |
| } |
| |
| inline bool hasOnConcurrency() const |
| { |
| return( onConcurrencyRoutine.hasCode() ); |
| } |
| |
| inline void setOnConcurrency(const BFCode & aProgram) |
| { |
| onConcurrencyRoutine.setCode( aProgram ); |
| } |
| |
| inline Operator * getOnConcurrencyOperator() const |
| { |
| AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( |
| onConcurrencyRoutine.getCode() ) |
| << " Concurrency Operator for " |
| << str_header( this ) << " !!!" |
| << SEND_EXIT; |
| |
| return( onConcurrencyRoutine.getCode()->getOperator() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mSynchronize |
| */ |
| inline AvmProgram & getOnSynchronizeRoutine() |
| { |
| return( onSynchronizeRoutine ); |
| } |
| |
| inline BFCode & getOnSynchronize() |
| { |
| return( onSynchronizeRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnSynchronize() const |
| { |
| return( onSynchronizeRoutine.getCode() ); |
| } |
| |
| inline bool hasOnSynchronize() const |
| { |
| return( onSynchronizeRoutine.hasCode() ); |
| } |
| |
| inline void setOnSynchronize(const BFCode & aProgram) |
| { |
| onSynchronizeRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER |
| * the Schedulability property |
| */ |
| inline bool isSchedulable() const |
| { |
| return( hasOnInit() && hasOnRun() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfRouter4Instance |
| */ |
| inline TableOfRouter & getRouters4Instance() |
| { |
| return( mTableOfRouter4Instance ); |
| } |
| |
| inline const TableOfRouter & getRouters4Instance() const |
| { |
| return( mTableOfRouter4Instance ); |
| } |
| |
| inline bool hasRouter4Instance() const |
| { |
| return( mTableOfRouter4Instance.nonempty() ); |
| } |
| |
| inline void setRouters4Instance(const TableOfRouter & aRouterTable) |
| { |
| mTableOfRouter4Instance = aRouterTable; |
| } |
| |
| |
| inline void appendRouter4Instance(const Router & aRouter) |
| { |
| mTableOfRouter4Instance.append( aRouter ); |
| } |
| |
| |
| inline Router & getRouter4Instance(avm_size_t offset) |
| { |
| AVM_OS_ASSERT_FATAL_ARRAY_INDEX_EXIT( |
| offset , mTableOfRouter4Instance.size() ) |
| << SEND_EXIT; |
| |
| |
| return( mTableOfRouter4Instance.get(offset) ); |
| } |
| |
| inline const Router & getRouter4Instance(avm_size_t offset) const |
| { |
| AVM_OS_ASSERT_FATAL_ARRAY_INDEX_EXIT( |
| offset , mTableOfRouter4Instance.size() ) |
| << SEND_EXIT; |
| |
| |
| return( mTableOfRouter4Instance.get(offset) ); |
| } |
| |
| |
| inline Router & getRouter4This() |
| { |
| AVM_OS_ASSERT_FATAL_EMPTY_COLLECTION_EXIT( mTableOfRouter4Instance ) |
| << "Table of Router for Instance !!!" |
| << SEND_EXIT; |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( hasInstanceStaticThis() ) |
| << "Unexpected an executable without machine< this > !!!" |
| << SEND_EXIT; |
| |
| return( mTableOfRouter4Instance.get( |
| getInstanceStaticThis().getOffset() ) ); |
| } |
| |
| inline const Router & getRouter4This() const |
| { |
| AVM_OS_ASSERT_FATAL_EMPTY_COLLECTION_EXIT( mTableOfRouter4Instance ) |
| << "Table of Router for Instance !!!" |
| << SEND_EXIT; |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( hasInstanceStaticThis() ) |
| << "Unexpected an executable without machine< this > !!!" |
| << SEND_EXIT; |
| |
| return( mTableOfRouter4Instance.get( |
| getInstanceStaticThis().getOffset() ) ); |
| } |
| |
| |
| inline bool hasRouter4This() const |
| { |
| return( mTableOfRouter4Instance.nonempty() |
| && hasInstanceStaticThis() |
| && mTableOfRouter4Instance.get( |
| getInstanceStaticThis().getOffset() ).valid() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mRouterTable4Prototype |
| */ |
| inline const Router & getRouter4Prototype(ExecutableForm * aModel) const |
| { |
| if( mTableOfRouter4Instance.nonempty() ) |
| { |
| TableOfRouter::const_iterator it = mTableOfRouter4Instance.begin(); |
| TableOfRouter::const_iterator endIt = mTableOfRouter4Instance.end(); |
| |
| for( ; it != endIt ; ++it ) |
| { |
| if( (*it).valid() |
| && ((*it).getMachine()->getExecutable() == aModel) |
| && (*it).getMachine()-> |
| getSpecifier().isDesignPrototypeStatic() ) |
| { |
| return( *it ); |
| } |
| } |
| } |
| |
| return( Router::_NULL_ ); |
| } |
| |
| inline const Router & getRouter4Prototype(InstanceOfMachine * aMachine) const |
| { |
| return( getRouter4Prototype(aMachine->getExecutable()) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfRouter4Model |
| */ |
| inline TableOfRouter & getRouters4Model() |
| { |
| return( mTableOfRouter4Model ); |
| } |
| |
| inline const TableOfRouter & getRouters4Model() const |
| { |
| return( mTableOfRouter4Model ); |
| } |
| |
| inline bool hasRouter4Model() const |
| { |
| return( mTableOfRouter4Model.nonempty() ); |
| } |
| |
| inline void setRouters4Model(const TableOfRouter & aRouterTable) |
| { |
| mTableOfRouter4Model = aRouterTable; |
| } |
| |
| |
| inline void appendRouter4Model(const Router & aRouter) |
| { |
| mTableOfRouter4Model.append( aRouter ); |
| } |
| |
| |
| inline Router & getRouter4Model(avm_size_t offset) |
| { |
| AVM_OS_ASSERT_FATAL_ARRAY_INDEX_EXIT( |
| offset , mTableOfRouter4Model.size() ) |
| << SEND_EXIT; |
| |
| return( mTableOfRouter4Model.get(offset) ); |
| } |
| |
| inline const Router & getRouter4Model(avm_size_t offset) const |
| { |
| AVM_OS_ASSERT_FATAL_ARRAY_INDEX_EXIT( |
| offset , mTableOfRouter4Model.size() ) |
| << SEND_EXIT; |
| |
| return( mTableOfRouter4Model.get(offset) ); |
| } |
| |
| |
| inline const Router & getRouter4Model(const ExecutableForm * aModel) const |
| { |
| if( mTableOfRouter4Model.nonempty() ) |
| { |
| TableOfRouter::const_iterator it = mTableOfRouter4Model.begin(); |
| TableOfRouter::const_iterator endIt = mTableOfRouter4Model.end(); |
| |
| for( ; it != endIt ; ++it ) |
| { |
| if( (*it).valid() |
| && ((*it).getMachine()->getExecutable() == aModel) ) |
| { |
| return( *it ); |
| } |
| } |
| } |
| |
| return( Router::_NULL_ ); |
| } |
| |
| inline const Router & getRouter4Model( |
| const InstanceOfMachine * aMachine) const |
| { |
| return( getRouter4Model(aMachine->getExecutable()) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mRdvCommunicationFlag |
| */ |
| inline bool hasRdvCommunication() const |
| { |
| return( mRdvCommunicationFlag ); |
| } |
| |
| void setRdvCommunication(bool aFlag = true) |
| { |
| mRdvCommunicationFlag = aFlag; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mInputEnabledCommunicationFlag |
| * MOC Attribute for Communication |
| */ |
| bool isInputEnabledCommunication() const |
| { |
| return( mInputEnabledCommunicationFlag ); |
| } |
| |
| void setInputEnabledCommunication(bool isInputEnabled = true) |
| { |
| mInputEnabledCommunicationFlag = isInputEnabled; |
| } |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////// |
| // STATIC ANALYSIS ATTRIBUTE |
| //////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * mRequiredData |
| */ |
| inline TableOfInstanceOfData & getRequiredData() |
| { |
| return( mRequiredData ); |
| } |
| |
| inline const TableOfInstanceOfData & getRequiredData() const |
| { |
| return( mRequiredData ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mUselessData |
| */ |
| inline TableOfInstanceOfData & getUselessData() |
| { |
| return( mUselessData ); |
| } |
| |
| inline const TableOfInstanceOfData & getUselessData() const |
| { |
| return( mUselessData ); |
| } |
| |
| |
| /** |
| * Control flow analysis |
| * source & targets Executable< [state]machine > for Transition |
| */ |
| inline void getOutgoingMachine(ListOfInstanceOfMachine & listOfMachine) |
| { |
| for( avm_size_t offset = 0 ; offset < getTransition().size() ; ++offset ) |
| { |
| getTransition().rawAt(offset)->getTransitionTarget( listOfMachine ); |
| } |
| } |
| |
| inline void getOutgoingTransition(ListOfAvmTransition & listOfTransition) |
| { |
| AvmTransition * aTransition; |
| |
| for( avm_size_t offset = 0 ; offset < getTransition().size() ; ++offset ) |
| { |
| aTransition = getTransition().rawAt(offset); |
| |
| listOfTransition.append( aTransition ); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mListOfBackwardReachableMachine |
| */ |
| inline void addBackwardReachableMachine(InstanceOfMachine * aMachine) |
| { |
| mBackwardReachableMachine.add_union( aMachine ); |
| } |
| |
| inline void addBackwardReachableMachine( |
| ListOfInstanceOfMachine & reachableMachines) |
| { |
| mBackwardReachableMachine.add_union( reachableMachines ); |
| } |
| |
| |
| inline ListOfInstanceOfMachine & getBackwardReachableMachine() |
| { |
| return( mBackwardReachableMachine ); |
| } |
| |
| inline const ListOfInstanceOfMachine & getBackwardReachableMachine() const |
| { |
| return( mBackwardReachableMachine ); |
| } |
| |
| |
| bool containsBackwardReachableMachine(InstanceOfMachine * aMachine) const |
| { |
| return( mBackwardReachableMachine.contains(aMachine) ); |
| } |
| |
| inline bool hasBackwardReachableMachine() const |
| { |
| return( mBackwardReachableMachine.nonempty() ); |
| } |
| |
| |
| inline void removeBackwardReachableMachine(InstanceOfMachine * aMachine) |
| { |
| if( mBackwardReachableMachine.nonempty() ) |
| { |
| mBackwardReachableMachine.remove( aMachine ); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mListOfBackwardReachableMachine |
| */ |
| inline void addBackwardReachableTransition(AvmTransition * aTransition) |
| { |
| mBackwardReachableTransition.add_union( aTransition ); |
| } |
| |
| inline void addBackwardReachableTransition( |
| ListOfAvmTransition & reachableTransitions) |
| { |
| mBackwardReachableTransition.add_union( reachableTransitions ); |
| } |
| |
| |
| inline ListOfAvmTransition & getBackwardReachableTransition() |
| { |
| return( mBackwardReachableTransition ); |
| } |
| |
| inline const ListOfAvmTransition & getBackwardReachableTransition() const |
| { |
| return( mBackwardReachableTransition ); |
| } |
| |
| |
| bool containsBackwardReachableTransition(AvmTransition * aTransition) const |
| { |
| return( mBackwardReachableTransition.contains(aTransition) ); |
| } |
| |
| inline bool hasBackwardReachableTransition() const |
| { |
| return( mBackwardReachableTransition.nonempty() ); |
| } |
| |
| |
| inline void removeBackwardReachableTransition(AvmTransition * aTransition) |
| { |
| if( mBackwardReachableTransition.nonempty() ) |
| { |
| mBackwardReachableTransition.remove( aTransition ); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mListOfForwardReachableMachine |
| */ |
| inline void addForwardReachableMachine(InstanceOfMachine * aMachine) |
| { |
| mForwardReachableMachine.add_union( aMachine ); |
| } |
| |
| inline void addForwardReachableMachine( |
| ListOfInstanceOfMachine & reachableMachines) |
| { |
| mForwardReachableMachine.add_union( reachableMachines ); |
| } |
| |
| |
| inline ListOfInstanceOfMachine & getForwardReachableMachine() |
| { |
| return( mForwardReachableMachine ); |
| } |
| |
| inline const ListOfInstanceOfMachine & getForwardReachableMachine() const |
| { |
| return( mForwardReachableMachine ); |
| } |
| |
| |
| bool containsForwardReachableMachine(InstanceOfMachine * aMachine) const |
| { |
| return( mForwardReachableMachine.contains(aMachine) ); |
| } |
| |
| inline bool hasForwardReachableMachine() const |
| { |
| return( mForwardReachableMachine.nonempty() ); |
| } |
| |
| |
| inline void removeForwardReachableMachine(InstanceOfMachine * aMachine) |
| { |
| if( mForwardReachableMachine.nonempty() ) |
| { |
| mForwardReachableMachine.remove( aMachine ); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mListOfForwardReachableMachine |
| */ |
| inline void addForwardReachableTransition(AvmTransition * aTransition) |
| { |
| mForwardReachableTransition.add_union( aTransition ); |
| } |
| |
| inline void addForwardReachableTransition( |
| ListOfAvmTransition & reachableTransitions) |
| { |
| mForwardReachableTransition.add_union( reachableTransitions ); |
| } |
| |
| |
| inline ListOfAvmTransition & getForwardReachableTransition() |
| { |
| return( mForwardReachableTransition ); |
| } |
| |
| inline const ListOfAvmTransition & getForwardReachableTransition() const |
| { |
| return( mForwardReachableTransition ); |
| } |
| |
| |
| bool containsForwardReachableTransition(AvmTransition * aTransition) const |
| { |
| return( mForwardReachableTransition.contains(aTransition) ); |
| } |
| |
| inline bool hasForwardReachableTransition() const |
| { |
| return( mForwardReachableTransition.nonempty() ); |
| } |
| |
| |
| inline void removeForwardReachableTransition(AvmTransition * aTransition) |
| { |
| if( mForwardReachableTransition.nonempty() ) |
| { |
| mForwardReachableTransition.remove( aTransition ); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * isReachableStateFlag |
| */ |
| bool isReachableState() |
| { |
| return( isReachableStateFlag ); |
| } |
| |
| void setReachableState(bool aReachableStateFlag) |
| { |
| isReachableStateFlag = aReachableStateFlag; |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| void header(OutStream & os) const; |
| |
| void strHeader(OutStream & os) const; |
| |
| static void toStream(OutStream & os, const TableOfRouter & aTableOfRouter, |
| const std::string & sectionName = "router:"); |
| |
| void toStream(OutStream & os) const; |
| |
| }; |
| |
| |
| } |
| |
| #endif /*EXECUTABLEFORM_H_*/ |
