root/simulator/trunk/vendor/cmake/Source/cmGlobalCodeBlocksGenerator.h

//    OSRail -- a network enabled railroad operations simulator and utilities
//    Copyright (C) 2007,2008 Samuel E. Henley sehenley@comcast.net
//
//    This program 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 2 of the License, or
//    (at your option) any later version.
//
//    This program 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 this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//
//----------------------------------------------------------------------
/// \file
/// Header file for CodeBlocks Global (Workspace Files) Generator for CMake
#ifndef cmGlobaCodeBlocksGenerator_h
#define cmGlobaCodeBlocksGenerator_h

#include "cmGlobalGenerator.h"
#include "cmGeneratedFileStream.h"

#if defined(CMAKE_BUILD_WITH_CMAKE)
# include <cmsys/MD5.h>
#endif

#include "cmSystemTools.h"

class cmLocalCodeBlocksGenerator;

namespace codeblocksgenerator
{
    /// Global list of targets for workspace
    class Dependent
    {
    public:
        Dependent(){}
        Dependent( const Dependent& ref ) : target( ref.target ), project_file( ref.project_file ){}

        const Dependent& operator=( const Dependent& ref )
        {
            if( &ref != this )
            {
                target = ref.target;
                project_file = ref.project_file;
            }

            return *this;
        }

        const cmTarget* target;
        std::string project_file;
    };

} //namespace codeblocksgenerator


///cmGlobalCodeBlocksGenerator is responsable for overseeing the generation process for the cmakelists file tree
class cmGlobalCodeBlocksGenerator : public  cmGlobalGenerator
{
public:
    /// Free any memory allocated with the GlobalGenerator
    cmGlobalCodeBlocksGenerator();
    virtual ~cmGlobalCodeBlocksGenerator();

    static cmGlobalGenerator* New(){ return new cmGlobalCodeBlocksGenerator; }

    /// Create a local generator appropriate to this Global Generator
    virtual cmLocalGenerator* CreateLocalGenerator();

    /// Get the name for this generator
    virtual const char* GetName() const { return GetActualName(); };
    static const char*  GetActualName() { return "CodeBlocks"; }

    /// Get the documentation entry for this generator.  */
    virtual void GetDocumentation( cmDocumentationEntry& entry ) const;

    /// Create LocalGenerators and process the CMakeLists files. This does not
    /// actually produce any makefiles, DSPs, etc.
    virtual void Configure();

    /// Generate the all required files for building this project/tree. This
    /// basically creates a series of LocalGenerators for each directory and
    /// requests that they Generate.
    virtual void Generate();

     /// Try to determine system infomation such as shared library
     /// extension, pthreads, byte order etc.
     virtual void EnableLanguage(std::vector<std::string>const& languages, cmMakefile *, bool optional);

    /// Create a build comand
    virtual std::string GenerateBuildCommand( const char* makeProgram,
                                              const char* projectName,
                                              const char* additionalOptions,
                                              const char* targetName,
                                              const char* config,
                                              bool ignoreErrors,
                                              bool fast );

    void gatherWorkspaceTargets( cmMakefile* makefile );
    std::map< std::string, codeblocksgenerator::Dependent >& getWorkspaceTargetList(){ return workspace_target_list; }

private:

    /// Create a CodeBlocks workspace file.
    void writeWorkspaceFile();

    /// A list used to build dependence list for projects
    /// in the workspace.
    std::map< std::string, codeblocksgenerator::Dependent > workspace_target_list; //Name, project file

};


//////////////////////////////////// Generator Utilities ///////////////////////////////////////

namespace codeblocksgenerator
{

    template < const int T >
    class CodeBlocksGeneratorException : public std::exception
    {
    public:
        CodeBlocksGeneratorException(){}
        virtual const char* what() const throw();
    };

    template<> inline const char* CodeBlocksGeneratorException<  0 >::what() const throw() { return (const char*) "Break"; }
    template<> inline const char* CodeBlocksGeneratorException<  1 >::what() const throw() { return (const char*) "Program Logic Error in insertProjectWorkspace"; }
    template<> inline const char* CodeBlocksGeneratorException<  2 >::what() const throw() { return (const char*) "Program Logic Error in insertProject"; }

    typedef CodeBlocksGeneratorException<  0 > debug_break;
    typedef CodeBlocksGeneratorException<  1 > program_error_insert_project_workspace;
    typedef CodeBlocksGeneratorException<  2 > program_error_insert_project;

    const int Executable          = 0x0001;
    const int Static_library      = 0x0002;
    const int Shared_library      = 0x0004;
    const int Module_library      = 0x0008;
    const int Utility             = 0x0010;
    const int Global_target       = 0x0020;
    const int Install_files       = 0x0040;
    const int Install_programs    = 0x0080;
    const int Install_directory   = 0x0100;
    const int Unknown_library     = 0x0200;
    const int All                 = 0x03ff;

    inline int convertTargetType( const cmTarget::TargetType n )
    {
        int result = Executable;
        result <<= n;
        return result;

    }


    /// write the workspace header
    /// \param directory - location of workspace
    /// \param name - workspace name
    /// \return full workspace path
    std::string writeWorkspaceHeader( const std::string& directory, const std::string& name );

    /// write the project header
    /// \param directory - location of project
    /// \param name - project name
    /// \return full project path
    std::string writeProjectHeader( const std::string& directory, const std::string& name );


