La commande MAKE
Ce tutoriel s'adresse aux débutants programmeurs sous Linux. Il vous présente la commande make et la création de fichier « makefile ». Je précise sous Linux, mais sachez qu'ils existent aussi sous windows, vous pouvez demander à VC++ de vous les construire.
Alors qu'est ce qu'un fichier makefile?
C'est un fichier nommé « makefile » qui permet, en ne tapant que « make » , dans le répertoire où il se trouve de compiler tout votre projet.
Par conséquent il rassemble toute les directives de compilation de votre projet.
Vous imaginez bien qu'à partir d'un certain nombre de fichier source, il devient tout à fait indispensable.
Imaginez-vous taper gcc fichier.c -Wall -c etc... pour chacun de vos fichiers!!! Make fait tout :)
L'édition d'un fichier Makefile:
Un fichier « makefile » s'édite à l'aide d'un éditeur de texte. Je vous conseille personnellement Xemacs.
Les Commentaires sont unilignes et commencent par #:
# commentaire...
Un tel fichier contient un ensemble de règle, un règle se compose de la manière suivante:
cible : dépendances
<tab> commandes
rem : <tab> correspond à une véritable tabulation..
La cible est le fichier à construire, les dépendances sont les fichiers dont on a besoin pour créer la cible. Les commandes sont les commandes à exécuter pour générer la cible.
Prenons un exemple, pour créer un fichier *.o nous avons besoin d'un fichier *.c et de fichiers *.h
main.o : main.c main.h autre.h <tab> gcc main.c -c -Wall
Ici si le fichier make de contient que ça, le lancement de la commande make va générer main.o.
L'intérêt de make réside dans le fait, qu'il ne reconstruit une cible que si les dépendances ont et modifier depuis la dernière utilisation de make, ou si la cible n'existe pas. Ce qui évite de tout recompiler à chaque fois.
Pour construire une cible, make se relance récursivement. Ce qui fait que l'ordre des règles importe peut.
Les macros:
Ce sont des variables de type chaîne de caractères.
Définition: MACRO = Valeur
Référence: $(MACRO) -> sert à son utilisation
Exemple:
MODULE = main.o aux.o
main : $(MODULE)
<tab> gcc $(MODULE) -o main
Il en existe des prédéfinis: les macros internes
$@ Contient le nom de la cible
$* Contient de nom de la cible sans suffixe ( si cible = main.c; $* = main)
$^ Contient le nom de toutes les dépendances
$? Liste des dépendances dont la date est postérieure à la cible
$< Contient la dépendance qui a provoqué la reconstruction de la cible
Les macros prédéfinies que l'on peut modifier:
$(CC) Contient le nom du compilateur
$(CPPFLAGS) Liste des options de pré-processage
$(CFLAGS) Liste des options de compilation
$(LDFLAGS) Liste des options de pré-édition des liens.
Un petit exemple pour illustrer tout ça :)
CC = gcc
CFLAGS = -Wall -O3
LDFLAGS = -lm
programme : main.o matrice.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
main.o : main.c matrice.h
<tab> $(CC) main.c -c $(CFLAGS)
matrice.o : matrice.h matrice.c
<tab> $(CC) $*.c -c $(CFLAGS)
Ici, l'exécution de la commande make, compilera le fichier 'programme ', en générant les fichiers *.o intermédiaires.
Remarque, le lancement de make ne génère que la première cible, et génère les autres si ils en a besoin pour la construire.
Pour compiler une cible particulière, on lance make avec le nom de la cible:
$ make matrice.o // Genère le fichier matrice.o
Les directives:
Ce sont des options pour le make. Elles sont à placer dans le fichier makefile.
En voici quelques unes:
.INIT : <commande à exécuter au début du make>
.DEFAULT : <commande à exécuter en cas d'erreur >
.DONE : <commande exécuter à la fin de make>
.IGNORE: Evite au make de s'arrêter en cas d'erreur
.SILENT: N'affiche pas les commandes exécutées
.PRECIOUS: <fichier>* Ne pas détruit pas les fichiers ..
.PHONY : <cible>* Déclares les cibles qui ne sont pas des fichiers
Exemple:
On veut créer une cible clean qui ne correspond pas à un fichier, qui une fois appeler dans le make va nettoyer le dossier actuel. On déclare donc clean comme cible non fichier.
.PHONY: clean
clean:
<tab> rm -f *.o
<tab> rm -f *~
Ainsi la commande $ make clean , va supprimer tous les fichiers *.o et les fichier *~
En général on définie également une cible « all » qui regroupe toutes les fichiers à produire.
De facon à ce que la commande $ make all construise tous les fichiers désirés.
.PHONY: clean all
all: prog1 prog2 prog3
Ainsi, la commande $make all ordonne la compilation des 3 programmes.
Il reste encore beaucoup de chose à dire sur le makefile, mais je vous laisse en regarder là doc, vous savez à présent le principal :).
Je termine ainsi par un exemple complet d'un projet devant générer deux programmes:
# Début du make file
# Déclaration des macros
CC = gcc
CFLAGS = -Wall -O3
LDFLAGS = -lm
.PHONY: all clean
all : prog1 prog2
prog1 : main.o affichage.o lecture.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
prog2 : main2.o affichage.o matrice.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
main2.o : main2.c affichage.h matrice.h
<tab> $(CC) main2.c -c $(CFLAGS)
main.o : main.c affichage.h lecture.h
<tab> $(CC) main.c -c $(CFLAGS)
affichage.o : affichage.h affichage.c
<tab> $(CC) affichage.c -c $(CFLAGS)
# etc...
clean:
<tab> rm -f *.o
<tab> rm -f *~
La commande $make all, générera ainsi prog1 et prog2.
La commande $make prog2, ne générera que le prog2.