root/simulator/trunk/vendor/cmake/Source/cmLocalCodeBlocksGenerator.cxx

//    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
/// Implementation file for CodeBlocks Local (Project Files) Generator for CMake

#include "cmGlobalCodeBlocksGenerator.h"
#include "cmLocalCodeBlocksGenerator.h"
#include "cmake.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmComputeLinkInformation.h"
#include "cmTest.h"


using namespace codeblocksgenerator;

void cmLocalCodeBlocksGenerator::Generate()
{

}

void cmLocalCodeBlocksGenerator::ConfigureFinalPass()
{
    cmLocalGenerator::ConfigureFinalPass();
    static_cast<cmGlobalCodeBlocksGenerator*>(GetGlobalGenerator())->gatherWorkspaceTargets( GetMakefile() );
}

namespace codeblocksgenerator
{
////////////////////////////////////// Project file //////////////////////////////////////////////////
    /// Text buffer for project
    Buffer project;

    /// A map - file extenstion to folder used by writeVirtualFolders and Units
    std::map< std::string, std::string > virtual_folder_extension;

    /// Hold a search first directory from pch mode, must have build type added for each build configure.
    /// used by PCH and Compiler includes, points to object directory for PCH mode 1
    std::string search_first_object_directory;

    /// Hold stripts
    std::vector< std::string > codeblocks_scripts;

    ///Hold target* for dependents list
    std::vector< const cmTarget* > workspace_depends;

    bool isDepends( const std::string& sz )
    {
        for( size_t i=0; i<workspace_depends.size(); i++ )
        {
            if( sz == workspace_depends[i]->GetName() ) return true;
        }
        return false;
    }

    ///Holds the codeblocks binary directory for this generator (cmake home)
    std::string codeblocks_binary_directory;

    ///Hold current build type or target type for this generator - changes for each build type.
    std::string current_build_type_name;

    ///Holds the binary directory for ths project(cmake start)
    std::string project_binary_directory;

    ///Hold any generated rpath for this target
    std::string rpath;


//------------------------------------ convert cmake list to strings ------------------------------------------------
    /// Conver a cmake string to a vector of strings - can't use cmSystemTools
    void list2vector( const std::string sz, std::vector< std::string >& vector, bool clear=true )
    {
        if( clear )vector.clear();

        size_t start = sz.find_first_not_of(" ;", 0 );
        while( start != std::string::npos )
        {
            std::string name;
            size_t stop = sz.find_first_of(" ;", start );

            if( stop != std::string::npos )
            {
                vector.push_back( sz.substr( start, stop - start ));
                start = sz.find_first_not_of(" ;", stop );
            }
            else
            {
                vector.push_back( sz.substr( start, sz.size() ));
                start = std::string::npos;
            }
        }
    }

//------------------------------------ convert a set to cmake list ------------------------------------------------
    /// Convert a set to a simi-colon cmake string
    void set2list( std::set< std::string >& set, std::string& result, bool clear=true )
    {
        if( clear )result.clear();
        std::set< std::string >::iterator i = set.begin();
        while( i != set.end() )
        {
            if( !result.empty() )result+= ';';
            result += *i++;
        }
    }

//------------------------------------ convert vector to cmake list ------------------------------------------------
    /// Convert a vector to simi-colon cmake string
    void vector2list( const std::vector< std::string >& vector, std::string& result, bool clear=true )
    {
        if( clear )result.clear();
        for( size_t i=0; i< vector.size(); i++ )
        {
            if( !result.empty() )result+= ';';
            result += vector[i];
        }
    }

//------------------------------------ Build Section Build Target Types ------------------------------------------------
    /// Get a vector of CMake build types
    void getBuilds( cmMakefile* mf, std::vector< std::string>& builds )
    {
        const char* p = mf->GetDefinition( "CMAKE_CONFIGURATION_TYPES" );
        if( p )
        {
            std::string sz = p;
            list2vector( sz, builds );
        }
        else
        {
            builds.push_back( "RelWithDebInfo" ); //default build for cmake
        }
    }



//------------------------------------ get a property target, global order ------------------------------------------------
/// Get a property - in target, then directory, then global - order.
const char* getProperty( cmMakefile* mf, const cmTarget& target, const char* property )
{
    const char* p = const_cast<cmTarget&>(target).GetProperty( property, cmProperty::TARGET );
    if( !p ) p = mf->GetProperty( property, cmProperty::DIRECTORY );
    // I would work up the chain of makefiles but codeblocks dosn't have sub-projects.
    if( !p ) p = mf->GetCMakeInstance()->GetProperty( property, cmProperty::GLOBAL );

    return p;
}

const char* getArchiveOutputDirectory( cmMakefile* mf, const cmTarget& target )
{
    bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;

    const char* p = const_cast<cmTarget&>(target).GetProperty("ARCHIVE_OUTPUT_DIRECTORY", cmProperty::TARGET );

    if( !p )
    {
        p = mf->GetDefinition( "CMAKE_ARCHIVE_OUTPUT_DIRECTORY" );
    }

    if( !p )
    {
        p = mf->GetDefinition( "LIBRARY_OUTPUT_PATH" );
    }

    if( !p )
    {
        static std::string sz;
        sz = codeblocks_binary_directory;
        if( !in_try_compile )
        {
            sz += "/bin/lib";
        }
        return sz.c_str();
    }

    return p;

}


const char* getSharedLibraryOutputDirectory( cmMakefile* mf, const cmTarget& target )
{

    static std::string sz;
    bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;

    #ifdef WIN32
        const char* p = mf->GetDefinition( "CMAKE_RUNTIME_OUTPUT_DIRECTORY" );
    #else //Linux
        const char* p = mf->GetDefinition( "LIBRARY_OUTPUT_PATH" );
    #endif


    if( !p )
    {
        p = const_cast<cmTarget&>(target).GetProperty( "LIBRARY_OUTPUT_DIRECTORY", cmProperty::TARGET );
    }

    if( !p )
    {
        p = mf->GetDefinition( "CMAKE_LIBRARY_OUTPUT_DIRECTORY" );
    }

    if( !p )
    {

        sz = codeblocks_binary_directory;
        if( !in_try_compile )
        {
        #ifdef WIN32
            sz += "/bin";
        #else //Linux
            sz += "/bin/lib";
        #endif
        }
    }
    else sz = p;

    #ifdef WIN32
        sz += '/';
        sz += current_build_type_name;
    #endif //WIN32



    return sz.c_str();
}

const char* getRunTimeOutputDirectory( cmMakefile* mf, const cmTarget& target )
{
    bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;

    const char* p = const_cast<cmTarget&>(target).GetProperty( "RUNTIME_OUTPUT_DIRECTORY", cmProperty::TARGET );

    if( !p )
    {
        p = mf->GetDefinition( "CMAKE_RUNTIME_OUTPUT_DIRECTORY" );
    }

    if( !p )
    {
        p = mf->GetDefinition( "EXECUTABLE_OUTPUT_PATH" );
    }

    if( !p )
    {
        static std::string sz;
        sz = codeblocks_binary_directory;
        if( !in_try_compile )
        {
            sz += "/bin";
        }
        return sz.c_str();
    }

    return p;
}

//------------------------------------ Project Header ------------------------------------------------
    //Write the project header
    //<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    //<CodeBlocks_project_file>
        //    <FileVersion major="1" minor="6" />
        /// Write a CodeBlocks Project Header and Trailer
    std::string writeProjectHeader( const std::string& codeblocks_binary_directory, const std::string& name )
    {
        project.clear();
        project << less << "?xml version=" << quote << "1.0" << quote << " encoding="
                << quote << "UTF-8" << quote << " standalone=" << quote << "yes" << quote << '?' << greater << endl;
        project << less << "CodeBlocks_project_file" << greater << endl;
        project << advance << less << "FileVersion major=" << quote << '1' << quote
                << " minor=" << quote << '6' << quote << endelement << endl << retreat;
        project << less << '/' << "CodeBlocks_project_file" << greater << endl;

        std::string project_file = codeblocks_binary_directory;
        project_file += '/';
        project_file += name;
        project_file += ".cbp";
        project.writeBuffer( project_file );

        return project_file;
    }

//------------------------------------ Project Title ------------------------------------------------
    /// Write Project Title
    void writeProjectTitleOption( const cmTarget& target )
    {
        project << advance << less << "Option title=" << quote << target.GetName() << ' ';
        switch( target.GetType() )
        {

            case cmTarget::EXECUTABLE : project << " Project"; break;
            case cmTarget::STATIC_LIBRARY : project << " Static Library"; break;
            case cmTarget::SHARED_LIBRARY : project << " Shared Library"; break;
            case cmTarget::MODULE_LIBRARY : project << " Module Library"; break;
            case cmTarget::UTILITY : project << " Utility Command"; break;
            case cmTarget::GLOBAL_TARGET : project << "Utility Command"; break;
            case cmTarget::INSTALL_FILES : project << "Install Files Project"; break;
            case cmTarget::INSTALL_PROGRAMS : project << "Install Programs Project"; break;
            case cmTarget::INSTALL_DIRECTORY : project << "Install Directories Project"; break;
            case cmTarget::UNKNOWN_LIBRARY :
            default:
                project << "Unknown Project Type"; break;

        }
        project << quote << endelement << endl << retreat;
    }

//------------------------------------ Project Platforms ------------------------------------------------
    /// Write Project platform Option
    void writePlatformsOption( cmMakefile* mf )
    {
        std::string platform;
        if( mf->IsDefinitionSet( "UNIX" ) )platform = "Unix";
        else if( mf->IsDefinitionSet( "WIN32" )) platform = "Windows";
        else platform = "All";
        project << advance << less << "Option platform=" << quote << platform << quote << endelement << endl << retreat;
    }

//------------------------------------ Extra Commands Target and Project  and Utilities ------------------------------------------------

    /// Write a custom command for project or target
    void writeCommands( cmMakefile* mf, const cmTarget& target, const cmCustomCommand& command, const char* label )
    {

        const cmCustomCommandLines& commandline = command.GetCommandLines();

        for( size_t j=0; j<commandline.size(); j++ )
        {
            cmCustomCommandLine line = commandline[j];
            if( command.GetWorkingDirectory() )
            {
                //must change to working codeblocks_binary_directory before command - use cmake
                std::string make_command = mf->GetRequiredDefinition( "CMAKE_COMMAND" );
                project << advance << less << label << quote;
                std::string sz = command.GetWorkingDirectory();
                project << make_command << " -E chdir " << sz << ' ';
            }
            else project << advance << less << label << quote;


            for( size_t k=0; k<line.size(); k++ )
            {
                if( k )project << ' ';
                std::string sz = line[k];

                project << sz;
            }
            project << quote << endelement << endl << retreat;
        }



    }

    /// Write all custom commands
    void writeCommands( cmMakefile* mf, const cmTarget& target, std::vector<cmCustomCommand> const& commands, const char* label )
    {
        for( size_t i=0; i< commands.size(); i++ )
        {
            writeCommands( mf, target, commands[i], label );
        }
    }

