Quelques mots de remerciements seront grandement appréciés.

Shell linux, creation des makefiles, commande make

La commande MAKE

Introduction
L'édition d'un fichier Makefile
Les macros
Les directives
Exemple complet

Introduction

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

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.

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 :).

Exemple complet

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.

A voir également

[C++] [Win32 API] ADO pour les nouveaux

Standard template library(stl)