Que sont et que font au juste les auto-tools ? Les auto-tools sont les outils autoconf, automake, libtool et ceux qui gravitent autour (nous évoquerons aclocal plus loin). Au premier abord, ils permettent de générer des fichiers Makefile que l'on peut paramétrer avec les options fournies au script configure. Si leur intérêt se limitait à cela, les développeurs préféreraient faire leurs propres fichiers Makefile et expliquer comment modifier les options par exemple dans un fichier que les Makefile pourraient inclure.

Les auto-tools permettent de générer des fichiers Makefile de façon portable, ce qui signifie qu'un programme, tant qu'il ne fait pas appel aux fonctionnalités propres de la plateforme sur laquelle il doit tourner, pourra être compilé partout où les auto-tools (et les dépendances de votre programme) fonctionnent. Notre exemple, conçu sur Darwin (Mac OS X) fonctionnera aussi bien sur Linux que sur Cygwin (MS Windows). Vous n'avez pas à tenir compte vous-même de la version de make et implicitement du format des fichiers Makefile et de leurs particularités par exemple.

Mieux, les auto-tools respectent les standards GNU et Unix, en particulier le FHS. Cela fait entre autre la joie des personnes qui créent des paquets pour nos distributions favorites lorsqu'elles respectent aussi le FHS. Ces personnes n'auront aucun mal à adapter les répertoires que votre programme utilise à l'arborescence du système.

Parmi les avantages des auto-tools par rapport à de simples fichiers Makefile, nous citerons encore le fait que les cibles (pour make) clean, distcheck et d'autres sont systématiquement générées, sans le moindre paramétrage supplémentaire de votre part. Il est aussi possible de paramétrer la compilation avec des options --enable-fonctionnalité ou --with-option pour le script configure de notre commande magique. Et j'en passe...

Qui fait quoi ? Nous avons trois commandes et deux types de fichiers (configure.ac et les fichiers Makefile.am). Au résultat, nous obtenons un fichier configure et en l'exécutant, des fichiers Makefile. C'est touffu !

Autoconf a pour but de générer un fichier configure qui, lorsqu'on le lance, génère des fichiers à partir de fichiers modèles d'extension .in. Ainsi, ce script transforme les fichiers Makefile.in en fichiers Makefile. Voici un mystère d'éclairci.

Mais d'où viennent ces fichiers Makefile.in ? C'est ici le rôle d'automake. Cet outil prend en compte des fichiers Makefile.am et génère des fichiers Makefile.in aux mêmes endroits.

Le rôle d'aclocal est de générer un fichier aclocal.m4 dont nous parlons peu. En effet, il contient des macros (écrites dans le langage m4), dont nous n'avons rarement besoin de connaître l'existence. Sachez cependant qu'elles sont utilisées par le script configure pour effectuer certains tests et définir des variables dont les fichiers Makefile auront l'usage.

