Plate-forme de détection de CMake

J'ai ajouté quelques fonctionnalités de boost::asio, qui a précipité certains compilateur "mises en garde":

Veuillez define _WIN32_WINNT ou _WIN32_WINDOWS de façon appropriée.

Que le problème a été traité avec ici. J'aimerais avoir CMake détecter le moment où je fais construire sur Windows et de faire des définitions ou des arguments de ligne de commande.

Trouvé une petite mine d'or sur le wiki de cmake: cmake.org/Wiki/CMake_Useful_Variables..

OriginalL'auteur 2NinerRomeo | 2012-03-16

  1. 21

    Voici une solution simple.

    macro(get_WIN32_WINNT version)
    if (WIN32 AND CMAKE_SYSTEM_VERSION)
        set(ver ${CMAKE_SYSTEM_VERSION})
        string(REPLACE "." "" ver ${ver})
        string(REGEX REPLACE "([0-9])" "0\" ver ${ver})

        set(${version} "0x${ver}")
    endif()
endmacro()

get_WIN32_WINNT(ver)
add_definitions(-D_WIN32_WINNT=${ver})
    simple et sympathique! +1
    si (WIN32) si cela est vrai même si vous êtes à la croix de la compilation sous Windows pour autre chose que Windows. Vous vous retrouverez avec -D_WIN32_WINNT même si vous êtes en train de construire quelque chose d'autre.
    Pour Windows 10, comme Windows Kits\8.1\Include\shared\sdkddkver.h(255): error C2177: constant too big, vérifiez @squareskittles réponse ci-dessous.

    OriginalL'auteur KneLL

  2. 21

    À l'intérieur de la CMakeLists.txt fichier que vous pouvez faire:

    IF (WIN32)
  # set stuff for windows
ELSE()
  # set stuff for other systems
ENDIF()
    C'est à mi-course, je suis de fouiller pour savoir comment définir les définitions de préprocesseur et le compilateur de ligne de commande de drapeaux. Je pense que l'éditeur de liens syntaxe est comme ça set(CMAKE_EXE_LINK_FLAGS "${CMAKE_EXE_LINK_FLAGS} -linkerflag") donc j'espère que ce sera le même pour les drapeaux du compilateur. J'ai aussi appris à ajouter des définitions de préprocesseur.

    OriginalL'auteur karlphillip

  3. 10

    Voici une version étendue du Glas de la réponse, vérifie aussi pour Windows 10.

    if (WIN32)
    macro(get_WIN32_WINNT version)
        if (CMAKE_SYSTEM_VERSION)
            set(ver ${CMAKE_SYSTEM_VERSION})
            string(REGEX MATCH "^([0-9]+).([0-9])" ver ${ver})
            string(REGEX MATCH "^([0-9]+)" verMajor ${ver})
            # Check for Windows 10, b/c we'll need to convert to hex 'A'.
            if ("${verMajor}" MATCHES "10")
                set(verMajor "A")
                string(REGEX REPLACE "^([0-9]+)" ${verMajor} ver ${ver})
            endif ("${verMajor}" MATCHES "10")
            # Remove all remaining '.' characters.
            string(REPLACE "." "" ver ${ver})
            # Prepend each digit with a zero.
            string(REGEX REPLACE "([0-9A-Z])" "0\" ver ${ver})
            set(${version} "0x${ver}")
        endif(CMAKE_SYSTEM_VERSION)
    endmacro(get_WIN32_WINNT)

    get_WIN32_WINNT(ver)
    add_definitions(-D_WIN32_WINNT=${ver})
endif(WIN32)
    Je confirme, cela fonctionne pour Windows 10 (a l'aide de @Glas, mais il s'est cassé quand j'ai mis à jour mon système).

    OriginalL'auteur squareskittles

  4. 4

    Comme karlphilip souligné, vous pouvez utiliser if(WIN32) de la plate-forme de détection.

    Vous aurez un certain nombre de possibilités pour le passage de préprocesseur pour l'application:

    • Utiliser un configurer l'en-tête qui obtient prétraitées par CMake est configure_file. Cette approche a l'avantage que tous les #defines sont en fait une partie du code et non pas de l'environnement de compilation. L'inconvénient est qu'il nécessite un (automatique) de l'étape de prétraitement par CMake
    • Utilisation add_definitions. Cela va ajouter le préprocesseur drapeau pour tous les fichiers source dans le projet, il est donc plus une approche rapide et sale.

    • Utiliser le COMPILE_DEFINITIONS de la propriété. Cela permet un contrôle précis sur la définit fichier par fichier (et même par-config):
      set_property(SOURCE ${YOUR_SOURCE_FILES} APPEND PROPERTY
      COMPILE_DEFINITIONS YOUR_FLAG1 YOUR_FLAG2)

      Moderne CMake versions (2.8.12 et supérieur), vous pouvez également utiliser le plus pratique target_compile_definitions commande pour cette.

    D'habitude, je préfère le dernier, mais c'est surtout une question de goût personnel.

    OriginalL'auteur ComicSansMS

  5. 1

    Une version améliorée de KneLLs réponse:

    macro(get_WIN32_WINNT version)
    if (WIN32 AND CMAKE_SYSTEM_VERSION)
        set(ver ${CMAKE_SYSTEM_VERSION})
        string(REGEX REPLACE "^([0-9])[.]([0-9]).*" "0\\" ver ${ver})
        set(${version} "0x${ver}")
    endif()
endmacro()

get_WIN32_WINNT(ver)
add_definitions(-D_WIN32_WINNT=${ver})

    KneLLs version n'a pas de travail dans mon cas, parce que CMAKE_SYSTEM_VERSION était 6.3.9600 qui a abouti à ${ver}=0x060306090000

    Cette version va échouer pour Windows 10 et les versions ultérieures, si. On doit vérifier si le premier nombre est plus grand que 9, et de le convertir à la bonne valeur hexadécimale.

    OriginalL'auteur Twonky

  6. -3

    C'est ce que je suis venu avec:

    if(${WIN32})
#this method adds the necessary compiler flag
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_WIN32_WINNT=0x0501")
#this adds a preprocessor definition to the project
add_definitions(-D_WIN32_WINNT=0x0501)
endif()

    Pour traiter avec les boost::asio "avertissement", soit la définition de préprocesseur ou de l'option de ligne de commande fait le travail.

    Ce qui est faux. Vous êtes en train d'ajouter la _WIN32_WINNT définir deux fois, et vous êtes également à la fixation de la version Windows à XP.
    Merci. Je suis tellement heureux que d'autres sont venus avec une solution de qualité supérieure depuis que j'ai posté cette question. Puisque vous l'ai porté mon attention sur elle, j'ai changé mes accepté de répondre.

    OriginalL'auteur 2NinerRomeo