cmakelist_generator.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "cmakelist_generator.h"


PString getCMakeListsHeader(){
        PString body;
        body += "#========================================\n";
        body += "#\tAuteur : Pierre Aubert\n";
        body += "#\tMail : pierre.aubert@lapp.in2p3.fr\n";
        body += "#\tLicence : CeCILL-C\n";
        body += "#========================================\n\n";
        
        body += "#========================================\n";
        body += "#\tThis file was generated automatically by phoenix_filegenerator https://gitlab.in2p3.fr/CTA-LAPP/PHOENIX_LIBS2/PhoenixFileGenerator\n";
        body += "#\tusing phoenix_generator library https://gitlab.in2p3.fr/CTA-LAPP/PHOENIX_LIBS2/PhoenixGenerator\n";
        body += "#\tYou should not modify this file\n";
        body += "#========================================\n\n";
        return body;
}


PString getFindPackageFileName(const PString & libName){
        if(libName == "") return "";
        return "Find" + libName.toUpper() + ".cmake";
}


PString getFullLibraryName(const PCMakeLibrary & cmakeLib){
#ifdef __APPLE
        if(cmakeLib.getIsShared()) return "lib" + cmakeLib.getName() + ".dylib";
#else
        if(cmakeLib.getIsShared()) return "lib" + cmakeLib.getName() + ".so";
#endif
        else return "lib" + cmakeLib.getName() + ".a";
}


void saveFindPackageHeader(std::ofstream & fs, const PString & libPrefix, const PVecPath & listHeader){
        if(listHeader.size() == 0lu || libPrefix == "") return;
        PString findHeaderVariable(libPrefix + "_INCLUDE_DIR");
        fs << std::endl << std::endl << "#Find the headers of the library " << libPrefix << std::endl;
        
        fs << "find_path(" << findHeaderVariable << std::endl;
        fs << "\tNAMES";
        for(PVecPath::const_iterator it(listHeader.begin()); it != listHeader.end(); ++it){
                fs << " " << it->replace("${CMAKE_CURRENT_BINARY_DIR}/", "").replace("${CMAKE_CURRENT_SOURCE_DIR}/", "");
        }
        fs << std::endl;
        
        bool isPHOENIXfind(libPrefix.isSameBegining("PHOENIX_") && libPrefix != "PHOENIX_");
        PString tmpPrefix(libPrefix);
        if(isPHOENIXfind){
                tmpPrefix = "PHOENIX/PLIB_" + libPrefix.substr(8, libPrefix.size() - 8lu);
        }
        
        fs << "\tPATHS ${PHOENIX_PREFIX}/include/" << tmpPrefix << " ${CMAKE_INSTALL_PREFIX}/include/" << tmpPrefix << std::endl;
        fs << "\t\t${CMAKE_INCLUDE_PATH}/"<<tmpPrefix<<" /usr/include/"<<tmpPrefix<<" /usr/local/include/"<<tmpPrefix<<" $ENV{HOME}/usr/include/" << tmpPrefix << std::endl;
        fs << ")" << std::endl << std::endl;
        
        fs << "if(" << findHeaderVariable << ")" << std::endl;
        fs << "\tmessage(STATUS \"Found "<<libPrefix<<" headers : ${" << findHeaderVariable << "}\")" << std::endl;
        fs << "else(" << findHeaderVariable << ")" << std::endl;
        fs << "\tmessage(FATAL_ERROR \""<<libPrefix<<" headers not found\")" << std::endl;
        fs << "endif(" << findHeaderVariable << ")" << std::endl << std::endl;
        fs << "include_directories(${" << findHeaderVariable << "})" << std::endl << std::endl << std::endl;
        if(isPHOENIXfind){
                fs << "include_directories(${" << findHeaderVariable << "}/../)" << std::endl << std::endl << std::endl;
        }
}