Enfin, le fichier configure.ac, fichier de configuration d'autoconf, est utilisé par celui-ci, par aclocal et indirectement par automake. Le premier génère le fichier configure en fonction du contenu de configure.ac. Le deuxième n'y fait que rechercher les noms des macros afin de copier celles nécessaires dans le fichier aclocal.m4 à partir de son dépôt (par exemple /usr/share/aclocal/*). Le dernier prévoit des variables pour ses fichiers Makefile.in en fonction des tests définis dans configure.ac.

L'ordre d'exécution des commandes est donc aclocal en premier, et ensuite indifféremment autoconf ou automake. Enfin, avant de compiler avec make, lancez le configure de la commande magique.

Afin d'aborder le sujet, nous allons nous servir d'un exemple simple, un programme qui affiche Bonjour le monde et prend fin, dont le code source est réparti sur deux fichiers plus celui des en-têtes. Voici ces trois fichiers :

/* main.c */
#include <stdio.h>
#include <stdlib.h>

#include "afficher.h"

int main(int argc, char**argv) {
	afficher("Bonjour le monde");
	exit(EXIT_SUCCESS);
}
		

/* afficher.c */
#include <stdio.h>
#include <stdlib.h>

#include "afficher.h"

int afficher(char*str) {
	printf("%s\n", str);
	return(0);
}
		

/* afficher.h */
#ifndef AFFICHER_H
#define AFFICHER_H

int afficher(char*str);

#endif
		

Le but de cet article est de compiler le programme bonjour à partir de ces sources.

Tout d'abord, démarrons dans un répertoire vide que nous appellerons racine, ou ${racine} dans nos scripts.

En général, pour un projet simple, créez un répertoire ${racine}/src/ et mettez-y tous les fichiers sources. Si votre projet doit contenir deux exécutables indépendants, créez un répertoire pour chacun de ces exécutables dans le répertoire racine, à la place du répertoire src/. Si par contre les deux exécutables partagent certains fichiers sources, vous devez les mettre dans le même répertoire à moins de créer une bibliothèque avec le code commun. Nous voici donc ici avec trois fichiers :

$ find .
./src
./src/afficher.c
./src/afficher.h
./src/main.c                                                             

		

Vous l'aurez compris, votre projet nécessite un fichier configure.ac à la racine, et un fichier Makefile.am à la racine ainsi que dans tous les sous-répertoires. Commençons par le fichier configure.ac; Vous pouvez le générer en lançant la commande autoscan. Vous obtiendriez un fichier configure.scan à renommer configure.ac. Voici ce fichier :

#                                               -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.

AC_PREREQ(2.59)
AC_INIT(FULL-PACKAGE-NAME, VERSION, BUG-REPORT-ADDRESS)
AC_CONFIG_SRCDIR([src/afficher.c])
AC_CONFIG_HEADER([config.h])

# Checks for programs.
AC_PROG_CC

# Checks for libraries.

# Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS([stdlib.h])

# Checks for typedefs, structures, and compiler characteristics.

# Checks for library functions.
AC_OUTPUT
		

Ce fichier fait appel à quelques notions que nous verrons dans des articles suivants. Aussi, nous allons nous limiter au fichier configure.ac suivant :

AC_PREREQ(2.59)
AC_INIT(bonjour, 0.1, ymettier@libertysurf.fr)
AM_INIT_AUTOMAKE

AC_PROG_CC
AC_PROG_MAKE_SET

AC_CONFIG_FILES([
        Makefile
        src/Makefile
        ])
AC_OUTPUT
		

La première ligne permet d'ôter toute ambiguité sur la version d'autoconf à utiliser. Cela est utile sur les machines où autoconf-2.5X cotoie encore l'ancienne version 2.13. La ligne AC_INIT vous oblige à indiquer le nom de votre projet (notion différente du nom de l'exécutable que nous allons générer), son numéro de version et une adresse électronique que les utilisateurs pourront utiliser pour envoyer des rapports de bogues (pensez à utiliser une liste de diffusion dédiée lorsqu'elle existe). La troisième ligne indique à automake qu'il faut s'initialiser.

Les deux lignes en AC_PROG_* testent la présence de programmes et définissent des variables. C'est grâce à elles que le script configure va vérifier la présence du compilateur, en général gcc, et définir la variable $CC. Idem pour make dont la version et l'implémentation (ce n'est pas toujours GNU Make) varient d'une plateforme à l'autre.

Enfin la ligne AC_CONFIG_FILES indique les fichiers à générer (à partir des fichiers portant le même nom, mais avec l'extension supplémentaire .in) et AC_OUTPUT lance la génération de ces fichiers.

L'étape suivante consiste à éditer des fichiers Makefile.am. Dans notre cas d'école, celui de la racine ne contient qu'une ligne définissant les sous-répertoires du projet (mettez une espace en guise de séparateur entre les différents sous-répertoires) :

SUBDIRS=src
		

Pour les autres fichiers Makefile.am, définissez en premier la variable bin_PROGRAMS qui doit contenir le nom des binaires à générer. Notre programme s'appelant bonjour, nous y mettons bonjour. La variable suivante définit les fichiers sources nécessaires à la compilation du programme bonjour. Le nom de la variable est constitué du nom du binaire, suivi de l'extension _SOURCES. Le fichiers ${racine}/src/Makefile.am est le suivant :

bin_PROGRAMS=bonjour

bonjour_SOURCES= \
	main.c \
	afficher.c afficher.h
		

Nous verrons dans un article suivant des éléments de syntaxe pour une utilisation un peu plus poussée de ces fichiers Makefile.am.

Maintenant que nous avons les fichiers en place, nous pouvons exécuter quelques commandes, dans l'ordre :

$ aclocal
$ autoconf
$ automake -a -c
configure.ac: installing `./install-sh'
configure.ac: installing `./missing'
Makefile.am: installing `./INSTALL'
Makefile.am: required file `./NEWS' not found
Makefile.am: required file `./README' not found
Makefile.am: required file `./AUTHORS' not found
Makefile.am: required file `./ChangeLog' not found
Makefile.am: installing `./COPYING'
src/Makefile.am: installing `./depcomp'                  
		

La première fois que l'on invoque automake de la sorte, nous nous rendons compte qu'il manque certains fichiers. Vous pouvez les créer vides, mais il est préférable de mettre votre nom et/ou celui de l'auteur du logiciel dans le fichier AUTHORS. Et quelques lignes dans le fichier README ne feront de mal à personne. Pour la postérité, indiquez dans le fichier ChangeLog la date de vos manipulations pour ajouter le support d'autoconf/automake ! Lorsque les fichiers manquants sont créés, invoquez automake -a -c à nouveau : il ne devrait plus rouspéter. Et vous venez de finir de générer tout le nécessaire à la commande magique que vous pouvez lancer :

$ ./configure 
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for gawk... gawk
checking whether make sets $(MAKE)... yes
checking for gcc... gcc           
[...]
configure: creating ./config.status
config.status: creating Makefile
config.status: creating src/Makefile
config.status: creating config.h
config.status: executing depfiles commands                                        
$ make
[...]
$ make install
		

Le projet bonjour va probablement prendre de l'ampleur. Voici quelques cas simples et courants que vous pouvez être amenés à rencontrer.

$ ./configure
$ make CFLAGS="-O2"
$ make install-strip
			

if test "x$GCC" = "xyes"; then
  CFLAGS="$CFLAGS -Wall"
fi
			

bin_PROGRAMS=bonjour

bonjour_SOURCES= \
	main.c \
	plouf.c plouf.h \
	afficher.c afficher.h
			

AC_SEARCH_LIBS(pow, m)
			

AC_SEARCH_LIBS(pow, m, [], [exit])
			

AC_SEARCH_LIBS(gzopen, z, [], [
	AC_MSG_ERROR([zlib est manquante])
])
			

$ find .
.
./AUTHORS
./ChangeLog
./configure.ac
./Makefile.am
./NEWS
./README
./src
./src/afficher.c
./src/afficher.h
./src/main.c
./src/Makefile.am

			

...mais ce sera pour une prochaine fois car il y a tant à dire sur autoconf, automake, et même libtool...

Merci à Guillaume Rousse pour ses précieux conseils lors de sa relecture.