Création et utilisation de makefile

Soyez le premier à donner votre avis sur cette source.

Vue 11 881 fois - Téléchargée 508 fois

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

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
17
Date d'inscription
mardi 25 janvier 2005
Statut
Membre
Dernière intervention
11 mai 2006

Bonjour,
je programme un compilateur, comme je dois utiliser yacc, lex, gcc, nasm, alink, utiliser un makefile est nécessaire, le voici :

OBJ = arbre.o assembleur.o pile.o tds.o grammaire.o scanner.o main.o
CC = gcc
OP = -Wall -ansi -g


all : analyseurs \
programme \
exec \
assemble

exec : /prog.exe<a.c

programme : $(OBJ)
$(CC) $(OBJ) -o prog.exe

main.o : main.c
$(CC) $(OP) -c main.c -o main.o

arbre.o : arbre.h arbre.c
$(CC) $(OP) -c arbre.c -o arbre.o

assembleur.o : assembleur.h assembleur.c
$(CC) $(OP) -c assembleur.c -o assembleur.o

pile.o : pile.h pile.c
$(CC) $(OP) -c pile.c -o pile.o

tds.o : tds.h tds.c
$(CC) $(OP) -c tds.c -o tds.o

grammaire.o : grammaire.h grammaire.c
$(CC) $(OP) -c grammaire.c -o grammaire.o

scanner.o : lex.yy.c
$(CC) $(OP) -c lex.yy.c -o scanner.o

clean :
rm -f prog.exe *.stackdump core *.o *~ grammaire.h grammaire.c lex.yy.c a.asm a.obj a.exe

analyseurs :
yacc -d grammaire.y -o grammaire.h
yacc grammaire.y -o grammaire.c
flex scanner.l

assemble :
nasm -fobj a.asm -o a.obj
alink -oPE a.obj -o a.EXE

les règles analyseur et programme fonctionnent mais la règle exec ne fonctionne pas
je veux faire une redirection car mon programme lit un fichier (./prog.exe<a.c). Apparament c'est le < qui pose problème, j'ai essayer \< et \\< mais ça marche pas

Merci pour votre aide

ps: je travaille avec Cygwin
Messages postés
787
Date d'inscription
samedi 8 juin 2002
Statut
Membre
Dernière intervention
7 juin 2007
1
Oui il y a celui fourni avec Visual (nmake.exe), dont la syntaxe est quasiment identique. Mais je trouve celui de MinGW plus versatile (on peut l'utiliser avec Visual par exemple) et complet, donc je n'ai pas trop cherché à l'utiliser :/
Messages postés
6535
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7
Très intéressant, c'est mieux que mes bat, qui recompilent tout à chaque fois :)
Connais tu un autre make que celui de MinGW sous Windows?
Messages postés
787
Date d'inscription
samedi 8 juin 2002
Statut
Membre
Dernière intervention
7 juin 2007
1
Pourquoi tu mets des \ à la fin des lignes, çà n'a aucun sens. Essaie plutôt :

SRC = main.cpp
OBJ = $(SRC:.cpp=.o)

EXE = echec

CC = g++
CFLAGS = -Wall -Os
LFLAGS = -mconsole

%.o: %.cpp *.hpp
<tab>$(CC) $(CFLAGS) -c $< -o $@

all: $(EXE)

$(EXE): $(OBJ)
<tab>$(CC) $^ $(LFLAGS) -o $(EXE)

strip: $(EXE)
<tab>strip --strip-all $(EXE)

clean:
<tab>del $(OBJ) $(EXE)

En remplaçant <tab> par une VRAIE tabulation (code ascii 9). Pour utiliser g++, les noms des variables changent (GFLAGS devient CXXFLAGS, et CC je sais pas, j'utilise que gcc).
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Modérateur
Dernière intervention
30 juillet 2012
41
euh.. HELP
Makefile:8: *** schémas de cible multiples. Arrêt.
max@Max:~/echec$

voici mon fichier :
@echo "Compilation du jeu d'échec..."\
SRC = main.cpp
OBJ = $(SRC:.cpp=.o)
EXE = echec
CC = g++
CFLAGS = -Wall -Os
LFLAGS = -mconsole
%.o: %.cpp *.hpp\
$(CC) $(CFLAGS) -c $(<) -o $(@)\
all: compile\
$(EXE): $(OBJ)\
$(CC) $(OBJ) $(LFLAGS) -o $(EXE)\
strip: $(EXE)\
strip --strip-all $(EXE)\
del $(OBJ)\
del $(EXE)\

avant j'avais pas mis les / mais il me mettait :
Makefile:9: *** séparateur manquant . Arrêt.
Afficher les 10 commentaires

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.