    /// Write pre and post build Target custom commands
    void writeTargetExtraCommands(  cmMakefile* mf, const cmTarget& target )
    {
        std::vector<cmCustomCommand> const& prebuild  = const_cast<cmTarget&>(target).GetPreBuildCommands();
        std::vector<cmCustomCommand> const& postbuild = const_cast<cmTarget&>(target).GetPostBuildCommands();

        if( !prebuild.empty() || !postbuild.empty() )
        {
            project << advance << "<ExtraCommands>" << endl;
            /// \note custom commands are found in two places in the
            /// target - prebuild, postbuild, prelink command are
            /// part of the target builds - utility commands are hung
            /// on a source file - the utility command has two source files
            /// after target.TraceDependencies( 0 ) is run, the first
            /// is a source file with the name of the target,
            /// the second source file has the name of the target.rule
            /// and contains the command that applies to utilities.

            // Check for the normal build extra commands

            if( !prebuild.empty() )writeCommands( mf, target, prebuild, "Add before=" );
            // No pre-link for codeblocks as of 8 Feb 2009

            if( !postbuild.empty() )writeCommands( mf, target, postbuild, "Add after=" );

            project << less << "/ExtraCommands" << greater << endl << retreat;
        }
    }

    /// Write Source file custom commands
    void writeExtraCommands(  cmMakefile* mf, const cmTarget& target )
    {

        // Check for the utility commands
        bool mode = false;
        std::vector<cmSourceFile*> const sources = const_cast<cmTarget&>(target).GetSourceFiles();
        for( size_t i=0; i<sources.size(); i++ )
        {

            if( sources[i]->GetPropertyAsBool( "CODEBLOCKS_NO_GENERATE" ))continue;

            const cmCustomCommand* custom_command = sources[i]->GetCustomCommand();
            if( custom_command )
            {
                project << advance << redirect;

                if( !mode )
                {
                    project << advance << less << "Mode before=" << quote << "always" << quote << endelement << endl << retreat;
                    mode = true;
                }
                writeCommands( mf, target, *custom_command, "Add before=" );
            }
        }

        if( project.isHold() )
        {
             project << direct << "<ExtraCommands>" << endl << flush;
             project << less << "/ExtraCommands" << greater << endl << retreat;
        }
        else project << retreat << direct;

    }

//------------------------------------ Target Section Utilities ------------------------------------------------
    /// Write the Target Section of a CMake utility Command.
    void writeTargetUtility( cmMakefile* mf, const cmTarget& target )
    {
        project << advance << less << "Target title=" << quote << current_build_type_name << quote << greater << endl;
        writePlatformsOption( mf );
        project << advance << less << "Option type=" << quote << "4" << quote << endelement << endl << retreat;
        writeExtraCommands( mf, target );
        project << less << "/Target" << greater << endl << retreat;
    }

//------------------------------------ Build Section Utilities ------------------------------------------------
    /// Write the Build Section of a CMake utility Command.
    void writeBuildUtility( cmMakefile* mf, const cmTarget& target )
    {

        project << advance << less << "Build" << greater << endl;
        //for each build type
        std::vector< std::string > build;
        getBuilds( mf, build );

        for( size_t i=0; i<build.size(); i++ )
        {
            current_build_type_name = build[i];
            writeTargetUtility( mf, target );
        }

        project << less << "/Build" << greater << endl << retreat;
    }

//------------------------------------ Project Section Utilities ------------------------------------------------
    /// Write the Project Section of a CMake utility Command.
    void writeUtilityProject( cmMakefile* mf, const cmTarget& target, const std::string& workspace_directory, const std::string& project_file )
    {
        project.clear();
        project << less << "?xml version=" << quote << "1.0" << quote << " encoding="
                << quote << "UTF-8" << quote << " standalone=" << quote << "yes" << quote << '?' << greater << endl;
        project << less << "CodeBlocks_project_file" << greater << endl;
        project << advance << less << "FileVersion major=" << quote << '1' << quote
                << " minor=" << quote << '6' << quote << endelement << endl << retreat;

        codeblocks_binary_directory = workspace_directory;
        project << advance << less << "Project" << greater << endl;
        writeProjectTitleOption( target );
        writePlatformsOption( mf );
        writeBuildUtility( mf, target );
        project << less << "/Project" << greater << endl << retreat;

        project << less << '/' << "CodeBlocks_project_file" << greater << endl;

        project.writeBuffer( project_file );
    }

    void writeCommandProject( cmMakefile* mf, const std::string& command, const std::string& title, const std::string& project_file )
    {
        project.clear();
        project << less << "?xml version=" << quote << "1.0" << quote << " encoding="
                << quote << "UTF-8" << quote << " standalone=" << quote << "yes" << quote << '?' << greater << endl;
        project << less << "CodeBlocks_project_file" << greater << endl;
        project << advance << less << "FileVersion major=" << quote << '1' << quote
                << " minor=" << quote << '6' << quote << endelement << endl << retreat;

        project << advance << less << "Project" << greater << endl;
        project << advance << less << "Option title=" << quote << title;
        project << quote << endelement << endl << retreat;
        project << advance << less << "Option platform=" << quote << "All" << quote << endelement << endl << retreat;
        project << advance << less << "Build" << greater << endl;


        // for each build type
        std::vector< std::string > build;
        getBuilds( mf, build );

        for( size_t i=0; i<build.size(); i++ )
        {
            current_build_type_name = build[i];
            project << advance << less << "Target title=" << quote << current_build_type_name << quote << greater << endl;
            project << advance << less << "Option platform=" << quote << "All" << quote << endelement << endl << retreat;
            project << advance << less << "Option type=" << quote << "4" << quote << endelement << endl << retreat;

            project << advance << "<ExtraCommands>" << endl << flush;
            project << advance << less << "Mode before=" << quote << "always" << quote << endelement << endl << retreat;
            project << advance << less << "Add before=" << quote;
            project << command;
            project << quote << endelement << endl << retreat;
            project << less << "/ExtraCommands" << greater << endl << retreat;

            project << less << "/Target" << greater << endl << retreat;
        }

        project << less << "/Build" << greater << endl << retreat;
        project << less << "/Project" << greater << endl << retreat;

        project << less << '/' << "CodeBlocks_project_file" << greater << endl;

        //if( !project.insertBuffer( "</CodeBlocks_project_file>", project_file ) ) throw program_error_insert_project();

        project.writeBuffer( project_file );

    }
//------------------------------------ Target Section Program Parameters ------------------------------------------------

    /// \note Target property CODEBLOCKS_EXECUTION_PARAMETERS sets command line prameters for executable
    /// under codeblocks.
    /// Write Execution parameters for the Target Section of a CMake Program or Library
    void writeExecutionParameters( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_EXECUTION_PARAMETERS", cmProperty::TARGET );

        if( p )
        {
            if( convertTargetType( target.GetType() ) & Executable )
            {
                std::vector< std::string > vector;
                std::string sz( p );
                list2vector( sz, vector );

                project << advance << less << "Option parameters=" << quote;
                for( int i=0; i<vector.size(); ++i )
                {
                    project << ' ';
                    project << vector[i];
                }

                project << quote << endelement << endl << retreat;
            }
            else
            {
                /// \todo warning - parameters for non-executable
            }
        }
    }

//------------------------------------ Target Section Program Console Runner ------------------------------------------------

    /// \note Target property CODEBLOCKS_USE_CONSOLE_RUNNER - run a console program under codeblocks and
    /// wait for a key to close.

    /// Write Use Console Runner for the Target Section of a CMake Program
    void writeConsoleRunner( cmMakefile* mf, const cmTarget& target )
    {
        bool use_console_runner =
            cmSystemTools::IsOn( const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_USE_CONSOLE_RUNNER", cmProperty::TARGET ));

        if( use_console_runner )
        {
            if( convertTargetType( target.GetType() ) & Executable )
            {
                 project << advance << less << "Option use_console_runner=" << quote << "1" << quote << endelement << endl << retreat;
            }
            else
            {
                /// \todo warning - console runner set for non-executable
            }
        }
    }

//------------------------------------ Target Section Program Host Application ------------------------------------------------

    /// \note Target property CODEBLOCKS_HOST_APPLICATION - run this program under codeblocks for dll/shared libraries

    /// Write Host Application for the Target Section of a CMake Library
    void writeHostApplication( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_HOST_APPLICATION", cmProperty::TARGET );

        if( p )
        {

            if( convertTargetType( target.GetType() ) & (Shared_library|Module_library) )
            {
                project << advance << less << "Option host_application=" << quote << p << quote << endelement << endl << retreat;
            }
            else
            {
                /// \todo warning - host application only effective for shared library/dll
            }
        }
    }

//------------------------------------ Target Section Program Output Type ------------------------------------------------
    /// Write Output Type for the Target Section of a CMake Program or Library
    void writeOutputType( cmMakefile* mf, const cmTarget& target )
    {
        std::string type;
        switch( target.GetType() )
        {
            case cmTarget::EXECUTABLE : type = "1"; break;
            case cmTarget::MODULE_LIBRARY :
            case cmTarget::STATIC_LIBRARY : type = "2"; break;
            case cmTarget::SHARED_LIBRARY : type = "3"; break;
            default:
                type = "4";
        }
        project << advance << less << "Option type=" << quote << type << quote << endelement << endl << retreat;
    }

//------------------------------------ Target Section Additional Outputs ------------------------------------------------
    /// Write Addition file dependences for the Target Section of a CMake Program or Library
    void writeAdditionalOutputs( cmMakefile* mf, const cmTarget& target )
    {
        std::string result;

//        std::vector<cmCustomCommand> const& prebuild  = const_cast<cmTarget&>(target).GetPreBuildCommands();
//        for( size_t i=0; i<prebuild.size(); i++ )
//        {
//            const cmCustomCommand& command = prebuild[i];
//
//            const cmCustomCommandLines& command_line = command.GetCommandLines();
//
//            for( size_t j=0; j<command_line.size(); j++ )
//            {
//                cmCustomCommandLine line = command_line[j];
//                for( size_t k=0; k<line.size(); k++ )
//                {
//                     result = line[k];
//                }
//            }
//
//        }

        // Find custom command outputs

        cmTargets& targets = mf->GetTargets();
        cmTargets::iterator it = targets.begin();
        std::string cmake_path = mf->GetHomeOutputDirectory();

        while( it != targets.end() )
        {

            cmTarget& target = it->second;
            std::vector<cmSourceFile*> const sources = const_cast<cmTarget&>(target).GetSourceFiles();
            for( size_t i=0; i<sources.size(); i++ )
            {

                if( sources[i]->GetPropertyAsBool( "CODEBLOCKS_NO_GENERATE" ))continue;

                const cmCustomCommand* command = sources[i]->GetCustomCommand();
                if( command )
                {
                    const cmCustomCommandLines& command_line = command->GetCommandLines();
                    for( size_t j=0; j<command_line.size(); j++ )
                    {
                        cmCustomCommandLine line = command_line[j];
                        for( size_t k=0; k<line.size(); k++ )
                        {
                            std::string param =line[k];
                            if( param.find( cmake_path ) != std::string::npos )
                            {
                                size_t ix = param.find( codeblocks_binary_directory );
                                if( ix != 0 && ix != std::string::npos )
                                {
                                    //remove flags
                                    param.erase( 0, ix );
                                }
                                if( !result.empty() )result += ';';
                                result += param;
                            }

                        }
                    }
                }

            }
            it++;
        }

        if( !result.empty() )
        {
            project << advance << less << "Option additional_output=" << quote << result << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Target Section External Dependencies ------------------------------------------------
    /// Write external file dependencies
    void writeExternalDependencies( cmMakefile* mf, const cmTarget& target  )
    {
        // Find dependent projects and add there output files
        // add output names for each project in our workspace
        std::set< std::string > heap;

        if( !workspace_depends.empty() )
        {
            std::string result;
            for( size_t i=0; i<workspace_depends.size(); i++ )
            {
                std::string name  = const_cast<cmTarget*>(workspace_depends[i])->GetFullPath( current_build_type_name.c_str() );
//                if( current_build_type_name == "Debug" )
//                {
//                    //Our libraries add a debug DEBUG_POSTFIX
//                    std::string postfix;
//                    const char* p = const_cast<cmTarget&>(target).GetProperty( "DEBUG_POSTFIX", cmProperty::TARGET );
//                    if( !p )postfix = "_d"; // Default
//                    else postfix = p;
//
//                    size_t ix = name.rfind( '.' );
//                    if( ix != std::string::npos )
//                    {
//                        name.insert( ix, postfix );
//                    }
//                    else
//                    {
//                        //warning building a library with no extension?
//                        name += postfix;
//                    }
//                }

                heap.insert( name );
            }

            std::set< std::string >::iterator it = heap.begin();
            while( it != heap.end() )
            {
                if( !result.empty() ) result += ';';
                std::string path = *it++;
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), path.c_str() );
                result += rel_path;
            }

            if ( !result.empty() )
            {
                project << advance << less << "Option external_deps=" << quote << result << quote << endelement << endl << retreat;
            }
        }
    }

//------------------------------------ Target Section Objects ------------------------------------------------
    /// Write directory for objects
    ///
    // Object output directory = project_file - project.cbp + build
    void writeObjectOutput( cmMakefile* mf, const cmTarget& target   )
    {
        std::string output = project_binary_directory;
        output += current_build_type_name;
        std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), output.c_str() );
        project << advance << less << "Option object_output=" << quote << rel_path << quote << endelement << endl << retreat;
    }

