Comment puis-je configurer les options du compilateur pour une cible spécifique dans une construction propre à la configuration à l'aide de CMake?

J'ai un CMakeLists où je veux construire certaines cibles à l'aide de la version dynamique de la C runtime, et quelques autres cibles à l'aide de la version statique.

Parce que ce doit être défini pour chaque cible, la méthode par défaut du paramètre CMAKE_CXX_FLAGS_<Config> ne fonctionne pas; il remplace pour toutes les cibles.

À cette fin, j'ai essayé quelque chose comme ce qui suit:

# @fn       set_target_dynamic_crt
# @brief    Sets the given target to use the dynamic version of the CRT (/MD or
#           /MDd)
# @param    ...  A list of targets to which this setting should be applied.
function( set_target_dynamic_crt )
    if ( MSVC )
        message (WARNING ${CMAKE_BUILD_TYPE})
        if (CMAKE_BUILD_TYPE STREQUAL "Debug")
            set_target_properties ( ${ARGN} PROPERTIES COMPILE_FLAGS "/MDd" )
        else()
            set_target_properties ( ${ARGN} PROPERTIES COMPILE_FLAGS "/MD" )
        endif()
    endif()
endfunction()

Cependant, cette choisit toujours la version (/MD) et quand j'ai une requête pour le type de version (le message l'appel ci-dessus), je reçois la chaîne vide. (Je soupçonne que c'est parce que je suis à l'aide de Visual Studio générateur; j'ai vu plus d'une référence qui dit CMAKE_BUILD_TYPE est pour les makefiles...)

Comment puis-je définir des options de compilation comme ceci par cible?

Il y a maintenant une meilleure solution, que ce qui est indiqué ci-dessous, pour résoudre ce problème. J'ai posté à ce sujet sur, de sorte que depuis, j'ai couru dans le même problème et le fait de ne pas trouver votre première question, voir ici: stackoverflow.com/questions/18065299/...

OriginalL'auteur Billy ONeal | 2012-04-17

  1. 28

    Dans CMake 2.8.12 j'ai ajouté un target_compile_options de commande pour répondre à ce besoin:

    http://public.kitware.com/Bug/view.php?id=6493

    http://www.cmake.org/cmake/help/git-master/manual/cmake-generator-expressions.7.html

    target_compile_options(tgt PRIVATE "/MD$<$<CONFIG:Debug>:d>")

    Voir

    http://www.cmake.org/cmake/help/git-next/manual/cmake-buildsystem.7.html#build-specification-with-generator-expressions

    pour plus d'relatives à CMAKE_BUILD_TYPE et plusieurs raisons pourquoi le générateur d'expression est mieux (par exemple, cible IMPORTÉ config de cartographie).

    OriginalL'auteur steveire

  2. 2

    La seule option que je sais de ce scénario est de diviser votre projet dans les sous-répertoires sur une cible de base et utiliser add_subdirectory.

    Selon la façon dont votre projet est actuellement mis en place, cela pourrait être un processus douloureux, je suppose.

    Le résultat serait à un niveau supérieur CMakeLists.txt qui a regardé comme par exemple

    cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
project(Test)
add_subdirectory(libB)
add_subdirectory(libA)
add_executable(main_exe "main.cpp")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")
target_link_libraries(main_exe lib_a lib_b)

    puis libA/CMakeLists.txt pourrait spécifier MD et MDd drapeaux:

    project(LibA)
add_library(lib_a a.cpp a.hpp)
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")

    et libB/CMakeLists.txt pour MT et MTd drapeaux:

    project(LibB)
add_library(lib_b b.cpp b.hpp)
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")

    Vous pouvez bien sûr ajouter toutes les cibles ayant besoin lié à la CRT statique dans un sous-répertoire et CMakeLists.txt et tous les CRT dynamiques les unes dans les autres, si vous avez beaucoup de cibles.

    Note qu'il y a une meilleure solution avec le target_compile_options() cmake fonction. C'est tout nouveau (juin 2013) et est disponible uniquement dans le quotidien compile, mais que c'est bien! Voir ici: stackoverflow.com/questions/18065299/...

    OriginalL'auteur Fraser

  3. 0

    CMAKE_BUILD_TYPE n'est valable que pour une seule configuration de générateurs. Le multi-configuration des générateurs (MSVC et Xcode) peuvent créer de multiples configurations dans un build-répertoire et le CMAKE_BUILD_TYPE drapeau n'aurait pas de sens.

    La COMPILE_FLAGS cible de propriété ne permet pas de distinguer les différentes configurations (Voir kitware le bugtracker pour plus d'informations).

    Une solution de contournement serait d'avoir deux construire-répertoires, semblable à la façon dont les gens utilisent le Makefile générateurs, et de définir un indicateur supplémentaire lors de la construction des binaires pour la distribution. (c'est à dire, la configuration de Version)

    La solution de contournement ne fonctionne pas si -- vous finissez par avoir à définir que dans un tas d'endroits différents. (Plus précisément, de modifier les configurations, vous devez passer par toutes les centaines de projets et du changement, et ensuite de le modifier dans le VS IDE lors de la construction, etc.)
    Non, je veux dire que vous devez utiliser exactement le code que vous avez posté dans la question, mais au lieu d'utiliser CMAKE_BUILD_TYPE, utilisez MY_RELEASEBUILD, et ne définissent que lorsque vous êtes sur le point de créer une version de la distribution. (En supposant que c'est OK pour utiliser /MDd lorsque vous sont en cours d'exécution en local)
    mais ensuite, vous devez sélectionner la bonne chose à l'intérieur de VS de match, et il ne peut pas être défini pour chaque cible. Le point de l'ensemble de la faire, c'était d'être en mesure d'utiliser CMAke construire en charge de la configuration.
    Il n'est pas possible. Je ne pense pas que je suis à vous comprendre correctement. Je propose quelque chose comme mkdir build; cd build; cmake ../ ; cd .. ; mkdir build libération; cd build libération; cmake -DRELEASE_BUILD=1. Oui, il serait sucer, mais au moins ça permettrait de tester les drapeaux localement (et cela fonctionne pour votre buildservers etc)
    Il en résulte quelque chose qui est plus difficile à entretenir que le maintien de la plate-forme séparée spécifique de rendre les fichiers. Oui, il "fonctionne" dans un sens pervers de "travail" - mais pas d'une façon qui justifie le coût.

    OriginalL'auteur phb