Cette section détaille la marche à suivre pour compiler et installer la bibliothèque Cogitant à partir des sources. Différents modes opératoires doivent être suivis selon le système d'exploitation et le compilateur. Le tableau ci-dessous récapitule les différentes architectures et compilateurs avec lesquels la bibliothèque a été testée.
| Système | Version | Compilateur | Version testée |
| GNU/Linux | Debian 9.3 | GNU C++ 6.3.0 | 5.3.2 |
| - | - | LLVM Clang 3.9.1 | 5.3.2 |
| MS Windows | 10 | Microsoft Visual C++ 2017 Community (15.5.0) | 5.3.2 |
| - | - | Microsoft Visual C++ 2015 Community (19.0.23026.1) | 5.3.1 |
| - | 8 | Microsoft Visual C++ 2013 Express (12.0.30501.00) | 5.3.1 |
| Mac OS | 10.10.5 | Apple LLVM 7.0.0 (Xcode 7.0) | 5.3.1 |
| - | - | GNU C++ 5.2.0 (Macports) | 5.3.1 |
| - | - | GNU C++ 4.9.3 (Macports) | 5.3.1 |
Remarque : Ces informations ne concernent que les classes de base de Cogitant (espace de nom cogitant), mais pas les classes de l'architecture client / serveur, ni les classes de dessin et d'interfacage avec Java.
Les instructions de compilation décrites ci-dessous concernent les classes de base de la bibliotèque. Si vous désirez utiliser des extensions (architecture client/serveur, dessin et édition de graphes, interfacage CommonC++, wxWidgets ou Java), la compilation s'effectue à peu près de la même façon, mais des options particulières doivent être fournies au mécanisme de compilation. Pour connaitre en détail ces options, vous pouvez vous reporter à la section Dessin de graphes - compilation et à la section Architecture client-serveur - compilation.
Deux méthodes sont disponibles pour la compilation de Cogitant. Selon le système d'exploitation utilisé, il faut utiliser une méthode ou l'autre. La première méthode consiste à utiliser un script configure, démarche bien connue des utilisateurs de systèmes de type Unix (désormais appelés juste Unix). Cette méthode a l'avantage d'être simple, mais l'inconvénient d'être disponible uniquement sous Unix, car requiert la présence d'un interpréteur de scripts shell (sh). L'autre méthode consiste à utiliser Cmake (http://www.cmake.org) dont le principal avantage est d'être disponible à la fois sous Unix et sous MS Windows, mais cette méthode demande d'installer Cmake avant de lancer la compilation de Cogitant.
Cogitant utilise le mécanisme classique pour la compilation sous Unix (./configure, make, make install). Si vous êtes familiers de ce mécanisme, il est inutile de lire cette section. Notez que Cmake peut aussi être utilisé sous Unix, se reporter à la section Installation avec Cmake pour plus d'informations. Assurez-vous d'avoir un compilateur C++ installé avant d'aller plus loin. Sous MacOS, installez Xcode (https://developer.apple.com/xcode/).
En premier lieu, il faut décompresser l'archive contenant les sources. Pour cela, procéder de la façon suivante :
Ceci a pour effet de créer un répertoire cogitant-5.x.x contenant les sources de la bibliothèque, mais aussi les fichiers entête, les documentations et les programmes d'exemple. Il faut maintenant compiler les sources pour construire le fichier bibliothèque, qui pourra être lié plus tard à vos applications. Avant cela, il est nécessaire de configurer la compilation de cette façon :
L'appel à configure (qui est un fichier script situé dans le répertoire cogitant) crée un certain nombre de fichiers permettant la construction de la bibliothèque. Il est possible de passer un certain nombre de paramètres à ce script pour configurer la compilation. La plupart de ces paramètres permettent de régler des détails de la compilation et il est souvent inutile d'y toucher à moins de savoir ce que l'on fait. Par contre, un paramètre est souvent utilisé, il s'agit de –prefix, qui permet de préciser dans quel répertoire le résultat de la compilation devra être installé. Par défaut, il s'agit du répertoire /usr/local (les fichiers entêtes sont donc installées dans /usr/local/include, la bibliothèque dans /usr/local/lib, etc.), mais si vous ne possédez pas les droits (root) sur ce répertoire, il est nécessaire d'indiquer un autre répertoire (./configure –prefix=/home/users/moi/usr par exemple). Dans ce cas, vous devrez fixer la valeur des variables d'environnement PATH et LD_LIBRARY_PATH pour pouvoir utiliser simplement la bibliothèque. Le but de cette documentation n'étant pas de décrire l'utilisation d'Unix, nous ne décrirons pas les manipulations devant être effectuées pour obtenir ce résultat et considérerons par la suite que les fichiers de la plate-forme sont correctement installés dans des répertoires accessibles dans les différents répertoires de recherche (c'est le cas par défaut si vous n'utilisez pas le paramètre –prefix). Se reporter au "gourou Unix" à votre disposition si vous ne vous sentez pas capable de réaliser ces opérations : Cogitant s'utilise comme n'importe quelle autre bibliothèque, et tout gourou Unix digne de ce nom connait la marche à suivre pour créer une arborescence usr spécifique à un utilisateur.
Une fois la configuration effectuée, il est possible de lancer la compilation de la bibliothèque de la façon suivante :
La compilation prend un certain temps, variable évidemment suivant les capacités de votre machine. Si la compilation s'est effectuée sans encombre, vous pouvez maintenant installer la bibliothèque dans les répertoires choisis au moment de l'appel à configure, pour cela, il suffit de taper :
Et c'est fini, vous pouvez maintenant compiler vos propres programmes qui utilisent la bibliothèque, et pour cela, référez vous à la section Compilation de programmes utilisant Cogitant.
Il est nécessaire d'utiliser les outils GNU plutôt que les outils Sun. Les noms des outils GNU sont habituellement préfixés par g sous SunOS. Ainsi, pour décompresser l'archive, utiliser le GNU tar plutôt que le tar de Sun (gtar zxvf cogitant-5.x.x.tar.gz). De même, pour compiler les sources de la bibliothèque utiliser le GNU make (gmake suivi de gmake install). Selon l'installation, il peut être nécessaire de préciser la commande make à utiliser pour l'appel des Makefiles des niveaux intérieurs, pour cela, tapez gmake MAKE=gmake. Si la compilation se termine immédiatement par une erreur, il est peut être nécessaire de régénérer certains fichiers. Pour cela tapez automake, autoconf, ./configure, make.
Le script configure détecte le compilateur par défaut et la compilation s'effectue avec ce compilateur, habituellement la version 4.x du GNU C++. Il est toutefois possible de forcer le script configure à utiliser un autre compilateur. Pour cela, il suffit de définir les variables d'environnement CC et CXX avant de lancer le script. Ces deux variables doivent avoir pour valeur respectivement le nom du compilateur C utilisé, et le nom du compilateur C++. Ces noms doivent être éventuellement préfixés par le chemin si les exécutables ne figurent pas dans le PATH.
Pour utiliser GNU C++ 5.x sous Debian testing/unstable
Le compilateur par défaut des versions récentes de Debian testing/unstable est gcc 5.2. Il est d'ailleurs recommandé d'utiliser cette version du compilateur. Si vous désirez utiliser une version plus ancienne (4.x) ou plus récente (5.x) du compilateur, il faut utiliser les commandes suivantes (après s'être assuré que cette version est correctement installée, évidemment).
Il est à noter que les noms des exécutables du compilateur donnés ci-dessus correspondent à une distribution Debian. Ces noms peuvent être différents selon le système. Notez qu'il est toutefois préférable d'utiliser les versions >= 4.4 du compilateur GNU.
Pour utiliser Intel C++ compiler
La compilateur Intel C++ peut être téléchargé gratuitement pour une utilisation non commerciale ici : http://software.intel.com/en-us/articles/non-commercial-software-download/ (Intel C++ Composer XE for Linux)
En supposant que le compilateur est installé dans le répertoire /opt/intel.
Pour utiliser le compilateur de Sun Studio
En supposant qu'il soit installé dans /opt/sunstudio12.1 :
Pour utiliser le compilateur LLVM Clang
En supposant que le compilateur soit accessible par /usr/bin/clang++-3.9 :
A noter que si vous avez déjà lancé le script configure, il est préférable de supprimer le fichier config.cache avant de re-lancer le script configure avec les nouvelles valeurs pour CC et CXX.
Le script configure peut recevoir des arguments qui permettent de configurer la façon dont Cogitant est compilée. ./configure –help donne la liste des arguments, certains étant communs à tous les scripts de configuration générés par le couple infernal autoconf/automake, d'autres étant spécifiques à Cogitant. Parmi les arguments spécifiques, nous n'en citerons que quelques uns.
–enable-optimize (et son opposé –disable-optimize) génère un code plus efficace, au prix d'une compilation plus longue. –disable-assert (et son opposé –enable-assert) supprime des vérifications effectuées dans Cogitant, et permet une exécution plus rapide des opérations, et doit donc être utilisé quand le code du programme que vous développez sur Cogitant a été débogué. Cmake est la deuxième méthode de compilation de Cogitant, mais contrairement à l'utilisation du configure, cette méthode requiert l'installation d'une application supplémentaire : Cmake. Cependant, cette application est disponible sous forme de paquets dans tous les systèmes Unix modernes. Pour vérifier que Cmake est correctement installé, taper simplement cmake –version dans un shell. La version 2.6.3 (au minimum) de Cmake est requise.
Nous décrivons ici la compilation de Cogitant avec Cmake dans un sous-répertoire du répertoire cogitant-5.x.x appelé cmake. Ce nom n'est évidemment qu'un exemple.
ccmake est une interface simplifiée permettant de configurer la compilation. Une fois ccmake chargé, taper c pour faire apparaître les options de configuration. L'écran qui apparaît alors permet de sélectionner les modules de Cogitant qui seront construits (Interfacage Java par exemple) et la configuration de la compilation (CMAKE_BUILD_TYPE peut prendre la valeur Release pour une compilation optimisée et Debug pour une compilation avec informations de débogage). Appuyer sur c (après avoir éventuellement modifié certaines valeurs) pour lancer la configuration, puis sur g pour générer les makefiles. En effet, la commande ccmake génère les makefiles correspondant à la configuration choisi, il ne reste donc plus qu'à compiler Cogitant par un simple :
Notez que Cmake peut aussi prendre en compte d'autres compilateurs tels qu'Intel C++, pour cela, on définira les variables d'environnement de la façon donnée plus haut avant d'appeler ccmake. Notons enfin que la commande cmake peut être utilisée à la place de ccmake et permet de passer les arguments de compilation en ligne de commande plutôt que dans une interface, ce qui peut être utile pour automatiser la construction de Cogitant. Se reporter à la documentation de cmake (http://www.cmake.org/HTML/RunningCMake.html) pour plus d'informations.
Ce compilateur est le compilateur conseillé sous MS Windows car il s'agit, contrairement aux versions précédentes, d'un compilateur respectant à peu près la norme. Toutefois, les solutions basées sur des outils libres ne doivent pas être oubliées avec Cygwin et Mingw qui sont décrits plus bas. La démarche décrite ici est valable pour la version Express du compilateur, qui a l'avantage d'être gratuite, mais la démarche peut être adaptée facilement avec les versions payantes du compilateur.
Le compilateur est disponible gratuitement sur le site de Microsoft à l'adresse suivante : http://www.microsoft.com/france/visual-studio/essayez/express.aspx (Visual Studio Express pour Windows Desktop)
Aller sur le site de Cmake http://www.cmake.org , télécharger la version MS Windows et l'installer.
Avant de compiler les sources, il est nécessaire de les extraire de l'archive, il est pour cela nécessaire d'utiliser un outil capable de traiter les fichiers tar.gz comme 7zip (outil libre disponible à http://www.7-zip.org/), ou Total Commander (http://www.ghisler.com).
Charger Cmake à partir du menu Démarrer et lui indiquer le répertoire contenant les sources de Cogitant dans le champ Where is the source code (par exemple D:\cogitant-5.x.x). Dans le deuxième champ Where to build the binaries, on indiquera, soit le même répertoire, soit un autre répertoire qui contiendra le résultat de la compilation (par exemple D:\cogitant-5.x.x\cmake). Cliquer sur Configure, et demander la création de fichiers pour Visual Studio 10 (2010), Visual Studio 11 (2012), Visual Studio 12 (2013), Visual Studio 14 (2015). Modifier éventuellement la valeur de certains paramètres, puis sur cliquer sur Configure. Cliquer alors sur Generate (ou Ok selon les versions de Cmake). Cmake se charge de créer des fichiers projets pour VC++.
Avec les répertoires cités ci-dessus, Cmake a créé un fichier cogitant.sln dans le répertoire D:\cogitant-5.x.x\cmake. Exécutez ce fichier, ce qui a pour effet d'ouvrir VC++ sur ce projet, et lancez la compilation par un appui sur F7 (après avoir éventuellement choisi le mode de compilation Debug ou Release). Attention, si vous voulez redistribuer une application compilée avec VC++, vous devez obligatoirement la compiler en mode Release car les DLL runtime de VC++ en mode débug ne sont pas redistribuables.
La suite Cygwin (http://www.cygwin.com) est un ensemble d'outils permettant de compiler facilement des sources prévus pour Unix. Le compilateur inclus dans cette suite est le GNU C++ 4.8. La compilation avec Cygwin se fait alors exactement de la même façon que sous Unix. Après avoir démarré Cygwin (bash –login), exécuter les commandes suivantes :
L'ensemble d'outils Mingw (http://www.mingw.org) est une version pour MS Windows du compilateur de GNU et des outils associés. Contrairement à Cygwin qui fournit une couche d'émulation d'Unix (à la fois les appels systèmes et les utilitaires en ligne de commande), Mingw ne contient que le compilateur et les outils nécessaires à la construction de programmes MS Windows pouvant utiliser l'API Win32, mais ne pouvant utiliser d'appels systèmes spécifiques à Unix. Le principal bénéfice de l'utilisation de Mingw par rapport à Cygwin réside en l'absence de "l'artillerie lourde" mise en place par Cygwin pour faire croire aux applications qu'elles s'exécutent sous Unix : ainsi, tout logiciel compilé avec Cygwin est dynamiquement lié à la bibliothèque cygwin1.dll qui doit être obligatoirement fournie avec vos applications (l'autre contrainte est qu'une application compilée avec Cygwin doit être GPL mais c'est aussi le cas d'une application utilisant Cogitant). Au contraire, Mingw produit un exécutable MS Windows "pur", ne nécessitant pas cette dll. Il est toutefois à noter que la compilation de sources C++ avec Mingw produit un exécutable nécessitant la bibliothèque libstd++.dll (fournie avec Mingw, mais qui doit être distribuée avec vos applications dans le cas d'une installation sur un poste sur lequel Mingw n'est pas installé). Cogitant peut être compilé à l'aide du script configure (comme sous Unix) ou avec CMake (methode conseillée).
Voir Configuration pour des instructions générales à propos de l'utilisation de CMake avec Cogitant. Pour Mingw, il faut évidemment choisir le générateur de "MinGW Makefiles" dans CMake. Une fois que les makefiles sont générés, ouvrir une invite de commandes. Se positionner dans le répertoire dans lequel les makefiles ont été générés et lancer l'exécution de la commande make de Mingw. En supposant que Mingw a été installé dans C:\mingw, Cogitant a été installé dans D:\cogitant-5.x.x, et les makefiles générés par CMake dans le sous répertoire cmake de D:\cogitant-5.x.x, les commandes suivantes doivent être exécutées :
Aucun outil n'est fourni avec Mingw pour construire une application, alors qu'il est nécessaire de disposer d'une application shell et d'autres outils pour compiler Cogitant ou d'autres programmes. C'est pourquoi il est nécessaire d'installer, en plus du package Mingw, le package MSys (pour minimal system). Ce package fournit (entre autres) un shell qui est nécessaire à l'exécution du script configure, et peut être téléchargé à partir du site principal de Mingw.
Une fois que les packages Mingw et MSys sont installés, ouvrir une session MSys à l'aide du menu Démarrer, et lancer la compilation par un ./configure –disable-shared suivi d'un make.