void saveFindPackageLibrary(std::ofstream & fs, const PString & libPrefix, const PString & libName, const PString & fullNameLibrary){
        if(libPrefix == "" || fullNameLibrary == "") return;
        PString findLibraryVariable(libPrefix + "_LIBRARY_DIR");
        fs << std::endl << std::endl << "#Find the binary or the library " << libPrefix << std::endl;
        
        fs << "set(LIBRARY_NAME \""<<fullNameLibrary<<"\")" << std::endl;
        fs << "if(APPLE)" << std::endl;
        fs << "\tset(LIBRARY_NAME \""<<fullNameLibrary.replace(".so", ".dylib")<<"\")" << std::endl;
        fs << "endif()" << std::endl;
        
        fs << "find_path(" << findLibraryVariable << std::endl;
        fs << "\tNAMES ${LIBRARY_NAME}" << std::endl;
        fs << "\tPATHS ${CMAKE_INSTALL_PREFIX}/lib ${CMAKE_INCLUDE_PATH}/lib /usr/lib /usr/local/lib /lib $ENV{HOME}/usr/lib" << std::endl;
        fs << ")" << std::endl << std::endl;
        fs << "if(" << findLibraryVariable << ")" << std::endl;
        fs << "\tmessage(STATUS \"Found lib "<<libPrefix<<" : ${" << findLibraryVariable << "}\")" << std::endl;
        fs << "else(" << findLibraryVariable << ")" << std::endl;
        fs << "\tmessage(FATAL_ERROR \"lib "<<libPrefix<<" not found\")" << std::endl;
        fs << "endif(" << findLibraryVariable << ")" << std::endl;
        fs << "set("<<libPrefix<<"_PREFIX \"${" << findLibraryVariable << "}/..\" CACHE STRING \"installtion prefix\")" << std::endl;
 
        fs << "set("<<libPrefix<<" "<<libName<<" CACHE STRING \"library name\")" << std::endl;
        
        fs << "set("<<libPrefix<<"_FILE ${"<<findLibraryVariable<<"}/"<<fullNameLibrary<< " CACHE STRING \"library file\")" << std::endl;
        
        fs << "set("<<libPrefix<<"_FOUND \"YES\" CACHE STRING \"true if the library has been found\")" << std::endl;
        fs << "link_directories(${" << findLibraryVariable << "})" << std::endl << std::endl << std::endl;
}


bool saveCMakeLibraryFindPackageFile(const PCMakeLibrary & cmakeLib, const PPath & extraFileName, const PPath & extraPreviousFileName){
        if(!cmakeLib.getWantGenerateFindPackage()) return true;
        std::ofstream fs;
        PPath findPackageFileName(getFindPackageFileName(cmakeLib.getName()));
        
        fs.open(findPackageFileName.c_str());
        if(!fs.is_open()){
                std::cerr << "saveCMakeLibraryFindPackageFile : can't open file '" << findPackageFileName << "'" << std::endl;
                return false;
        }
        
        if(extraPreviousFileName != ""){
                fs << extraPreviousFileName.loadFileContent() << std::endl;
        }
        PPath libPrefix(cmakeLib.getName().toUpper());
        saveFindPackageHeader(fs, libPrefix, cmakeLib.getListHeaders());
        PPath fullLibraryName(getFullLibraryName(cmakeLib));
        saveFindPackageLibrary(fs, libPrefix, cmakeLib.getName(), fullLibraryName);
        if(extraFileName != ""){
                fs << extraFileName.loadFileContent() << std::endl;
        }
        fs.close();
        return true;
}


