  Compilation séparée et Make
  Benjamin Drieu (drieu@bocal.cs.univ-paris8.fr)
  v1.0 - 30 Avril 1997

  Cette documentation explique comment utiliser make pour la compilation
  séparée: comment écrire un fichier Makefile, l'utiliser, et quelles
  sont les conventions utilisées dans les fichiers Makefile. La version
  de make à laquelle je ferais référence au cours de ce document est Gnu
  Make.
  ______________________________________________________________________

  Table of Contents:

  1.      Introduction

  1.1.    Comment marche la compilation

  1.2.    Compilation séparée

  1.2.1.  Utilité

  1.2.2.  Ce que fait make

  1.3.    Makefile  ?

  2.      Règles

  2.1.    Qu'est-ce qu'une règle ?

  2.2.    Cible

  2.3.    Dépendances

  2.4.    Commandes

  3.      Mon premier Makefile  !

  3.1.    Fichier exemple Makefile

  3.2.    Et maintenant ?

  4.      Macro-commandes et variables

  4.1.    Déclaration

  4.2.    Appel

  4.3.    Exemple

  5.      Un Makefile  un peu plus complexe et commenté

  6.      Caractères jokers

  7.      Patterns et variables automatiques

  7.1.    Pattern

  7.2.    Exemple idiot

  7.3.    Liste des variables automatiques

  8.      Conventions d'appellation

  8.1.    Noms d'exécutables et d'arguments

  8.2.    Noms de répertoires de destination

  8.3.    Noms de cibles

  9.      Copyright
  ______________________________________________________________________

  11..  IInnttrroodduuccttiioonn

  11..11..  CCoommmmeenntt mmaarrcchhee llaa ccoommppiillaattiioonn

  ______________________________________________________________________

           *.c  *.h (Fichiers source)
                        |
                   COMPILATEUR
                        |
               *.o (Fichier objet)
                        |
      Librairies -->  LIEUR <-- Fichiers objet
                        |
               Fichier executable

  ______________________________________________________________________

  11..22..  CCoommppiillaattiioonn ssééppaarrééee

  11..22..11..  UUttiilliittéé

  L'utilité est triple:

  ·  La programmation est modulaire, donc plus compréhensible

  ·  La séparation en plusieurs fichiers produit des listings plus
     lisibles

  ·  La maintenance est plus facile car seule une partie du code est
     recompilée

  11..22..22..  CCee qquuee ffaaiitt mmaakkee

  ·  _m_a_k_e assure la compilation séparée grâce à gcc

  ·  _m_a_k_e utilise des macro-commandes et des variables

  ·  _m_a_k_e permet de ne recompiler que le code modifié

  ·  _m_a_k_e permet d'utiliser des commandes _s_h_e_l_l, et ainsi d'effectuer
     une installation

  Make est essentiel lorsque l'on veut effectuer un portage, car la
  plupart des logiciels libres UNIX (c'est-à-dire des logiciels qui sont
  fournis avec le code source) l'utilisent pour leur installation.

  11..33..  MMaakkeeffiillee  ??

  Le fichier Makefile est un fichier nécessaire à _m_a_k_e. Un fichier
  Makefile indique à _m_a_k_e comment exécuter les instructions nécessaires
  à l'installation d'un logiciel ou d'une librairie.

  Le fichier Makefile doit se trouver dans le répertoire courant
  lorsqu'on appelle _m_a_k_e à l'invite du shell.

  Les instructions contenues dans un fichier Makefile obéissent à une
  syntaxe particulière un peu stupide.

  22..  RRèègglleess

  Les fichiers Makefile sont structurés grâce aux _r_è_g_l_e_s. Ce sont elles
  qui définissent ce qui doit être exécuté ou non, et qui permettent de
  compiler un programme de différentes façons.

  22..11..  QQuu''eesstt--ccee qquu''uunnee rrèèggllee ??

  Une _r_è_g_l_e est une suite d'instructions qui seront exécutées pour
  construire une _c_i_b_l_e, mais uniquement si des _d_é_p_e_n_d_a_n_c_e_s sont plus
  récentes.

  La syntaxe d'une règle est la suivante:

  ______________________________________________________________________
  cible: dependances
          commandes
          ...
  ______________________________________________________________________

  22..22..  CCiibbllee

  La cible est généralement le nom d'un fichier qui va être généré par
  les commandes qui vont suivre, ou une action gérée par ces mêmes
  commandes, par exemple clean ou install (Voir chapitre IX [Cibles]
  pour plus de détails sur les conventions utilisées dans l'attribution
  d'un nom à une règle).

  22..33..  DDééppeennddaanncceess

  Les dépendances sont les fichiers ou les règles nécessaires à la
  création de la cible. Par exemple un fichier en-tête ou un fichier
  source dans le cas d'une compilation C. Dans le cas d'un fichier, la
  cible n'est construite que si ce fichier est plus récent que la cible.

  22..44..  CCoommmmaannddeess

  C'est une suite de commandes shell qui seront exécutées au moment de
  la création de la cible. Une étrangeté de la syntaxe des fichiers
  Makefile oblige l'utilisateur de _m_a_k_e à insérer une tabulation au
  début de chaque ligne, faute de quoi _m_a_k_e affichera une erreur au
  moment de son exécution.

  La syntaxe de _m_a_k_e oblige aussi l'utilisateur à ajouter une caractère
  "_b_a_c_k_s_l_a_s_h" ('\') à la fin de chaque ligne dès que les commandes à
  exécuter dépassent une ligne de texte.

  33..  MMoonn pprreemmiieerr MMaakkeeffiillee  !!

  Maintenant que nous connaissons la syntaxe d'un fichier Makefile, nous
  allons en créer un pour apprendre à les utiliser.

  33..11..  FFiicchhiieerr eexxeemmppllee MMaakkeeffiillee

  ______________________________________________________________________
  # Mon premier Makefile

  all: foobar.o main.c
          gcc -o main foobar.o main.c

  foobar.o: foobar.c foobar.h
          gcc -c foobar.c -o foobar.o
  ______________________________________________________________________

  33..22..  EEtt mmaaiinntteennaanntt ??

  Si vous avez enregistré l'exemple ci-dessus dans un fichier Makefile,
  il ne nous reste plus qu'a exécuter _m_a_k_e dans le même répertoire que
  celui où vous avez enregistré le fichier.

  Make s'exécute tout simplement en lançant la commande:

  $ make all

  Make va alors interpréter le fichier Makefile et exécuter les
  commandes contenues dans la règle _a_l_l, une fois que les dépendances
  _f_o_o_b_a_r_._o et _m_a_i_n_._c seront vérifiées.

  C'est à dire dire que si foobar.o ou main.c sont plus récents que le
  fichier main, _m_a_k_e recompilera main.

  Notez que si j'avais simplement tapé: "make" le résultat serait le
  même car quand _m_a_k_e est exécuté sans argument, _m_a_k_e exécute la
  première règle recontrée.

  44..  MMaaccrroo--ccoommmmaannddeess eett vvaarriiaabblleess

  Les habitué(e)s de la programmation C ne seront pas dépaysé(e)s par le
  concept des variables de _m_a_k_e. En fait, il faut plutôt considérer les
  variables comme des macro-commandes (#define en C).
  44..11..  DDééccllaarraattiioonn

  La déclaration se fait tout simplement avec la syntaxe ci-dessous:

  NOM = VALEUR

  Les espaces insérés ici ne sont pas obligatoires, mais facilitent la
  lisibilité du Makefile. La valeur affectée à la variable peut comme
  pour les macro-commandes du C comporter n'importe quels caractères,
  elle peut aussi être une autre variable.

  44..22..  AAppppeell

  La syntaxe de l'appel de la macro-commande est la suivante:

  $(NOM)

  44..33..  EExxeemmppllee

  prefix = /usr/local
  bindir = $(prefix)/bin

  55..  UUnn MMaakkeeffiillee  uunn ppeeuu pplluuss ccoommpplleexxee eett ccoommmmeennttéé

  ______________________________________________________________________
  # $(BIN) est la nom du binaire généré
  BIN = foo

  # $(OBJECTS) sont les objets qui seront générés après la compilation
  OBJECTS = main.o foo.o

  # $(CC) est le compilateur utilisé
  CC = gcc

  # all est la première règle à être exécutée car elle est la première
  # dans le fichier Makefile. Notons que les dépendances peuvent être
  # remplacées par une variable, ainsi que n'importe quel chaine de
  # caractères des commandes
  all: $(OBJECTS)
          $(CC) $(OBJECTS) -o $(BIN)

  # ensuite les autres règles
  main.o: main.c main.h
          $(CC) -c mainc
  foo.o: foo.c foo.h main.h
          $(CC) -c foo.c
  ______________________________________________________________________

  66..  CCaarraaccttèèrreess jjookkeerrss

  Les caractères jokers s'utilisent comme sous _s_h_e_l_l. Les caractères
  valides sont * ? [...]. Par exemple, toto?.c représente tous les
  fichiers commençant par toto, finissant par .c, avec une lettre entre
  ces deux chaînes.

  Comme sous shell, le caractère '\' permet d'inhiber l'action des
  caractères jokers. Par exemple 's.c' fait référence à st*r.c et non
  pas à tous les fichiers commençant par st et finissant par r.c.

  Exemples:

  ______________________________________________________________________
  clean:
          # ici le caractère joker * est géré par le shell et non pas
          # par make
          rm -f *.o

  print: *.c
          # le $? est une variable automatique (Voir chapitre VII
          # [Patterns et variables automatiques])
          lpr -Php $?
  ______________________________________________________________________

  77..  PPaatttteerrnnss eett vvaarriiaabblleess aauuttoommaattiiqquueess

  77..11..  PPaatttteerrnn

  Un pattern s'utilise un peu comme un caractère joker, mais uniquement
  dans le cas des cibles. Le caractère faisant office de joker est le
  caractère pourcent ('%').

  L'intérêt est d'avoir plusieurs cibles. Les patterns permettent de
  filtrer les cibles pour savoir pour lesquelles d'entre elles les
  commandes qui suivent seront exécutées.

  77..22..  EExxeemmppllee iiddiioott

  Pourquoi cet exemple est-il idiot ? Tout simplement parcequ'on met
  pèle-mêle tous les fichiers à compiler dans la même variable OBJECTS.
  Le plus simple aurait été d'utiliser plusieurs variables et de faire
  des règles différentes pour chaque type de compilation (normale, x11,
  athena).

  ______________________________________________________________________
  # Notons que les objets sont à la fois des fichiers objets à lier et
  # des exécutables à compiler
  OBJECTS = text/main.o text/foo.o x11/main x11/bar athena/main
  # Le compilateur est bien sûr gcc
  CC = gcc

  # Les dépendances sont tous les objets
  all: $(OBJECTS)
          # On va quand même faire quelque chose dans cette règle
          echo DONE

  # Ici les règles pour tous les fichiers .o se trouvant dans le
  # répertoire 'text'
  text/%.o: text/%.c
          $(CC) -c text/$*.c

  # Ici les règles pour tous les fichiers se trouvant dans le répertoire
  # 'x11'
  x11/%: x11/%.c
          $(CC) -lX11 x11/$*.c

  # Ici les règles pour les fichiers se trouvant dans le répertoire
  # 'athena'
  athena/%: athena/%.c
          $(CC) -lXaw -lXext -lXmu -lXt -lX11 athena/$*.c
  ______________________________________________________________________

  77..33..  LLiissttee ddeess vvaarriiaabblleess aauuttoommaattiiqquueess

  Les variables automatiques sont des variables qui sont actualisées au
  moment de l'exécution de chaque règle, en fonction de la cible et des
  dépendances.

  ·  $@: nom de la cible

  ·  $<: première dépendance de la liste des dépendances

  ·  $?: les dépendances plus récentes que la cible

  ·  $^: toutes les dépendances

  ·  $*: dans le cas de l'utilisation des patterns, la chaine
     correspondant au %

  88..  CCoonnvveennttiioonnss dd''aappppeellllaattiioonn

  88..11..  NNoommss dd''eexxééccuuttaabblleess eett dd''aarrgguummeennttss

  Entre parenthèses les valeurs par défaut

  ·  AR: programme de maintenance d'archive (_a_r)

  ·  CC: compilateur C (_c_c)

  ·  CXX: compilateur C++ (_c_+_+)

  ·  RM: commande pour effacer un fichier (_r_m)

  ·  TEX: programme pour créer un fichier TeX dvi à partir d'un source
     TeX (_t_e_x)

  ·  ARFLAGS:  paramètres à passer au programme de maintenance
     d'archives ()

  ·  CFLAGS: paramètres à passer au compilateur C ()

  ·  CXXFLAGS: paramètres à passer au compilateur C++ ()

  88..22..  NNoommss ddee rrééppeerrttooiirreess ddee ddeessttiinnaattiioonn

  Entre parenthèses les valeurs usuelles

  ·  prefix: racine du répertoire d'installation (/usr/local)

  ·  exec_prefix: racine pour les binaires ($(prefix))

  ·  bindir: répertoire d'installation des binaires ($(exec_prefix)/bin)

  ·  libdir: répertoire d'installation des librairies
     ($(exec_prefix)/lib)

  ·  datadir: répertoire d'installation des données statiques pour le
     programme ($(exec_prefix)/lib)

  ·  statedir: répertoire d'installation des données modifiables par le
     programme ($(prefix)/lib)

  ·  includedir: répertoire d'installation des en-têtes
     ($(prefix)/include)

  ·  mandir: répertoire d'installation des fichiers de manuel
     ($(prefix)/man)

  ·  man_xdir: répertoire d'installation des fichiers de la section _x du
     manuel ($(prefix)/manx)

  ·  infodir: répertoire d'installation des fichiers info
     ($(prefix)/info)

  ·  srcdir: répertoire d'installation des fichiers source
     ($(prefix)/src)

  88..33..  NNoommss ddee cciibblleess

  Un utilisateur de _m_a_k_e peut donner à ses cibles le nom qu'il désire.
  Mais pour des raisons de lisibilité, on donne toujours un nom standard
  à ses cibles selon leur comportement.

  Quelques exemples de cibles standard:

  ·  all: compile tous les fichiers source pour créer l'exécutable
     principal

  ·  install: exécute _a_l_l, et copie l'exécutable, les librairies, les
     datas, et les fichiers en-tête s'il y en a dans les répertoires de
     destination

  ·  uninstall: détruit les fichiers créés lors de l'installation, mais
     pas les fichiers du répertoire d'installation (où se trouvent les
     fichiers source et le Makefile)

  ·  clean: détruit tout les fichiers créés par _a_l_l

  ·  info: génère un fichier _i_n_f_o

  ·  dvi: génère un fichier _d_v_i

  ·  dist: crée un fichier _t_a_r de distribution

  99..  CCooppyyrriigghhtt

  Ce document est placé sous copyright © 1997 de Benjamin Drieu,
  association APRIL.

  Ce document peut être reproduit et distribué dans son intégralité ou
  partiellement, par quelque moyen physique que ce soit. Il reste malgré
  tout sujet aux conditions suivantes :

  ·  La mention du copyright doit être conservée, et la présente section
     préservée dans son intégralité sur toute copie intégrale ou
     partielle.

  ·  Si vous distribuez ce travail en partie, vous devez mentionner
     comment obtenir une version intégrale de ce document et être en
     mesure de la fournir.