I. Introduction

CMake lit des fichiers de script et produit des fichiers natifs pour la plateforme sur laquelle il a été lancé. Il peut créer des Makefile GNU, des projets KDevelop, XCode ou Visual Studio.

CMake est un logiciel libre sous license BSD. Il est développé par Kitware Inc..

Vous trouverez plus d'informations relatives à CMake sur la page principale sur CMake de ce site.

II. Pourquoi utiliser CMake ?

CMake est un outil officiel de KDE 4, suite à un choix effectué en mMars 2006, principalement pour ses qualités techniques par rapport aux précédents outils de KDE, tels que automake ou unsermake :

  • CMake est développé indépendemment de KDE et peut être utilisé dans d'autres projets que celui-ci ;
  • la durée de compilation est plus faible, notemment grâce à la non-utilisation de libtools ;
  • le fichier CMake est plus facile à écrire.

III. Comment compiler KDE avec CMake ?

III-A. Télécharger et installer CMake

III-A-1. Linux, BSD, et autres systèmes Unix

Téléchargez d'abord la dernière version de CMake.

Une fois le téléchargement terminé, désarchivez et compilez-le :

 
Sélectionnez
$ mkdir cmake-build
$ cd cmake-build
$ ../bootstrap
$ make
$ make install

Par défaut, CMake sera installé dans /usr/local, assurez-vous donc d'avoir /usr/local/bin dans vos répertoires d'exécution ($PATH). Pour changer ce répertoire (/usr sous Debian, par exemple), ajoutez l'option --prefix=PATH à la commande boostrap.

Lisez ces instructions si vous voulez utiliser la version en cours de développement.

III-A-2. Windows

Téléchargez d'abord la dernière version de CMake.

Une fois téléchargé, lancez l'installeur de CMake.

Lisez ces instructions si vous voulez utiliser la version en cours de développement.

III-B. Lancer CMake

III-B-1. Linux, BSD, et autres systèmes Unix

Vous devez lancer CMake pour générer les fichiers de compilation pour votre système. Les compilations dans l'arborescence des sources et en dehors sont supportées par CMake, mais, actuellement, les compilations dans l'arborescence sont empêchées par l'implémentation de KDE.

En supposant que vous avez kdelibs/ dans ~/src/kdelibs/ (utilisez locate kdelibs/ au besoin), utilisez ces commandes :

 
Sélectionnez
$ lskdelibs/$ mkdir kdelibs-build$ cd kdelibs-build$ cmake ../kdelibs

Ceci générera les Makefiles pour construire kdelibs/ dans kdelibs-build/.

III-B-2. Windows

Vous devez lancer CMake pour générer les fichiers de compilation pour votre système. Les compilations dans l'arborescence des sources et en dehors sont supportées par CMake, mais, actuellement, les compilations dans l'arborescence sont empêchées par l'implémentation de KDE.

En supposant que vous avez kdelibs\ dans c:\daten\kde4, utilisez ces commandes :

 
Sélectionnez
mkdir kdelibs-build
cd kdelibs-build
cmake ../kdelibs

Ceci générera les Makefiles pour construire kdelibs\ dans kdelibs-build\. Lisez la page KDE sous Windows pour plus d'informations sur la compilation de KDE sous Windows.

III-B-3. Fichies de projet KDevelop

Si vous préférez utiliser des fichiers de projet pour KDevelop 3 (qui sont simplement des Makefiles accompagnés de quelques données pour KDevelop), lancez CMake de cette façon :

 
Sélectionnez
$ cmake ../kdelibs -GKDevelop3

Utilisez cmake -h pour savoir quels générateurs sont supportés ainsi que ses autres options.

III-B-4. CMake et Qt4

Pour trouver le réperoire de Qt4, CMake cherche qmake dans le répertoire d'exécution. CMake n'utilisez pas la variable d'environnement QTDIR. Assurez-vous d'abord que qmake se trouve dans le répertoire d'exécution qui vous utilisez.

III-B-5. Aller plus loin

Une fois que CMake a terminé, il va créer un fichier nommé CMakeCache.txt. Ce fichier contient tous les paramètres que CMake a détecté sur votre système. Si vous voulez lancer CMake avec un autre générateur ou que vous voulez que CMake refasse la détection, supprimez ce fichier.