bool saveCMakeLibrary(std::ofstream & fs, const PCMakeLibrary & cmakeLib){
        if(cmakeLib.getName() == "" || cmakeLib.getListSources().size() == 0lu) return true;
        if(cmakeLib.getRemoveDefinitions() != "") fs << "remove_definitions("<<cmakeLib.getRemoveDefinitions()<<")" << std::endl;
        if(cmakeLib.getAddDefinitions() != "") fs << "add_definitions("<<cmakeLib.getAddDefinitions()<<")" << std::endl;
        fs << "add_library(" << cmakeLib.getName();
        if(cmakeLib.getIsShared()){
                fs << " SHARED";
        }
        fs << std::endl;
        const PVecPath & listSources = cmakeLib.getListSources();
        for(PVecPath::const_iterator it(listSources.begin()); it != listSources.end(); ++it){
                fs << "\t" << *it << std::endl;
        }
        fs << ")" << std::endl << std::endl;
        const PVecString & listDependencies = cmakeLib.getListLibDependecies();
        if(listDependencies.size() != 0lu){
                fs << "target_link_libraries(" << cmakeLib.getName() << std::endl;
                for(PVecString::const_iterator it(listDependencies.begin()); it != listDependencies.end(); ++it){
                        fs << "\t" << *it << std::endl;
                }
                fs << ")" << std::endl << std::endl;
        }
        PPath libInstall(cmakeLib.getInstallDirectory());
        if(libInstall != ""){
                fs << "install(TARGETS "<<cmakeLib.getName()<<" LIBRARY DESTINATION "<<libInstall<<" ARCHIVE DESTINATION "<<libInstall<<")" << std::endl;
        }
        const PVecPath & listHeaders = cmakeLib.getListHeaders();
        if(listHeaders.size() != 0lu){
                fs << "set(headers" << cmakeLib.getName()<<" " << std::endl;
                for(PVecPath::const_iterator it(listHeaders.begin()); it != listHeaders.end(); ++it){
                        fs << "\t" << *it << std::endl;
                }
                fs << ")" << std::endl << std::endl;
                fs << "install(FILES ${headers" << cmakeLib.getName()<<"} DESTINATION include/"<<cmakeLib.getName().toUpper()<<")" << std::endl;
        }
        if(cmakeLib.getOtherCommandAfter() != ""){fs << cmakeLib.getOtherCommandAfter();}
        if(cmakeLib.getWantGenerateFindPackage()){
                if(!saveCMakeLibraryFindPackageFile(cmakeLib)){
                        std::cerr << "saveCMakeLibrary : can't create the find_package cmake macro file" << std::endl;
                        return false;
                }
        }
        return true;
}


bool saveCMakeExecutable(std::ofstream & fs, const PCMakeExecutable & cmakeExecutable){
        if(cmakeExecutable.getName() == "" || cmakeExecutable.getListSources().size() == 0lu){
                std::cerr << "saveCMakeExecutable : no source or name for target" << std::endl;
                return true;
        }
        if(cmakeExecutable.getRemoveDefinitions() != "") fs << "remove_definitions("<<cmakeExecutable.getRemoveDefinitions()<<")" << std::endl;
        if(cmakeExecutable.getAddDefinitions() != "") fs << "add_definitions("<<cmakeExecutable.getAddDefinitions()<<")" << std::endl;
        fs << "add_executable(" << cmakeExecutable.getName();
        fs << std::endl;
        const PVecPath & listSources = cmakeExecutable.getListSources();
        for(PVecPath::const_iterator it(listSources.begin()); it != listSources.end(); ++it){
                fs << "\t" << *it << std::endl;
        }
        fs << ")" << std::endl << std::endl;
        const PVecString & listDependencies = cmakeExecutable.getListDependecies();
        if(listDependencies.size() != 0lu){
                fs << "target_link_libraries(" << cmakeExecutable.getName() << std::endl;
                for(PVecString::const_iterator it(listDependencies.begin()); it != listDependencies.end(); ++it){
                        fs << "\t" << *it << std::endl;
                }
                fs << ")" << std::endl << std::endl;
        }
        PPath libInstall(cmakeExecutable.getInstallDirectory());
        if(libInstall != ""){
                fs << "install(TARGETS "<<cmakeExecutable.getName()<<" RUNTIME DESTINATION "<<libInstall<<" ARCHIVE DESTINATION "<<libInstall<<")" << std::endl;
        }
        if(cmakeExecutable.getOtherCommandAfter() != ""){fs << cmakeExecutable.getOtherCommandAfter();}
        fs << std::endl << std::endl;
//      if(cmakeExecutable.getWantGenerateFindPackage()){
//              if(!saveCMakeLibraryFindPackageFile(cmakeExecutable)){
//                      cerr << "saveCMakeLibrary : can't create the find_package cmake macro file" << std::endl;
//                      return false;
//              }
//      }
        return true;
        
}


bool saveCMakeUsePackages(std::ofstream & fs, const PVecString & listPackages){
        if(listPackages.size() == 0lu) return true;
        for(PVecString::const_iterator it(listPackages.begin()); it != listPackages.end(); ++it){
                fs << "find_package("<<*it<<" REQUIRED)" << std::endl;
        }
        fs << std::endl << std::endl;
        return true;
}


bool saveCMakeIncludeDirectories(std::ofstream & fs, const PVecPath & listIncludeDirectories){
        if(listIncludeDirectories.size() == 0lu) return true;
        fs << "include_directories" << std::endl;
        for(PVecPath::const_iterator it(listIncludeDirectories.begin()); it != listIncludeDirectories.end(); ++it){
                fs << *it << std::endl;
        }
        fs << ")" << std::endl;
        fs << std::endl << std::endl;
        return true;
}


