Les outils Automake et Autoconf....

Sommaire

1. Concepts de base
   • Utilité des outils
   • Fonctionnement global
2. Outil Autoconf
   • Principe
   • Fichiers nécessaires (Configure.in...)
   • Mini-exemple
3. Outil Automake
   • Principe
   • Dépendances (Makefile.am...)
   • Mini-exemple
4. Gestion des fichiers d'en-tête (outil Autoheader)
   • Principe
   • Fichiers associés (acconfig.h...)
5. Outil Configure
   • Principe
   • Fichiers créés (Makefile...)
6. Tableau récapitulatif
7. FAQ & Eventuels problèmes
8. Bibliographie

• Utilité des outils

Actuellement, si l'on veut développer une application informatique "correctement", on va écrire plusieurs fichiers sources. La multiplicité de ces fichiers fait que la maintenance de notre projet devient vite contraignante. C'est pourquoi, paresse oblige, ces tâches (compilation, gestion des dépendances....) sont confiées à un Makefile.

Mais certaines opérations restent encore difficile en raison de l'évolution de notre programme, ou encore en raison de l'adaptation sur différents systèmes. Ainsi, il faut quand même maintenir le Makefile.

Ces outils ont deux objectifs principaux :

• simplifier le développement de programme portable. Ils permettent aux développeurs de se concentrer sur l'écriture du programme, en simplifiant les détails de portabilité entre les Unix et en lui permettant de décrire la structure de son application avec un langage plus simple que celui du Makefile.
• simplifier la compilation des programmes distribués sous formes de fichiers sources. Tous les programmes sont compilés en utilisant deux étapes simples et standards (./configure et make). Il n'y a pas besoin d'installer d'outils spécifiques pour l'installation.

• Fonctionnemement global

Seul les développeurs de programme doivent avoir installés les outils présentés ci-après. Les personnes qui veulent simplement installer un logiciel à partir des sources n'ont pas besoin d'outils spéciaux, excepté un shell Unix, un programme make et un compilateur C.

• Automake : système pour décrire la structure de l'application, en permettant au développeur d'écrire un Makefile simplifié. Cet outil génère un fichier 'moule' du Makefile à partir d'un série de macros.
  
  
• Autoconf : outil qui fournit une structure de portabilité, basée sur un ensemble de tests des spécificités de la machine au moment de l'installation.

