| /******************************************************************************* |
| * 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: 7 déc. 2011 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #ifndef ROUTINE_H_ |
| #define ROUTINE_H_ |
| |
| #include <fml/common/BehavioralElement.h> |
| #include <fml/common/SpecifierElement.h> |
| |
| #include <collection/BFContainer.h> |
| |
| #include <fml/expression/AvmCode.h> |
| #include <fml/expression/StatementConstructor.h> |
| #include <fml/expression/StatementTypeChecker.h> |
| |
| #include <fml/operator/Operator.h> |
| |
| |
| namespace sep |
| { |
| |
| class BehavioralPart; |
| |
| class Machine; |
| |
| class ObjectElement; |
| |
| class Variable; |
| |
| |
| class Routine : |
| public BehavioralElement, |
| public SpecifierImpl, |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( Routine ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( Routine ) |
| |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| BF mModel; |
| |
| BFVector mParameters; |
| |
| BFVector mReturns; |
| |
| BFCode mCode; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| Routine(Machine * aContainer, const std::string & aNameID, |
| const Modifier & aModifier, const Specifier & aSpecifier, |
| const BF & aModel = BF::REF_NULL); |
| |
| |
| Routine(BehavioralElement * aContainer, const std::string & aNameID, |
| const Specifier & aSpecifier = |
| Specifier::DESIGN_PROTOTYPE_STATIC_SPECIFIER, |
| const BF & aModel = BF::REF_NULL) |
| : BehavioralElement( CLASS_KIND_T( Routine ), aContainer, aNameID ), |
| SpecifierImpl( aSpecifier ), |
| |
| mModel( aModel ), |
| |
| mParameters( ), |
| mReturns( ), |
| mCode( ) |
| { |
| //!! NOTHING |
| } |
| |
| Routine(const BehavioralPart & aBehavioralPart, |
| const std::string & aNameID, |
| const Specifier & aSpecifier = |
| Specifier::DESIGN_PROTOTYPE_STATIC_SPECIFIER); |
| |
| |
| public: |
| inline static Routine * newDefine( |
| Machine * aContainer, Modifier aModifier, |
| Specifier aSpecifier, const std::string & aNameID) |
| { |
| |
| return( new Routine(aContainer, aNameID, aModifier, |
| aSpecifier.setDesignModel()) ); |
| } |
| |
| static Routine * newDefine( |
| Machine * aContainer, const std::string & aNameID); |
| |
| inline static Routine * newDefine( |
| const BehavioralPart & aBehavioralPart, |
| const std::string & aNameID) |
| { |
| |
| return( new Routine(aBehavioralPart, aNameID, |
| Specifier::DESIGN_MODEL_SPECIFIER) ); |
| } |
| |
| inline static Routine * newInvoke( |
| BehavioralElement * aContainer, const std::string & aNameID) |
| { |
| return( new Routine(aContainer, aNameID, |
| Specifier::DESIGN_INSTANCE_DYNAMIC_SPECIFIER) ); |
| } |
| |
| static Routine * newInvoke(Machine * aContainer, const BF & aModel); |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~Routine() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * the Type Specifier |
| */ |
| inline const BF & getType() const |
| { |
| return( mModel ); |
| } |
| |
| // inline bool hasType() const |
| // { |
| // return( mModel.valid() ); |
| // } |
| // |
| // inline void setType(const BF & aType) |
| // { |
| // mModel = aType; |
| // } |
| // |
| |
| /** |
| * GETTER - SETTER |
| * mModel as Routine Model |
| */ |
| inline Routine * getModel() const |
| { |
| return( mModel.as_ptr< Routine >() ); |
| } |
| |
| inline bool hasModel() const |
| { |
| return( mModel.is< Routine >() ); |
| } |
| |
| inline void setModel(const BF & aModel) |
| { |
| mModel = aModel; |
| |
| if( aModel.is< Routine >() ) |
| { |
| BehavioralElement::setNameID( |
| aModel.to_ptr< Routine >()->getNameID() ); |
| } |
| else |
| { |
| BehavioralElement::setNameID( aModel.str() ); |
| } |
| } |
| |
| // Model as Invokable Operator |
| inline Operator * getModelOperator() const |
| { |
| return( mModel.as_ptr< Operator >() ); |
| } |
| |
| inline bool hasModelOperator() const |
| { |
| return( mModel.is< Operator >() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mCode |
| */ |
| inline BFCode & getCode() |
| { |
| return( mCode ); |
| } |
| |
| inline const BFCode & getCode() const |
| { |
| return( mCode ); |
| } |
| |
| inline bool hasCode() const |
| { |
| return( mCode.valid() ); |
| } |
| |
| inline bool doSomething() const |
| { |
| return( mCode.valid() && StatementTypeChecker::doSomething(mCode) ); |
| } |
| |
| inline void setCode(const BFCode & aCode) |
| { |
| mCode = aCode; |
| } |
| |
| inline void seqCode(const BFCode & aCode) |
| { |
| if( mCode.valid() ) |
| { |
| mCode = StatementConstructor::newCodeFlat( |
| OperatorManager::OPERATOR_SEQUENCE, mCode, aCode); |
| } |
| else |
| { |
| mCode = aCode; |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mParameters |
| */ |
| inline BFVector & getParameters() |
| { |
| return( mParameters ); |
| } |
| |
| inline const BF & getParameter(avm_offset_t offset) const |
| { |
| return( mParameters[offset] ); |
| } |
| |
| inline const BF & getParameter(const std::string & aNameID) const |
| { |
| return( getByNameID(mParameters, aNameID) ); |
| } |
| |
| avm_offset_t getParameterOffset(const std::string & label) const |
| { |
| return( getOffsetByNameID(mParameters, label) ); |
| } |
| |
| |
| inline bool hasParameters() const |
| { |
| return( mParameters.nonempty() ); |
| } |
| |
| bool hasParameterOffset(Variable * aParameter) const; |
| |
| |
| inline void appendParameter(const BF & anInput) |
| { |
| mParameters.append( anInput ); |
| } |
| |
| void saveParameter(Variable * anInput); |
| |
| inline void appendParameter(const std::string & label, const BF & anInput) |
| { |
| mParameters.append( anInput ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mReturns |
| */ |
| inline BFVector & getReturns() |
| { |
| return( mReturns ); |
| } |
| |
| inline const BF & getReturn(avm_offset_t offset) const |
| { |
| return( mReturns[offset] ); |
| } |
| |
| inline const BF & getReturn(const std::string & aNameID) const |
| { |
| return( getByNameID(mReturns, aNameID) ); |
| } |
| |
| avm_offset_t getReturnOffset(const std::string & label) const |
| { |
| return( getOffsetByNameID(mReturns, label) ); |
| } |
| |
| |
| inline bool hasReturns() const |
| { |
| return( mReturns.nonempty() ); |
| } |
| |
| bool hasReturnOffset(Variable * aReturn) const; |
| |
| |
| inline void appendReturn(const BF & anOutput) |
| { |
| mReturns.append( anOutput ); |
| } |
| |
| void saveReturn(Variable * anOutput); |
| |
| inline void appendReturn(const std::string & label, const BF & anOutput) |
| { |
| mReturns.append( anOutput ); |
| } |
| |
| |
| /** |
| * GETTER |
| * the parameters / returns |
| */ |
| inline const BF & getParamReturn(const std::string & aNameID) const |
| { |
| const BF & bfParam = getParameter(aNameID); |
| |
| return( bfParam.valid() ? bfParam : getReturn(aNameID) ); |
| |
| } |
| |
| static const BF & getByNameID( |
| const BFVector & params, const std::string & aNameID); |
| |
| static avm_offset_t getOffsetByNameID( |
| const BFVector & params, const std::string & label); |
| |
| |
| /** |
| * MACRO |
| * INLINING |
| */ |
| inline bool isInlinableStatement() const |
| { |
| return( getSpecifier().isDesignInstanceDynamic() && hasModel() |
| && getModel()->getModifier().hasNatureMacro() ); |
| } |
| |
| inline BFCode inlineStatement() const |
| { |
| return( inlineCode( getModel()->mCode ) ); |
| } |
| |
| |
| inline bool isInlinableExpression() const |
| { |
| return( getSpecifier().isDesignInstanceDynamic() && hasModel() |
| && getModel()->getModifier().hasNatureMacro() |
| && getModel()->getReturns().singleton() |
| && getModel()->getCode()->isOpCode( AVM_OPCODE_RETURN ) ); |
| } |
| |
| inline BF inlineExpression() const |
| { |
| return( inlineCode( getModel()->mCode->first() ) ); |
| } |
| |
| |
| BFCode inlineCode(const BFCode & aCode) const; |
| |
| BF inlineCode(const BF & aCode) const; |
| |
| |
| /** |
| * Serialization |
| */ |
| void strParameters(OutStream & os, const std::string & sep = ", ") const; |
| |
| void strReturns(OutStream & os, const std::string & sep = ", ") const; |
| |
| void strHeader(OutStream & os) const; |
| |
| void toStream(OutStream & os) const; |
| |
| |
| void strInvokeParameters(OutStream & os, const std::string & sep = ", ") const; |
| |
| void strInvokeReturns(OutStream & os, const std::string & sep = ", ") const; |
| |
| void toStreamInvoke(OutStream & os, const std::string & sep = ", ") const; |
| |
| }; |
| |
| |
| } /* namespace sep */ |
| #endif /* ROUTINE_H_ */ |