//------------------------------------ Target Section Workin Directory ------------------------------------------------
    /// Write the executable working directory
    void writeWorkingDirectory( cmMakefile* mf, const cmTarget& target   )
    {
        std::string path;
        path = codeblocks_binary_directory + "/bin/" + current_build_type_name;
        std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), path.c_str() );
        project << advance << less << "Option working_dir=" << quote << rel_path << quote << endelement << endl << retreat;
    }

//------------------------------------ Target Section Program Output Executable Target------------------------------------------------
    /// Write the output file name and path
    void writeOutputExecitable( cmMakefile* mf, const cmTarget& target  )
    {
        std::string name = target.GetName();
        std::string result;
//        std::string result = const_cast<cmTarget&>(target).GetFullPath(current_build_type_name.c_str());

        bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;

        std::string execution_output_path = getRunTimeOutputDirectory( mf, target );
        //Check if a test program.
        std::map<cmStdString, cmTest*>& tests = mf->GetTests();

        if( mf->GetCMakeInstance()->GetIsInTryCompile() != 0 )
        {
            result = name;
        }
        else if( !tests.empty() )
        {
            std::map<cmStdString, cmTest*>::iterator i = tests.begin();
            while( i != tests.end() )
            {
                std::vector<std::string> const& command = i->second->GetCommand();
                if( !command.empty() )
                {
                    std::string test_name = command[0];
                    size_t ix = test_name.rfind( name );
                    if( ix != std::string::npos )
                    {
                        test_name.insert( ix, "$(TARGET_NAME)/" );
                        result = test_name;
                        break;
                    }
                }
                i++;
            }
        }


        if( result.empty() )
        {
            if( execution_output_path.length() > 0 )result = execution_output_path += '/';

            result += current_build_type_name + '/' + name;

        }

        std::string rel_path;
        if( in_try_compile )
        {
            rel_path = result;
        }
        else
        {
            rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), result.c_str() );
        }


        project << advance << less << "Option output=" << quote << rel_path << quote
                                       << " prefix_auto=" << quote<< '1' << quote
                                       << " extension_auto=" << quote << '1' << quote
                                       <<  endelement << endl << retreat;


    }

//------------------------------------ Target Section Program Output Static Target------------------------------------------------

    /// Write the output file name and path
    void writeOutputStaticLibrary( cmMakefile* mf, const cmTarget& target  )
    {

        std::string name = target.GetName();
        std::string result;
//        std::string result = const_cast<cmTarget&>(target).GetFullPath(current_build_type_name.c_str());

        bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;


        if( current_build_type_name == "Debug" && !in_try_compile )
        {
            std::string postfix;
            const char* p = const_cast<cmTarget&>(target).GetProperty( "DEBUG_POSTFIX", cmProperty::TARGET );
            if( !p )postfix = "_d"; // Default
            else postfix = p;
            name += postfix;
        }

        std::string libaray_output_path = getArchiveOutputDirectory( mf, target );

        if( libaray_output_path.length() > 0 )result = libaray_output_path + '/'; //else will put it in the top directory

        result +=  name;

        if( !result.empty() )
        {

            std::string rel_path;
            if( in_try_compile )
            {
                rel_path = result;
            }
            else
            {
                rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), result.c_str() );
            }


            project << advance << less << "Option output=" << quote << rel_path << quote
                                       << " prefix_auto=" << quote<< '1' << quote
                                       << " extension_auto=" << quote << '1' << quote
                                       <<  endelement << endl << retreat;
        }



    }
//------------------------------------ Target Section Program Output Shared Target------------------------------------------------

    /// Write the output file name and path
    void writeOutputSharedLibrary( cmMakefile* mf, const cmTarget& target  )
    {

        std::string name = target.GetName();
        std::string result;
//        std::string result = const_cast<cmTarget&>(target).GetFullPath(current_build_type_name.c_str());

        bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;

        char prefix = '1';

        if( current_build_type_name == "Debug" && !in_try_compile )
        {
            std::string postfix;
            const char* p = const_cast<cmTarget&>(target).GetProperty( "DEBUG_POSTFIX", cmProperty::TARGET );
            if( !p )postfix = "_d"; // Default
            else postfix = p;
            name += postfix;
        }

        std::string libaray_output_path = getSharedLibraryOutputDirectory( mf, target );

        if( libaray_output_path.length() > 0 )result = libaray_output_path + '/';

        if(convertTargetType( target.GetType()) & (Shared_library|Module_library)  )
        {
            const char* p = const_cast<cmTarget&>(target).GetProperty( "PREFIX", cmProperty::TARGET );
            if( !p )
            {
                p = mf->GetDefinition("CMAKE_SHARED_LIBRARY_PREFIX");
            }
            if( p )
            {
                result += p;
                prefix = '0';
            }
            else prefix = '1';
        }

        if( !result.empty() )
        {

            result += name;

            std::string rel_path;
            if( in_try_compile )
            {
                rel_path = result;
            }
            else
            {
                rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), result.c_str() );
            }


            project << advance << less << "Option output=" << quote << rel_path << quote
                                       << " prefix_auto=" << quote<< prefix << quote
                                       << " extension_auto=" << quote << '1' << quote
                                       <<  endelement << endl << retreat;
        }




    }


// --------------------------------------rpath-----------------------------------------------------


    void storeRPath( cmMakefile* mf, const cmTarget& target  )
    {
        //CMAKE_SKIP_BUILD_RPATH
        if( cmSystemTools::IsOn( mf->GetDefinition( "CMAKE_SKIP_BUILD_RPATH" )) )return;

        if( cmSystemTools::IsOn( mf->GetDefinition( "CMAKE_BUILD_WITH_INSTALL_RPATH" )) )
        {
            const char* p = mf->GetDefinition( "CMAKE_BUILD_WITH_INSTALL_RPATH" );
            if( p )rpath = p;
            return;
        }

        cmComputeLinkInformation* li = const_cast<cmTarget&>(target).GetLinkInformation( current_build_type_name.c_str() );
        if( !li ) return;

        std::string sz = li->GetRPathString( false );
        if( !sz.empty() )
        {
            rpath = li->GetRuntimeFlag();
            rpath += sz;
        }
   }

//------------------------------------ Target Section Program Output ------------------------------------------------

    /// Write the output file name and path
    void writeOutput( cmMakefile* mf, const cmTarget& target  )
    {

        if( convertTargetType( target.GetType()) & ( Shared_library|Module_library)  )
        {
            storeRPath( mf, target );
            writeOutputSharedLibrary( mf, target  );
        }
        else if( convertTargetType( target.GetType()) & Static_library  )
        {
            writeOutputStaticLibrary( mf, target  );
        }
        else if( convertTargetType( target.GetType() ) & Executable )
        {
            storeRPath( mf, target );
            writeOutputExecitable( mf, target  );
        }
        else
        {
            /// \todo error in program - lost build type
        }

    }



