CPPGenerator.h

Go to the documentation of this file.

/*
    Copyright (C) 2010-2011
    Johannes Feuser <feuser@uni-bremen.de>
    This file is part of the openETCS library.

    The openETCS library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    The openETCS library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with the openETCS library.  If not, see <http://www.gnu.org/licenses/>.
*/

/*!
 *  \author Johannes Feuser <feuser@uni-bremen.de>
 *  \brief  
 */

#ifndef __OETCS_GEN_CPPGENERATOR_H__
#define __OETCS_GEN_CPPGENERATOR_H__


#include <chrono>
#include <iomanip>
#include <sstream>

#include <string>
#include <map>
#include "AbstractModel.h"
#include <list>
#include <vector>
#include "Generator.h"
#include <regex>




namespace GOPPRR { struct CGraph; } 
namespace GOPPRR { struct CProject; } 
namespace GOPPRR { struct CObject; } 
namespace GOPPRR { struct CPort; } 


namespace oETCS {

namespace GEN {


/*!
 *  \brief generator for C++ sources
 */
class CCPPGenerator : public oETCS::GEN::CGenerator 
{
  public:
    /*!
         *  \brief default oonstructor
         */
    explicit CCPPGenerator() throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CCPPGenerator() throw();
    
    

    /*!
         *  \brief generation method
         *
         *  Generates from a syntax tree the corresponding output.
         *  \remark pure virtual method, which must be reimplemented by any
         *          inheriting class.
         *
         *  \param[in] pTree pointer to the syntax tree used for generation
         *  \param[in] OutStream stream object used for output of generation
         */
    virtual void Generate(::DSM::CSyntaxTree * const pSyntaxTree, ::std::ostream & OutStream) throw(::oETCS::GEN::Error::CException);
    
    


