GEN/Main.cpp

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/>.
*/

/*!
 *  \file
 *  \author Johannes Feuser <feuser@uni-bremen.de>
 *  \brief main file for generator binary
 *
 *  File holding the main() function and CMain class for the openETCS
 *  generator binary execution.
 */

#include "Main.h"
#include <fstream>




namespace oETCS {

namespace GEN {


CMain::CMain(char ** ppArguements, int iNumberArguments)  throw()  
:m_bHelp(false),
 m_bSource(false),
 m_bBuildConfig(false),
 m_bVMConfig(false),
 m_bContraintChecking(false),
 m_OutputDirectory("./")
{
  // Bouml preserved body begin 00020D82
    const char* const pOptions(":absvc:o:h");
    int               iOption(0);
    
    
    // check, if any argument was delivered
    if (iNumberArguments > 0)
    {
    
        // get binary name from argument vector
        m_BinaryName = ppArguements[0];
        
        
        // check, if no additional arguments at all were supplied
        if (iNumberArguments == 1)
        {
            // activate help flag
            m_bHelp = true;

            // store error message
            m_ErrorMessage << "at least the XML model file is required as argument" << ::std::endl;
            
        } // if (iNumberArguments == 1)
        else
        {
            // process all options in argument vector
            do
            {
                // get current option 
                iOption = getopt(iNumberArguments, ppArguements, pOptions);
                
                // switch the current option
                switch (iOption)
                {
                    case 'b':
                        // activate build configuration flag
                        m_bBuildConfig = true;
                        break;


                    case 's':
                        // activate source flag
                        m_bSource = true;
                        break;


                    case 'v':
                        // activate VM configuration flag
                        m_bVMConfig = true;
                        break;


                    case 'a':
                        // activate all generation flags
                        m_bBuildConfig = true;
                        m_bSource = true;
                        m_bVMConfig = true;
                        break;


                    case 'c':
                        // activate constraint checking flag
                        m_bContraintChecking = true;

                        // get constraint file name from argument
                        m_ContraintFile = optarg;
                        break;


                    case 'o':
                        // set output directory from argument
                        m_OutputDirectory = optarg;
                        break;


                    case 'h':
                        // activate help flag
                        m_bHelp = true;
                        break;


                    case ':':
                        // activate help flag
                        m_bHelp = true;

                        // store error message
                        m_ErrorMessage << "option -" << char(optopt) << " needs an operand" << ::std::endl;
                        break;


                    case '?':
                        // activate help flag
                        m_bHelp = true;

                        // store error message
                        m_ErrorMessage << "unknown option -" << char(optopt) << ::std::endl;                        
                        break;

                } // switch (iOption)

            }
            while (iOption != -1);
            
            // check, if all options were parsed successfully and there is still one left
            if (iOption == -1 && (optind == (iNumberArguments - 1) || iNumberArguments > 2))
            {
                // set XML file name as last argument
                m_XMLFile = ppArguements[iNumberArguments - 1];

            } // if (iOption == -1 && (optind == (iNumberArguments - 1) || iNumberArguments == 2))
            else
            {
                // set error message
                m_ErrorMessage << "XML model file must always passed as argument" << ::std::endl;
                
                // activate help flag
                m_bHelp = true;
                
            } // else

        } // else
        
    } // if (iNumberArguments > 0)
  // Bouml preserved body end 00020D82

} //  CMain::CMain()  throw() 




CMain::~CMain()  throw()  
{
  // Bouml preserved body begin 00020E02
    // empty destructor
  // Bouml preserved body end 00020E02

} // CMain::~CMain()  throw() 




int CMain::Execute()  throw()  
{
  // Bouml preserved body begin 00097382
    int                 iReturnValue(0);
    ::GOPPRR::CGraph*   pRootGraph(0);
    ::std::fstream      SourceFile;
    ::std::fstream      CMakeFile;
    ::std::fstream      PIMFile;
    ::std::fstream      PSMFile;
    ::std::fstream      ReportFile;
    ::std::string       FileNamePrefix;
    ::std::string       SourceFileName;
    ::std::string       CMakeFileName;
    ::std::string       PIMFileName;
    ::std::string       PSMFileName;
    ::std::string       ReportFileName;
    
    
    
    
    // check, if help was activate
    if (m_bHelp)
    {
        // first print error message
        ::std::cout << m_ErrorMessage.str();
        
        // than usage
        this->PrintUsage();
        
        // set execution code
        iReturnValue = 1;
        
    } // if (m_bHelp)
    else
    {
        try
        {
            // print starting of parsing
            ::std::cout << "Parsing XML model file...";
            ::std::cout.flush();
            
            // first parse XML model file and create syntax tree
            m_Lexer.CreateSyntaxFromFile(m_XMLFile, pRootGraph);
            
            // print finishing of parsing
            ::std::cout << "done" << ::std::endl;
            
            // get filename prefix from root graph
            if (pRootGraph != 0)
            {
                // set filename prefix from root graph ID
                FileNamePrefix = pRootGraph->m_ID;
                
                // remove all white spaces from prefix
                while (FileNamePrefix.find(" ") != std::string::npos)
                {
                    // replace current white space with _
                    FileNamePrefix.replace(FileNamePrefix.find(" "), 1, "_");
                    
                } // while (FileNamePrefix.find(" ") != std::string::npos)
                
            } // if (pRootGraph != 0)
            
            // check, if filename prefix is still empty
            if (FileNamePrefix.empty())
            {
                // set default prefix
                FileNamePrefix = "openETCS";
                
            } // if (FileNamePrefix.empty())

            
            
            // check for source generation flag
            if (m_bSource)
            {
                // set source file name
                SourceFileName  = m_OutputDirectory + "/";
                SourceFileName += FileNamePrefix;
                SourceFileName += ".cpp";
                
                // open file stream for output 
                SourceFile.open(SourceFileName, ::std::ios_base::out);
                
                // check, if source file could be opened
                if (not SourceFile.is_open())
                {
                    // print error message
                    ::std::cout << "Could not open " << SourceFileName << " for source generation!" << ::std::endl;
                    
                } // if (not SourceFile.is_open())
                else
                {
                    try
                    {
                        // print starting of parsing
                        ::std::cout << "generating C++ source file " << SourceFileName << "...";
                        ::std::cout.flush();
                        
                        // call C++ generator with syntax tree
                        m_CppGenerator.Generate(m_Lexer.GetGOPRRTree(), SourceFile);
                        
                        // print finishing of parsing
                        ::std::cout << "done" << ::std::endl;

                    } // try
                    catch (const ::std::exception& Exception)
                    {
                        // print error
                        ::std::cout << "abort" << ::std::endl;
                        ::std::cerr << Exception.what() << ::std::endl;
                        
                        // set execution code
                        iReturnValue = 3;
                        
                    } // catch (const ::std::exception& Exception)
                
                    // always close file here
                    SourceFile.close();
                    
                } // else

            } // if (m_bSource)
            
            
            // check for build generation
            if (m_bBuildConfig)
            {
                // set cmake file name
                CMakeFileName  = m_OutputDirectory + "/";
                CMakeFileName += "CMakeLists.txt";
                
                // open file stream for output 
                CMakeFile.open(CMakeFileName, ::std::ios_base::out);

                // check, if cmake file could be opened
                if (not CMakeFile.is_open())
                {
                    // print error message
                    ::std::cout << "Could not create " << CMakeFileName << " for build configuration generation!" << ::std::endl;

                } // if (not CMakeFile())
                else
                {
                    try
                    {
                        // print starting of parsing
                        ::std::cout << "generating CMake build configuration file " << CMakeFileName << "...";
                        ::std::cout.flush();

                        // call build config generator with syntax tree
                        m_BuildGenerator.Generate(m_Lexer.GetGOPRRTree(), CMakeFile);

                        // print finishing of parsing
                        ::std::cout << "done" << ::std::endl;

                    } // try
                    catch (const ::std::exception& Exception)
                    {
                        // print error
                        ::std::cout << "abort" << ::std::endl;
                        ::std::cerr << Exception.what() << ::std::endl;

                        // set execution code
                        iReturnValue = 4;

                    } // catch (const ::std::exception& Exception)

                    // always close file here
                    CMakeFile.close();

                } // else
                
            } // if (m_bBuildConfig)
            
            
            // check for VM configuration
            if (m_bVMConfig)
            {
                // set PIM file name
                PIMFileName  = m_OutputDirectory + "/";
                PIMFileName += FileNamePrefix;
                PIMFileName += "_PIM";
                PIMFileName += ".cfg";

                // open file stream for output 
                PIMFile.open(PIMFileName, ::std::ios_base::out);

                // check, if config file could be opened
                if (not PIMFile.is_open())
                {
                    // print error message
                    ::std::cout << "Could not open " << PIMFileName << " for hypervisor configuration generation!" << ::std::endl;

                } // if (not PIMFile.is_open())
                else
                {
                    try
                    {
                        // print starting of parsing
                        ::std::cout << "generating Xen PIM config file " << PIMFileName << "...";
                        ::std::cout.flush();

                        // call C++ generator with syntax tree
                        m_VMGenerator.Generate(m_Lexer.GetGOPRRTree(), PIMFile);

                        // print finishing of parsing
                        ::std::cout << "done" << ::std::endl;

                    } // try
                    catch (const ::std::exception& Exception)
                    {
                        // print error
                        ::std::cout << "abort" << ::std::endl;
                        ::std::cerr << Exception.what() << ::std::endl;

                        // set execution code
                        iReturnValue = 5;

                    } // catch (const ::std::exception& Exception)

                    // always close file here
                    PIMFile.close();

                } // else
                
                // check, if model requires PSM configuration, too
                if (m_VMGenerator.HasPSM(m_Lexer.GetGOPRRTree()))
                {
                    // set PSM file name
                    PSMFileName  = m_OutputDirectory + "/";
                    PSMFileName += FileNamePrefix;
                    PSMFileName += "_PSM";
                    PSMFileName += ".cfg";
                    
                    // open file stream for output 
                    PSMFile.open(PSMFileName, ::std::ios_base::out);

                    // check, if config file could be opened
                    if (not PSMFile.is_open())
                    {
                        // print error message
                        ::std::cout << "Could not open " << PSMFileName << " for hypervisor configuration generation!" << ::std::endl;

                    } // if (not PSMFile.is_open())
                    else
                    {
                        try
                        {
                            // print starting of parsing
                            ::std::cout << "generating Xen PSM config file " << PSMFileName << "...";
                            ::std::cout.flush();

                            // call C++ generator with syntax tree
                            m_VMGenerator.GeneratePSM(m_Lexer.GetGOPRRTree(), PSMFile);

                            // print finishing of parsing
                            ::std::cout << "done" << ::std::endl;

                        } // try
                        catch (const ::std::exception& Exception)
                        {
                            // print error
                            ::std::cout << "abort" << ::std::endl;
                            ::std::cerr << Exception.what() << ::std::endl;

                            // set execution code
                            iReturnValue = 6;

                        } // catch (const ::std::exception& Exception)

                        // always close file here
                        PSMFile.close();

                    } // else
                    
                } // if (m_VMGenerator.HasPSM(m_Lexer.GetGOPRRTree()))
                
            } // if (m_bVMConfig)
            
            
            
            // check for constrain checking
            if (m_bContraintChecking)
            {
                // set report file name
                ReportFileName  = m_OutputDirectory + "/";
                ReportFileName += FileNamePrefix;
                ReportFileName += ".log";

                // open file stream for output 
                ReportFile.open(ReportFileName, ::std::ios_base::out);

                // check, if report file could be opened
                if (not ReportFile.is_open())
                {
                    // print error message
                    ::std::cout << "Could not create " << ReportFileName << " for static semantics report generation!" << ::std::endl;

                } // if (not ReportFile.is_open())
                else
                {
                    try
                    {
                        // print starting of parsing
                        ::std::cout << "WARNING: OCL usage currently not supported! Using static constraint implementation!" << ::std::endl;
                        ::std::cout << "generating report for static semantics / model constraints " << ReportFileName << "...";
                        ::std::cout.flush();

                        // call build constraint report generator with project model
                        m_ConstraintChecker.Check(m_Lexer.GetGOPRRTree()->GetProject(), "", &ReportFile);

                        // print finishing of parsing
                        ::std::cout << "done" << ::std::endl;

                    } // try
                    catch (const ::std::exception& Exception)
                    {
                        // print error
                        ::std::cout << "abort" << ::std::endl;
                        ::std::cerr << Exception.what() << ::std::endl;

                        // set execution code
                        iReturnValue = 7;

                    } // catch (const ::std::exception& Exception)

                    // always close file here
                    ReportFile.close();

                } // else
                
                
                
            } // if (m_bContraintChecking)
            
            
        } // try
        catch (const ::DSM::Error::CException& Exception)
        {
            // print error message
            ::std::cout << "abort" << ::std::endl;
            ::std::cerr << Exception.what() << ::std::endl;
            
            // set execution code
            iReturnValue = 2;
            
        } // catch (const ::DSM::Error::CException& Exception)
        catch (const ::std::exception& Exception)
        {
            // print error message
            ::std::cerr << Exception.what() << ::std::endl;

            // set execution code
            iReturnValue = 2;
            
        } // catch (const ::std::exception& Exception)
        catch (...)
        {
            // print error message
            ::std::cerr << "unhandled and unknown exception" << ::std::endl;

            // set execution code
            iReturnValue = 2;
            
        } // catch (...)
        
    } // else
    

    
    // return execution code
    return iReturnValue;
  // Bouml preserved body end 00097382

} // int CMain::Execute()  throw() 




void CMain::PrintUsage()  throw()  
{
  // Bouml preserved body begin 00098F02
    // print usage
    ::std::cout << "Usage: " << m_BinaryName << " -a | [ -b ] [ -s ] [ -v ] [ -c <constraints file> ] [-o <output directory> ] [ -h ] <XML model file>" << ::std::endl;
    ::std::cout << "       -b generate build configuration" << ::std::endl;
    ::std::cout << "       -s generate C++ source file" << ::std::endl;
    ::std::cout << "       -v generate Xen configuration file(s)" << ::std::endl;
    ::std::cout << "       -a generates all output files" << ::std::endl;
    ::std::cout << "       -c check static semantics for <constraints file>" << ::std::endl;
    ::std::cout << "       -o sets the output directory to <output directory> instead of current one" << ::std::endl;
    ::std::cout << "       -h prints this short help" << ::std::endl;
    ::std::cout << "       The model file <XML model file> must always be set" << ::std::endl;
  // Bouml preserved body end 00098F02

} // void CMain::PrintUsage()  throw() 






} // namespace oETCS::GEN

} // namespace oETCS


int main(int argc, char* argv[])
{
  ::oETCS::GEN::CMain Main(argv, argc);


  // execute Main object and return numerical result
  return Main.Execute();

} // int main(int argc, char* argv[])