Si CMake ne trouve pas quelque chose, mais que vous savez où il est, vous pouvez lui dire manuellement où il se trouve. CMake utilise des variables pour stocker ses informations. Ces variables sont situées dans le fichier mentionné ci-dessus : CMakeCache.txt. Il existe trois manières de configurer ces variables  :

  • donner à CMake la valeur correcte via la ligne de commande : cmake ../kdelibs -DNOM_DE_LA_VARIABLE=valeur ;
  • utiliser ccmake, qui fournit une GUI basée sur curse pour éditer les variables CMake (ccmake ../kdelibs) ;
  • éditer directement le fichier CMakeCache.txt (déconseillé).

Vous pouvez lancer ccmake ../kdelibs au moins une fois, dans le but d'avoir une idée des variables que CMake utilise. Appuyez sur "T" pour voir également les variables "avancées".

III-B-6. Variables en ligne de commande

Quelques variables en ligne de commande de cmake que vous pouvez être amené à modifier :

  • CMAKE_INSTALL_PREFIX : cmake ../kdelibs -DCMAKE_INSTALL_PREFIX=/opt/kde4, l'équivalent de ./configure --prefix=/opt/kde4 ;
  • CMAKE_BUILD_TYPE : pour choisir le type de compiléation désiré, on peut choisir entre debugfull, Debug, Profile, RelWithDebInfo et Release (par défaut, RelWithDebInfo) ;
  • KDE4_BUILD_TESTS=ON: créer des Makefile avec des programmes de test, fournit aussi des cibles de test ;
  • KDE4_TEST_OUTPUT=xml : tests utilisant le framework QTestLib pour créer des fichiers de log en XML ;
  • KDE4_DISABLE_MULTIMEDIA=ON : compile KDE sans aucun support multimédia (audio et vidéo) ;
  • BUILD_foo=OFF : désactive la compilation du projet dans le répertoire foo ;
  • WITH_foo : il y a différentes options, par exemple WITH_CUPS ou WITH_Jasper. Si vous voulez les désactiver, CMake n'ira rien chercher dans ce paquet. S'ils sont activés, CMake tentera de les trouver. S'il n'y arrive pas, ajustez les variables comme décrit plus haut.

III-C. Vaiables d'environnement

Si vous avez des en-têtes et des bibliothèques installés dans des chemins non standard que CMake ne peut trouver, modifiez les variables d'environnement suivantes. Elles peuvent être très utiles, par exemple si vous voulez installer kdesupport dans ~/install/kdesupport. Voici quelques conventions de nommage qui ne fonctionneront pas comme argument avec la command CMake :

  • CMAKE_INCLUDE_PATH (par exemple : CMAKE_INCLUDE_PATH=/sw/include) ;
  • CMAKE_LIBRARY_PATH (par exemple : CMAKE_LIBRARY_PATH=/sw/lib) ;
  • CMAKE_PROGRAM_PATH (par exemple : CMAKE_LIBRARY_PATH=/sw/bin).

Avec CMake 2.6.0 et supérieurs, on peut avoir le même effet en ne définissant que cette variable :

  • CMAKE_PREFIX_PATH (par exemple : export CMAKE_PREFIX_PATH=/sw).

Pour plus d'informations, vous pouvez consulter la page sur les variables utiles du wiki de CMake.

III-D. Aller plus loin

Si CMake finit son exécution avec "Generating done", c'est qu'il n'y a eu aucune erreur ; s'il termine avec "Configuring done", il y en a eu, il faut les corriger. Une fois que CMake a fini de s'exécuter, lancez votre outil de compilation (comme make, KDevelop, XCode ou MSVC), lancez la compilation et attentez que ce soit fini. À ce moment, lancez make install.

Si vous avez une erreur dans ce genre :

 
Sélectionnez
CMake Error: This project requires some variables to be set,
and cmake can not find them. Please set the following variables: X11_XTest_LIB (ADVANCED)

Il se peut qu'il vous manque une bibliothèque (ou toute autre dépendance). Pour savoir laquelle, cherchez dans cmake/modules pour savoir quelle variable CMake n'arrive pas à trouver. Dans l'exemple précédent, il s'agit de

 
Sélectionnez
find_library(X11_XTest_LIB Xtst ${X11_LIB_SEARCH_PATH})

La bibliothèque manquante est donc Xtst. Vous devez la trouver (peut-être en installant libXtst-devel) et relancer CMake.

IV. Utiliser CMake pour une petite application

Voici le plus simple CMakeLists.txt possible :

 
Sélectionnez
add_executable(hello main.cpp)

Il sert à créer un exécutable hello (ou hello.exe sous Windows) à partir du fichier source main.cpp. Vous pouvez mettre à la fois des fichiers C et C++ si besoin est. Vous pouvez également mettre différents exécutables et bibliothèques dans CMakeList.txt. Le même fichier source peut être utilisé dans différents projets, il sera compilé pour chacun des projets. La part la plus importante du langage de CMake est les variables :

 
Sélectionnez
set( MY_SOURCES main.cpp widget.cpp)
message(STATUS "my sources: ${MY_SOURCES}")

