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 :)
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
Remarque : <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 ne 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.
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
Les macros prédéfinies que l'on peut modifier:
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
Ce sont des options pour le make. Elles sont à placer dans le fichier makefile.
En voici quelques unes:
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.