//------------------------------------ Target Section Create Def File ------------------------------------------------

    /// \note Target property CODEBLOCKS_CREATE_DEF_FILE creates a def file for the windows linker.
    /// Write a def file for windows dlls
    void writeCreateDEFFile( cmMakefile* mf, const cmTarget& target )
    {
        bool create_def_file =
            cmSystemTools::IsOn( const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_CREATE_DEF_FILE", cmProperty::TARGET ));

        if( create_def_file )
        {
            if( convertTargetType( target.GetType() ) & (Shared_library|Module_library) )
            {
                 project << advance << less << "Option createDefFile=" << quote << "1" << quote << endelement << endl << retreat;
            }
            else
            {
                /// \todo warning - property only meaningful for a dll under windows  - no warning unde linux -
            }
        }
    }

//------------------------------------ Target Section Create Import Library ------------------------------------------------

    /// \note Target property CODEBLOCKS_CREATE_IMPORT_LIBRARY - create an import library for the windows linker

    /// Write an import library for windows dlls
    void writeCreateImportLibrary( cmMakefile* mf, const cmTarget& target )
    {
        bool create_import_library =
            cmSystemTools::IsOn( const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_CREATE_IMPORT_LIBRARY", cmProperty::TARGET ));

        if( create_import_library )
        {
            if( convertTargetType( target.GetType() ) & (Shared_library|Module_library) )
            {
                 project << advance << less << "Option createStaticLib=" << quote << "1" << quote << endelement << endl << retreat;
            }
            else
            {
                /// \todo warning - property only meaningful for a dll under windows  - no warning unde linux -
            }
        }
    }

//------------------------------------ Target Section Compiler Relation ------------------------------------------------
    /// \note Target property CODEBLOCKS_COMPILER_OPTIONS_PRIORITY sets the relative order/priority of link directories,
    /// The meaning in CMake is between makefile settings and build type settings.
    /// - not supported by CMake and will lead to different builds between this local generator and the main local generator.

    /// Write a priority value for Compiler Options
    void writeCompilerRelation( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_COMPILER_OPTIONS_PRIORITY", cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "Option projectompilerOptionsRelation=" << quote << p << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Target Section Linker Relation ------------------------------------------------
    /// \note Target property CODEBLOCKS_LINKER_OPTIONS_PRIORITY sets the relative order/priority of link directories,
    /// The meaning in CMake is betwen makefile settings and build type settings.
    /// - not supported by CMake and will lead to different builds between this generator and the main generator.

    /// Write a priority value Linker Options
    void writeLinkerOptionRelation( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_LINKER_OPTIONS_PRIORITY", cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "Option projectLinkerOptionsRelation=" << quote << p << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Target Section Compiler Includes Relation ------------------------------------------------
    /// \note Target property CODEBLOCKS_COMPILER_INCLUDES_PRIORITY sets the relative order/priority of link directories,
    /// The meaning in CMake is betwen makefile settings and build type settings.
    /// - not supported by CMake and will lead to different builds between this generator and the main generator.

    /// Write a priority value Compiler Includes Options
    void writeIncludeDirectoryRelation( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_COMPILER_INCLUDES_PRIORITY", cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "Option projectIncludeDirsRelation=" << quote << p << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Target Section Resource Compiler Includes Relation ------------------------------------------------
    /// \note Target property CODEBLOCKS_RESOURCE_INCLUDES_PRIORITY sets the relative order/priority of link directories,
    /// The meaning in CMake is betwen makefile settings and build type settings.
    /// - not supported by CMake and will lead to different builds between this generator and the main generator.

    /// Write a pirority value for Resource Includes Option
    void writeResourceIncludeDirectoryRelation( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_RESOURCE_INCLUDES_PRIORITY", cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "Option projectResourceIncludeDirsRelation=" << quote << p << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Target Section Linker Includes Relation ------------------------------------------------
    /// \note Target property CODEBLOCKS_LINKER_INCLUDES_PRIORITY sets the relative order/priority of link directories,
    /// The meaning in CMake is between makefile settings and build type settings.
    /// - not supported by CMake and will lead to different builds between this generator and the main generator.

    /// Write a priority value for Linker Include Options
    void writeLibraryDirectoryRelation( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_LINKER_INCLUDES_PRIORITY", cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "Option projectLibDirsRelation=" << quote << p << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Target Section Scripts ------------------------------------------------

    /// \note Target property CODEBLOCKS_SCRIPT - run a target level codeblocks script

    /// Add any CodeBlocks scripts to a Target
    void writeTargetScripts( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_SCRIPT", cmProperty::TARGET );

        if( p )
        {
            std::string script = p;
            codeblocks_scripts.push_back( script );
            std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), script.c_str() );
            project << advance << less << "Script file=" << quote << rel_path << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Target Section Compiler Options ------------------------------------------------

    /// Write target level compiler options and defines
    void writeTargetCompilerOptions( cmMakefile* mf, const cmTarget& target )
    {

        std::set< cmStdString > languages;
        target.GetLanguages( languages );
        std::string build = cmSystemTools::UpperCase( current_build_type_name );
        std::set< cmStdString >::iterator it = languages.begin();
        std::string tag;
        while( it != languages.end() )
        {
            std::string result;
            tag = "CMAKE_";
            tag += *it;
            tag += "_FLAGS_";
            tag += build;

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )result += p;

            if( convertTargetType( target.GetType() ) & Shared_library )
            {
                tag = "CMAKE_SHARED_LIBRARY_";
                tag += *it;
                tag += "_FLAGS_";
                tag += build;

                p = mf->GetDefinition( tag.c_str() );
                if( p && strlen(p) > 0 )
                {
                    result += ' ';
                    result += p;
                }
            }

            if( convertTargetType( target.GetType() ) & Module_library )
            {
                tag = "CMAKE_MODULE_LIBRARY_";
                tag += *it;
                tag += "_FLAGS_";
                tag += build;

                p = mf->GetDefinition( tag.c_str() );
                if( p && strlen(p) > 0 )
                {
                    result += ' ';
                    result += p;
                }

            }


            std::vector<std::string> flags;
            list2vector( result, flags );
            for( size_t i=0; i<flags.size(); i++ )
            {
                project << advance << less << "Add option=" << quote << flags[i] << quote << endelement << endl << retreat;
            }



            bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;
            if( !in_try_compile ) //Used for something else in try compile.
            {


                /// Common define flags in a CMake project
                tag = "COMPILE_DEFINITIONS_";
                tag += build;


                p = mf->GetProperty(tag.c_str(), cmProperty::DIRECTORY );
                if( p )
                {
                    std::string sz = p;
                    std::vector< std::string > flags;
                    list2vector( sz, flags );
                    project << advance << less << "Add option=" << quote;
                    for( size_t i =0; i<flags.size(); i++ )
                    {
                        if( i ) project << ' ';
                        project <<  "-D";
                        project << flags[i];
                    }

                    project << quote << endelement << endl << retreat;
                }

                p = const_cast<cmTarget&>(target).GetProperty(tag.c_str(), cmProperty::TARGET);
                if( p )
                {
                    std::string sz = p;
                    std::vector< std::string > flags;
                    list2vector( sz, flags );
                    project << advance << less << "Add option=" << quote;
                    for( size_t i =0; i<flags.size(); i++ )
                    {
                        if( i ) project << ' ';
                        project <<  "-D";
                        project << flags[i];
                    }

                    project << quote << endelement << endl << retreat;

                }
            }


            it++; //Next language?
        }

    }

//------------------------------------ Target Section Compiler Includes Options ------------------------------------------------
    /// Write Target level includes
    void writeTargetAddCompilerDirectories( cmMakefile* mf, const cmTarget& target )
    {
        /// \note CMake assumes that includes go with any target in the project file
    }

//------------------------------------ Target Section Compiler ------------------------------------------------

    void writeTargetCompilerSettings( cmMakefile* mf, const cmTarget& target )
    {
        project << redirect << advance;
        writeTargetCompilerOptions( mf, target );
        writeTargetAddCompilerDirectories( mf, target );
        if( project.isHold() )
        {
            project << retreat << direct << advance << less << "Compiler" << greater << endl << flush;
            project << less << '/' << "Compiler" << greater << endl << retreat;
        }
        else project << retreat << direct;
    }

//------------------------------------ Target Section Linker Options ------------------------------------------------

    void writeTargetLinkerOptions( cmMakefile* mf, const cmTarget& target )
    {
        std::set< cmStdString > languages;
        std::string build = cmSystemTools::UpperCase( current_build_type_name );
        std::string tag;


        tag = "LINK_FLAGS_";
        tag += build;
        const char* p = const_cast<cmTarget&>(target).GetProperty( tag.c_str(), cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
        }


        if( convertTargetType( target.GetType() ) & Executable )
        {

            tag = "CMAKE_EXE_LINKER_FLAGS_";
            tag += build;

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )
            {
                project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
            }
        }


        if( convertTargetType( target.GetType() ) & Shared_library )
        {
            tag = "CMAKE_SHARED_LINKER_FLAGS_";
            tag += build;

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )
            {
                project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
            }
        }


        if( convertTargetType( target.GetType() ) & Module_library )
        {
            tag = "CMAKE_MODULE_LINKER_FLAGS_";
            tag += build;

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )
            {
                project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
            }
        }

    }

//------------------------------------ Target Section Linker Includes ------------------------------------------------

    /// Write target level linker includes
    void writeTargetAddLinkerDirectories( cmMakefile* mf, const cmTarget& target )
    {
        const std::vector<std::string>& link_directories = const_cast<cmTarget&>(target).GetLinkDirectories();

        for( size_t i=0; i<link_directories.size(); i++ )
        {
            if( !link_directories[i].empty() )
            {
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), link_directories[i].c_str() );
                project << advance << less << "Add directory=" << quote << rel_path << quote << endelement << endl << retreat;
            }
        }

    }

//------------------------------------ Target Section Linker Libraries ------------------------------------------------
    /// Write Libraries
    void writeTargetAddLinkerLibraries( cmMakefile* mf, const cmTarget& target )
    {
        std::vector< std::string > heap;

        const cmTarget::LinkLibraryVectorType& libraries = target.GetOriginalLinkLibraries();
        for( size_t i=0; i<libraries.size(); i++ )
        {
            std::pair< std::string, cmTarget::LinkLibraryType> library = libraries[i];
            std::string result = library.first;

/*            if( isDepends( result ) )
            {
                // A library that we build
                if( current_build_type_name == "Debug" )
                {
                    std::string postfix;
                    const char* p = const_cast<cmTarget&>(target).GetProperty( "DEBUG_POSTFIX", cmProperty::TARGET );
                    if( !p )postfix = "_d"; // Default
                    else postfix = p;
                    result += postfix;
                }

                heap.push_back( result );

            }
            // a debug library
            else */ if( current_build_type_name == "Debug" && library.second == cmTarget::DEBUG )
            {
                heap.push_back( result );
            }
            // an optimized library
            else if( current_build_type_name != "Debug" && library.second == cmTarget::OPTIMIZED )
            {
                heap.push_back( result );
            }
            // any library
            else if( library.second == cmTarget::GENERAL )
            {
                heap.push_back( result );
            }
        }

        std::vector< std::string >::iterator it = heap.begin();
        while( it != heap.end() )
        {
            project << advance << less << "Add library=" << quote << *it++ << quote << endelement << endl << retreat;

        }

    }

//------------------------------------ Target Section Linker ------------------------------------------------

    void writeTargetLinkerSettings( cmMakefile* mf, const cmTarget& target )
    {
        project << redirect << advance;
        writeTargetLinkerOptions( mf, target );

//        if( const_cast<cmTarget&>(target).GetType() != cmTarget::STATIC_LIBRARY )
//        {
            writeTargetAddLinkerDirectories( mf, target );
            writeTargetAddLinkerLibraries( mf, target );
//        }

        if( project.isHold() )
        {
            project << retreat << direct << advance << less << "Linker" << greater << endl << flush;
            project << less << '/' << "Linker" << greater << endl << retreat;
        }
        else project << retreat << direct;
    }

//------------------------------------ Target Section Resource Includes ------------------------------------------------
    /// \note Target property CODEBLOCKS_RESOURCE_INCLUDE_DIRECTORIES is a list of resource include directories

    void writeTargetAddResourceCompilerDirectories( cmMakefile* mf, const cmTarget& target )
    {
            std::vector< std::string > resource;
            std::vector< std::string > directories;

            const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_RESOURCE_INCLUDE_DIRECTORIES", cmProperty::TARGET );
            if( p )
            {
               list2vector( p, resource );
            }

            for( size_t i=0; i<resource.size(); i++ )
            {
                std::string sz = resource[i];
                directories.push_back( sz );
            }

            //Purge
            sort( directories.begin(), directories.end() );
            std::vector< std::string >::iterator end = std::unique( directories.begin(), directories.end() );
            directories.erase( end, directories.end() );

            for( size_t j=0; j<directories.size(); j++ )
            {
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), directories[j].c_str() );
                project << advance << less << "Add directory=" << quote << rel_path << quote << endelement << endl << retreat;
            }
    }

