Sign in to follow this  
Calypso

 tutoriel Les Bases du Makefile

Recommended Posts

Niveau requis Débutant

Temps estimé : 30 minutes

 

Bonsoir,

 

Ça fait longtemps que je ne vous ai pas fais un petit tutoriel. Aujourd'hui je vais vous apprendre les principales bases du Makefile, un outil très pratique souvent utilisé dans la compilation des sources. Vous retrouvez par un exemple un Makefile dans les sources de Metin2 ou encore celles de WoW.

 

Pour faire simple, Makefile est un fichier qui contient plusieurs paramètres pour compiler vos sources avec gcc (un compilateur C). Le tutoriel vous permettra de mieux comprendre le fonctionnement de cet outil et surtout son utilité.

 

Révélation

 

Dans ce tutoriel, je vais partir d'un exemple assez concret. Je souhaite que mon Makefile créé un exécutable de deux fichiers sources (.c). Manuellement, ça donne ça :

gcc fichier1.c fichier2.c -o test

-o test est tout simplement un paramètre qui permet de changer le nom du fichier exécutable à la sortie. Je souhaite que mon Makefile compile automatiquement mes sources et je souhaite aussi lui implémenter plusieurs paramètres.

 

 

Makefile

 

Révélation

 

Le Makefile est présenté de cette façon :

cible: dependance
commandes
Pour obtenir la cible, nous avons besoin des dépendances. On exécute la commande souhaité pour obtenir la cible en utilisant les dépendances. Pour commencer :
CC              = gcc

RM              = rm -f

NAME            = test

SRCS            = fichier1.c \
                 fichier2.c

OBJS            = $(SRCS:.c=.o)
On commence juste par créer des "variables". Cela m'évitera de ré-écrire tout le temps la même chose. C'est utile seulement quand le fichier Makefile est très grand. Je pars du principe que vous avez déjà quelques connaissances en programmation pour comprendre. Dans ma variable SRCS, je stocke tous mes fichiers sources (.c). Et dans la variable OBJS, tous mes fichiers temporaires, fichiers objets (.o). gcc a besoin des fichiers .o pour les compiler en .c ensuite. GCC le fait automatiquement en ligne de commande, mais pas dans le Makefile ! La variable NAME contient le nom de mon exécutable à la sortie. Développons le Makefile avec la base :
CC              = gcc

RM              = rm -f

NAME            = test

SRCS            = fichier1.c \
                 fichier2.c

OBJS            = $(SRCS:.c=.o)

all: $(NAME)

$(NAME): $(OBJS)
   $(CC) $(OBJS) -o $(NAME)
Nous avons all : qui va compiler tous les fichiers sources pour créer l'exécutable principale. Donc vous voyez que l'on fait appel à NAME:

Pour obtenir $(NAME) (donc le fichier test), nous avons besoin des fichiers objets créés à partir des .c. Et juste en dessous (après une tabulation !!!), on exécute la commande à exécuter : gcc objs (donc tous les fichiers .o) -o test

 

A partir de là, vous avez la base de tout. Essayez de faire make dans votre répertoire et la compilation se fera ! Vous me direz, ça va aussi vite avec la commande. Oui et non. Vous avez juste à écrire make pour compiler votre programme, à force de le faire, ça vous fait gagner du temps. D'autant plus que quand vous commencez à avoir x fichiers sources, ça devient très très très très pratique.

 

Rajoutons des petites fonctionnalités à notre Makefile :

CC              = gcc

RM              = rm -f

NAME            = test

SRCS            = fichier1.c \
                 fichier2.c

OBJS            = $(SRCS:.c=.o)

all: $(NAME)

$(NAME): $(OBJS)
   $(CC) $(OBJS) -o $(NAME)

clean:
   $(RM) $(OBJS)

fclean: clean
   $(RM) $(NAME)

re: fclean all
J'ai rajouté trois fonctionnalités : clean, fclean et re. A utiliser de cette manière : make clean, make fclean ou make re.

 

Il n'y a rien de bien compliqué. Si vous faites make clean, tous les fichiers objets (les .o) vont êtres supprimés. C'est d'ailleurs la commande que j'exécute. fclean va non seulement supprimer tous les fichiers temporaires mais il va aussi supprimer l'exécutable : rm -f test. Enfin pour finir, on a le make re. Celui ci va effectuer la commande fclean et refaire appel à all qui va recompiler tous vos fichiers sources.

 

 

Vous pouvez tester pleins de choses et découvrir la magie du Makefile. Il devient indispensable quand on sait l'utiliser et il est très pratique pour vos projets en C.

 

Cordialement,

Hey hey

Share this post


Link to post
Share on other sites

C'est une bonne initiative mais je trouve que, meme pour la base, y a beaucoup de lignes pour pas grand chose.

Pas de flag de compilation, pas d'include d'Headers 

 

CC=gcc
CFLAGS=-Wall -Werror -Wextra -pedantic -I include/ //Flags de compilations de base plutot utiles + le -I(Dossier des includes (Headers tout ca...)
VPATH= src/ //Le repertoire des .c par rapport a ./
SRC= fichier.c\
    fichier1.c //les .c 
OBJS=$(SRC:.c=.o) 
EXEC=fichier //le nom du binaire

all: $(EXEC)

$(EXEC): $(OBJS)

clean: $(OBJS)
       $(RM) $(EXEC) $(OBJS)
// make, make clean
.PHONY: all clean

 

Je pense que cette version peut etre une meilleure base pour les debutants

Share this post


Link to post
Share on other sites

Bonjour,

 

La version proposé par Caly est plus compréhensible pour un débutant, elle est largement plus structuré et organisé, ce qui permettra à une personne en apprentissage de mieux comprendre.

Share this post


Link to post
Share on other sites
Sign in to follow this