Discussion :

[KateA]

salut,

je suis en train d'esayer de faire mon premier makefile. J'ai lu le tutoriel de gl, et d'autres tutoriels, mais je n'y arrive pas.
Mon projet est constitué de 4 fichiers .c :
f1.c, f2.c, f3.c et main.c
main.c utilise f3.c.
f3.c utilise f1.c et f2.c.
Voici ce que j'ai fait, et qui ne marche pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
CC = gcc
CFLAGS = -W -Wall -ansi -g
LDFLAGS =
EXEC = programme
 
all: $(EXEC)
 
programme: f3.o main.o
	$(CC) $(CFLAGS) $+ -o $@
 
main.o: main.c
	$(CC) $(CFLAGS) -c $< -o $@
 
f3.o: f2.o f1.o f3.c
	$(CC) $(CFLAGS) -c $< -o $@
 
f2.o: f2.c
	$(CC) $(CFLAGS) -c $< -o $@
 
f1.o: f1.c
	$(CC) $(CFLAGS) -c $< -o $@
 
clean:
	rm -rf *.o
 
mrproper: clean
	rm -rf $(EXEC)

peut on m'aider à le corriger et l'améliorer ?
Merci

[ok.Idriss]

Salut.

Avant de rafiner ton Makefile essayes de le faire fonctionner correctement : la cible ALL est inutile ... ta cible principale est programme dont les cibles qui suivent sont des dépendances ...

Un exemple de Makefile qui marcherait avec ton projet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
compilo = gcc
options = -Wall -Wextra # ...
 
prog : main f3 f2 f1
    $(compilo) $(options) main.o f3.o f2.o f1.o -o programme
main: f3
    $(compilo) -c main.c $(options) -o main.o
f3: f2 f1
    $(compilo) -c f3.c $(options) -o f3.o
f2:
    $(compilo) -c f2.c $(options) -o f2.o
f1:
    $(compilo) -c f1.c $(options) -o f1.o
clean:
    rm -rf *.o

[KateA]

Tu as changer certains noms et je suis perdu, ça donne quoi en laissant les mêmes noms (et abbréviations) que dans le tuto ?

[ok.Idriss]

Tu as changer certains noms et je suis perdu, ça donne quoi en laissant les mêmes noms que dans le tuto ?

Je l'ai fait exprès ... ces noms sont des noms de variables ou de cibles qui peuvent être n'importe quoi. On retrouve bien souvent les mêmes noms dans les Makefile et je tenais à te faire comprendre que ce n'est pas fixe.

Il faut bien comprendre qu'un Makefile (minimal) s'écrit de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
cible: dépendances
    commandes

Les dépendances sont en générale des cibles et les commandes peuvent être raccourcies par des variables tel que CC pour pouvoir limiter les modifications (par exemple si on veut changer de compilo).

As-tu essayé de faire make avec ce Makefile ?

[KateA]

oui ça marche, mais je ne sais pas pourquoi, et je n'arrive pas à l'adapter au cas plus compliqué avec des variables internes.

[ok.Idriss]

Voici un petit résumé :

Un Makefile est un fichier qui sert à simplifier certaines tâches de construction tel que la compilation d'un projet (qui peut se faire entièrement à la ligne de commande).

Ex : pour ton projet, tu pourrait exécuter dans l'ordre ces commandes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
gcc -c f1.c -Wall -Wextra -o f1.o
gcc -c f2.c -Wall -Wextra -o f2.o
gcc -c f3.c -Wall -Wextra -o f3.o
gcc -c main.c -Wall -Wextra -o main.o
gcc main.o f3.o f2.o f1.o -o programme

Pour éviter de faire tout cela sur chaque poste où l'on doit compiler ce programme, on utilise un Makefile.

Le Makefile se décompose en cibles définies de la façon suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
cible: dépendances
    commandes

Avec ce projet un comme le tient un, un Makefile minimal donnerait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
prog : main f3 f2 f1
    gcc main.o f3.o f2.o f1.o -o programme
main: f3
    gcc -c main.c -Wall -Wextra -o main.o
f3: f2 f1
    gcc -c f3.c -Wall -Wextra -o f3.o
f2:
    gcc -c f2.c -Wall -Wextra -o f2.o
f1:
    gcc -c f1.c -Wall -Wextra -o f1.o

La commande make exécute la première cible qui exécute en premier ses dépendances (qui exécutent d'abord leurs dépendances et ainsi de suite) ... pour fabriquer une cible en particulier, on fait make NomDeLaCible.

Pour simplifier les commandes, on peut utiliser des variables de la même façon qu'en Bash ... exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# variables :
compilo = gcc
options = -Wall -Wextra # ...
 
# cibles :
prog : main f3 f2 f1
    $(compilo) $(options) main.o f3.o f2.o f1.o programme
main: f3
    $(compilo) -c main.c $(options) -o main.o
f3: f2 f1
    $(compilo) -c f3.c $(options) -o f3.o
f2:
    $(compilo) -c f2.c $(options) -o f2.o
f1:
    $(compilo) -c f1.c $(options) -o f1.o

Enfin, tu peut ajouter d'autres cibles à l'exemple de clean (une cible peut contenir n'importe quelle commande).

Après, on peut ajouter des conditions, des raccourcis ... bref, c'est tout un langage (voir dans les tutos).

C'est un peu plus clair ?