//------------------------------------ Target Section Resource ------------------------------------------------

    /// Write resouce section for target
    void writeTargetResourceCompilerSettings( cmMakefile* mf, const cmTarget& target )
    {
        project << advance << redirect;
        writeTargetAddResourceCompilerDirectories( mf, target );
        if( project.isHold() )
        {
            project << direct << less << "ResourceCompiler" << greater << endl << flush;
            project << less << '/' << "ResourceCompiler" << greater << endl;
        }
        else project << direct;

        project << retreat;
    }

//------------------------------------ Project and Target Section Compiler Id ------------------------------------------------

//    const char* generator_table[][2] =
//    {
//        { "Borland Makefiles",            "bcc" },        //Borland C++ Compiler (5.5, 5.82)
//        { "CodeBlocks",                   "gcc" },        // this IDE any of
//        { "MSYS Makefiles",               "gcc" },
//        { "MinGW Makefiles",              "gcc" },
//        { "NMake Makefiles",              "msvctk" },     //Microsoft Visual C++ Toolkit 2003
//        { "Unix Makefiles",               "gcc" },
//        { "Visual Studio 6",              "msvctk" },
//        { "Visual Studio 7",              "msvctk" },
//        { "Visual Studio .net 2003",      "msvctk" },
//        { "Visual Studio 8 2005",         "msvc8" },      //Microsoft Visual C++ 2005/2008
//        { "Visual Studio 8 2005 Win64",   "msvc8" },
//        { "Visula Studio 9 2008",         "msvc8" },
//        { "Visula Studio 9 2008 Win64",   "msvc8" },
//        { "Watcom WMake",                 "ow" },         //OpenWatcom (W32) Compiler
//        { "Codeblocks - MinGW Makefiles", "gcc" },
//        { "Codeblocks - Unix Makefiles",  "gcc" },
//        { "Eclipse - MinGW Makefiles",    "gcc" },
//        { "Eclipse - NMake Makefiles",    "gcc" },
//        { "Eclipse - Unix  Makefiles",    "gcc" },
//        { 0,                              "cygwin" },      //Cygwin GCC
//        { 0,                              "dmc" },         //Digital Mars Compiler
//        { 0,                              "dmd" },         //Digital Mars D Compiler
//        { 0,                              "gdc" },         //GDC D Compiler
//        { 0,                              "arm-elf-gcc" }, //GNU ARM GCC Compiler
//        { 0,                              "avr-gcc" },     //GNU AVR GCC Compiler
//        { 0,                              "ppc-gcc" },     //GNU GCC Compiler for PowerPC
//        { 0,                              "tricore-gcc" }, //GNU GCC Compiler for TriCore
//        { 0,                              "msp430-gcc" },  //GNU GCC Compiler for MSP430
//        { 0,                              "icc" },         //Intel C/C++ Compiler
//        { 0,                              "mingw32-gcc" }, //MinGW
//        { 0,                              "sdcc" },        //SDCC Compiler
//        { 0,                              "tcc"  },        //Tiny C Compiler
//    };
//
//    const int size_generator_table = sizeof( generator_table ) / ( 2 * sizeof( const char*));

    std::string getCompilerName(  cmMakefile* mf )
    {
        std::string compiler = "gcc";


        if( !cmSystemTools::IsOn( mf->GetDefinition( "CMAKE_COMPULER_IS_GNUCXX" )) )
        {
            /// \todo other compilers
            const char* pcxx = mf->GetDefinition( "CMAKE_CXX_COMPILER" );
            const char* pc = mf->GetDefinition( "CMAKE_C_COMPILER" );

            bool unixx = cmSystemTools::IsOn( mf->GetDefinition( "UNIX" ));
            bool win32 = cmSystemTools::IsOn( mf->GetDefinition( "WIN32" ));
            bool cygwin = cmSystemTools::IsOn( mf->GetDefinition( "CYGWIN" ));
            bool msvc = cmSystemTools::IsOn( mf->GetDefinition( "MSVC" ));
            bool msvc80 = cmSystemTools::IsOn( mf->GetDefinition( "MSVC80" ));

        }

        return compiler;
    }


    /// Write Compiler ID for target and project
    void writeCompilerId( cmMakefile* mf, const cmTarget& target )
    {
        std::string compiler = getCompilerName( mf );

        project << advance << less << "Option compiler=" << quote << compiler << quote << endelement << endl << retreat;
    }


//------------------------------------ Project Object Names ------------------------------------------------
/// \note from CMake documentation "CMake computes for every source file an object file name
/// that is unique to the source file and deterministic with respect to the full path to the source file."
///

/// \note Global/Directory/Target property CODEBLOCKS_USE_EXTENDED_OBJECT_NAMES add the source file extension to objects
    /// Write Extended object name flag for project
    void writeExtendedObjectNames( cmMakefile* mf, const cmTarget& target )
    {
        if( cmSystemTools::IsOn( getProperty( mf, target, "CODEBLOCKS_USE_EXTENDED_OBJECT_NAMES" )) )
        {
             project << advance << less << "Option extended_obj_names=" << quote << "1" << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Project Note CData ------------------------------------------------

    /// \note Target property CODEBLOCKS_NOTE sets a note for a project

    /// Write note for project
    void writeNoteCData( const char* note )
    {


        std::string text;

        if( note )text = note;
        else text = "-- Set Target Property CODEBLOCKS_NOTE ---";


        project << advance << less << "notes" << greater << endl;
        project << advance << less << '!' << "[CDATA[" << endl;
        project << text;
        project << "]]" << greater << endl << retreat;
        project << less << '/' << "notes" << greater << endl << retreat;
    }

//------------------------------------ Project Notes ------------------------------------------------

    /// \note Target property CODEBLOCKS_SHOW_NOTE displays a note for a project

    // Write note and show note for project
    void writeNotes( cmMakefile* mf, const cmTarget& target )
    {
        const char* note = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_NOTE", cmProperty::TARGET );
        const char* sw = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_SHOW_NOTE", cmProperty::TARGET );

        if( note || sw )
        {
            std::string is;
            if( cmSystemTools::IsOn( sw ) )is = "1";
            else is = "0";

            project << advance << less << "Option show_notes=" << quote << is << quote << greater << endl;
            writeNoteCData( note );
            project << less << '/' << "Option" << greater << endl << retreat;
        }
    }

//------------------------------------ Project PCH ------------------------------------------------

    /// \note Global/Directory/Target property CODEBLOCKS_PCH_MODE={ 0, 1, 2 } - Generate in a directory alongside header,
    ///       in object directory, or default to alongside header. Generator will add the directory for option
    ///       1 to the top of the compiler include list.

    /// Write Pre-Compiled Header Flag for project section
    void writePCH( cmMakefile* mf, const cmTarget& target )
    {
        project << advance << less << "Option pch_mode=";
        const char* p = getProperty( mf, target, "CODEBLOCKS_PCH_MODE" );
        if( !p ) p = "2";
        project << quote << p << quote << endelement << endl << retreat;
        if( strcmp( p, "1" ) == 0 )
        {
            search_first_object_directory = const_cast<cmTarget&>(target).GetDirectory(); //must have build added, this is the object codeblocks_binary_directory
        }


    }

//------------------------------------ Project Default Target (Build Type ) ------------------------------------------------

    /// \note Target property CODEBLOCKS_DEFAULT_BUILD sets the default build type for the codeblocks ide

    /// Write the Default Build Type for project section
    void writeDefaultTarget( cmMakefile* mf, const cmTarget& target )
    {
        std::vector< std::string > builds;
        getBuilds( mf, builds );
        if( builds.empty() )builds.push_back( "RelWithDebInfo" ); //default build for cmake
        std::string default_target;

        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_DEFAULT_BUILD", cmProperty::TARGET );


        if( p )
        {
            if( std::find( builds.begin(), builds.end(), p ) != builds.end() )default_target = p;
        }
        else
        {
            default_target = builds[0];
        }

        if( default_target.empty() )
        {
            /// \todo warning - target type not in "CMAKE_CONFIGURATION_TYPES"
            default_target = "RelWithDebInfo"; //cmake default build
        }

        project << advance << less << "Option default_target=" << quote << default_target << quote << endelement << endl << retreat;
    }

//------------------------------------ Project Virtual Targets Alias------------------------------------------------


    /// Write Alias for a Build Type for the Project Section
    void writeAlias( const std::string& alias, const std::string& targets )
    {
        if( targets.empty() )
        {
            /// \todo warning alias with no targets
        }
        else
        {
            project << advance << less << "Add alias=" << quote << alias << quote
                    << " targets=" << quote << targets << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Project Virtual Targets ------------------------------------------------

    /// \note Target property CODEBLOCKS_VIRTUAL_BUILDS sets a list of virtual build types for a project file
    /// As an Example All RelWithDebInfo Debug Release MinSizeRel Development Debug The build types must
    /// be in CMAKE_BUILD_TYPES or it will be considered as an alias and probably fail.

    /// Write list of Alias for a Build Type for the Project Section
    void writeVirtualTargets( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_VIRTUAL_BUILDS", cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "VirtualTargets" << greater << endl;

            std::vector<std::string> names;
            list2vector( p, names );
            //get each build type
            std::vector< std::string > builds;
            getBuilds( mf, builds );

            std::string targets;
            std::string alias;

            for( size_t i=0; i<names.size(); i++ )
            {
                if( std::count( builds.begin(), builds.end(), names[i] ) == 0 )
                {
                    if( !alias.empty() )writeAlias( alias, targets );
                    alias = names[i];
                    targets.clear();
                }
                else
                {
                    if( !targets.empty() ) targets += ';';
                    targets += names[i];
                }
            }

            if( !alias.empty() )writeAlias( alias, targets );

            project << less << '/' << "VirtualTargets" << greater << endl << retreat;
        }
    }


//------------------------------------ Project Compiler Options ------------------------------------------------
    /// Write Compiler flags for the project section
    void writeCompilerOptions( cmMakefile* mf, const cmTarget& target )
    {
        std::set< cmStdString > languages;
        target.GetLanguages( languages );
        std::set< cmStdString >::iterator it = languages.begin();
        std::string tag;
        while( it != languages.end() )
        {
            std::string result;
            tag = "CMAKE_";
            tag += *it;
            tag += "_FLAGS";

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )result += p;


            if( convertTargetType( target.GetType() ) & Shared_library )
            {
                tag = "CMAKE_SHARED_LIBRARY_";
                tag += *it;
                tag += "_FLAGS";

                p = mf->GetDefinition( tag.c_str() );
                if( p && strlen(p) > 0 )
                {
                    result += ' ';
                    result += p;
                }
            }

            if( convertTargetType( target.GetType() ) & Module_library )
            {
                tag = "CMAKE_MODULE_LIBRARY_";
                tag += *it;
                tag += "_FLAGS";

                p = mf->GetDefinition( tag.c_str() );
                if( p && strlen(p) > 0 )
                {
                    result += ' ';
                    result += p;
                }

            }

            std::vector<std::string> flags;
            list2vector( result, flags );
            for( size_t i=0; i<flags.size(); i++ )
            {
                project << advance << less << "Add option=" << quote << flags[i] << quote << endelement << endl << retreat;
            }



            p = mf->GetDefineFlags();

            if( p && strlen(p) > 0 )
            {
                project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
            }

            bool in_try_compile = mf->GetCMakeInstance()->GetIsInTryCompile() != 0;
            if( !in_try_compile ) //Used for something else in try compile.
            {

                p = mf->GetProperty("COMPILE_DEFINITIONS");
                if( p )
                {
                    std::string sz = p;
                    std::vector< std::string > flags;
                    list2vector( sz, flags );
                    project << advance << less << "Add option=" << quote;
                    for( size_t i =0; i<flags.size(); i++ )
                    {
                        if( i ) project << ' ';
                        project <<  "-D";
                        project << flags[i];
                    }

                    project << quote << endelement << endl << retreat;

                }
            }

            /// \todo check C and CXX or Fortran flags ????? under a workspace/project/target hierarchy.
            it++; //Next language?
        }

    }

//------------------------------------ Project Compiler Includes Options ------------------------------------------------
    /// Write project level compiler includes
    void writeAddCompilerDirectories( cmMakefile* mf, const cmTarget& target )
    {
        const std::vector< std::string >& includes = mf->GetIncludeDirectories();
        for( size_t i=0; i<includes.size(); i++ )
        {
            if( !includes[i].empty() )
            {
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), includes[i].c_str() );
                project << advance << less << "Add directory=" << quote << rel_path << quote << endelement << endl << retreat;
            }
        }
    }