Utilisez la commande SET() pour définir la valeur d'une variable. Si vous mettez plus d'une chaîne de caractères, la variable sera une liste. Une liste est une liste de chaînes séparées par des virgules. Si vous voulez un seul élément, la variable n'aura que cet élément pour valeur. Pour avoir la valeur d'une variable, utilisez ${NOM_DE_LA_VARIABLE}. Vous pouvez parcourir une liste en utilisant FOREACH() :

 
Sélectionnez
foreach(next_ITEM ${MY_SOURCES})
   message(STATUS "next item: ${next_ITEM}")
endforeach(next_ITEM ${MY_SOURCES})

Les commandes de CMake sont sensibles à la casse, de même que les noms de variables ou de paramètres.

Vous pouvez aussi tester diverses choses :

 
Sélectionnez
if (UNIX)
   message(STATUS "This is UNIX (including OS X and CygWin)")
endif (UNIX)
 
if (MSVC)
   set(MY_SRCS ${MY_SRCS} winextra.cpp)
endif (MSVC)

Dans ce second exemple, on ajoute un élément dans une liste.

V. Utiliser CMake dans le cadre de KDE4

Voici un CMakeList.txt basique pour construire un petit projet KDE4 

 
Sélectionnez
project( kde4project )
find_package( KDE4 REQUIRED )
include_directories( ${KDE4_INCLUDES} )
 
set( KDE4ProjectSources kde4mainapp.cpp someclass.cpp someotherclass.cpp )
 
kde4_add_executable( kde4project ${KDE4ProjectSources} )
 
target_link_libraries( kde4project ${KDE4_KDEUI_LIBS} ${KDE4_KPARTS_LIBS} )
 
install( TARGETS kde4project  ${INSTALL_TARGETS_DEFAULT_ARGS} )

target_link_libraries contient les bibliothèques de développement qui sont utilisées dans votre programme. Par exemple, si vous voulez utiliser libtidy-devel, le nom de fichier de la bibliothèque est probablement /usr/local/lib/libtidy.a. Vous pouvez alors ajouter -ltidy à la commande d'appel de GCC. Dans ce cas, ajoutez tidy dans target_link_libraries. Si possible, utilisez les variables et macros prédéfinies, telles que ${KDE4_KDEUI_LIBS}.

install (TARGETS) est l'endroit où les fichiers obtenus seront installés. Si vous n'avez pas cette ligne, make install ne fonctionnera pas.

VI. Scripts pour CMake

CMake peut être étendu avec des scripts. CMake a par défaut un certain nombre de scripts ; sous Unix, ils sont installés dans /usr/local/share/CMake/Modules/. Les bibliothèques de KDE installent également des modules dans /share/apps/cmake/modules/. Les fichiers s'y trouvant seront utilisé en priorité, avant ceux du dossier des modules globaux au système. Vous pouvez également écrire des macros pour CMake. Elles sont puissantes et peuvent être requises pour construire certains logiciels, mais elles ne sont pas faites pour remplacer un langage de programmation.

VII. Convertir des logiciels de KDE basés sur autotools vers CMake

Dans kdesdk/cmake/, vous pouvez trouver le script am2cmake. Il s'agit d'un script Ruby, Ruby est donc requis sur votre système. Lancez am2cmake dans le dossier principal de vos sources :

 
Sélectionnez
$ cd src/mykooltool/$ am2cmake --kde4

N'oubliez pas l'option --kde4 : sinon, les fichiers générés ne seront pas adaptés à un logiciel pour KDE. Les fichiers convertis sont susceptibles de fonctionner tels quels, mais les projets complexes requierront quelques modifications supplémentaires.

Il se peut que vous deviez :

  • ajouter des répertoires d'include en utilisant INCLUDE_DIRECTORIES() ;
  • ajouter des bibliothèques de link en utilisant TARGET_LINK_LIBRARIES() ;
  • ajouter des switch de compilation en utilisant ADD_DEFINITIONS() ;
  • ajouter des vérification de type configure ; lisez comment effectuer des vérifications de la plateforme et comment trouver les logiciels déjà installés ;
  • un fichier AdditionalInfo.txt est créé. Il vous permettra de voir tous les *.in et *.in.in de votre projet. Les noms de fichier sont ceux qui doivent être convertis manuellement pour CMake.

VIII. Remerciements

Merci à Thibaut Cuvelier pour sa relecture !