    /// write a project and its dependencies into the workspace file
    /// \param project_file - path of the project file
    /// \param workspace_file - path of the workspace  file
    /// \param depends - list  project dependencies
    /// \param active - make this the active project
    void insertProjectWorkspace( const std::string& project_file,
                                 const std::string& workspace_file,
                                 const std::vector< std::string >& depends,
                                 bool active = false );




    /// write a Utility project file
    /// \param target the utility tartget
    /// \param project_file = the utility project cbp file path
    /// \param mf - cmMakefile from cmake
    void writeUtilityProject( cmMakefile* mf, const cmTarget& target, const std::string& workspace_directory, const std::string& project_file );

    /// write a Excutable or Library project file
    /// \param target the tartget
    /// \param project_file = the project cbp file path
    /// \param mf - cmMakefile from cmake
    void writeProject( cmMakefile* mf, const cmTarget& target, const std::string& project_directory,
                       const std::string& project_file, std::vector<const cmTarget*>& workspace_depends );


    class Buffer
    {
    public:
        std::vector<char> buffer;
        std::vector<char> hold;
        bool redirect;
        int tabs;
        bool new_line;
        /// Insert a string into a file
        /// \param before - before this string
        /// \param file - this file path
        /// \return false fail
       bool insertBuffer( const char* before, const std::string file )
       {
            std::ifstream is( file.c_str() );
            std::string base(( std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
            is.close();

            size_t start = base.find( before );
            if( start != std::string::npos )
            {
                 std::ofstream os( file.c_str() );
                 std::copy( base.data(), &base.data()[start], std::ostreambuf_iterator<char>(os) );
                 std::copy( buffer.begin(), buffer.end(), std::ostreambuf_iterator<char>(os) );
                 std::copy( &base.data()[start], &base.data()[base.size()], std::ostreambuf_iterator<char>(os) );
                 os.close();
                 return true;
            }

            return false; //error
        }

        bool writeBuffer( const std::string file )
        {
            #if defined( CMAKE_BUILD_WITH_CMAKE )
                if( cmSystemTools::FileExists( file.c_str() ) )
                {
                    std::ifstream is( file.c_str() );
                    std::string base(( std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
                    is.close();

                    char md5out[32];
                    cmsysMD5* md5 = cmsysMD5_New();
                    cmsysMD5_Initialize( md5 );
                    cmsysMD5_Append( md5, reinterpret_cast<unsigned char const*>(base.data()), base.size() );
                    cmsysMD5_FinalizeHex(md5, md5out);
                    std::string file_md5( md5out, 32 );

                    cmsysMD5_Initialize( md5 );
                    cmsysMD5_Append( md5, reinterpret_cast<unsigned char const*>(&buffer[0]), buffer.size() );
                    cmsysMD5_FinalizeHex( md5, md5out );
                    cmsysMD5_Delete(md5);
                    std::string buffer_md5( md5out, 32 );

                    if( buffer_md5.compare( &file_md5[0] ) == 0 )return true;
                }

            #endif
            std::ofstream os( file.c_str() );
            std::copy( buffer.begin(), buffer.end(), std::ostreambuf_iterator<char>(os) );
            os.close();

            return true;
        }

        void add( const char ch )
        {
            if( redirect )hold.push_back( ch );
            else buffer.push_back( ch );
        }

        void isNewLine()
        {
            if( new_line )
            {
                for( int i=0; i < tabs; i++ ) add( '\t' );
                new_line = false;
            }
        }

        bool isHold() { return !hold.empty(); }

        void clear()
        {
            buffer.clear();
            tabs = 0;
            new_line = true;
            hold.clear();
            redirect = false;
        }
    };

    inline Buffer& operator<<( Buffer& context, const char* string )
    {
        context.isNewLine();
        const char* p = string;
        while( *p != '\0' )context.add( *p++ );
        return context;
    }

    inline Buffer& operator<<( Buffer& context, const char& ch )
    {
        context.isNewLine();
        context.add( ch );
        return context;
    }

    inline Buffer& operator<<( Buffer& context, const std::string& string )
    {
        context.isNewLine();
        const char* p = string.c_str();
        while( *p != '\0' )context.add( *p++ );
        return context;
    }

    inline Buffer& operator<<( Buffer& context, Buffer& (*pf)( Buffer& context ) )
    {
        return pf( context );
    }

    inline Buffer& endl( Buffer& context )
    {
        context << '\n';
        context.new_line = true;
        return context;
    }

    inline Buffer& advance( Buffer& context )
    {
        context.tabs++;
        return context;
    }

    inline Buffer& retreat( Buffer& context )
    {
        if ( context.tabs )context.tabs--;
        return context;
    }

    inline Buffer& quote( Buffer& context )
    {
        context << '\"';
        return context;
    }

    inline Buffer& less( Buffer& context )
    {
        context << '<';
        return context;
    }

    inline Buffer& greater( Buffer& context )
    {
        context << '>';
        return context;
    }

    inline Buffer& endelement( Buffer& context )
    {
        context << "/>";
        return context;
    }

    inline Buffer& redirect( Buffer& context )
    {
        context.redirect = true;
        context.hold.clear();
        return context;
    }

    inline Buffer& direct( Buffer& context )
    {
        context.redirect = false;
        return context;
    }

    inline Buffer& flush( Buffer& context )
    {
        context.redirect = false;
        for( size_t i=0; i< context.hold.size(); i++ ) context.add( context.hold[i] );
        context.hold.clear();
        return context;
    }

}  //namespace codeblocksgenerator



#endif  //cmGlobalCodeBlocksGenerator_h