//------------------------------------ Project Compiler Section ------------------------------------------------

    void writeCompiler( cmMakefile* mf, const cmTarget& target )
    {
        project << advance << redirect;
        writeCompilerOptions( mf, target );
        writeAddCompilerDirectories( mf, target );
        if( project.isHold() )
        {
             project << direct << less << "Compiler" << greater << endl << flush;
             project << less << '/' << "Compiler" << greater << endl;
        }

        project << retreat;
    }

//------------------------------------ Project Linker Options ------------------------------------------------

    void writeLinkerOptions( cmMakefile* mf, const cmTarget& target )
    {

        //SET(CMAKE_DL_LIBS "dl")
        //SET(CMAKE_SHARED_LIBRARY_C_FLAGS "-fPIC")
        //SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-shared")
        //SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "-rdynamic")
        //SET(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-rpath,")
        //SET(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP ":")
        //SET(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG "-Wl,-soname,")
        //SET(CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG "-Wl,-soname,")

        std::set< cmStdString > languages;
        std::string tag;

        const char* p = const_cast<cmTarget&>(target).GetProperty( "LINK_FLAGS", cmProperty::TARGET );
        if( p )
        {
            project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
        }

        if( convertTargetType( target.GetType() ) & Executable )
        {

            tag = "CMAKE_EXE_LINKER_FLAGS";

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )
            {
                project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
            }
        }


        if( convertTargetType( target.GetType() ) & Shared_library )
        {
            tag = "CMAKE_SHARED_LINKER_FLAGS";

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )
            {
                project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
            }
        }


        if( convertTargetType( target.GetType() ) & Module_library )
        {
            tag = "CMAKE_MODULE_LINKER_FLAGS_";

            const char* p = mf->GetDefinition( tag.c_str() );
            if( p && strlen(p) > 0 )
            {
                project << advance << less << "Add option=" << quote << p << quote << endelement << endl << retreat;
            }
        }

        // user allowed rpath
        if( !rpath.empty() )
        {
            project << advance << less << "Add option=" << quote << rpath << quote << endelement << endl << retreat;
        }




    }

//------------------------------------ Project Linker Includes ------------------------------------------------
    /// Write project level Linker Includes
    void writeAddLinkerDirectories( cmMakefile* mf, const cmTarget& target )
    {
        const std::vector<std::string>& link_directories = mf->GetLinkDirectories();

        for( size_t i=0; i<link_directories.size(); i++ )
        {
            if( !link_directories[i].empty() )
            {
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), link_directories[i].c_str() );
                project << advance << less << "Add directory=" << quote << rel_path << quote << endelement << endl << retreat;
            }
        }
    }

//------------------------------------ Project Linker Libraries ------------------------------------------------
    /// Only Target level libraries in CMake
    void writeAddLinkerLibraries( cmMakefile* mf, const cmTarget& target )
    {

    }

//------------------------------------ Project Linker Section ------------------------------------------------

    void writeLinker( cmMakefile* mf, const cmTarget& target )
    {
        project << advance << redirect;
        writeLinkerOptions( mf, target );
        if( const_cast<cmTarget&>(target).GetType() != cmTarget::STATIC_LIBRARY )
        {
            writeAddLinkerDirectories( mf, target );
            writeAddLinkerLibraries( mf, target );
        }

        if( project.isHold() )
        {
            project << direct << less << "Linker" << greater << endl << flush;
            project << less << '/' << "Linker" << greater << endl;
        }
        else project << direct;

        project << retreat;
    }

//------------------------------------ Project Resource Includes ------------------------------------------------
    /// Write resource directories fot Directory and global
    void writeAddResourceCompilerDirectories( cmMakefile* mf, const cmTarget& target )
    {
            std::vector< std::string > resource;
            std::vector< std::string > directories;

            const char* p = mf->GetProperty( "CODEBLOCKS_RESOURCE_INCLUDE_DIRECTORIES", cmProperty::DIRECTORY );
            if( p )
            {
                list2vector( p, resource, false );
            }

            // Should be in workspace but codeblocks only allows projects under a workspace.
            if( !p )
            {
                p = mf->GetCMakeInstance()->GetProperty( "CODEBLOCKS_RESOURCE_INCLUDE_DIRECTORIES", cmProperty::GLOBAL );

                if( p )
                {
                    list2vector( p, resource, false );
                }
            }

            for( size_t i=0; i<resource.size(); i++ )
            {
                std::string sz = resource[i];
                directories.push_back( sz );
            }

            //Purge
            sort( directories.begin(), directories.end() );
            std::vector< std::string >::iterator end = std::unique( directories.begin(), directories.end() );
            directories.erase( end, directories.end() );

            for( size_t j=0; j<directories.size(); j++ )
            {
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), directories[j].c_str() );
                project << advance << less << "Add directory=" << quote << rel_path << quote << endelement << endl << retreat;
            }
   }

//------------------------------------ Project Resource Compiler Section ------------------------------------------------
    /// Write resource for project section
    void writeResourceCompiler( cmMakefile* mf, const cmTarget& target )
    {
        project << advance << redirect;
        writeAddResourceCompilerDirectories( mf, target );
        if( project.isHold() )
        {
            project << direct << less << "ResourceCompiler" << greater << endl << flush;
            project << less << '/' << "ResourceCompiler" << greater << endl;
        }
        else project << direct;

        project << retreat;
    }

