Skip to content

17.CMake.md

Latest commit

 

History

History
166 lines (113 loc) · 6.8 KB

17.CMake.md

File metadata and controls

166 lines (113 loc) · 6.8 KB

CMake

Une brève introduction à cmake.

Alt text

CMake est un programme multiplate-forme permettant de produire une solution de compilation pour un projet. Il pourra par exemple génerer un ensemble de Makefile, un projet Visual Studio, un projet Code::Blocks, etc. Le projet peut ensuite être compilé avec la solution choisie.

Cmake est un logiciel complexe qui permet de faire beaucoup de chose. Dans le cadre de cette formation, nous n'avons pas le temps de tout explorer. Ce chapitre donne les bases de son utilisation.

Le fichier d'entrée est le CMakeLists.txt qui doit être écrit par l’utilisateur et fourni en entrée à CMake.

Le CMakeLists.txt de base

La syntaxe est très simple: le fichier est constitué d’une suite de commandes décrivant le processus de compilation du projet.

    nom_commande(argument1 argument2 ...)

Le CMakeLists.txt doit contenir les information nécessaire à la compilation du code. On retrouvera donc l'ensemble des .h et .cpp du code, les librairies dont dépendent le code (ex : boost, qt, etc.), mais également des informations de compilation (ex : version du cpp utilisé).

Ainsi, un projet de base contenant un .h/.cpp ainsi que le main.cpp sera accompagné du CMakeLists.txt.

Alt text

Le CMakeLists.txt contiendra les informations suivantes :

    # version de cmake minimum acceptée pour le projet
    cmake_minimum_required(VERSION 2.8)
    
    # déclaration du projet et son nom
    project(ProjetSimpleCMake)
    
    # ajout des fichiers
    set(SRC_FILES main.cpp
                  Image.cpp
                Image.h)
                
    # ajout de l'exécutable
    add_executable(ProjetSimple1 ${SRC_FILES})

Il est possible d'utiliser des pattern :

    cmake_minimum_required(VERSION 2.8)
    project(ProjetSimpleCMake)
    file(GLOB SRC_FILES *.cpp *.h)
    add_executable(ProjetSimple1 ${SRC_FILES})

Pour un code plus complexe où le code est génralement dans un sous dossier, il est possible d'avoir un calcul récursif à partir du point d'entrée.

Alt text

    cmake_minimum_required(VERSION 2.8)
    project(ProjetSimpleCMake)
    file(GLOB_RECURSE SRC_FILES *.cpp *.h)
    add_executable(ProjetSimple1 ${SRC_FILES})

Une bonne pratique du Cpp est d'isoler les .h des .cpp dans un répertoire 'include'. Cela permet, dans le cas de compilation d'une librairie que l'on voudrait partager d'avoir les includes prêt à être diffusé. En effet, pour utiliser une librairie dans un autre projet, on a besoin de la libriairie (.a, .dylib, .dll, etc. ) mais également des include (.h) pour la compilation (#include "monFichier.h").

Alt text

Dans ce cas, le CMakeLists.txt pourra s'écrire ainsi :

    cmake_minimum_required(VERSION 2.8)
    project(ProjetSimpleCMake)
    include_directories(include)
    file(GLOB_RECURSE SRC_FILES *.cpp *.h)
    add_executable(ProjetSimple1 ${SRC_FILES})

La commande include_directories() peut prendre plusieurs repertoires en argument. Il est possible de l’appeler plusieurs fois pour ajouter itérativement des répertoires.

Une autre bonne pratique est de lancer la création du projet (et sa compilation) dans un dossier à part, que l'on nomme usuellement "build"

Création du projet via cmale (en ligne de commande) :

cd mon-projet/build
cmake ../

La compilation se fait ensuite via la commande

make

Après un premier lancement de CMake dans le repertoire build, il n’est plus necessaire de préciser le chemin vers le repertoire source pour relancer CMake:

cd mon-projet/build
cmake .
make

L'ajout de librairie

L'ajout de la librairie SDL dans le CMakeLists.txt :

    find_package(SDL REQUIRED)
    include_directories(${SDL_INCLUDE_DIR})
    add_executable(MonExecutable ${SRC_FILE})
    target_link_libraries(MonExecutable ${SDL_LIBRARY})

La commande find_package(Lib) recherche un fichier FindLib.cmake dans le repertoire d’installation de CMake. La commande REQUIRED rend obbligatoire de trouver SDL pour la création du projet.

Il est possible de spécifier d'autre répertoire de recherche des FindLib.Cmake en ajoutant des chemins aux variables CMAKE_MODULE_PATH :

list(APPEND CMAKE_MODULE_PATH ${CMAKE_EXTERN_ROOT})

CMAKE_EXTERN_ROOT = un dossier contenant les librairies que je veux ajouter.

La commande target_link_libraries() permet de linker le projet à la librairie en question. Il est possible d'y mettre en ensemble de librairies en concatenant les XXX_LIBRARY dans une même variable.

L'ajout de la librairie OpenGL dans le CMakeLists.txt :

    find_package(OpenGL REQUIRED)
    include_directories(${OPENGL_INCLUDE_DIR})
    add_executable(MonExecutable ${SRC_FILE})
    target_link_libraries(MonExecutable ${OPENGL_LIBRARIES})

On remarque le nom des librairies sont différents : SDL_LIBRARY vs OPENGL_LIBRARIES. Attention : Le nom des variables définies par les bibliothèques n’est pas standard.

Un peu plus loin...

Il peut être utile de modifier l’organisation du repertoire de build, en particulier pour placer les executables et les bibliothèques dans des repertoires particuliers séparés. Pour cela il suffit de modifier les variables CMake suivantes:

    # Executables compilés dans le repertoire build/bin:
    set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
    # Bibliothèques compilés dans le repertoire build/lib:
    set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)

La variable PROJECT_BINARY_DIR est définie par CMake et contient le chemin du repertoire de build.

La variable CMAKE_BUILD_TYPE pour choisir sa configuration (CMake en propose plusieurs de base dont Debug et Release, mais il est possible d’en définir d’autres). Dans CMakeLists.txt on ajoute (après project()):

    if(NOT CMAKE_BUILD_TYPE)
        set(CMAKE_BUILD_TYPE ”Release” CACHE STRING
            ”Choose the type of build, options are: Debug Release.” FORCE)
    endif(NOT CMAKE_BUILD_TYPE)
    # Affiche la configuration activée:
    message(${CMAKE_BUILD_TYPE})

Ainsi la configuration par défaut est Release. Ensuite on lance CMake dans chaque repertoire de build en activant la bonne configuration:

cd mon-projet-build-Release
cmake ../mon-projet -DCMAKE_BUILD_TYPE=Release
cd ../mon-projet-build-Debug
cmake ../mon-projet -DCMAKE_BUILD_TYPE=Debug

Inutile de respecifier la configuration lors du relancement de CMake dans chacun des repertoire: la variable est mise en cache dans CMakeCache.txt.

L'interface

Cmake est proposé avec une interface

Alt text