8.4  make

• Maintenance, mise à jour et regénération de fichiers dépendants
• Sources ® exécutables
• Recompilation quand nécessaire (dates)
• Fichier de règles de dérivation
  
  Makefile ou makefile
• Appel

  make targets
          

  Format d'une règle

• Quoi, pourquoi, comment

Quoi

target

Objectif

Généralement un fichier

Pourquoi

dependencies

Liste des fichiers/cibles dont dépend target

Comment

commands

Précédées d'une tabulation \t

  Exemple de Makefile

#
# makefile pour un programme C
#

executable: f1.o f2.o
        cc -o executable f1.o f2.o
        
f1.o: f1.c fichier.h
        cc -c f1.c

f2.o: f2.c fichier.h
        cc -c f2.c

clean:
        rm -f *~ *.o executable

# et voila !
    

  Algorithme de make

• Pour chaque cible
  • Vérifier les dépendances
    • ® Récursion
    • ® Date des fichiers de base
  • Si modification

    alors ®

    Lancer les commandes

    fsi

    sinon ®

    Fichier à jour

  Commodités

• Commentaires
  
  # this is a comment
• Inclusion de fichiers Makefile : include file
• Cible par défaut : all
  
  all: executable
• Macros dans le style des variables sh
• Cibles spéciales
• Règles implicites

  Macros dans un makefile

• Définition
  
  MACRO=valeur
• Exemples :
  
  CFILES=*.c

OBJECTS=fichier1.o fichier2.o
• Référence :
  
  $(MACRO)
• Macros prédéfinies
• Macros spéciales

  Macros prédéfinies

• Exemples pour C
  
  $(CC) compilateur C
  
  $(CFLAGS) options pour le compilateur C
  
  $(LINT) pour lint
• Autres langages
  
  $(FC) Compilateur Fortran
  
  $(PC) Compilateur Pascal
  
  $(AS) Assembleur
• Etc.
  
  $(RM) = rm -f

  Macros spéciales

• Récursion dans les règles
  
  $(MAKE) targets
• $(MAKEFLAGS)
• $(SHELL) : interpréteur pour les commandes
  
  défaut : /bin/sh
• 
  
  $(HOST_ARCH) architecture de la machine
  
  $(TARGET_ARCH), $(HOST_MACH), $(TARGET_MACH)

  Cibles spéciales

• .INIT : cible préliminaire
• .DONE : cible ajoutée après les cibles
• .IGNORE : ignore les erreurs
• .SILENT : exécution silencieuse
• .PRECIOUS : fichiers à ne pas effacer en cas d'échec
• .SUFFIXES : liste des suffixes pour les règles implicites
• .PHONY : entrées qui n'est pas un fichier
• Exemple :

.PHONY : clean 
clean:
        rm -f *~ *.o executable

• Þ make n'est pas perturbé
  • par un eventuel fichier clean
  • si rm retourne une erreur

  Règles implicites

• Modèle de règle
• Application si suffixes correspondent
  
  .c ® .o
• Macros spéciales
  
  $< fichier de dépendance
  
  $@ fichier cible
  
  $* nom de base de ces fichiers

  Exemple makefile

#
# un makefile plus joli, plus propre, ...

all: executable

OBJECTS = f1.o f2.o 

.SUFFIXES: .c .o

.c.o: fichier.h
        $(CC) $(CFLAGS) $<

executable: $(OBJECTS)
        $(CC) $(CFLAGS) -o executable \
                        $(OBJECTS)
.PHONY: clean 
clean:
        $(RM) $(OBJECTS) executable *~

# et voila !
    

  Remarques

• Options de make
  
  -s : silent
  
  -d : affiche les dépendances quand recompile
  
  ...
• Commandes shell :
  
  accès aux variables shell par $$
  
  continuation \ nécessaire
• Génération automatique de Makefile

  Exemple makefile et sh

# un makefile avec du shell

all: executable

SOURCES = *.c
.SILENT:

lignes:
        echo "nombre de lignes"
        for file in $(SOURCES) ; \
        do \
         echo "$$file = `wc -l $$file `";\
        done

informations:
        $(MAKE) lignes
        ...

# et voila !