//------------------------------------ Project Unit Section ------------------------------------------------
    /// Write Compile for Unit section
    void writeUnitCompilerVar( cmMakefile* mf, const cmTarget& target, cmSourceFile* source  )
    {
//        const char* p = source->GetLanguage();
//        if( p )
//        {
//
//            std::string language = p;
//            if( language.compare( "CXX" ) == 0 )language = "CPP";
//
//            if(    language.compare( "CPP" ) == 0
//                || language.compare( "C" ) == 0
//                || language.compare( "WINDRES" ) == 0 )
//                      project << advance << less << "Option compilerVar=" << quote << language << quote << endelement << endl << retreat;
//        }
    }

    /// BuildCommand - undocumented used for individual source file flags and includes.

    void writeUnitBuildCommand( cmMakefile* mf, const cmTarget& target, cmSourceFile* source  )
    {
//        const char* p = source->GetLanguage();

          const char* p = source->GetProperty( "COMPILE_FLAGS" );
          if( p )
          {

              std::string compiler = getCompilerName( mf );

              std::vector<std::string> flags;
              std::string result = p;
              list2vector( result, flags );


              if( flags.size() > 0 )
              {
                  project << advance << less << "Option compiler=" << quote << compiler << quote << " use=\"1\" " <<  "buildCommand=" << quote
                          << "$compiler " << "$options ";


                  for( size_t i=0; i<flags.size(); i++ )
                  {
                      if( flags[i].find("-I") == 0 )
                      {
                          std::string path = flags[i].substr( 2 );
                          std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), path.c_str() );
                          project << "-I" << rel_path << " ";
                      }
                      else
                      {
                          project << flags[i] << " ";

                      }


                  }

                  project << "$includes -c $file -o $object" << quote <<  endelement << endl << retreat;

              }
          }

    }


    /// \note Source file property CODEBLOCKS_SOURCE_NO_COMPILE - Do not compile this file
    /// could be supported with the cmake property EXTERNAL_OBJECT

    /// Write Compiler enable/diable for Unit section
    void writeUnitCompiler( cmMakefile* mf, const cmTarget& target, cmSourceFile* source )
    {
        const char* p = source->GetProperty( "CODEBLOCKS_SOURCE_NO_COMPILE" );
        if( !p ) source->GetProperty( "EXTERNAL_OBJECT" );
        if( cmSystemTools::IsOn( p ) )
        {
            project << advance << less << "Option compile=" << quote << '0' << quote << endelement << endl << retreat;
        }
    }

    /// \note Source file property CODEBLOCKS_SOURCE_NO_LINK - Do not link this file
    /// could be supported with the cmake property SYMBOLIC

    /// Write Linker enable/diable for Unit section
    void writeUnitLink( cmMakefile* mf, const cmTarget& target, cmSourceFile* source  )
    {
        const char* p = source->GetProperty( "CODEBLOCKS_SOURCE_NO_LINK" );
        if( !p ) source->GetProperty( "SYMBOLIC" );
        if( cmSystemTools::IsOn( p ) )
        {
            project << advance << less << "Option link=" << quote << '0' << quote << endelement << endl << retreat;
        }
    }

    /// \note Source file property CODEBLOCKS_SOURCE_WEIGHT (number) - Lower number files are
    /// compiled first.

    /// Write Source file priority for Unit section
    void writeUnitWeight( cmMakefile* mf, const cmTarget& target, cmSourceFile* source  )
    {
        const char* p = source->GetProperty( "CODEBLOCKS_SOURCE_WEIGHT" );
        if( p )
        {
            project << advance << less << "Option weight=" << quote << p << quote << endelement << endl << retreat;
        }
    }


    /// \note Source file property CODEBLOCKS_VIRTUAL_FOLDER (Folder name only)
    /// will override all virtual folder properties - a folder is created and the source
    /// is placed under it.

    /// Write Virtual Folders for Unit section
    void writeUnitVirtualFolder( cmMakefile* mf, const cmTarget& target, cmSourceFile* source )
    {
        const char* p = source->GetProperty( "CODEBLOCKS_VIRTUAL_FOLDER" );

        if( p )
        {
            // The folder should exist - set in writeVirtualFolders
            // Put it in a spacfic folder
            project << advance << less << "Option virtualFolder=" << quote << p << quote << endelement << endl << retreat;
        }
        else if( !virtual_folder_extension.empty() )
        {
            if( cmSystemTools::IsOn( source->GetProperty( "GENERATED" )) )
            {
                project << advance << less << "Option virtualFolder=" << quote << "Generated" << quote << endelement << endl << retreat;
            }
            else
            {
                // not generated put it in by extension
                std::string ext = source->GetExtension();
                if( virtual_folder_extension.count( ext ) != 0 )
                {
                    project << advance << less << "Option virtualFolder=" << quote << virtual_folder_extension[ext] << quote << endelement << endl << retreat;
                }
            }

        }

        //Not using virtual folders exit


    }

    /// \note Source file property CODEBLOCKS_SOURCE_TARGETS is a list of targets
    /// that this source file is attached, no CODEBLOCKS_SOURCE_TARGETS property
    /// attaches this file to all build targets. This is not support in cmake and
    /// the makefile generator used will include the source in all targets. It can
    /// be used to keep two groups of builds, for example Linux_Debug and Win32_debug
    /// in the same CodeBlocks project file.

    /// Write Target property for Unit section.
    void writeUnitTarget( cmMakefile* mf, const cmTarget& target, cmSourceFile* source  )
    {
        const char* p = source->GetProperty( "CODEBLOCKS_SOURCE_TARGETS" );

        if( p )
        {
            std::vector< std::string > arg;
            list2vector( p, arg );
            for( size_t i=0; i<arg.size(); i++ )
                project << advance << less << "Option target=" << quote << arg[i] << quote << endelement << endl << retreat;
        }

    }

    /// \note Global/Director/Target property CODEBLOCKS_GENERATED_FILES = is a list
    /// of files that are generate by other targets to be include in this project file.
    /// Files are cumulative from global to target.

    /// Write Generated Source for Unit section.
    void writeGeneratedSources( cmMakefile* mf, const cmTarget& target )
    {
        std::vector< std::string> generated;

        if( getProperty( mf, target, "CODEBLOCKS_GENERATED_FILES" ) ) //there is a configuration file
        {
            //files are cumulative
            const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_GENERATED_FILES", cmProperty::TARGET );
            if( p )
            {
               list2vector( p, generated, false );
            }

            p = mf->GetProperty( "CODEBLOCKS_GENERATED_FILES", cmProperty::DIRECTORY );
            if( p )
            {
                list2vector( p, generated, false );
            }

            // Should be in workspace but codeblocks only allows projects under a workspace.
            p = mf->GetCMakeInstance()->GetProperty( "CODEBLOCKS_GENERATED_FILES", cmProperty::GLOBAL );
            if( p )
            {
                 list2vector( p, generated, false );
            }
        }

        //Purge
        sort( generated.begin(), generated.end() );
        std::vector< std::string>::iterator end = std::unique( generated.begin(), generated.end() );
        generated.erase( end, generated.end() );

        //Purge any of may own source/project
        std::vector<cmSourceFile*> const sources = const_cast<cmTarget&>(target).GetSourceFiles();
        for( size_t i=0; i<sources.size(); i++ )
        {
            if( cmSystemTools::IsOn( sources[i]->GetProperty( "GENERATED" )) )
            {
                const std::string path = sources[i]->GetFullPath();
                std::vector<std::string>::iterator found = std::find( generated.begin(), generated.end(), path );
                if( found != generated.end() )
                {
                    generated.erase( found );
                }

            }
        }

        for( size_t i=0; i<generated.size(); i++ )
        {
            std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), generated[i].c_str() );
            project << advance << less << "Unit filename=" << quote << rel_path << quote << greater << endl;
            project << advance << less << "Option compile=" << quote << '0' << quote << endelement << endl << retreat;
            project << advance << less << "Option link=" << quote << '0' << quote << endelement << endl << retreat;
            if( !virtual_folder_extension.empty() )
            {
                project << advance << less << "Option virtualFolder=" << quote << "Generated" << quote << endelement << endl << retreat;
            }
            project << less << '/' << "Unit" << greater << endl << retreat;
        }



    }

    /// \note Global/Director/Target property CODEBLOCKS_SCRIPT_FILES = is a list
    /// of files that are scripts - Files are cumulative from global to target.

    /// Write Script files for Virtual folder section of project
    void writeScriptSources( cmMakefile* mf, const cmTarget& target )
    {
        if( getProperty( mf, target, "CODEBLOCKS_SCRIPT_FILES" ) ) //there is a configuration file
        {
            //files are cumulative
            const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_SCRIPT_FILES", cmProperty::TARGET );
            if( p )
            {
               list2vector( p, codeblocks_scripts, false );
            }

            p = mf->GetProperty( "CODEBLOCKS_SCRIPT_FILES", cmProperty::DIRECTORY );
            if( p )
            {
                list2vector( p, codeblocks_scripts, false );
            }

            // Should be in workspace but codeblocks only allows projects under a workspace.
            p = mf->GetCMakeInstance()->GetProperty( "CODEBLOCKS_SCRIPT_FILES", cmProperty::GLOBAL );
            if( p )
            {
                 list2vector( p, codeblocks_scripts, false );
            }
        }

        //makefile always one script
        //Purge
        sort( codeblocks_scripts.begin(), codeblocks_scripts.end() );
        std::vector< std::string>::iterator end = std::unique( codeblocks_scripts.begin(), codeblocks_scripts.end() );
        codeblocks_scripts.erase( end, codeblocks_scripts.end() );

        for( size_t i=0; i<codeblocks_scripts.size(); i++ )
        {
            std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), codeblocks_scripts[i].c_str() );
            project << advance << less << "Unit filename=" << quote << rel_path << quote << greater << endl;
            project << advance << less << "Option compile=" << quote << '0' << quote << endelement << endl << retreat;
            project << advance << less << "Option link=" << quote << '0' << quote << endelement << endl << retreat;
            if( !virtual_folder_extension.empty() )
            {
                project << advance << less << "Option virtualFolder=" << quote << "Scripts" << quote << endelement << endl << retreat;
            }
            project << less << '/' << "Unit" << greater << endl << retreat;
        }



    }

    /// \note Global/Director/Target property CODEBLOCKS_CONFIGURED_FILES = is a list
    /// of files  that are the source for a generated source file or script - this is a clue
    /// to programmer not to edit a generated file but edit it's source and re-configure.
    /// Files are cumulative from global to target.

    /// Write Configure files for Virtual folder section of project
    void writeConfigurationSources( cmMakefile* mf, const cmTarget& target )
    {
        if( getProperty( mf, target, "CODEBLOCKS_CONFIGURED_FILES" ) ) //there is a configuration file
        {
            //files are cumulative
            std::vector< std::string > configure;

            const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_CONFIGURED_FILES", cmProperty::TARGET );
            if( p )
            {
               list2vector( p, configure );
            }

            p = mf->GetProperty( "CODEBLOCKS_CONFIGURED_FILES", cmProperty::DIRECTORY );
            if( p )
            {
                list2vector( p, configure, false );
            }

            // Should be in workspace but codeblocks only allows projects under a workspace.
            p = mf->GetCMakeInstance()->GetProperty( "CODEBLOCKS_CONFIGURED_FILES", cmProperty::GLOBAL );
            if( p )
            {
                 list2vector( p, configure, false );
            }

            //Purge
            sort( configure.begin(), configure.end() );
            std::vector< std::string>::iterator end = std::unique( configure.begin(), configure.end() );
            configure.erase( end, configure.end() );

            for( size_t i=0; i<configure.size(); i++ )
            {
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), configure[i].c_str() );
                project << advance << less << "Unit filename=" << quote << rel_path << quote << greater << endl;
                project << advance << less << "Option compile=" << quote << '0' << quote << endelement << endl << retreat;
                project << advance << less << "Option link=" << quote << '0' << quote << endelement << endl << retreat;
                if( !virtual_folder_extension.empty() )
                {
                    project << advance << less << "Option virtualFolder=" << quote << "Configure" << quote << endelement << endl << retreat;
                }
                project << less << '/' << "Unit" << greater << endl << retreat;
           }
        }
    }

    /// \note Global/Director/Target  property CODEBLOCKS_RESOURCE_FILES = is a list
    /// of files  that are the source for a generated resources - Files are cumulative
    /// from global to target.

        /// Write Resource files for Virtual folder section of project
    void writeResourceSources( cmMakefile* mf, const cmTarget& target )
    {
        if( getProperty( mf, target, "CODEBLOCKS_RESOURCE_FILES" ) ) //there is a configuration file
        {
            //files are cumulative
            std::vector< std::string > resource;

            const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_RESOURCE_FILES", cmProperty::TARGET );
            if( p )
            {
               list2vector( p, resource );
            }

            p = mf->GetProperty( "CODEBLOCKS_RESOURCE_FILES", cmProperty::DIRECTORY );
            if( p )
            {
                list2vector( p, resource, false );
            }

            // Should be in workspace but codeblocks only allows projects under a workspace.
            p = mf->GetCMakeInstance()->GetProperty( "CODEBLOCKS_RESOURCE_FILES", cmProperty::GLOBAL );
            if( p )
            {
                 list2vector( p, resource, false );
            }

            //Purge
            sort( resource.begin(), resource.end() );
            std::vector< std::string>::iterator end = std::unique( resource.begin(), resource.end() );
            resource.erase( end, resource.end() );

            for( size_t i=0; i<resource.size(); i++ )
            {
                std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), resource[i].c_str() );
                project << advance << less << "Unit filename=" << quote << rel_path << quote << greater << endl;
                project << advance << less << "Option compile=" << quote << '0' << quote << endelement << endl << retreat;
                project << advance << less << "Option link=" << quote << '0' << quote << endelement << endl << retreat;
                if( !virtual_folder_extension.empty() )
                {
                    project << advance << less << "Option virtualFolder=" << quote << "Resources" << quote << endelement << endl << retreat;
                }
                project << less << '/' << "Unit" << greater << endl << retreat;
           }
        }
    }

    /// Write Units section.
    void writeUnits( cmMakefile* mf, const cmTarget& target )
    {
        //for each project file
        std::vector<cmSourceFile*> const sources = const_cast<cmTarget&>(target).GetSourceFiles();
        for( size_t i=0; i<sources.size(); i++ )
        {
            if( cmSystemTools::IsOn( const_cast<cmTarget&>(target).GetProperty( "SYMBOLIC", cmProperty::TARGET ))  )continue;

            const std::string path = sources[i]->GetFullPath();
            std::string rel_path = cmSystemTools::RelativePath( codeblocks_binary_directory.c_str(), path.c_str() );
            project << advance << less << "Unit filename=" << quote << rel_path << quote << greater << endl;
            writeUnitCompilerVar( mf, target, sources[i] );
            writeUnitBuildCommand( mf, target, sources[i] );
            writeUnitCompiler( mf, target, sources[i] );
            writeUnitLink( mf, target, sources[i] );
            writeUnitWeight( mf, target, sources[i] );
            writeUnitVirtualFolder( mf, target, sources[i] );
            writeUnitTarget( mf, target, sources[i] );
            project << less << '/' << "Unit" << greater << endl << retreat;
        }

        //Scripts
        writeResourceSources( mf, target );

        //Scripts
        writeScriptSources( mf, target );

        //Configure files
        writeConfigurationSources( mf, target );

        //Generated files not in this project
        writeGeneratedSources( mf, target );


    }