Voici le schéma des dépendances entre les fichiers et les outils (le fichier acconfig.h sera présenté plut tard, restons pour l'instant dans un schèma simple!! :) ).

• Principe

Autoconf est un outil qui génère un script exécutable (configure) pour adapter l'installation de nos codes sources en fonction du système et de la machine d'installation. Le script configure est indépendant d'Autoconf, ainsi l'utilisateur n'a pas besoin d'avoir l'outil Autoconf.

• Fichiers nécessaires (Configure.in...)

• Configure.in : ce fichier contient un ensemble de macros Autoconf, décrivant les options et les caractéristiques du système à tester (comme la présence de fichiers d'en-tête ou de fonctions). De nombreuses macros existent déjà pour tester certains aspects, mais il est possible de créer ses propres macros à partir de "templates".
  Pour commencer, vous pouvez lancer la commande autoscan, qui va générer un fichier nommé configure.scan. Ce fichier peut servir de prototype pour configure.in. Cette commande examine les fichiers sources en cherchant les problèmes de portabilité. Il ne vous reste plus qu'à renommer le fichier configure.scan en configure.in, et à le compléter par d'autres macros...
  Le langage de configure.in est procédural, c ’est à dire que chaque ligne du fichier est une commande qui est exécutée (pour la syntaxe, regardez l'exemple).
  
  
• aclocal.m4 : nécessaire lorsque l'on utilise Automake, ou bien si on a défini ses propres macros. Il est possible de générer ce fichier à partir de la commande aclocal. Cet outil recherche les définitions de macros externes dans les fichiers .m4 (écrit si on redéfini des macros) et dans le fichier Configure.in, et créé le fichier aclocal.m4. Par exemple, si on utilise Automake, l'outil aclocal rendra compréhensible les macros automake (ex. AM_INIT_AUTOMAKE issue de configure.in) pour Autoconf (en les traduisant dans le fichier aclocal.m4).
  
  Ce qui donne le schéma de relation suivant :
  
  
  

• Mini exemple

• les lignes qui commencent par dnl sont des commentaires et ne sont pas exécutées par autoconf.
• le fichier doit toujours commencer par la macro AC_INIT(exemple.c). Cette macro prend en argument le nom d'un des fichiers caractéristique de notre package (pour vérifier que le programme est exécuté au bon endroit).
• il doit également toujours se terminer par AC_OUTPUT(Makefile). Cette macro contient la liste des fichiers que configure doit générer. Il s'agit normalement de la liste du ou des Makefile dans chacun de leur répertoire (chacun des fichiers est séparés par un espace (AC_OUTPUT(Makefile src/Makefile man/Makefile X/Imakefile).

yb@I2000 > autoscan

dnl Process this file with autoconf to produce a configure script
AC_INIT(exemple.c)
AM_INIT_AUTOMAKE(exemple, 1.0)
dnl Checks for programs
AC_PROG_CC
AC_OUTPUT(Makefile)


yb@I2000 > aclocal
yb@I2000 > autoconf

• Principe

Automake se base sur le fichier Configure.in pour savoir quels sont les Makefile.in à générer. La description de ce que doit contenir un de ces fichiers est elle-même contenue dans un fichier Makefile.am (voir le § suivant).

• Dépendances (Makefile.am...)

• Makefile.am : ce fichier décrit comment le code doit être construit. Il contient une série de définitions de macros Automake sous la forme :
      variable = valeur
  Il peut également contenir des définitions de "cible" de Makefike (ex. : clean, install...). Toutes ces définitions vont induire les règles du Makefile.
  
  
• Configure.in : ce fichier, décrit pour l'outil Autoconf, peut contenir également certaines macros Automake, par exemple pour savoir quels sont les Makefile.in à générer. Pour utiliser Automake, ce fichier doit contenir au moins un ligne spécifique qui est :

  AM_INIT_AUTOMAKE(package,version)

  Les paramètres à la directive AM_INIT_AUTOMAKE permettent de définir le nom du package correspondant au programme, ainsi que son numéro de version.
  Pour d'autres règles, voir le § mini-exemple...

• Mini exemple

• pour chaque Makefile.am, il doit y avoir un Makefile correspondant dans la macro AC_OUTPUT du fichier Configure.in.
• il y a en général un Makefile.am par répertoire du projet. Pour chaque répertoire avec des sous-répertoires, le fichier Makefile.am doit contenir la ligne suivante :

  SUBDIRS = dir dir ...

  où chaque dir est le nom d'un sous-répertoire.
  
• une ligne commençant par ## dans le fichier Makefile.am est ignorée par Automake. Il s'agit donc d'un ligne de commentaire.
• si le package doit créer un programme, alors dans le fichier Makefile.am situé dans le répertoire où le programme doit être construit, il y aura une ligne du type :

  bin_PROGRAMS = monProgramme

  où monProgramme est le nom du programme. Ensuite, il y a une ligne pour spécifier les fichiers sources nécessaires :

  monProgramme_SOURCES = file file ...

  où chaque file est le nom d'un fichier source lié au programme (ex. : main.c). Les fichiers desquels dépendent les file, comme par exemple les fichiers inclus, sont automatiquement détectés et incorporés au Makefile.

Reprenons notre exemple, avec cette fois ci, deux répertoires (src et doc), et l'appel à une bibliothèque (libexemple.a).

## Process this file with automake to produce makefile.in
SUBDIRS = src doc
bin_PROGRAMS = exemple
exemple_SOURCES = exemple.c fonction.c exemple.h
exemple_LDADD = libexemple.a


yb@I2000 > automake --add-missing

• Principe

• Fichiers associés (acconfig.h ...)

• AM_CONFIG_HEADER(config.h)
  Cette macro (nécessaire) spécifie le nom du fichier d'en-tête qui contiendra les définitions de macros du pré-processeur. Normalement, il s'agit de config.h. Ainsi, les fichiers sources comporteront : #include "config.h". Cette macro peut optionnellement définir le nom du fichier créé par Autoheader (en entrée de configure). Par défaut, il s'agit de config.h.in. Mais ce nom n'est pas "génial" pour le système de fichier DOS. Il peut être mieux de le renommer tout simplement config.in. Ce qui donnera la macro suivante :
  AM_CONFIG_HEADER(config.h:config.in)
  Cette macro sous entend l'utilisation d'Automake, si ce n'est pas le cas, on peut utiliser AC_CONFIG_HEADER(...).
  
  
• AC_CHECK_HEADERS(unistd.h)
  Permet de vérifier la présence ou non d'un (ou des) fichier(s) d'en-tête, listé(s) en argument (séparé par des espaces). Ainsi, dans le fichier config.h.in, on aura le code suivant :
  /* Define as 1 if you have unistd.h. */
#define HAVE_UNISTD_H 0
  Sur les systèmes qui ont 'unistd.h', le script configure changera le 0 en 1. Sur les autres, il laissera la ligne inchangée.
  

• Ce fichier est utilisé pour décrire les macros qui ne sont pas reconnues par l'outil Autoheader. Il s'agit généralement d'un fichier inintéressant, qui consiste en une collection de lignes de #undef.
  Si vous générer un fichier d'en-tête portable (en utilisant la macro AM_CONFIG_HEADER dans le fichier Configure.in), alors il faut écrire le fichier acconfig.h, qui contiendra les lignes suivantes :

  /* Name of package */
#undef PACKAGE
/* Version of package */
#undef VERSION


• Principe

Ce script shell est fourni régulièrement avec le package pour l'utilisateur final. Il est créé par le développeur en lançant l'outil Autoconf.

• Fichiers créés (Makefile ...)

• config.status : la première étape pour construire un programme est de lancer le script configure. Ce script va créer le fichier config.status, qui est lui-même un script shell. La première fois que l'on utilise configure, il lancerera automatiquement le script config.status. Ce script, relancé par la suite, va recréer les fichiers listés. En fait, il décrit quelles options de configuration étaient spécifiées lors de la dernière configuration du package.
  
  
• un ou plusieurs Makefile : un dans chaque sous-répertoires du projet. C'est le fichier que make va lire pour construire le programme, en compilant tous les fichiers sources et mettant à jour les binaires.
  
  
• config.h : ce fichier décrit les variables du pré-processeur C, sur lesquelles le code C s'appuiera pour adapter son comportement en fonction du système. Il contient les directives #define. Ce fichier est optionnel, créé si l'on gère un fichier d'en-tête.
  
  
• config.cache : ce fichier est utilisé par le script configure pour mettre en cache les résultats entre les différentes utilisations.
  
  
• config.log : il contient tous les messages produits par le compilateur, pour l'aide au débuggage si configure rencontre un problème.
  
  

Voici un tableau qui synthétise les différents outils à utiliser dans le développement d'un package :

Autoconf me dis quelque chose à propos de macros indéfinies :

Cela signifie qu'il y a des macros dans le fichier configure.in, qui ne sont pas définies par Autoconf. Vous utilisez une vieille version d'Autoconf; essayer d'en installer une nouvelle version.

Mon Makefile ne contient aucun caractères :

Cela peut signifier que vous avez essayer d'utiliser une substitution autoconf dans le Makefile.in sans avoir ajouter un appel approprié à AC_SUBST au scrip configure. Ou cela peut tout simplement signifier que vous devez reconstruire le Makefile. Pour le reconstruire depuis le Makefile.in, lancer le script shell config.status sans arguments. Si vous devez forcer configure à être relancé, lancez d'abord config.status --recheck.

Message du type No rule to make target... needed by .deps/.P :

Les dépendances des fichiers sont stockées dans un répertoire appelé .deps. Si un fichier disparaît brutalement, il se peut qu'il soit encore référencé lors du make, ce qui conduit à ce message. Le plus simple est d'effacer le répertoire .deps.

Impossible de refaire make :

Lorsque une erreur a été commise dans un Makefile.am, les mécanismes automatiques qui permettent de régénérer les Makefile peuvent ne plus fonctionner. Il faut alors les recréer soi-même grâce à Automake et Autoconf, comme expliqué dans la section \ref{sec:base}.

configure: error: source directory already configured :

Il est possible de compiler des sources dans plusieurs répertoires, comme nous l'avons vu dans le premier exemple, page \pageref{sec:base}. Mais ceci n'est vrai qu'à condition de ne pas avoir compilé dans le répertoire de sources. En effet, lorsque l'on configure le répertoire de sources pour y effectuer une compilation, on créé un certain nombre de fichiers qui peuvent interférer avec ceux des autres répertoires de compilation, et engendrer des problèmes difficiles à détecter. Dans sa grande bonté, Autoconf empêche ce genre de situation.

Problèmes de syntaxe dans le fichier configure.in :

La syntaxe des macros utilisées par Autoconf impose que les parenthèses délimitant les paramètres d'une fonction soient accolées au nom de la fonction. Donc :

AC_DEFINE(CFLAGS) juste

AC_DEFINE (CFLAGS) faux

Voici les références sur lesquelles je me suis appuyé pour la réalisation de ce site :

• http://www.gnu.org/manual/autoconf-2.13/html_mono/autoconf.html

  Retrouver la documentation de référence sur l'outil Autconf publiée par GNU (en anglais).

  
  
• http://www.gnu.org/manual/automake-1.4/html_mono/automake.html

  Manuel de l'outil Automake publié par GNU (en anglais).

  
  
• http://www.amath.washington.edu/~lf/tutorials/autoconf

  Un bon site avec différents liens intéressants sur le sujet.

  
  

• Managing Projects with make, by Andrew Oram & Steve Talbott (O'Reilly)

  Un livre sur le compilateur Make.

  
  
• Programming with GNU Software, by Mike Loukides & Andy Oram (O'Reilly)

  Un autre livre, sur l'ensemble des outils GNU.

  
  

Breugnot Yannick © 2000