root/simulator/trunk/vendor/cmake/Source/cmPackageConfigureCommand.cpp

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


#include <iostream>
#include <fstream>
#include <string>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <cstdlib>
#include <algorithm>
#include <cctype>

//#include <signal.h>

#include "cmake.h"
#include "cmMakefile.h"
#include "cmTest.h"

#include "cmPackageConfigureCommand.h"

using namespace std;

/// \addtogroup utilities "Utilities"
/// @{
///   \addtogroup utilitiescmake "Utilities CMake Custom Command PURGECONFIGURE"
///   @{


/// \file
/// Special CMake command to filter and unwined the output
/// of xxx-config and pkg-config programes.
///
/// from cmCacheManager.h in cmake source

bool cmPackageConfigureCommand::InitialPass( std::vector<std::string> const& args, cmExecutionStatus &status )
{
    std::string error;

    if( args.empty()  )
    {
        SetError( "Error Must have at least a target" );
        return false;
    }

    cmTarget* target = Makefile->FindTarget( args[0].c_str() );

    if( !target )
    {
        error = "Error unknown target:";
        error += args[0];
        SetError( error.c_str() );
        return false;
    }

    std::vector< std::string >& argument_list = arguments[args[0]];
    argument_list.clear();



    std::string sz;
    try
    {
        for( size_t i=1; i<args.size(); i++ )
        {
            if( args[i].empty() )continue; //some are empty

            std::string raw = args[i];

            argument_list.push_back( raw );
        }

    }
    catch( ... )
    {
        error = "Error reading string:";
        error += sz;
        SetError( error.c_str() );
        return false;
    }

    return true;
}


// static would not work - we are included in command bootstrap cpp file.
namespace packageconfigure
{
    //FILE* log_file = 0;
    //const char* log_file_name = "/home/samuel/working/simulator/branches/dashboard-682/MAKE/bin/packageconfigure/log.txt";

    const char* cmake_flags[] =
    {
        "CMAKE_C_FLAGS_",
        "CMAKE_CXX_FLAGS_"
    };

 //------------------------------------ convert cmake list to strings ------------------------------------------------
    /// Convert 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 cmake list to strings ------------------------------------------------
    /// Convert a cmake string to a vector of strings - can't use cmSystemTools
    void list2vector( const std::string sz, std::vector< cmsys::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( const std::set< std::string >& set, std::string& result, char sep=';', bool clear=true )
    {
        if( clear )result.clear();
        std::set< std::string >::iterator i = set.begin();
        while( i != set.end() )
        {
            if( !result.empty() )result+= sep;
            result += *i++;
        }
    }

//------------------------------------ convert cmake list to a set strings ------------------------------------------------
    /// Convert a cmake string to a set of strings - can't use cmSystemTools
    void list2set( const std::string sz, std::set< std::string >& set, bool clear=true )
    {
        if( clear )set.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 )
            {
                set.insert( sz.substr( start, stop - start ));
                start = sz.find_first_not_of(" ;", stop );
            }
            else
            {
                set.insert( sz.substr( start, sz.size() ));
                start = std::string::npos;
            }
        }
    }

//------------------------------------ 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];
        }
    }