//------------------------------------ Project Virtual Folders ------------------------------------------------

    /// \note Global/Director/Target  property CODEBLOCKS_VIRTUAL_FOLDERS = default or a list(name
    /// followed by file extensions). The extensions must have a leading asterisk.
    /// For example: Sources *.cpp *.cxx Headers *.h *.hpp Sources/Assembly *.s
    /// "default" will enable virtual folders with:
    /// "Sources;*.cpp;*.cxx;*.c;Headers*.h;*.hxx;*.hpp;Generated;Resources;*xrc;Scripts;*.sh;*.bat;*.cmd;*"
    /// Any file that has a Generated property will go under Generated, any codeblocks script file will go under
    /// Scripts along with the current CMakeList.txt file. A lone asterisk means any file without an extension.
    /// default followed by a list will add that list to the default list above. DIRECTORY property will
    /// override the GLOBAL property, TARGET property will override DIRECTORY and a
    /// SOURCE property of CODEBLOCKS_VIRTUAL_FOLDER (Folder name only)
    /// will override all.

    /// Write Virtual folder section of project
    void writeVirtualFolders( cmMakefile* mf, const cmTarget& target )
    {
        virtual_folder_extension.clear();
        const char* p = getProperty( mf, target, "CODEBLOCKS_VIRTUAL_FOLDERS" );

        if( p )
        {
            std::vector< std::string > folders;
            std::vector< std::string > arg;

            list2vector( p, arg );

            if( arg[0] == "default" )
            {
                std::vector< std::string > it;
                list2vector( "Sources;*.cpp;*.cxx;*.c;Headers;*.h;*.hxx;*.hpp;Generated;Resources;*.xrc;*.rc;*.rc2;Scripts;Configure;*.in", it );
                //std::back_insert_iterator< std::vector< std::string > > bi(it);
                //std::copy( arg.begin(), arg.end(), bi );
                it.insert( it.end(), arg.begin()+1, arg.end() );
                arg.swap( it );
            }

            std::string last_folder;

            for( size_t i = 0; i<arg.size(); i++ )
            {
                if( arg[i].empty() ) continue;

                if( arg[i].at(0) == '*' )
                {
                    if( last_folder.empty() )
                    {
                        /// \todo warning file extention but no folder
                        continue;
                    }

                    if( arg[i].length() == 1 )virtual_folder_extension["*"] = last_folder;
                    else
                    {
                        size_t start = 1;
                        if( arg[i].at(start) == '.' )start++;
                        if( arg[i].length() > start )
                        {
                            std::string key = arg[i].substr( start, std::string::npos ); // cmSource GetExtension - return no dot.
                            virtual_folder_extension[key] = last_folder;
                        }
                        else
                        {
                            /// \todo warning file extention is a dot?
                            continue;
                        }
                    }
                }
                else
                {
                    last_folder = arg[i];
                    if( std::count( folders.begin(), folders.end(), last_folder ) == 0 ) //keep user order
                    {
                        folders.push_back( last_folder );
                    }
                }

            }

            // Get source folders ad to list
            bool found_generated_source = false;
            std::vector<cmSourceFile*> const sources = const_cast<cmTarget&>(target).GetSourceFiles();
            for( size_t i=0; i<sources.size(); i++ )
            {
                const char* p = sources[i]->GetProperty( "CODEBLOCKS_VIRTUAL_FOLDER" );
                if( p )folders.push_back( std::string( p ) );
            }

            /// \note Global/Director/Target  property CODEBLOCKS_RESOURCE_FILES = is a list
            /// of files  that are the source for a generated resources - Files are cumulative
            /// from global to target.

            last_folder = "Resources";
            if( std::count( folders.begin(), folders.end(), last_folder ) == 0 )
            {
                 const char* p = getProperty( mf, target, "CODEBLOCKS_RESOURCE_FILES" );
                 if( p )
                 {
                     folders.push_back( last_folder ); // A lest one configure file was found
                 }
            }

            last_folder = "Scripts";
            if( std::count( folders.begin(), folders.end(), last_folder ) == 0 )
            {
                folders.push_back( last_folder ); // A lest one script CMakeLists.txt
            }

            last_folder = "Generated";
            if( found_generated_source && std::count( folders.begin(), folders.end(), last_folder ) == 0 )
            {
                folders.push_back( last_folder ); // A lest one generated source
            }

            /// \note Global/Director/Target  property CODEBLOCKS_CONFIGURED_FILES = is list
            /// of files  that are the source for a generated source file or script - this is a clue
            /// to programmer not to edit a generated file but edit it's source and re-configure.
            /// Files are cumulative from global to target.

            last_folder = "Configure";
            if( std::count( folders.begin(), folders.end(), last_folder ) == 0 )
            {
                 const char* p = getProperty( mf, target, "CODEBLOCKS_CONFIGURED_FILES" );
                 if( p )
                 {
                     folders.push_back( last_folder ); // A lest one configure file was found
                 }
            }

            /// \note Purge CodeBlocks default folders Sources Headers Scripts and Resources,
            /// it may be that Unit virtualFolder are folders not virtual folders
            /// If a folder is in the Unit section but not in the virtualFolders Option
            /// it will show in the codeblocks ide, but the complete path will be include in the folder.
            std::string default_codeblocks_folders = "SourcesHeadersScriptsResources";
            std::vector< std::string > tz;
            for( size_t i=0; i<folders.size(); i++ )
            {
               if( default_codeblocks_folders.find( folders[i] ) == std::string::npos ) tz.push_back( folders[i] );
            }

            folders.swap( tz );

            std::string result;
            vector2list( folders, result );

            project << advance << less << "Option virtualFolders=" << quote << result << quote << endelement << endl << retreat;
        }
    }


//------------------------------------ Target Section ------------------------------------------------
    /// Write Target section of project
    void writeBuildTarget( cmMakefile* mf, const cmTarget& target  )
    {
        project << advance << less << "Target title=" << quote << current_build_type_name << quote << greater << endl;
        writePlatformsOption( mf );
        writeOutput( mf, target );
        writeWorkingDirectory( mf, target );
        writeObjectOutput( mf, target );
        writeExternalDependencies( mf, target );
        writeAdditionalOutputs( mf, target );
        writeOutputType( mf, target );
        writeCompilerId( mf, target );
        writeConsoleRunner( mf, target );
        writeExecutionParameters( mf, target );
        writeHostApplication( mf, target );
        writeCreateDEFFile( mf, target );
        writeCreateImportLibrary( mf, target );
        writeCompilerRelation( mf, target );
        writeLinkerOptionRelation( mf, target );
        writeIncludeDirectoryRelation( mf, target );
        writeResourceIncludeDirectoryRelation( mf, target );
        writeLibraryDirectoryRelation( mf, target );
        writeTargetScripts( mf, target );
        writeTargetCompilerSettings( mf, target );
        writeTargetLinkerSettings( mf, target );
        writeTargetResourceCompilerSettings( mf, target );
        writeTargetExtraCommands( mf, target );


        project << less << '/' << "Target" << greater << endl << retreat;
    }

//------------------------------------ Build Section Scripts ------------------------------------------------

    /// \note Directory property CODEBLOCKS_SCRIPT - run a directory (CMakeLists) level codeblocks script

    /// Write Build scripts of Build section.
    void writeBuildScripts( cmMakefile* mf, const cmTarget& target )
    {
        const char* p = const_cast<cmTarget&>(target).GetProperty( "CODEBLOCKS_SCRIPT", cmProperty::DIRECTORY );

        if( p )
        {
            std::string script = p;
            codeblocks_scripts.push_back( script );
            project << advance << less << "Script file=" << quote << script << quote << endelement << endl << retreat;
        }
    }

//------------------------------------ Build Section ------------------------------------------------
    /// Write Build sectin of project
    void writeBuild( cmMakefile* mf, const cmTarget& target  )
    {
        project << advance << less << "Build" << greater << endl;
        writeBuildScripts( mf, target );

        //for each build type
        std::vector< std::string > build;

        getBuilds( mf, build );

        for( size_t i=0; i<build.size(); i++ )
        {
            current_build_type_name = build[i];
            writeBuildTarget( mf, target );
        }
        project << less << '/' << "Build" << greater << endl << retreat;

    }

//------------------------------------ Project  ------------------------------------------------
    /// Write the project
    void writeProject( cmMakefile* mf, const cmTarget& target, const std::string& workspace_directory,
                       const std::string& project_file, std::set<const cmTarget*>& depends  )
    {
        search_first_object_directory.clear(); //pch mode 1 - search first
        virtual_folder_extension.clear();
        codeblocks_scripts.clear();
        current_build_type_name.clear();
        rpath.clear(); //executable target rpath flags

        workspace_depends.clear();
        std::set<const cmTarget*>::iterator it = depends.begin();
        while( it != depends.end() )workspace_depends.push_back( *it++ );

        codeblocks_binary_directory = workspace_directory;
        project_binary_directory = project_file;
        size_t ix = project_binary_directory.rfind( target.GetName() ); //assume cbp file name after target
        if( ix != std::string::npos )project_binary_directory.resize( ix );

        std::string current_list_file = mf->GetCurrentListFile(); //There are other reasons then cmake
        codeblocks_scripts.push_back( current_list_file );


        project.clear();
        project << less << "?xml version=" << quote << "1.0" << quote << " encoding="
                << quote << "UTF-8" << quote << " standalone=" << quote << "yes" << quote << '?' << greater << endl;
        project << less << "CodeBlocks_project_file" << greater << endl;
        project << advance << less << "FileVersion major=" << quote << '1' << quote
                << " minor=" << quote << '6' << quote << endelement << endl << retreat;


        project << advance << less << "Project" << greater << endl;
        writeProjectTitleOption( target );
        writePlatformsOption( mf );
        // makefile
        writePCH( mf, target );
        writeDefaultTarget( mf, target );
        writeCompilerId( mf, target );
        writeVirtualFolders( mf, target );
        writeExtendedObjectNames( mf, target );
        writeNotes( mf, target );
        writeBuild( mf, target );
        writeVirtualTargets( mf, target );
        writeCompiler( mf, target );
        writeResourceCompiler( mf, target );
        writeLinker( mf, target );
        writeExtraCommands( mf, target );
        writeUnits( mf, target );
        project << less << "/Project" << greater << endl << retreat;

        project << less << '/' << "CodeBlocks_project_file" << greater << endl;


        project.writeBuffer( project_file );
    }

} //namespace codeblocksgenerator

    void cmLocalCodeBlocksGenerator::writeProject( cmMakefile* mf, const cmTarget& target, const std::string& workspace_directory,
                       const std::string& project_file, std::set<const cmTarget*>& depends  )
    {
        codeblocksgenerator::writeProject( mf, target, workspace_directory, project_file, depends  );
    }


    void cmLocalCodeBlocksGenerator::writeUtilityProject( cmMakefile* mf, const cmTarget& target, const std::string& workspace_directory,
                                                          const std::string& project_file )
    {
        codeblocksgenerator::writeUtilityProject( mf, target, workspace_directory, project_file );
    }


    void cmLocalCodeBlocksGenerator::writeCommandProject( cmMakefile* mf,
                                                          const std::string& command,
                                                          const std::string& title,
                                                          const std::string& project_file )
    {
        codeblocksgenerator::writeCommandProject( mf, command, title, project_file );
    }

//////////////////////////////////////////////////////////////////////////////////////////////