Préconisation IRD/DSI Equipe IS DSI / Informatique scientifique et Appui aux partenaires du Sud Auteur : Romain Gabriel 1 Encadrant : Clive Canape 1 1 Equipe «informatique scientifique et Appui aux partenaires du Sud». Dernière modif. : 27/05/2010 Référence : - Version : 1.0 Pages: 27 Diffusion : - Liens utiles : http://www.cmake.org/ IRD DSI Informatique scientifique PAGE 1 / 27 06.2010
Sommaire 1. OBJECTIFS......03 2. COMPLEMENTS D'INFORMATIONS SUR LES BIBLIOTHEQUES......05 3. DEMARCHE ET OUTILS...06 1. Installation des outils...06 2. Architecture du projet à compiler....07 3. Fonctionnement de et exemple...09 4. Détails de la démarche...12 5. Portage multi-plateformes...13 6. Création de packages et installeurs...16 7. Règles personnalisées...17 4. COMPILATION ET COMPLEMENT...19 1. Compilation du projet...19 2. Quelques options complémentaires.....22 5. CONCLUSION...23 IRD DSI Informatique scientifique PAGE 2 / 27 06.2010
1. Objectifs : La conception d'un programme informatique passe par plusieurs étapes. La structuration du logiciel en est une préliminaire, qui permettra de structurer correctement les composantes du programme. Les langages de programmation utilisés par les scientifiques de l'ird (Institut de Recherche pour le Développement, que ce soit le C/C++, le Fortran ou le Java sont des langages compilés, c'est-à-dire qu'ils sont traduits une fois pour toutes par un programme annexe : le compilateur. Le nouveau fichier généré est appelé un exécutable. Cette phase de compilation, dans le cas d'un projet simple, est réalisée en une commande peu complexe, car le nombre de fichier n'est pas important. Un projet complexe étant généralement synonyme d'une multiplication du nombre de fichiers le constituant, la phase de compilation peut devenir laborieuse. Il faut notamment résoudre les problèmes de dépendances (internes et externes de l'exécutable lors de sa compilation. Ce document présente alors un outil de build, sélectionné pour ses performances et sa simplicité de prise en main, qui est conçu pour rendre moins complexe la phase de compilation. Les objectifs sont donc les suivants : comprendre les mécanismes de ces outils et de la compilation ; prendre en main le logiciel présenté ; mettre en œuvre une compilation multi-plateforme (portabilité et installation. Pour faciliter la compréhension, des exemples seront utilisés. Il sera alors plus simple d'adapter la démarche à des cas qui seront similaires. Les langages de programmation abordés seront le C/C++ et le Fortran. L'outil présenté ici n'est pas le plus performant pour le langage Java. La compilation d'un programme et de ses bibliothèques (parfois appelées, à tort, «librairies» peut devenir complexe et fastidieuse, plus particulièrement quand le nombre de fichiers est important. Exemple : Compilation d'un programme et d'une bibliothèque statique constitués respectivement d'un unique fichier (main.c et ex.c. Les commandes nécessaires à l'obtention d'un exécutable sont les suivantes : gcc -c ex.c ar r libex.a ex.o gcc -o executable main.c -L./ -lex IRD DSI Informatique scientifique PAGE 3 / 27 06.2010
Le problème apparaît avec un nombre plus grand de fichiers : les commandes deviennent plus complexes, et les erreurs plus fréquentes. Un outil de build, dans ce cas, vise à résoudre ce problème, en adoptant une syntaxe intuitive et portable, qui sera présentée au cours du document. Les intérêts d'utiliser un tel outil sont donc les suivants : regrouper plusieurs options de compilation de façon claire ; L'outil présenté ici,, est en fait un générateur de «makefile», qui définissent les instructions de compilation lorsque l'on utilise la commande «make». Il est fréquent de rencontrer plusieurs variantes de cette commande (make install / make debug ayant chacune un rôle particulier. Il sera possible de faire cela rapidement avec l'outil. réaliser une compilation multi-plateforme rapidement ; Les règles nécessaires à la compilation d'un projet sur un système Unix-like, Mac OS X ou Windows pourront être définies dans le même fichier, ce qui facilitera la portabilité des sources. créer des packages et des installeurs simplement ; La génération de packages (.deb,.rpm ou d'installeurs (.exe sera grandement facilitée par un module de, ce qui est un atout considérable. La distribution de votre projet pourra ainsi être rapide, sans nécessiter un accès au code source. pouvoir réaliser facilement des batteries de test. Cette fonctionnalité ne sera pas abordée, mais il faut savoir qu'un module nommé CTest le permet. Les options qu'il propose sont nombreuses (voir site officiel. IRD DSI Informatique scientifique PAGE 4 / 27 06.2010
2. Complément d'informations sur les bibliothèques : Une bibliothèque est un ensemble de fonctions, de procédures, de classes... qui peuvent être utilisées par divers programmes. Les fichiers contenant les bibliothèques ont, sous un système Unix-like, généralement l'extension.a (bibliothèque dite statique et.so (bibliothèque dite partagée, ou dynamique. Sous un système Windows, ces dernières sont reconnaissables à l'extension.lib,.a (statiques ou.dll (partagées, qu'il est extrêmement fréquent de rencontrer. Ces mêmes bibliothèques porterons l'extension.dylib sur un système Mac OS X. Chacun de ces types possède des avantages et des inconvénients, et ce sont ces caractéristiques qui les distinguent. Il existe cependant une différence majeure entre les deux. Lors de l'utilisation d'une bibliothèque statique (.a/.lib, le compilateur va chercher le code dont le programme a besoin et en effectuer une copie dans l'exécutable généré. Ainsi, ce dernier ne nécessitera pas la présence de la bibliothèque pour son exécution. Au contraire, lors de l'utilisation d'une bibliothèque partagée (.so/.dll/.dylib, le programme ne chargera cette bibliothèque que lors de l'exécution. Il en résulte un exécutable de taille moindre, ainsi qu'une consommation de mémoire RAM moins importante. Un des défauts que l'on pourra trouver à ce type de bibliothèque est que leur utilisation entraîne un temps d'exécution plus important, étant donné que les liens sont édités de manière dynamique. Il faut cependant modérer ces propos, en précisant que la différence est tellement minime que, dans la majorité des cas, elle ne constituera pas un critère concret. Un autre point important doit être précisé. Certaines fonctions présentes dans les bibliothèques pourraient servir à plusieurs programmes différents. Une seule bibliothèque partagée pourrait alors être utilisée par plusieurs programmes, simultanément ou non. Une bibliothèque statique peut également être utilisée par plusieurs programmes. Cependant, le code de la bibliothèque sera «incorporé» à tous les programmes en question, et c'est dans ce cas précis que ce type de bibliothèque montre ses lacunes. La perte de mémoire disque peut devenir importante pour peu qu'il y ait beaucoup de programme faisant appel à une bibliothèque de ce type. Aussi, la mise à jour d'une bibliothèque partagée ne nécessite pas la recompilation du programme, ce qui présente un grand avantage. IRD DSI Informatique scientifique PAGE 5 / 27 06.2010
3. Démarche et outils : 1. Installation des outils Les outils nécessaires pour pouvoir compiler un programme en utilisant l'outil sont différents selon le système d'exploitation utilisé. Il faudra évidemment avoir un compilateur installé sur le système. Pour un système Windows (2000, XP, Vista, 7 Obligatoire : Installation de (version 2.8 pour Windows. Il existe un installeur pour les OS Windows 32 bits, téléchargeable sur le site internet officiel : http://www.cmake.org/cmake/resources/software.html Optionnel (outils qui nous servirons lors de la création de règles personnalisées dans notre exemple : Installation de NSIS (Nullsoft Scriptable Install System pour Windows. Ce logiciel va permettre, couplé avec une fonctionnalité de, de créer facilement un installeur Windows pour les programmes que l'on souhaite compiler. Pour un système Unix-like Obligatoire : Installation de (version 2.8. Sur des distributions linux répandues, l'outil est présent via les gestionnaires de paquets. Par exemple, sous Debian/Ubuntu : «apt-get install cmake» et sous RedHat/CentOS : «yum install cmake» Si le paquet est introuvable, il est possible de télécharger les sources sur le site officiel, rubrique «Download» : http://www.cmake.org/cmake/resources/software.html Optionnel (outils qui serviront également à la créations de règles personnalisées dans notre exemple : Installation de rpm. Sur des distributions autres que celles basées sur Redhat, il faudra installer un package permettant la créations de paquets.rpm. Typiquement, sur une distribution Debian : «apt-get install rpm» Pour un système Mac Le portage sous un ordinateur Mac ne sera pas abordé dans ce document. Il est cependant tout à fait possible, et tous les outils nécessaires (, les compilateurs... sont disponibles pour Mac OS X sur les sites officiels déjà mentionnés. IRD DSI Informatique scientifique PAGE 6 / 27 06.2010
2. Architecture de l'exemple La présentation de l'outil dans ce document sera faite grâce à un exemple. La prise en main du logiciel sera alors plus rapide, et son adaptation à un autre projet plus simple. Deux langages de programmation seront traités, car utilisés par les scientifiques de l'ird : le C et le Fortran (90. Pour ce faire, un programme sans réel but a été écrit, puis traduit dans ces deux langages. Son fonctionnement se basera sur le modèle suivant : Le programme principal (exe utilise : 1 bibliothèque statique ; 1 bibliothèque partagée utilisant elle-même 2 autres bibliothèques partagées ; 1 bibliothèque partagée externe (déjà présente ; un programme externe sous certaines conditions. (règle personnalisée. Bibliothèque partagée Bibliothèque statique Bibliothèque Partagée exe Bibliothèque partagée Bibliothèque externe Programme externe Les fichiers sont organisés de la façon suivante (arborescence page suivante : un unique fichier «main» à la racine. Il contient le code du programme principal. un dossier «src» contenant 4 sous-dossiers (correspondant chacun à une bibliothèque nommés : calcul (2 fichiers conversion (3 fichiers heure (1 fichier menu (2 fichiers un dossier «include» contenant les fichiers header (.h uniquement pour le langage C. IRD DSI Informatique scientifique PAGE 7 / 27 06.2010
Langage Fortran 90 Langage C Note : Dans un soucis d'organisation, on prévoira un dossier nommé «cmake» vide. En effet, les commandes que nous entrerons lors de la compilation vont générer des fichiers, qu'il sera bon de séparer du code source. IRD DSI Informatique scientifique PAGE 8 / 27 06.2010
3. Fonctionnement de et exemple Ce n'est pas une règle, mais un conseil : il vaut mieux créer un fichier Lists.txt dans chaque dossier et sous-dossier de votre arborescence contenant des fichiers source. Il est possible de tout faire à partir d'un fichier Lists.txt placé à la racine, mais à l'usage, il sera beaucoup plus clair et pratique en fractionnant celui-ci, comme cela a été fait sur l'exemple montré page précédente. Ces fichiers Lists.txt (qui sont finalement que de simples fichiers texte contiennent un ensemble de commandes écrites ligne par ligne qui forment donc un langage de script. Il est également possible d'utiliser des variables présentes par défaut où d'en créer d'autres. Elles sont reconnaissables au signe "$". Exemple : Le contenu de la variable TEST sera appelée de la façon suivante : ${TEST} A savoir : s'utilisera de la sorte : placé dans le dossier «cmake», on utilise les commandes : «cmake..» (.. signifiant que l'on démarre du dossier parent puis «make». Note : Pour aborder cette partie, il est fortement conseillé de se munir de l'annexe 1 : mémo. Elle présente quelques variables et fonctions de base de. Celles qui sont présentées sont incontournables, et seront nécessaires à la création de tout projet avec cet outil. Une brève description et un exemple sont donnés pour chaque, ce qui aidera à la compréhension Une présentation du code nécessaire à la compilation sera fournie avant les explications. Cela permet de se faire une idée sur la complexité du programme, et vous comprendrez alors qu'il est possible de compiler toute sorte de projet relativement facilement. Note : Etant donné que nous couvrons 2 langages de programmation distincts, les 2 versions seront détaillées. IRD DSI Informatique scientifique PAGE 9 / 27 06.2010
Fichier Lists.txt principal (racine du projet : Langage Fortran 90 CMAKE_MINIMUM_REQUIRED(VERSION 2.6 PROJECT(TutoBuild Langage C CMAKE_MINIMUM_REQUIRED(VERSION 2.6 PROJECT(TutoBuild ENABLE_LANGUAGE(Fortran ENABLE_LANGUAGE(C SET(SRC ${CMAKE_SOURCE_DIR}/src SUBDIRS(${SRC} FILE(GLOB_RECURSE source_files ${CMAKE_SOURCE_DIR}/main.f90 ADD_EXECUTABLE(exe ${source_files} TARGET_LINK_LIBRARIES(exe menu calcul conversion heure SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build/lib SET(SRC "${CMAKE_SOURCE_DIR}/src" INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/include/libconversion ${CMAKE_SOURCE_DIR}/include/libcalcul ${CMAKE_SOURCE_DIR}/include/libheure ${CMAKE_SOURCE_DIR}/include/libmenu SUBDIRS(${SRC} FILE(GLOB_RECURSE source_files ${CMAKE_SOURCE_DIR}/main.c ADD_EXECUTABLE(exe ${source_files} TARGET_LINK_LIBRARIES(exe m menu heure conversion calcul SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build/lib Fichier Lists.txt dans le dossier src : Langage Fortran 90 ou C SUBDIRS(${SRC}/calcul SUBDIRS(${SRC}/conversion SUBDIRS(${SRC}/heure SUBDIRS(${SRC}/menu Il n'y a aucun fichier source dans ce répertoire. Le CmakeLists.txt sert alors uniquement à spécifier qu'il faut descendre dans l'arborescence, et parcourir les dossier calcul, conversion, heure et menu. IRD DSI Informatique scientifique PAGE 10 / 27 06.2010
Fichier Lists.txt dans le dossier src/calcul : Langage Fortran 90 ou C FILE(GLOB_RECURSE source_files pythagore.f90 rectangle.f90 ADD_LIBRARY(calcul SHARED ${source_files} Il faudra bien sûr, selon le langage utilisé, adapter ce code et spécifier les bonnes extensions de fichier. En langage C, les extensions seraient donc.c et non.f90. Fichier Lists.txt dans le dossier src/conversion : Langage Fortran 90 ou C FILE(GLOB_RECURSE source_files conversion_dollars.f90 conversion_yen.f90 conversion_francs.f90 ADD_LIBRARY(conversion STATIC ${source_files} Fichier Lists.txt dans le dossier src/heure : Langage Fortran 90 ou C FILE(GLOB_RECURSE source_files heure.f90 ADD_LIBRARY(heure SHARED ${source_files} Fichier Lists.txt dans le dossier src/menu : Langage Fortran 90 ou C FILE(GLOB_RECURSE source_files menu_heure.f90 menu_pythagore.f90 ADD_LIBRARY(menu SHARED ${source_files} TARGET_LINK_LIBRARIES(menu heure calcul IRD DSI Informatique scientifique PAGE 11 / 27 06.2010
La différence majeure vient du fait d'utiliser la commande ADD_LIBRARY à la place de ADD_EXECUTABLE. Comme le montre cet exemple, il sera également possible de lier des bibliothèques entre-elles, étant donné que la commande TARGET_LINK_LIBRARIES n'est pas réservée à l'exécutable. 4. Détails de la démarche Il ne sera détaillé dans cette partie qu'une façon de faire, qui ne devra par conséquent pas obligatoirement suivi de façon stricte. Il ne faut cependant pas oublier que cela reste un langage de script, et que certaines règles de base sont toujours valables. Exemple : Une variable devra obligatoirement être déclarée avant (sous-entendu précédemment dans le fichier son utilisation. Les commentaires sont reconnaissables à la présence du signe "#" en début de ligne. Dans le code final, les lignes de couleur rouge visent simplement à mettre en évidence les différences qu'il existe entre les deux versions (Fortran 90 et C. Une démarche type pourrait débuter par l'écriture du fichier Lists.txt principal de la façon suivante : Déclarations de la version minimale à utiliser, du langage de programmation et choix d'un nom pour le projet : CMAKE_MINIMUM_REQUIRED(VERSION 2.6 PROJECT(TutoBuild ENABLE_LANGUAGE(Fortran On choisit donc d'utiliser la version 2.6 au minimum, étant donné qu'elle a apporté le support du Fortran. Prévoir qu'il faudra descendre dans les sous-répertoires de l'arborescence : SET(SRC ${CMAKE_SOURCE_DIR}/src SUBDIRS(${SRC} On déclare alors une variable (SET nommée arbitrairement SRC, dont le contenu sera le chemin absolu à partir de la variable ${CMAKE_SOURCE_DIR} vers le répertoire «src». On notera que ${CMAKE_SOURCE_DIR} désignera, quelque soit les circonstances, la racine de votre projet. Il faudra parcourir ce dossier ; on utilise alors la commande SUBDIRS prenant pour paramètre cette nouvelle variable. Répertorier tous les fichiers constituants le programme principal (sans les bibliothèques : FILE(GLOB_RECURSE source_files ${CMAKE_SOURCE_DIR}/main.f90 On utilise la commande FILE, et le paramètre GLOB_RECURSE, suivi du nom voulu pour la variable qui contiendra la liste des fichiers (exemple: source_files. Il suffit alors de déclarer, ligne par ligne, le chemin absolu de chaque fichier, toujours à partir de la racine du projet. IRD DSI Informatique scientifique PAGE 12 / 27 06.2010
Nommer l'exécutable que l'on souhaite obtenir et spécifier les bibliothèques qui seront nécessaires à son fonctionnement : ADD_EXECUTABLE(exe ${source_files} TARGET_LINK_LIBRARIES(exe menu calcul conversion heure On utilise la commande ADD_EXECUTABLE, prenant comme paramètres le nom souhaité (ici : exe et la liste des fichiers, contenue alors dans notre variable ${source_files}. Les bibliothèques sont liées grâce à la commande TARGET_LINK_LIBRARIES, qui prend comme premier paramètre le nom de l'exécutable suivi de toutes les bibliothèques. Prévoir un dossier spécifique où seront générés les bibliothèques et l'exécutable : SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build/lib Il suffit pour cela de modifier (commande SET des variables présentes par défaut, et qui sont EXECUTABLE_OUTPUT_PATH et LIBRARY_OUTPUT_PATH. Ici, on voudra que l'exécutable se trouve dans le dossier «build», et les bibliothèques dans le sous-dossier build/lib. Il reste maintenant à écrire les fichiers Lists.txt présents dans les sous-dossiers de l'arborescence, ce qui ne présente à partir de maintenant plus beaucoup de difficultés étant donné que cela se base sur la même syntaxe (cf partie 2.3. On a alors une première ébauche fonctionnelle pour la compilation du projet. Cependant, est un outil multi-plateforme et propose de nombreuses autres propriétés encore non utilisées. La suite du document est donc réservé à celles-ci : portage multi-plateforme, création de packages et installeurs et règles personnalisées. Note : Ces trois dernières parties fonctionnant généralement «ensemble», le code final des fichiers Lists.txt pour le projet d'exemple ne sera fournit qu'à la fin du document. Dans chaque partie, seuls des exemples basiques seront présentés. 5. Portage multi-plateforme Le code fournit précédemment est minimaliste. propose de nombreuses options pratiques qui n'ont alors pas été utilisées. Parmi celles-ci, on en retrouve certaines qui permettent un portage multi-plateforme (tout du moins au niveau de la compilation de notre application. La réserve est d'avoir un code lui-même portable, c'est-à-dire qu'il ne fait pas appel à des commandes et/ou des fonctions particulières (exemple : une commande système spécifique à un système Unix-like. Les différences qu'il peut y avoir entre la compilation sur un système Unix-like et sur un système Windows seront traitées par des conditions, grâce aux mots clés «IF», «ELSE» et «ENDIF». Exemple : un compilateur différent de GCC. Dans l'exemple choisi, ces conditions seront ajoutées au fichier Lists.txt principal, situé à la racine de notre projet. Il serait cependant tout à fait possible d'en ajouter dans n'importe quel fichier Lists.txt, quelque soit son emplacement. IRD DSI Informatique scientifique PAGE 13 / 27 06.2010
Un portage multi-plateforme induit généralement quelques changements au niveau de la compilation. Par exemple, les bibliothèques, sur un système Windows, devront être placées (si aucune configuration n'est effectuée dans le même répertoire que l'exécutable, ce qui n'est pas le cas sur un système Unix-like. À l'aide des conditions : IF(UNIX, IF(WIN32 et IF(APPLE. Voici un exemple permettant de passer outre ce problème : IF(WIN32 SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build ENDIF(WIN32 IF(UNIX SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build/lib ENDIF(UNIX On modifie simplement le répertoire de destination des bibliothèques différemment selon le système d'exploitation utilisé. Il sera possible de procéder à toutes les modifications que l'on souhaite grâce à ces conditions. Le code final fourni en annexe présente plusieurs autres possibilités, incluant entre autre les règles personnalisées. Pour aller plus loin : Outre ces conditions, il va falloir, par sécurité, vérifier la présence de certains packages ou programmes particuliers. En effet, un portage multi-plateforme va augmenter le nombre de cas indésirables (la présence de logiciels non mis à jour, l'absence de ceux-ci ou d'un package particulier.... Les commandes FIND_PROGRAM, FIND_PACKAGE et FIND_LIBRARY vont être alors utiles. Dans un soucis de clarté, il sera pratique de réserver un dossier, que l'on nomme généralement «cmakemodules» qui contiendra tous les fichiers nécessaires à la recherche de ces dépendances. Pour les plus connus, des modules sont déjà écrits et installés par défaut avec, ce qui simplifiera la tâche. Par exemple, pour rechercher le programme «Cygwin» sur Windows, on va créer un fichier nommé : «FindCygwin.cmake» dans le dossier cmake-modules. Il faudra alors indiquer à qu'il peut rechercher la présence de modules dans ce dossier, par la commande : «SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake-modules/"» Celle-ci ne fait que modifier une variable déjà présente par défaut : CMAKE_MODULE_PATH. Lorsque l'on voudra vérifier si ce logiciel est installé, on ajoutera dans notre fichier Lists.txt la commande suivante : «INCLUDE(FindCygwin» va alors rechercher un fichier nommé FindCygwin.cmake dans le répertoire par défaut ET dans le répertoire que l'on a indiqué. Contenu d'un fichier FindXXX.cmake Il va dépendre de ce que l'on recherche, et du système d'exploitation utilisé. La recherche d'un programme, par exemple, sera totalement différente si l'on est sur un système Windows ou si l'on est sur un système Unix-like. Prenons le cas d'un système Unix-like, et de la recherche d'un programme particulier : Valgrind. IRD DSI Informatique scientifique PAGE 14 / 27 06.2010
MESSAGE(STATUS "Detecting program Valgrind" FIND_PROGRAM(VALGRIND_CMD valgrind IF(VALGRIND_CMD MESSAGE(STATUS "Detecting program Valgrind - done" SET(VALGRIND YES ELSE(VALGRIND_CMD MESSAGE(FATAL_ERROR "Could not find program Valgrind" ENDIF(VALGRIND_CMD La première ligne va seulement afficher un message STATUS (précédé des caractères «--» spécifiant quel programme l'on recherche. La seconde ligne recherche le programme en question, en essayant la commande unix correspondante. Dans ce cas, pour lancer valgrind, on utilise la commande du même nom. La variable VALGRIND_CMD sera alors créée uniquement si la commande fonctionne. On a alors usage de conditions. Si la variable a été créée, c'est que le programme a été trouvé. On peut alors effectuer un traitement particulier. Dans cet exemple, on décide d'afficher uniquement un message le signalant, et de déclarer une variable. Sinon, on affiche un message de type FATAL_ERROR, qui lui, va stopper la génération des fichiers, et donc empêcher la compilation du projet. Attention, la recherche d'un programme sous un système Windows est totalement différente. Il faut en effet partir du principe qu'un programme installé a généré une entrée dans la base de registre. Prenons pour exemple la recherche du programme «Cygwin». Voici une façon de faire : MESSAGE(STATUS "Detecting program Cygwin" GET_FILENAME_COMPONENT(CYGWIN_CHECK_PATH [HKEY_LOCAL_MACHINE\\SOFTWARE\\Cygwin\\setup;rootdir] PATH IF(CYGWIN_CHECK_PATH MATCHES "^/" MESSAGE(FATAL_ERROR "Could not find program Cygwin" ELSE(CYGWIN_CHECK_PATH MATCHES "^/" MESSAGE(STATUS "Detecting program Cygwin - done" SET(CYGWIN_INSTALL_PATH "${CYGWIN_CHECK_PATH}Cygwin" MESSAGE("${CYGWIN_INSTALL_PATH}" ENDIF(CYGWIN_CHECK_PATH MATCHES "^/" On récupère, avec la commande GET_FILENAME_COMPONENT la valeur de la clé «rootdir» située dans la base de registre. Cette clé, présente dans beaucoup de programme (avec éventuellement un nom différent désigne le répertoire dans lequel le logiciel a été installé. Si celle-ci est introuvable, ce que l'on va récupérer dans la variable CYGWIN_CHECK_PATH sera le caractère «/» uniquement. À partir de là, on peut construire une condition de type IF / ELSE. Dans notre cas, on choisit de simplement afficher un message et de sauvegarder dans une variable le chemin où est installé le logiciel recherché. IRD DSI Informatique scientifique PAGE 15 / 27 06.2010
6. Création de packages et d'installeurs Dans l'optique de distribuer son application, la création de packages et d'installeurs est une étape indispensable. Cela donne la possibilité de ne pas distribuer les sources, mais aussi de ne pas imposer l'étape de la compilation à l'utilisateur. Pour couvrir la plupart des systèmes d'exploitations, on voudra généralement obtenir un package.deb (distributions Linux basées sur Debian, un package.rpm (distributions Linux basées sur Redhat, et un installeur Windows (.exe. Pour générer ceux-ci, propose un outil complémentaire et présent par défaut : CPack. A savoir : Une règle est automatiquement associée à cet outil : il s'agit de «package». La commande «make package» appellera donc par défaut l'outil CPack. Le projet sera compilé avant la création des packages et installeurs. En effet, il faut que l'exécutable et les bibliothèques aient été générés. Dans cet exemple, nous allons créer les packages.deb et.rpm si l'on se trouve sur un système d'exploitation Unix-like, et l'installeur.exe si l'on se trouve sur un système d'exploitation Windows. Les commentaires seront précédés du caractère "#". # Description brève pour le package en question. SET(CPACK_PACKAGE_DESCRIPTION "Exemple CPack tuto build." # Description plus précise du contenu du package. SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Une plus longue description pour notre programme." # Choix d'un nom pour le package. SET(CPACK_PACKAGE_NAME "tuto-build" # Déclaration optionnelle de prérequis. Il en existe pour d'autre systèmes également. SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.3.6, libgcc1 (>= 1:4.1" # Si l'on se trouve sur un système Unix-like. IF(UNIX INSTALL( PROGRAMS build/exe DESTINATION sbin INSTALL( PROGRAMS build/lib/libcalcul.so build/lib/libconversion.a build/lib/libheure.so build/lib/libmenu.so DESTINATION lib SET(CPACK_GENERATOR "DEB;RPM" ENDIF(UNIX # Le package généré installera le fichier «build/exe» dans le dossier /usr/sbin. # Le package généré installera également les fichiers libcalcul.so, libconversion.a, # libheure.so, libmenu.so dans le dossier /usr/lib # Choix des packages à générer. Ici on choisit DEB (.deb et RPM (.rpm. # Si l'on se trouve sur un système Windows 32 bits. IF(WIN32 # On voudra que l'installation génère un raccourci dans le menu Démarrer, portant pour nom TutoBuild et exécutant le programme «exe». SET(CPACK_PACKAGE_EXECUTABLES "exe" "TutoBuild" INSTALL( PROGRAMS build/exe.exe DESTINATION bin INSTALL( PROGRAMS build/libcalcul.dll # L'installeur généré placera le fichier «build/exe.exe» dans le sous-dossier bin. # L'installeur placera également les fichiers libcalcul.dll, libcalcul.a, libheure.dll et # libmenu.dll dans le sous-dossier bin. IRD DSI Informatique scientifique PAGE 16 / 27 06.2010
build/libconversion.a build/libheure.dll build/libmenu.dll DESTINATION bin SET(CPACK_GENERATOR "NSIS" ENDIF(WIN32 # On choisit cette fois de générer un package avec NSIS. # Choix d'un auteur pour le package/installeur en question. SET(CPACK_PACKAGE_CONTACT "Romain Gabriel" # Choix d'un «distributeur» pour le package. SET(CPACK_PACKAGE_VENDOR "Institut de Recherche pour le Développement." # Renseignement du numéro de version (de type x.y.z SET(CPACK_PACKAGE_VERSION_MAJOR "0" SET(CPACK_PACKAGE_VERSION_MINOR "0" SET(CPACK_PACKAGE_VERSION_PATCH "1" # Déclaration d'une variable VERSION qui regroupe ces numéros de version majeurs, mineurs et patch. SET(VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.$ {CPACK_PACKAGE_VERSION_PATCH}" # Choix d'un nom pour le package généré. Il se compose donc ici du nom choisit au début, suivi du numéro complet de version ainsi que du type de processeur (x86 généralement. SET(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION_MAJOR}.$ {CPACK_PACKAGE_VERSION_MINOR}-${CMAKE_SYSTEM_PROCESSOR}" # Inclusion du module CPack, à faire nécessairement APRES la déclaration de toutes nos variables. INCLUDE(CPack Il existe d'autres variables prédéfinies qu'il est possible de modifier, et permettant de personnaliser le package (notamment tout ce qui concerne les descriptions, les auteurs... Il faudra alors se référer aux ressources disponibles sur le site officiel pour obtenir une liste exhaustive des options disponibles pour ce module CPack. 7. Règles personnalisées Les règles personnalisées se rapportent à la commande «make», qui sera utilisée pour compiler le projet une fois les fichiers générés par. Exemple : la règle personnalisée «profilage» et les commandes qui lui sont spécifiques ne seront exécutées que lorsque l'on utilisera la commande «make profilage». Généralement, elles sont utilisées pour proposer différents types de compilation, ou pour lancer des logiciels externes. On retrouve alors plusieurs fonctionnalités regroupées, ce qui est un point fort de. A savoir : propose une variable, nommée CMAKE_BUILD_TYPE, que l'on va pouvoir initialiser lorsque l'on voudra générer les fichiers avec la commande. Selon sa valeur, il sera possible d'utiliser par exemple des flags de compilation différents. IRD DSI Informatique scientifique PAGE 17 / 27 06.2010
IF(CMAKE_BUILD_TYPE MATCHES Profiling SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pg -g" ELSE(CMAKE_BUILD_TYPE MATCHES Profiling SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -02" Cette option concerne. Il suffira alors d'utiliser la commande : «cmake -DCMAKE_BUILD_TYPE=Profiling» pour remplir la condition et utiliser les flags «-pg -g» au lieu de «-O2». Pour agir sur la commande «make», il faudra utiliser la commande : ADD_CUSTOM_TARGET, qui prend comme paramètres le nom souhaité suivi des commandes système que l'on souhaite exécuter. Exemple : SET(PROG_CMD ${CMAKE_SOURCE_DIR}/build-profiling/exe SET(REPORT_PATH ${CMAKE_SOURCE_DIR}/build-profiling/rapport ADD_CUSTOM_TARGET(valgrind COMMAND make COMMAND mkdir -p ${REPORT_PATH} COMMAND valgrind ${PROG_CMD} 2> ${REPORT_PATH}/valgrind.txt En utilisant la commande «make valgrind», les commandes système déclarées grâce au mot clé COMMAND dans le fichier vont être exécutées dans l'ordre. Dans cet exemple : la première commande exécutée sera «make» : le projet va être compilé ; la deuxième commande exécutée sera «mkdir -p <dossier>» : la variable ${REPORT_PATH} sera remplacée par sa valeur. Un dossier spécifique est donc créé pour contenir le rapport d'exécution de Valgrind. La troisième commande exécutée sera «valgrind <commande> 2> <dossier>/valgrind.txt» : les variables seront là encore remplacées, et le logiciel Valgrind sera exécuté, va analyser le programme de notre projet, et sa sortie d'erreur sera redirigée vers un fichier dans le dossier voulu. Etant donné qu'il s'agit d'un programme disponible uniquement sur les systèmes Unix-like, il sera bon d'ajouter une condition IF(UNIX avant de créer cette règle personnalisée. D'autres exemples sont fournis dans le code final du Lists.txt principal (cf : annexe 2 page 26, notamment un utilisant l'outil de génération de documentation : Doxygen. IRD DSI Informatique scientifique PAGE 18 / 27 06.2010
4. Compilation et complément : 1. Compilation du projet : Sur un système Unix-like : Une fois à la racine du projet, on se place dans le répertoire «cmake» par la commande : «cd cmake». On lance alors l'outil en lui spécifiant de commencer à la racine du projet : «cmake..» et la génération des fichiers va commencer, affichant des messages en conséquence. On pourra accessoirement spécifier des variables de la façon suivante : «cmake -DCMAKE_BUILD_TYPE=Profiling..» pour changer le type de build si l'on en a prévu plusieurs dans notre code. Il suffit ensuite d'utiliser, toujours dans ce même dossier (où des fichiers ont été générés, la commande «make», «make package» ou d'utiliser une règle personnalisée «make <règle>». Pour un système Windows (2000, XP, Vista, 7 L'installation de pour Windows fournit également une interface graphique (cmake-gui facilitant la génération des fichiers. Lors de son lancement, la fenêtre principale apparaît. On peut alors renseigner dans le premier champ le dossier racine de notre projet, et dans le second champ le dossier où seront générés les fichiers (on renseigne alors notre dossier cmake prévu à cet effet. IRD DSI Informatique scientifique PAGE 19 / 27 06.2010
En cliquant une première fois sur «Configure», le choix du type de projet à générer est proposé. On pourra choisir VisualStudio, MinGW... Il suffit alors de valider. Pour générer les fichiers, il faudra cliquer sur «Generate», précédé d'un second clic sur «Configure» si le bouton Generate n'est pas disponible. IRD DSI Informatique scientifique PAGE 20 / 27 06.2010
Les projets VisualStudio sont alors générés dans le dossier, et sont compilables en utilisant VisualStudio. Pour MinGW, il faudra utiliser la commande «mingw32-make», à condition d'avoir installé MinGW et d'avoir configuré le raccourci vers cette commande (autrement, il faudra renseigner le chemin absolu vers mingw32-make.exe. 2. Quelques options complémentaires : L'option «cmake -G» : Permet de choisir un générateur particulier. Par exemple, pour utiliser le compilateur MinGW, on utilisera la commande : «cmake -G "MinGW Makefiles"». Pour générer un projet Eclipse, on pourra utiliser la commande : «cmake -G "Eclipse CDT4 Unix Makefiles"». En utilisant la commande «cmake --help», la liste des générateurs disponibles est affichée. Par défaut, le générateur sera GCC (système Unix-like. ADD_CUSTOM_COMMAND : Permet de lancer des commandes spécifiques qui vont générer un fichier de sortie. Cette commande est à différencier de ADD_CUSTOM_TARGET, dont les commandes ne seront exécutées que lors du «make target». ADD_DEPENDENCIES : Permet de spécifier des dépendances pour des cibles : ADD_LIBRARY, ADD_EXECUTABLE et ADD_CUSTOM_TARGET. Exemple : ADD_DEPENDENCIES(librairie1 librairie2 Cela va spécifier que la librairie2 devra être présente pour ajouter la librairie 1. LINK_DIRECTORIES : Permet de spécifier les répertoires dans lequel l'éditeur de lien (compilateur va rechercher les bibiliothèques. Exemple : LINK_DIRECTORIES(repertoire1 repertoire2 Les bibliothèques seront alors recherchées dans le répertoire1 et dans le répertoire2. A savoir : D'une façon générale, il est possible d'obtenir de l'aide sur une commande particulière en utilisant la commande Unix : «cmake --help-command <commande>» où <commande> est à remplacer par la commande voulue. IRD DSI Informatique scientifique PAGE 21 / 27 06.2010
5. Conclusion : est un outil puissant, qui dispose de nombreux atouts en sa faveur. On peut citer sa portabilité, sa facilité de prise en main, et sa syntaxe relativement simple, qui permettent d'obtenir des résultats satisfaisant en peu de temps. Le fait de pouvoir fractionner les fichiers Lists.txt aide grandement à obtenir une bonne lisibilité du code. Ce document ne présente cependant qu'une liste non exhaustive de commandes. Il faut savoir qu'il en existe de nombreuses autres, qui seront peut-être indispensables à la compilation d'un projet spécifique. En ce qui concerne, vous retrouverez plus d'informations sur le site officiel, qui propose une liste complète des options disponibles, accompagnée d'exemples. IRD DSI Informatique scientifique PAGE 22 / 27 06.2010
Annexe 1 : mémo Les variables de base : ${CMAKE_SOURCE_DIR} Dans tous les cas, par défaut, cela correspondra à la racine de votre projet. Par convention, tous les chemins que l'on utilisera dans nos commandes seront des chemins absolus ayant pour racine cette variable. Exemple : Dans l'arborescence présentée, le dossier «src» aura pour chemin ${CMAKE_SOURCE_DIR}/src ${CMAKE_C_FLAGS}, ${CMAKE_Fortran_FLAGS}, ${CMAKE_CXX_FLAGS} Ce sont respectivement la liste des flags qui seront utilisés pour la compilation des langages C, Fortran et C++. Il suffira d'assigner les options voulues à la variable correspondant au langage utilisé. Des exemples seront donnés par la suite. ${LIBRARY_OUTPUT_PATH} ${EXECUTABLE_OUTPUT_PATH} Ces variables spécifient le répertoire dans lequel seront générés respectivement les bibliothèques et l'exécutable. Par défaut, elles n'ont pas de valeur, et seront donc interprétées comme «le répertoire courant». Il sera appréciable de leur spécifier une valeur, pour ainsi générer ces fichiers dans un répertoire vide. ${CMAKE_MODULE_PATH} Cette variable va spécifier dans quel répertoire (autre que celui par défaut chercher les fichier de type FindXXX.cmake, où XXX sera le nom d'un programme, d'une bibliothèque ou d'un package que l'on va spécifier comme nécessaire au bon fonctionnement du projet. Note : Le contenu de ces variables peut bien sûr être modifié, de la même façon que l'on peut créer des variables personnelles. Cf page 24. IRD DSI Informatique scientifique PAGE 23 / 27 06.2010
Les commandes de base : (en situation CMAKE_MINIMUM_REQUIRED(VERSION 2.6 Spécifie la version de nécessaire au projet. Ici, on spécifie la version 2.6 en particulier car le langage Fortran n'est géré qu'à partir de cette version. Vous pourrez, selon les besoins, nécessiter une version plus récente car elle dispose de fonctionnalités nouvelles. Il faudra alors se référer à la documentation du site officiel pour connaître la liste des nouveautés. A savoir : Le mot clé MINIMUM_REQUIRED est explicite. Si la version de est inférieure à la 2.6, une erreur sera affichée et la génération des fichiers sera stoppée. PROJECT(TutoBuild Commande facultative mais qu'il sera bon de spécifier. Elle permet simplement de nommer le projet en cours. Ce nom n'a pas d'incidence, et son choix sera totalement arbitraire. SET(SRC "${CMAKE_SOURCE_DIR}/src" Commande indispensable à tout projet. Elle permet de créer des variables rapidement, et de modifier la valeur de celles déjà crées. La syntaxe sera toujours la même : SET(<nom_de_variable> "<valeur>". Exemple : Définir les flags -Wall et -g pour le langage C (avec les compilateurs GCC se fera grâce à la commande SET(CMAKE_C_FLAGS "-Wall -g" INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include/libconversion Spécifie un dossier contenant des fichiers headers (.h ou.hpp. Pour les langages C et C++, cette commande sera très utile. Dans le code source, il ne sera alors pas nécessaire d'indiquer le chemin relatif des fichiers header si les dossiers les contenants ont été déclarés grâce à cette commande. Exemple : #include "include/libconversion/conversion.h" deviendra #include "conversion.h" SUBDIRS(${SRC} Où ${SRC} est simplement une variable contenant un chemin. Cette commande permet de spécifier qu'il faut descendre dans l'arborescence, et que le dossier pointé par la variable ${SRC} contient lui aussi un fichier Lists.txt qu'il faut interpréter. Dans notre exemple, ${SRC} serait déclaré par la commande : SET(SRC "${CMAKE_SOURCE_DIR}/src" IRD DSI Informatique scientifique PAGE 24 / 27 06.2010
FILE(GLOB_RECURSE source_files conversion_dollars.c conversion_yen.c conversion_francs.c Cette commande permet d'assigner à une variable (ici ${source_files} une liste de fichiers. Cela devra être fait pour chaque bibliothèque, par exemple. GLOB_RECURSE sera utilisé à chaque fois, car il permet l'utilisation de «motif», et par exemple utiliser l'expression "*.c" pour designer tous les fichier.c se trouvant dans le même répertoire que le fichier Lists.txt courant. Exemple : Dans ce cas, la bibliothèque conversion est composée de 3 fichiers, qu'il faut alors lister. ADD_EXECUTABLE(exec ${source_files} Permet de procéder à la compilation de l'exécutable. Dans cet exemple, il sera nommé «exec» et son (ses fichier(s source sera (seront défini(s auparavant dans une variable ${source_files}. Lors de la création d'un projet, aussi simple soit-il, cette commande sera obligatoirement utilisée. ADD_LIBRARY(conversion SHARED ${source_files} De la même manière que pour l'exécutable, cette commande permet de procéder à la compilation et à la création d'une bibliothèque, en précisant les fichiers source qui la composent. Dans cet exemple, notre bibliothèque sera nommée «conversion», et le fichier généré sera «libconversion.so» (sur un système Unix-like. Note : Le mot clé SHARED va générer une bibliothèque dynamique (ou partagée. On pourra le remplacer par le mot clé STATIC, qui procédera à la création d'une bibliothèque statique. TARGET_LINK_LIBRARIES(exec m menu heure conversion calcul Pour préciser au compilateur que l'exécutable a besoin de certaines librairies pour compiler et s'exécuter, cette commande sera utilisée. Sa syntaxe n'est pas compliquée : Le premier paramètre sera le nom de l'exécutable, et tous les suivants les bibliothèques dont il a besoin. Note : En spécifiant le mot «m», la bibliothèque recherchée sera «libm.so» ou «libm.a» (ou.dll /.lib sur un système Windows. Il en sera de même pour toutes les autres. ENABLE_LANGUAGE(Fortran Certains langages ne sont pas supportés par défaut par l'outil. Il faut alors lui spécifier quel langage de programmation est utilisé. Ainsi, pour le Fortran par exemple, il sera obligatoire de donner cette commande. Pour le C, cela n'est pas obligatoire. Par convention, il sera préférable de toujours spécifier le langage avec lequel nous travaillons. Exemple : ENABLE_LANGUAGE(CXX pour le C++. IRD DSI Informatique scientifique PAGE 25 / 27 06.2010
Annexe 2 : code final du Lists.txt principal Langage Fortran 90 CMAKE_MINIMUM_REQUIRED(VERSION 2.6 PROJECT(TutoBuild ENABLE_LANGUAGE(Fortran SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake-modules/" ## Configuration relative aux bibliothèques SET(SRC ${CMAKE_SOURCE_DIR}/src SUBDIRS(${SRC} ## Fin bibliothèques. ## Configuration pour l'exécutable. FILE(GLOB_RECURSE source_files ${CMAKE_SOURCE_DIR}/main.f90 ADD_EXECUTABLE(exe ${source_files} TARGET_LINK_LIBRARIES(exe menu calcul conversion heure ## Fin exécutable. ## Make doc INCLUDE(FindDoxygen IF(DOXYGEN SET(DOC_CONFIG_DIR ${CMAKE_SOURCE_DIR}/doc SET(DOC_CONFIG_FILE ${DOC_CONFIG_DIR}/doc_config_file IF(UNIX ADD_CUSTOM_TARGET(doc COMMAND mkdir ${DOC_CONFIG_DIR} COMMAND ${DOXYGEN} -g ${DOC_CONFIG_FILE} COMMAND ${DOXYGEN} ${DOC_CONFIG_FILE} COMMAND mv html latex ${DOC_CONFIG_DIR} ENDIF(UNIX IF(WIN32 ADD_CUSTOM_TARGET(doc COMMAND mkdir ${DOC_CONFIG_DIR} COMMAND ${DOXYGEN} -g ${DOC_CONFIG_FILE} COMMAND ${DOXYGEN} ${DOC_CONFIG_FILE} COMMAND move html ${DOC_CONFIG_DIR} COMMAND move latex ${DOC_CONFIG_DIR} ENDIF(WIN32 ELSE(DOXYGEN MESSAGE(STATUS "Doxygen not found - Target doc not available" ENDIF(DOXYGEN ## Fin Make doc ## Make installer SET(CPACK_PACKAGE_DESCRIPTION "Exemple CPack tuto build." SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Une plus longue description pour notre programme." SET(CPACK_PACKAGE_NAME "tuto-build" SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.3.6, libgcc1 (>= 1:4.1" IF(UNIX INSTALL( PROGRAMS build/exe DESTINATION sbin INSTALL( PROGRAMS build/lib/libcalcul.so build/lib/libconversion.a build/lib/libheure.so build/lib/libmenu.so DESTINATION lib SET(CPACK_GENERATOR "DEB;RPM" ENDIF(UNIX IF(WIN32 SET(CPACK_PACKAGE_EXECUTABLES "exe" "TutoBuild" INSTALL( PROGRAMS build/exe.exe DESTINATION bin SET(CPACK_GENERATOR "NSIS" ENDIF(WIN32 Langage C CMAKE_MINIMUM_REQUIRED(VERSION 2.6 PROJECT(TutoBuild SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake-modules/" ## Chemin des headers et parcours des bibliothèques. SET(SRC ${CMAKE_SOURCE_DIR}/src INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include/libconversion INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include/libcalcul INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include/libheure INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include/libmenu SUBDIRS(${SRC} ## Fin bibliothèques. ## Configuration pour l'exécutable. FILE(GLOB_RECURSE source_files ${CMAKE_SOURCE_DIR}/main.c ADD_EXECUTABLE(exe ${source_files} TARGET_LINK_LIBRARIES(exe m menu heure conversion calcul ## Fin exécutable. ## Make doc INCLUDE(FindDoxygen IF(DOXYGEN SET(DOC_CONFIG_DIR ${CMAKE_SOURCE_DIR}/doc SET(DOC_CONFIG_FILE ${DOC_CONFIG_DIR}/doc_config_file IF(UNIX ADD_CUSTOM_TARGET(doc COMMAND mkdir ${DOC_CONFIG_DIR} COMMAND ${DOXYGEN} -g ${DOC_CONFIG_FILE} COMMAND ${DOXYGEN} ${DOC_CONFIG_FILE} COMMAND mv html latex ${DOC_CONFIG_DIR} ENDIF(UNIX IF(WIN32 ADD_CUSTOM_TARGET(doc COMMAND mkdir ${DOC_CONFIG_DIR} COMMAND ${DOXYGEN} -g ${DOC_CONFIG_FILE} COMMAND ${DOXYGEN} ${DOC_CONFIG_FILE} COMMAND move html ${DOC_CONFIG_DIR} COMMAND move latex ${DOC_CONFIG_DIR} ENDIF(WIN32 ELSE(DOXYGEN MESSAGE(STATUS "Doxygen not found - Target doc not available" ENDIF(DOXYGEN ## Fin Make doc ## Make installer SET(CPACK_PACKAGE_DESCRIPTION "Exemple CPack tuto build." SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Une plus longue description pour notre programme." SET(CPACK_PACKAGE_NAME "tuto-build" SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.3.6, libgcc1 (>= 1:4.1" IF(UNIX INSTALL( PROGRAMS build/exe DESTINATION sbin INSTALL( PROGRAMS build/lib/libcalcul.so build/lib/libconversion.a build/lib/libheure.so build/lib/libmenu.so DESTINATION lib SET(CPACK_GENERATOR "DEB;RPM" ENDIF(UNIX IF(WIN32 SET(CPACK_PACKAGE_EXECUTABLES "exe" "TutoBuild" INSTALL( PROGRAMS build/exe.exe DESTINATION bin IRD DSI Informatique scientifique PAGE 26 / 27 06.2010
SET(CPACK_PACKAGE_CONTACT "Romain Gabriel" SET(CPACK_PACKAGE_VENDOR "Institut de Recherche pour le Développement." SET(CPACK_PACKAGE_VERSION_MAJOR "0" SET(CPACK_PACKAGE_VERSION_MINOR "0" SET(CPACK_PACKAGE_VERSION_PATCH "1" SET(VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.$ {CPACK_PACKAGE_VERSION_MINOR}.$ {CPACK_PACKAGE_VERSION_PATCH}" SET(CPACK_SOURCE_PACKAGE_FILE_NAME "$ {CPACK_PACKAGE_NAME}-${VERSION}-src" SET(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-$ {CPACK_PACKAGE_VERSION_MAJOR}.$ {CPACK_PACKAGE_VERSION_MINOR}-${CMAKE_SYSTEM_PROCESSOR}" INCLUDE(CPack ## Fin Make installer ## Configuration si OS Windows uniquement. IF(WIN32 MESSAGE(STATUS "Operating system: Windows" INCLUDE(FindCygwin INCLUDE(FindVLC SET(EXECUTABLE_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2" SET(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -O2" ENDIF(WIN32 ## Fin configuration OS Windows. ## Configuration si OS Unix-like uniquement. IF(UNIX MESSAGE(STATUS "Operating system: Unix-like" IF(CMAKE_BUILD_TYPE MATCHES Profiling SET(EXECUTABLE_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build-profiling SET(LIBRARY_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build-profiling/lib SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pg -g" INCLUDE(FindValgrind IF(VALGRIND SET(PROG_CMD $ {CMAKE_SOURCE_DIR}/build-profiling/exe SET(REPORT_PATH $ {CMAKE_SOURCE_DIR}/build-profiling/rapport ADD_CUSTOM_TARGET(valgrind COMMAND make COMMAND mkdir -p ${REPORT_PATH} COMMAND valgrind ${PROG_CMD} 2> $ {REPORT_PATH}/valgrind.txt ENDIF(VALGRIND ELSE(CMAKE_BUILD_TYPE MATCHES Profiling SET(EXECUTABLE_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build/lib SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2" ENDIF(CMAKE_BUILD_TYPE MATCHES Profiling ENDIF(UNIX ## Fin configuration OS Unix-like. INSTALL( PROGRAMS build/libcalcul.dll build/libconversion.a build/libheure.dll build/libmenu.dll DESTINATION bin SET(CPACK_GENERATOR "NSIS" ENDIF(WIN32 SET(CPACK_PACKAGE_CONTACT "Romain Gabriel" SET(CPACK_PACKAGE_VENDOR "Institut de Recherche pour le Développement." SET(CPACK_PACKAGE_VERSION_MAJOR "0" SET(CPACK_PACKAGE_VERSION_MINOR "0" SET(CPACK_PACKAGE_VERSION_PATCH "1" SET(VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.$ {CPACK_PACKAGE_VERSION_MINOR}.$ {CPACK_PACKAGE_VERSION_PATCH}" SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}- ${VERSION}-src" SET(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-$ {CPACK_PACKAGE_VERSION_MAJOR}.$ {CPACK_PACKAGE_VERSION_MINOR}-${CMAKE_SYSTEM_PROCESSOR}" INCLUDE(CPack ## Fin Make installer ## Configuration si OS Windows uniquement. IF(WIN32 MESSAGE(STATUS "Operating system: Windows" INCLUDE(FindCygwin INCLUDE(FindVLC SET(EXECUTABLE_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/build SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2" ENDIF(WIN32 ## Fin configuration OS Windows. ## Configuration si OS Unix-like uniquement. IF(UNIX MESSAGE(STATUS "Operating system: Unix-like" IF(CMAKE_BUILD_TYPE MATCHES Profiling SET(EXECUTABLE_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build-profiling SET(LIBRARY_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build-profiling/lib SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pg -g" INCLUDE(FindValgrind IF(VALGRIND SET(PROG_CMD $ {CMAKE_SOURCE_DIR}/build-profiling/exe SET(REPORT_PATH $ {CMAKE_SOURCE_DIR}/build-profiling/rapport ADD_CUSTOM_TARGET(valgrind COMMAND make COMMAND mkdir -p ${REPORT_PATH} COMMAND valgrind ${PROG_CMD} 2> $ {REPORT_PATH}/valgrind.txt ENDIF(VALGRIND ELSE(CMAKE_BUILD_TYPE MATCHES Profiling SET(EXECUTABLE_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build SET(LIBRARY_OUTPUT_PATH $ {CMAKE_SOURCE_DIR}/build/lib SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2" ENDIF(CMAKE_BUILD_TYPE MATCHES Profiling ENDIF(UNIX ## Fin configuration OS Unix-like. IRD DSI Informatique scientifique PAGE 27 / 27 06.2010