//------------------------------------ add a definition to cache - mark it as advance ------------------------------------------------
    /// Add cache definition
    static void addCacheDefinition( cmMakefile* makefile, std::vector< std::string >& names, std::vector< std::string >& results, const char* note )
    {
        //log_file = fopen( log_file_name, "ab" );
        //fprintf( log_file, "addCacheDefinition\n" );
        //fclose( log_file );
        if( !names.size() )return;

        size_t size = names.size();
        for( size_t j=0; j<size; j++ )
        {
            if( !results[j].empty() )
            {
                std::string symbol;
                std::string sz;
                sz = "Advanced flag for variable ";
                sz += names[j];
                symbol = names[j];
                symbol += "-ADVANCED";
                makefile->AddCacheDefinition( names[j].c_str(), results[j].c_str(), note, cmCacheManager::STRING );
                makefile->AddCacheDefinition( symbol.c_str(), "1", sz.c_str(), cmCacheManager::INTERNAL );

            }
        }
    }


    static char graph( char ch )
    {
        if( ch == '\\' )return '/';  //for Windows paths
        if( std::isgraph( ch ))return ch;
        return ' ';
    }

    void saveResult( const char* p, std::set< std::string >& target_build_types, std::map< std::string, std::set< std::string > >& results )
    {
        if( p )
        {
            std::string raw = p;
            std::string sz;

            sz.reserve( raw.size() );
            std::transform( raw.begin(), raw.end(), std::back_inserter( sz ), graph );
            std::vector< std::string > buffer;
            list2vector( sz, buffer );
            for( size_t i=0; i<buffer.size(); i++ )
            {
                sz = buffer[i];
                std::set< std::string >::iterator it = target_build_types.begin();
                while( it != target_build_types.end() )results[*it++].insert( buffer[i] );
            }
        }
    }

    void saveCFlagResult( const std::string& name, std::set< std::string >& target_build_types, std::map< std::string, std::set< std::string > >& results )
    {
        std::vector< std::string > hold;
        list2vector( name, hold );

        if( target_build_types.empty() )
        {
            std::set< std::string > types;
            types.insert( "RelWithDebInfo" );
            types.insert( "Release" );
            types.insert( "MinSizeRel" );
            for( size_t i=0; i<hold.size(); i++ ) saveResult( hold[i].c_str(), types, results );
        }
        else
        {
            for( size_t i=0; i<hold.size(); i++ ) saveResult( hold[i].c_str(), target_build_types, results );
        }
    }

    void saveLibsResult( const std::string& name, std::set< std::string >& target_build_types, std::map< std::string, std::set< std::string > >& results, bool found_debug )
    {
        std::vector< std::string > hold;
        list2vector( name, hold );

        if( target_build_types.empty() )
        {
            std::set< std::string > types;
            types.insert( "optimized" );
            if( !found_debug )types.insert( "general" );
            for( size_t i=0; i<hold.size(); i++ ) saveResult( hold[i].c_str(), types, results );
        }
        else
        {
            for( size_t i=0; i<hold.size(); i++ ) saveResult( hold[i].c_str(), target_build_types, results );
        }
    }

    void mergeCFlags( cmMakefile* makefile, cmTarget* target,
                      const std::string& build_type_index,
                      std::string& language,
                      std::set< std::string >& heap )
    {
        //global flags
        std::set< std::string > global_flags;
        std::string global = "CMAKE_";
        global += language;
        global += "_FLAGS";
        const char* p = makefile->GetDefinition( global.c_str() );
        if( p )list2set( p, global_flags );

        std::set< std::string > build_flags;
        std::string build = "CMAKE_";
        build += language;
        build += "_FLAGS_";
        build += cmSystemTools::UpperCase( build_type_index );
        p = makefile->GetDefinition( build.c_str() );
        if( p )list2set( p, build_flags );

        std::set< std::string > local_flags;
        std::string local;
        switch( target->GetType() )
        {
        case cmTarget::STATIC_LIBRARY : local = "CMAKE_STATIC_"; break;
        case cmTarget::SHARED_LIBRARY : local = "CMAKE_SHARED_LIBRARY_"; break;
        case cmTarget::MODULE_LIBRARY : local = "CMAKE_SHARED_MODULE_"; break;
        case cmTarget::EXECUTABLE :
        default:
            break;
        }

        if( !local.empty() )
        {
            local += language;
            local += "_FLAGS";
            p = makefile->GetDefinition( local.c_str() );
            if( p )list2set( p, local_flags );
        }

        //look for cflags
        std::set< std::string > compiler_flags;
        p = target->GetProperty( "COMPILE_FLAGS" );
        if( p )list2set( p, compiler_flags );
        std::set< std::string >::iterator it = heap.begin();
        while( it != heap.end() )
        {
            //cflags only ones remaining
            std::set< std::string >::iterator ix = it;
            std::string line = *it++;
            size_t count = std::count( global_flags.begin(), global_flags.end(), line );
            count += std::count( build_flags.begin(), build_flags.end(), line );
            count += std::count( local_flags.begin(), local_flags.end(), line );
            count += std::count( compiler_flags.begin(), compiler_flags.end(), line );
            if( !count )
            {
                build_flags.insert( line );
            }
            heap.erase( ix );

        }
        std::string result;
        set2list( build_flags, result, ' ' );
        makefile->AddDefinition( build.c_str(), result.c_str() );

    }


    void mergeLibrarySearchPaths( cmMakefile* makefile, cmTarget* target,
                                  const std::string& build_type_index,
                                  std::set< std::string >& heap )
    {
        const std::vector< std::string >& includes = target->GetLinkDirectories();

        std::set< std::string >::iterator it = heap.begin();
        while( it != heap.end() )
        {

            std::set< std::string >::iterator ix = it;
            std::string line = *it++;
            if( line.find( "-L" ) == 0 )
            {
                std::string sz = line.substr( 2, line.size() );
                if( std::count( includes.begin(), includes.end(), sz ) == 0 )
                {
                    target->AddLinkDirectory( sz.c_str() );
                }
                heap.erase( ix );
            }
        }

    }

    struct Package
    {
        cmTarget::LinkLibraryType type;
        std::string               name;
    };

    bool operator==( const cmTarget::LibraryID& a, const Package& b )
    {
        if( b.name != a.first )return false;
        if( b.type != a.second )return false;
        return true;
    }

    void mergeLibraries( cmMakefile* makefile, cmTarget* target,
                         const std::string& build_type_index,
                         std::set< std::string >& heap )
    {
        Package library;

        if( build_type_index == "debug" )library.type = cmTarget::DEBUG;
        else if( build_type_index == "optimized" )library.type = cmTarget::OPTIMIZED;
        else library.type = cmTarget::GENERAL;


        const cmTarget::LinkLibraryVectorType& libraries = target->GetLinkLibraries();

        std::set< std::string >::iterator it = heap.begin();
        while( it != heap.end() )
        {
             std::set< std::string >::iterator ix = it;
             std::string line = *it++;
             if( line.find( "-l" ) == 0 )
             {
                 library.name = line.substr( 2, line.size() );
                 if( std::count( libraries.begin(), libraries.end(), library ) == 0 )
                 {
                     target->AddLinkLibrary( *makefile, target->GetName(), library.name.c_str(), library.type );
                     //if( strcmp( target->GetName(), "Simulator" ) == 0
                     //    && library.type == cmTarget::DEBUG ) cout << library.name << endl;
                 }
                 heap.erase( ix );
             }
        }

    }

    void mergeCompilerSearchPaths( cmMakefile* makefile, cmTarget* target,
                                   const std::string& build_type_index,
                                   std::set< std::string >& heap )
    {
        std::vector< std::string >& includes = makefile->GetIncludeDirectories();

        std::set< std::string >::iterator it = heap.begin();
        while( it != heap.end() )
        {

            std::set< std::string >::iterator ix = it;
            std::string line = *it++;
            if( line.find( "-I" ) == 0 )
            {
                std::string sz = line.substr( 2, line.size() );
                if( std::count( includes.begin(), includes.end(), sz ) == 0 )
                {
                    includes.push_back( sz );
                }
                heap.erase( ix );
            }
            makefile->SetIncludeDirectories( includes );
        }

    }

    void mergeDefinitions( cmMakefile* makefile, cmTarget* target,
                           const std::string& build_type_index,
                           bool current_build,
                           std::set< std::string >& heap )
    {
        std::set< std::string > global_defines;
        std::string symbol = "COMPILE_DEFINITIONS";
        const char* p = makefile->GetProperty( symbol.c_str(), cmProperty::DIRECTORY );
        if( p ) list2set( p, global_defines, false );
        p = target->GetProperty( symbol.c_str(), cmProperty::TARGET );
        if( p ) list2set( p, global_defines, false );
        symbol += '_';
        symbol +=  cmSystemTools::UpperCase( build_type_index );
        std::set< std::string > build_defines;
        p = makefile->GetProperty( symbol.c_str(), cmProperty::DIRECTORY );
        if( p ) list2set( p, build_defines, false );
        p = target->GetProperty( symbol.c_str(), cmProperty::TARGET );
        if( p ) list2set( p, build_defines, false );

        std::set< std::string > defines;
        std::set< std::string >::iterator it = heap.begin();
        while( it != heap.end() )
        {
             std::set< std::string >::iterator ix = it;
             std::string line = *it++;
             if( line.find( "-D" ) == 0 )
             {
                 std::string look = line.substr( 2, line.size());
                 size_t count = std::count( global_defines.begin(), global_defines.end(), look );
                 count += std::count( build_defines.begin(), build_defines.end(), look );
                 if( !count )
                 {
                     defines.insert( look );
                 }

                 heap.erase( ix );
             }


        }

        if( !defines.empty() )
        {
            std::set< std::string >::iterator x = defines.begin();
            while( x != defines.end() )
            {
                std::string sz = (*x);
                target->AppendProperty( symbol.c_str(), (*x).c_str() );
                if( current_build )
                {
                    makefile->AppendProperty( "COMPILE_DEFINITIONS", (*x).c_str() );
                }
                x++;
            }
        }
    }

    struct Returns
    {
        std::string buffer;
        int         return_value;
        bool        exit_value;
    };

    static std::map< std::string, Returns > command_cache;

    bool doCommand( std::string& line, std::string* buffer, int* return_value, std::string& working_directory )
    {
        std::string key = line + working_directory;
        Returns& x = command_cache[key];
        if( !x.buffer.empty() )
        {
            *buffer = x.buffer;
            *return_value = x.return_value;
        }
        else
        {

            std::vector< cmsys::String > command;
            list2vector( line, command );
            x.exit_value = cmSystemTools::RunSingleCommand( command, buffer, return_value, working_directory.c_str(), false, 0.0 );
            x.buffer = *buffer;
            x.return_value = *return_value;
        }

        return x.exit_value;
    }


    //------------------------------------ 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;
    }



}  //namespace packageconfigure


