Création et utilisation de makefile

Télécharger le projet
Commenter

Description

D'après ce que j'ai pu constater, beaucoup d'entre vous utilisent Dev-C++ ou d'autres environnement basés sur GCC... Mais nulle part je n'ai trouvé d'explications sur les makefile, qui sont utiles à partir d'un certain degré de complexité dans les projets (Dev-C++ les génère automatiquement, mais ce n'est pas le cas de tous les environnements)

A noter : ce tutorial suppose que vous utiliser le make de MinGW, ce qui est le cas si vous utilisez Dev-C++, MinGW ou autre environnement basé dessus...

Il se peut que make.exe soie renommé en mingw32-make.exe dans votre environnement, ou qu'un autre make.exe soie en conflit avec celui de GCC (pensez à vérifier votre PATH)

Enfin, ceci s'applique à la version Windows, bien que pour Linux il suffise de remplacer la commande "del" par "rm", mais les utilisateurs de Linux savent en général comment traduire du Windows en Unix (ce qui n'est pas toujours le cas dans le sens inverse)

Source / Exemple : 


Dans un fichier de ce type, les commentaires commencent par un symbole #

Des explications plus détaillées sont fournies après l'exemple de makefile, ne vous en faites pas si des points vous semblent obscurs à la première lecture

#################### début du fichier ####################

# 1) définition des macros
# une macro est utilisable en l'appelant avec $(macro), qui sera alors remplacé par le contenu de la macro, par exemple si SRC = main.c, la macro $(SRC) sera remplacée par main.c

# ici on définit les modules sources de notre projet, séparés par un espace
SRC = main.c

# cette ligne génère automatiquement les noms des modules objets à partir des modules sources, par exemple main.c deviendra main.o, etc
OBJ = $(SRC:.c=.o)

# ici on définit le nom de l'exécutable final
EXE = main.exe

# on définit ici notre compilateur, gcc pour du code C et g++ pour du code C++
CC = gcc

# sur cette ligne on met les options du compilateur, séparées par des espaces (taper gcc --help pour avoir la liste des options disponibles, il y en a moults, mais personnellement j'utilise toujours ces deux là)
CFLAGS = -Wall -Os

# on définit ici les options de l'éditeur de liens, -mconsole pour une application console, -mwindows pour une application graphique, et -mdll pour une librairie (il y en a d'autres, mais moins utiles)
LFLAGS = -mconsole

# 2) description de la compilation des modules objets
# cette section décrit à make comment transformer nos modules sources en fichiers objets qui seront utilisés par le linker pour générer l'exécutable

# cette ligne décrit la génération des modules objets à partir des modules sources, le symbole *.h signifiant qu'on souhaite recompiler tous les modules en cas de changement d'un entête (on peut contrôler la recompilation des modules soi-même, mais il faut gérer manuellement les dépendances de chaque module, cette solution est donc plus simple bien que moins efficace)
%.o: %.c *.h
	$(CC) $(CFLAGS) -c $(<) -o $(@)
# le $(<) désigne le fichier .c, alors que le $(@) désigne le fichier .o
# ces macros sont définies par make, si vous utilisez le make de Delphi ou celui de VC++, elles seront très probablement différentes de celles-ci

# 3) définition des commandes
# ces commandes pourront être appelées ensuite (voir plus bas)

# par défaut, make cherche une cible appelée "all", on lui dit ici qu'elle correspond à "compile"
all: compile

# ici, on prévient make que "compile" est équivalent au nom de notre exécutable
compile: $(EXE)

# cette ligne définit la compilation de notre exécutable, en fonction des fichiers sources modifiés (ceux qui n'ont pas été modifiés ne seront pas recompilés)
$(EXE): $(OBJ)
	$(CC) $(OBJ) $(LFLAGS) -o $(EXE)

# ici on définit une cible "strip", pour retirer les informations de débogage de notre exécutable, qui devient donc plus compact (utile pour les release)
strip: $(EXE)
	strip --strip-all $(EXE)

# ici, on fait le ménage, en supprimant tous les fichiers objets ainsi que l'exécutable, sans supprimer ceux des autres projets, pour les étourdis qui mettent tout dans le même répertoire (on ne fait donc pas un simple del *.o)
clean:
	del $(OBJ)
	del $(EXE)

#################### fin du fichier ####################

Bon c'est bien joli tout çà mais comment on s'en sert ?

Il suffit d'enregistrer votre makefile dans un fichier... "makefile", évidemment :)

Ensuite, à partir d'une console, taper :
	"make" pour compiler la cible par défaut, c'est à dire "all", qui renvoie alors à "compile" qui renvoie à notre exécutable... c'est un peu tordu mais "make", "make all" et "make compile" fournissent donc le même résultat, à savoir la compilation de "main.exe"
	"make strip" pour supprimer les informations de débogage de l'exécutable
	"make clean" pour supprimer les fichiers objets

On peut également les combiner, par exemple "make clean compile strip" fera le ménage, la compilation, puis le retrait des informations de débogage... L'équivalent de la commande "Build", en somme ;)

Quel intérêt ? En tapant juste "make", on ne recompile que les fichiers qui ont été modifiés depuis la dernière compilation, ce qui accélère la compilation... Tout en pouvant forcer la recompilation totale avec "make clean compile" !

De plus, les makefile sont facilement réutilisables : il suffit de changer SRC, EXE et éventuellement LFLAGS (qui définit les libs utilisées par votre projet, par exemple LFLAGS = -mwindows -lws2_32 définira une application windows utilisant la librairie winsock) pour que votre makefile génère un nouveau projet avec les libs adéquates !

On peut également rajouter des commandes, par exemple si vous utilisez UPX, vous pouvez rajouter dans votre makefile (n'importe où, du moment que c'est après la définition de la commande all) :

compress: $(EXE)
	upx --best $(EXE)

Notez que l'indentation de la seconde ligne doit se faire avec une VRAIE tabulation (caractère n°9 en ASCII), et non avec une suite d'espaces. Ceci est valable pour toutes les commandes comme clean, compile, etc !

ce que make interprétera comme:
	pour exécuter la commande 'compress', j'ai besoin de 'main.exe' (en effet, $(EXE) est remplacé par la valeur de EXE, dans notre cas, main.exe), si ce fichier n'existe pas, je dois le construire auparavant (et tous les fichiers dont il dépend, s'ils ne sont pas disponibles ou obsolètes). Ensuite, j'exécute la commande 'upx --best main.exe'

Ainsi, la commande 'make clean compress' provoquera la recompilation totale du projet (le 'clean' effaçant tous les modules objets), puis la compression de main.exe une fois la compilation terminée (mais ne supprimera pas les informations de débogage, il faudrait appeler 'make clean strip compress' pour cela)...

En cas d'erreur, make s'interrompt, et vous pouvez corriger votre code à l'aide des messages d'erreur affichés, puis le relancer, et ainsi de suite...

Si vous avez tenu jusque là, vous devriez pouvoir utiliser make, une fois que vous y aurez gouté vous ne pourrez plus vous en passer, vous verrez ;)

Conclusion :


J'ai fait ce tut à partir des explications d'un ami, de la FAQ de MinGW et de plusieurs autres sites, mais tous n'étaient pas très clair...

J'espère avoir synthétisé tout çà de manière concise, sinon bah dites moi ce qui ne vas pas :p
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_Nebula)