bool saveCMakeLinkDirectories(std::ofstream & fs, const PVecPath & listLinkDirectories){
        if(listLinkDirectories.size() == 0lu) return true;
        fs << "link_directories" << std::endl;
        for(PVecPath::const_iterator it(listLinkDirectories.begin()); it != listLinkDirectories.end(); ++it){
                fs << *it << std::endl;
        }
        fs << ")" << std::endl;
        fs << std::endl << std::endl;
        return true;
}


bool saveCMakeListsGenerator(const PPath & fileName, const PCMakeListsGenerator & cmakeGenerator){
        if(fileName == "") return false;
        std::ofstream fs;
        fs.open(fileName.c_str());
        if(!fs.is_open()){
                std::cerr << "saveCMakeListsGenerator : can't open file '" << fileName << "'" << std::endl;
                return false;
        }
        bool b = saveCMakeListsGenerator(fs, cmakeGenerator);
        fs.close();
        return b;
}


bool saveCMakeListsGenerator(std::ofstream & fs, const PCMakeListsGenerator & cmakeGenerator){
        if(cmakeGenerator.getProjectName() != ""){
                fs << "project(" << cmakeGenerator.getProjectName() << ")" << std::endl;
                fs << "cmake_minimum_required(VERSION 3.0)" << std::endl << std::endl;
        }
        fs << "set(PHOENIX_PREFIX \"$ENV{HOME}/usr\" CACHE STRING \"PHOENIX prefix prefix\")" << std::endl;
        fs << "set(CMAKE_INSTALL_PREFIX \"${PHOENIX_PREFIX}\")" << std::endl;
        if(cmakeGenerator.getCmakeModulePath() != ""){
                fs << "set(CMAKE_MODULE_PATH "<<cmakeGenerator.getCmakeModulePath()<<")" << std::endl;
        }
//      fs << "add_definitions(-g -O2 -Wall -Werror)" << std::endl;
        bool b = saveCMakeUsePackages(fs, cmakeGenerator.getListPackage());
        b &= saveCMakeIncludeDirectories(fs, cmakeGenerator.getListIncludeDirectories());
        b &= saveCMakeLinkDirectories(fs, cmakeGenerator.getListLinkDirecories());
        const std::vector<PCMakeLibrary> & listLib = cmakeGenerator.getListLibraries();
        bool haveFindMacro(false);
        if(listLib.size() != 0lu){
                for(std::vector<PCMakeLibrary>::const_iterator it(listLib.begin()); it != listLib.end(); ++it){
                        b &= saveCMakeLibrary(fs, *it);
                        haveFindMacro |= it->getWantGenerateFindPackage();
                }
        }
        const std::vector<PCMakeExecutable> & listExecutable = cmakeGenerator.getListExecutable();
        if(listExecutable.size() != 0lu){
                for(std::vector<PCMakeExecutable>::const_iterator it(listExecutable.begin()); it != listExecutable.end(); ++it){
                        b &= saveCMakeExecutable(fs, *it);
                        haveFindMacro |= it->getWantGenerateFindPackage();
                }
        }
        if(haveFindMacro){
                fs << "install(FILES";
                for(std::vector<PCMakeLibrary>::const_iterator it(listLib.begin()); it != listLib.end(); ++it){
                        if(!it->getWantGenerateFindPackage()) continue;
                        fs << " ${CMAKE_CURRENT_SOURCE_DIR}/" << getFindPackageFileName(it->getName());
                }
                for(std::vector<PCMakeExecutable>::const_iterator it(listExecutable.begin()); it != listExecutable.end(); ++it){
                        if(!it->getWantGenerateFindPackage()) continue;
                        fs << " ${CMAKE_CURRENT_SOURCE_DIR}/" << getFindPackageFileName(it->getName());
                }
                fs << " DESTINATION share/cmake)" << std::endl << std::endl;
        }
        if(cmakeGenerator.getTestDirectory() != ""){
                fs << "if(SELF_TESTS_MODE)" << std::endl;
                fs << "\tinclude(CTest)" << std::endl;
                fs << "\tadd_subdirectory("<<cmakeGenerator.getTestDirectory()<<")" << std::endl;
                fs << "endif()" << std::endl << std::endl;
        }
        fs << std::endl << std::endl << std::endl;
        return b;
}