void cmPackageConfigureCommand::FinalPass()
{
        //log_file = fopen( log_file_name, "ab" );
        //fprintf( log_file, "finalPass\n" );
        //fclose( log_file );
    std::map< std::string, std::vector< std::string > >::iterator targets = arguments.begin();
    while( targets != arguments.end() )
    {
        std::vector< std::string >& argument_list = (*targets).second;

        //cout << (*targets).first << endl;

        std::string raw;
        const char* p = Makefile->GetDefinition( "CMAKE_CONFIGURATION_TYPES" );
        if( !p )raw = "RelWithDebInfo";
        else raw = p;

        std::vector< std::string > build_types;
        packageconfigure::list2vector( raw, build_types );
        build_types.push_back( std::string( "debug" ) ); //library types
        build_types.push_back( std::string( "optimized" ) ); //library types
        build_types.push_back( std::string( "general" ) ); //library types
        // Type builds with a set of results
        std::map< std::string, std::set< std::string > >results;
        for( size_t j=0; j<build_types.size(); j++ )
            results.insert( std::pair< std::string, std::set< std::string > >
                ( build_types[j], std::set< std::string >() ) );

        std::string command;
        std::string working_directory = Makefile->GetStartDirectory();
        std::string output;
        std::string buffer;
        int return_value;

       // for each argument
        std::vector< std::string >::iterator it = argument_list.begin();
        // set the target_build_types to the default build type
        std::set< std::string > target_build_types;
        target_build_types.clear();

        // the target
        cmTarget* target = Makefile->FindTarget( (*targets).first.c_str() );
        if( !target ) continue;

        // search paths for pc and config files
        /// \note PackageConfigure CMake Global, Directory and Target Property PACKAGECONFIGURE_PC_FILES
        /// sets the location of a working directory for pkg-config utility pc files. This is used for
        /// files that override or augment the /usr/... /lib/pkgconfig directory files.
        /// If ARCHIVE_OUTPUT_DIRECTORY is set - set to ARCHIVE_OUTPUT_DIRECTORY/pkgconfig,
        /// if not then LIBRARY_OUTPUT_DIRECTORY/pkgconfig.
        /// if not then LIBRARY_OUTPUT_PATH/pkgconfig.
        /// or defaults to CMAKE_BINARY_DIR/pkgconfig.
        /// If the pkgconfig directory is found pkg-config will use the system directory if it doesn't
        /// find the pc file, it's the current directory.
        std::string pc_search_path;
        p = packageconfigure::getProperty( Makefile, target, "PACKAGECONFIGURE_PC_FILES" );
        if( p )pc_search_path = p;
        else
        {
            if( !p )
            {
                p = packageconfigure::getProperty( Makefile, target, "ARCHIVE_OUTPUT_DIRECTORY" );
            }
            if( p ) pc_search_path = p;
            if( !p )
            {
                p = packageconfigure::getProperty( Makefile, target, "LIBRARY_OUTPUT_DIRECTORY" );
            }
            if( p ) pc_search_path = p;
            if( !p )
            {
                p = Makefile->GetDefinition( "LIBRARY_OUTPUT_PATH" );
            }
            if( p ) pc_search_path = p;
            if( !p  )
            {
                pc_search_path = Makefile->GetStartOutputDirectory();
            }
            pc_search_path += "/pkgconfig/";
        }


        /// \note PackageConfigure CMake Global, Directory and Target Property PACKAGECONFIGURE_XXX-CONFIG_FILES
        /// sets the location of a working directory for xxx-config scripts. This is used for
        /// files that replace, override or augment the /usr/... /bin scripts.
        /// If set defaults to EXECUTABLE_OUTPUT_PATH - else CMAKE_BINARY_DIR

        std::string xxx_config_search_path;
        p = packageconfigure::getProperty( Makefile, target, "PACKAGECONFIGURE_XXX-CONFIG_FILES" );
        if( p )xxx_config_search_path = p;
        else
        {
            p = Makefile->GetDefinition( "EXECUTABLE_OUTPUT_PATH" );
            if( p ) xxx_config_search_path = p;
            else xxx_config_search_path = Makefile->GetStartOutputDirectory();
        }

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

            std::string param = *it++;

            if( std::count( build_types.begin(), build_types.end(), param ) == 0 )
            {
                std::string command;

                if( param.find( "-config" ) != std::string::npos )
                {
                    command.clear();
                    command = "./";
                    command += param;
                    std::vector< std::string >::iterator cmd = it;
                    while( cmd != argument_list.end() )
                    {
                        param = *cmd;
                        if( std::count( build_types.begin(), build_types.end(), param ) != 0 )break; //stop on a new build type
                        if( param.find( "--" ) == std::string::npos )break; //xxx-config only have switches
                        if( param.find( "-config" ) != std::string::npos )break; //stop on a new xxx-config command
                        command += ' ';
                        command += param;
                        cmd++;
                    }
                    it = cmd; //next



                    //Will not work under windows symbols not exported to dll - normally
                    if( packageconfigure::doCommand( command, &buffer, &return_value, xxx_config_search_path ))
                    {
                        packageconfigure::saveResult( buffer.c_str(), target_build_types, results );
                    }
                    else
                    {
                        //system wide
                        command.erase( 0, 2 );
                        if( packageconfigure::doCommand( command, &buffer, &return_value, xxx_config_search_path ))
                        {
                            packageconfigure::saveResult( buffer.c_str(), target_build_types, results );
                        }
                    }
                    target_build_types.clear();
                }
                else
                {
                    bool found_debug = false;
                    //No target type (Debug, Release, etc)
                    //So defult to a debug .pc file
                    if( target_build_types.empty() )
                    {
                        std::string pc_file = param;
                        target_build_types.clear();
                        target_build_types.insert( "Debug" );
                        size_t ix = pc_file.rfind( ".pc" );
                        if( ix != std::string::npos )pc_file.insert( ix, "_debug" );
                        else pc_file += "_debug";

                        command = "pkg-config --cflags ";
                        command += pc_file;

                        //cout << command;

                        if( packageconfigure::doCommand( command, &buffer, &return_value, pc_search_path )
                            && !return_value )
                        {
                            packageconfigure::saveCFlagResult( buffer, target_build_types, results );
                            //cout << buffer << endl;
                        }
                        // No xxx_debug.pc file goto system directory for flags
                        else
                        {
                            command.clear();

                            command = "pkg-config --cflags ";
                            command += param;
                            if( packageconfigure::doCommand( command, &buffer, &return_value, working_directory )
                                && !return_value )
                            {
                                 packageconfigure::saveCFlagResult( buffer, target_build_types, results );
                            }
                        }

                        // Do the above but for libraries
                        target_build_types.clear();
                        target_build_types.insert( "debug" );

                        command.clear();

                        command = "pkg-config --libs ";
                        command += pc_file;  //constructed with xxx_debug.pc
                        //cout << command;
                        if( packageconfigure::doCommand( command, &buffer, &return_value, pc_search_path )
                            && !return_value )
                        {
                            packageconfigure::saveLibsResult( buffer, target_build_types, results, found_debug );
                            found_debug = true;
                            //cout << buffer << endl;
                        }
                        // No xxx_debug.pc file goto system directory for flags
                        else
                        {
                            command.clear();

                            command = "pkg-config --libs ";
                            command += param;
                            if( packageconfigure::doCommand( command, &buffer, &return_value, working_directory )
                                && !return_value )
                            {
                                 packageconfigure::saveLibsResult( buffer, target_build_types, results, found_debug );
                            }
                        }

                        target_build_types.clear();
                    }

                    command.clear();
                    command = "pkg-config --cflags ";
                    command += param;

                    std::string buffer;
                    int return_value;
                    if( packageconfigure::doCommand( command, &buffer, &return_value, pc_search_path )
                        && !return_value )
                    {
                        packageconfigure::saveCFlagResult( buffer, target_build_types, results );
                    }

                    command.clear();

                    command = "pkg-config --libs ";
                    command += param;

                    if( packageconfigure::doCommand( command, &buffer, &return_value, pc_search_path )
                        && !return_value )
                    {
                        packageconfigure::saveLibsResult( buffer, target_build_types, results, found_debug );
                    }
                }
            }
            else
            {
                target_build_types.insert( param ); //new target_build_types
            }

        }


        std::string current_build_type;
        p = Makefile->GetDefinition( "CMAKE_BUILD_TYPE" );
        if( p ) current_build_type = p;

        //Do each build
        for( size_t build_type_index=0; build_type_index < build_types.size(); build_type_index++ )
        {
            std::string build = build_types[build_type_index];
            std::string build_name = build;

            std::set< std::string >& heap = results[build];
            bool current_build = false;
            if( !current_build_type.empty() )
            {
                if( build == current_build_type )current_build = true;
                else
                {
                    if( current_build_type == "Debug" && build == "debug" )current_build = true;
                    else if( current_build_type != "Debug" && build == "optimized" )current_build = true;
                    else if( build == "general" )current_build = true;
                }

            }

            //flags in this build
            packageconfigure::mergeDefinitions( Makefile, target, build_name, current_build, heap );
            packageconfigure::mergeCompilerSearchPaths( Makefile, target, build_name, heap );
            packageconfigure::mergeLibrarySearchPaths( Makefile, target, build_name, heap );
            packageconfigure::mergeLibraries( Makefile, target, build_name, heap );

            std::set< cmStdString > languages;
            target->GetLanguages( languages );

            std::set< cmStdString >::iterator it = languages.begin();


            while( it != languages.end() )
            {
                std::string language = *it++;

                packageconfigure::mergeCFlags( Makefile, target, build_name, language, heap );

            }


        }

        targets++;

    }
    arguments.clear();

}





///   @}   group utilitiescmake
/// @}   group utilities