  private:
    /*!
         *  \brief internal helper method
         *
         *  Generates source code of a root graph (EVC state machine) from
         *  a GOPPRR syntax tree.
         *
         *  \param[in] pRootGraph pointer to the root graph of the openETCS model
         *  \param[in] pProject pointer to the parent project of the openETCS model
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateRootGraph(GOPPRR::CGraph * const pRootGraph, GOPPRR::CProject * const pProject, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for creating all function block classes in a project.
         *
         *  \param[in] pProject pointer to the parent project of the openETCS model
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateFunctionBlockElements(GOPPRR::CProject * const pProject, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code of any sub type of function block graph from
         *  a GOPPRR syntax tree.
         *
         *  \param[in] pFunctionBlock pointer to the function block graph
         *  \param[in] pProject pointer to the parent project of the openETCS model
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateFunctionBlock(GOPPRR::CGraph * const pFunctionBlock, GOPPRR::CProject * const pProject, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code of any type of communication graph from
         *  a GOPPRR syntax tree.
         *
         *  \param[in] pCommnication pointer to the function block graph
         *  \param[in] pProject pointer to the parent project of the openETCS model
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateCommunication(GOPPRR::CGraph * const pCommunication, GOPPRR::CProject * const pProject, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for data flow objects (CDataFlow) for a MainFunctionBlock
         *  graph
         *
         *  \param[in] pMainFunctionBlock pointer to the main function block
         *  \param[in] pEVCGraph pointer to EVC root graph
         *  \param[in] pEVCState pointer to the related EVCState object
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateDataFlow(GOPPRR::CGraph * const pMainFunctionBlock, GOPPRR::CGraph * const pEVCGraph, GOPPRR::CObject * const pEVCState, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for adding objects in a sub function block to
         *  a certain data flow objectt
         *
         *  \param[in] OID OID of the related main function block graph
         *  \param[in] pSubFunctionBlock pointer to current sub function block graph
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateDataFlow(const ::std::string & OID, GOPPRR::CGraph * const pSubFunctionBlock, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code adding the related CBitFlow objects
         *  for a communication graph
         *
         *  \param[in] OID OID of the related main function block graph
         *  \param[in] pCommGraph pointer to current communication graph
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateDataFlowForCommunication(const ::std::string & OID, GOPPRR::CGraph * const pCommGraph, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for DMI widgets (CDMIWidget) for a MainFunctionBlock
         *  graph
         *
         *  \param[in] pMainFunctionBlock pointer to the main function block
         *  \param[in] pEVCGraph pointer to EVC root graph
         *  \param[in] pEVCState pointer to the related EVCState object
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateDMI(GOPPRR::CGraph * const pMainFunctionBlock, GOPPRR::CGraph * const pEVCGraph, GOPPRR::CObject * const pEVCState, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for DMI widgets (CDMIWidget) for a SubFunctionBlock
         *  graph
         *
         *  \param[in] OID OID of the related main function block
         *  \param[in] pSubFunctionBlock pointer to the subfunction block
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateDMI(const ::std::string & OID, GOPPRR::CGraph * const pSubFunctionBlock, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for EVC transitions in a certain main function block.
         *
         *  \param[in] pMainFunctionBlock pointer to the main function block graph
         *  \param[in] pEVCState pointer to related EVC state object
         *  \param[in] pRootGraph pointer to the root graph (EVCStateMachine)
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateEVCTransitions(GOPPRR::CGraph * const pMainFunctionBlock, GOPPRR::CObject * const pEVCState, GOPPRR::CGraph * const pRootGraph, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for creating all states of all control flows.
         *
         *  \param[in] pProject pointer to the openETCS project object
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateControlFlows(GOPPRR::CProject * const pProject, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for creating all states of all control flows.
         *
         *  \param[in] pRootGraph pointer to the root graph of the openETCS model
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateTransitions(GOPPRR::CGraph * const pRootGraph, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for creating all trainsitions of control flows in a certain
         *  function block graph (data flow).
         *
         *  \param[in] pFunctionBlock pointer data flow graph
         *  \param[in] pControlFlow pointer to the related control flow graph
         *  \param[in] pEVCState pointer to parent EVC state object
         *  \param[in] pState pointer to the state object
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateTransitions(GOPPRR::CGraph * const pFunctionBlock, GOPPRR::CObject * const pEVCState, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code for creating all trainsitions of control flows in a certain
         *  function block graph (data flow).
         *
         *  \param[in] pFunctionBlock pointer to the data flow grah
         *  \param[in] pControlFlow pointer to the related control flow graph
         *  \param[in] pEVCState pointer to parent EVC state object
         *  \param[in] pState pointer to the state object
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateTransitions(GOPPRR::CGraph * const pFunctionBlock, GOPPRR::CGraph * const pControlFlow, GOPPRR::CObject * const pEVCState, GOPPRR::CObject * const pState, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code of for the language classes
         *
         *  \param[in] pProject pointer to the project of the openETCS model
         *  \param[in] OutStream stream object used for output of generation
         */
    void GenerateLanguage(GOPPRR::CProject * const pProject, ::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
      *  \brief internal helper method
      *
      *  Builds the abstract function block model for a function block graph
      *  recursively.
      *
      *  \param[in,out] pFunctionBlock:    pointer to current function block graph
      *  \param[in] FBNodes map of nodes objects indexed by their OID
      */
    void BuildAbstractModel(GOPPRR::CGraph * const pFunctionBlock, ::std::map< ::std::string, oETCS::GEN::CFBNode >& FBNodes) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code header, like initial comment block and includes.
         *  Is independent from model tree reprensentation
         *
         *  \param[in] OutStream stream object used for output of generation
         */
    static void GenerateHeader(::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Generates source code footer.
         *
         *  \param[in] OutStream stream object used for output of generation
         */
    static void GenerateFooter(::std::ostream & OutStream) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper methods
         *
         *  Evaluates, if a certain GOPPRR object is a function block element.
         *
         *  \param[in] pObject pointer to the object to evaluate
         *
         *  \return true, if object is a function block element
         */
    static bool IsFunctionBlock(GOPPRR::CObject * const pObject) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Gets a string with the corresponding C++ type for a certain port
         *  of a function block object.
         *
         *  \param[in] pPort pointer to the port
         *  \return              string with the C++ data type
         */
    static ::std::string TypeFromPort(GOPPRR::CPort * const pPort) throw(::GOPPRR::Error::CException);
    
    

    /*!
         *  \brief internal helper method
         *
         *  Gets a string with the corresponding data type prefix for  certain port
         *  of a function block object.
         *
         *  \param[in] pPort pointer to the port
         *  \return              string with the prefix
         */
    static ::std::string PrefixFromPort(GOPPRR::CPort * const pPort) throw(::GOPPRR::Error::CException);
    
    

    /*!
     *  \brief internal helper method
     *
     *  Processes recursively a abstract function block node model to find start
     *  nodes.
     *
     *  \param[in] pNode node to be processed
     *  \param[in,out] ExecutionOrder:   list with OID in order of their later execution
     *  \param[in,out] NodeStack:        vector with pointer to already recursively processed nodes to detect data flow loops
     */
    static void ProcessAbstractModel(const oETCS::GEN::CFBNode & Node, ::std::list< ::std::string >& ExecutionOrder, ::std::vector< const oETCS::GEN::CFBNode * >& NodeStack) throw();
    
    

    /*!
     *  \brief map with function block meta model type names to C++ domain framework names
     */
    ::std::map< ::std::string, ::std::string > m_FBMap;
    
    

    /*!
     *  \brief map with function block meta model method/port names to C++ domain framework method names
     */
    ::std::map< ::std::string, ::std::string  > m_FBMMap;
    
    

    /*!
     *  \brief map of already generated transition OIDs
     */
    ::std::map< ::std::string, bool > m_GeneratedTransitions;
    
    

    /*!
     *  \brief map of already generated EVC transition OIDs
     */
    ::std::map< ::std::string, bool > m_GeneratedEVCTransitions;
    
    

    /*!
     *  \brief map of already generated control flow OIDs
     */
    ::std::map< ::std::string, bool > m_GeneratedControlFlows;
    
    


}; // class CCPPGenerator : public oETCS::GEN::CGenerator





} // namespace oETCS::GEN

} // namespace oETCS

#endif // __ OETCS_GEN_CPPGENERATOR_H__