probleme avec make

**KateA** · 31/01/2010, 18h45

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** · 31/01/2010, 19h05

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** · 31/01/2010, 19h24

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** · 31/01/2010, 19h28

Envoyé par KateA

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** · 31/01/2010, 19h30

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** · 31/01/2010, 19h47

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 ?

**KateA** · 31/01/2010, 21h09

J'ai compris un peu le principe, mais j'ai des difficultés à utiliser les raccourcis, et pourtant j'aimerais bien les utiliser... Ca donnerai quoi avec les raccourci ?

Il y a autre chose que je ne comprends pas : si tu commences la ligne par f1:, je croyais que ca créait un fichier nommé f1...

**ok.Idriss** · 31/01/2010, 22h29

Envoyé par KateA

Il y a autre chose que je ne comprends pas : si tu commences la ligne par f1:, je croyais que ca créait un fichier nommé f1...

Non, ça c'est simplement le nom d'une cible, comme clean dans ton premier Makefile par exemple (il n'y a pas de fichier clean qui sera crée) ...

**KateA** · 01/02/2010, 12h55

Ok. Le makefile que tu a écrit dans ton 1er message marche.
Mais comment le rendre plus "standard", notamment avec toutes les variables internes et tout ?
(c'est surtout sa que j'ai essayer de faire et que j'ai pas réussi)

**souviron34** · 01/02/2010, 15h18

théoriquement :

une cible est identifiée par ::
une instruction est identifée par :
une variable est identifée par un =

On peut donc avoir :

Code :

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

1
2
3
4
5
6
#---------------------------------------------------
#
#  Definiton des outils
#
#---------------------------------------------------
CC = /usr/bin/gcc

(par exemple, sur unixoide)

Code :

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

1
2
3
4
5
6
7
8
9
10
#---------------------------------------------------
#
#  Definitions des chemins
#
#---------------------------------------------------
HOME_DIR 	= ..
SOURCE_DIR 	= ./
EXE_DIR 	= $(HOME_DIR)/bin
INCLUDE_DIR 	= $(SOURCE_DIR)/include
LIB_DIR         = $(HOME_DIR)/lib/

Code :

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

1
2
3
4
5
6
7
#---------------------------------------------------
#
#  Options
#
#---------------------------------------------------
CFLAGS  = -Wall -Wextra -I$(INCLUDE_DIR)# ...
LDFLAGS = -L$(LIB_DIR) -lm

(CFLAGS est une variable par défaut)

Code :

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

1
2
3
4
5
6
7
8
9
 
#---------------------------------------------------
#
#  Directives pour la compilation
#
#---------------------------------------------------
 
.c.o:
	$(CC) $(CFLAGS) -c $< $(LDFLAGS)

Avec une ligne de cible comme :

Code :

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

f2::    $(CC) $(SOURCE_DIR)/f2.c  -o $(BIN_DIR)/f2

la cible all permet de ne pas donner de paramètre lorsque le makefile est appelé, et donc de taper "make" tout simplement. Par défaut il ira exécuter ce qu'il y a sous la cible all.

Code :

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

all:: f2

Pour compiler, il suffira donc de taper "make" au lieu de "make f2".

Ce qui permet de compiler tout un tas de choses d'un seul coup.

De même, on n'utilise pas de "mrproper", mais "clean" est une cible standard.

Code :

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

1
2
3
clean::
        cd $(LIB_DIR) ; rm -rf * ; cd $(BIN_DIR) ; rm -rf * ;
        echo 'tout est nettoyé'

**KateA** · 01/02/2010, 19h17

D'accord, merci pour ce cours théorique.
J'ai quand même du mal à appliquer tout ça, et les variables internes du type $<,$@,$+ etc.
Comment les utiliser avec mon makefile (avec le projet que j'ai présenté au début) ?

**souviron34** · 02/02/2010, 00h50

Exemple 1, avec une bibliothèque :

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
#---------------------------------------------------
#
#  Definition de la cible par défaut
#
#---------------------------------------------------
tout: all
 
 
#---------------------------------------------------
#
#  Definition des chemins
#
#---------------------------------------------------
SOURCE_DIR = ./
EXE_DIR = $(SOURCE_DIR)
OBJECT_DIR = $(SOURCE_DIR)
INCLUDE_DIR = $(SOURCE_DIR)
LIB_DIR = $(SOURCE_DIR)
 
#---------------------------------------------------
#
#  Definition du nom du programme
#
#---------------------------------------------------
EXEC = $(EXE_DIR)/programme
 
 
#---------------------------------------------------
#
#  Definition des outils
#
#---------------------------------------------------
CC = gcc
 
# outil d'archivage pour créer une bibliothèque
#
AR = ar rv
RANLIB = ar ts
 
 
#---------------------------------------------------
#
#  Definition des flags de compilation
#
#---------------------------------------------------
CFLAGS = -W -Wall -ansi -g -I$(INCLUDE_DIR)
LDFLAGS =  -L$(LIB_DIR) -lm
 
 
#---------------------------------------------------
#
#  Definition de la bibliothèque utilisée
#
#---------------------------------------------------
# son nom
#
MYLIB = $(LIB_DIR)/MyLib.a
 
# sa construction
#
OBJS = $(OBJECT_DIR)/f1.o \
	$(OBJECT_DIR)/f2.o \
	$(OBJECT_DIR)/f3.o
 
$(MYLIB): $(OBJS)
	$(AR) $(MYLIB) $(OBJS) ;
	$(RANLIB) $(MYLIB) ;
	cd $(SOURCE_DIR)
 
 
#---------------------------------------------------
#
#  Directives pour la compilation
#
#---------------------------------------------------
 
$(SOURCE_DIR)/.c$(OBJECT_DIR)/.o:
	$(CC) $(CFLAGS) -c $(SOURCE_DIR)/$< $(OBJECT_DIR)
 
 
 
#---------------------------------------------------
#
#  Cibles
#
#---------------------------------------------------
 
 
all:: programme
 
programme:: $(MYLIB)
	$(CC) $(CFLAGS) $(SOURCE_DIR)/main.c  $(LDFLAGS)   \
             $(MYLIB) -o $(EXEC)
 
clean::
	rm -rf *.o *.a $(EXEC)

Exemple 2, sans bibliothèque :

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#---------------------------------------------------
#
#  Definition de la cible par défaut
#
#---------------------------------------------------
tout: all
 
 
#---------------------------------------------------
#
#  Definition des chemins
#
#---------------------------------------------------
SOURCE_DIR = ./
EXE_DIR = $(SOURCE_DIR)
OBJECT_DIR = $(SOURCE_DIR)
INCLUDE_DIR = $(SOURCE_DIR)
LIB_DIR = $(SOURCE_DIR)
 
#---------------------------------------------------
#
#  Definition du nom du programme
#
#---------------------------------------------------
EXEC = $(EXE_DIR)/programme
 
 
#---------------------------------------------------
#
#  Definition des outils
#
#---------------------------------------------------
CC = gcc
 
 
#---------------------------------------------------
#
#  Definition des flags de compilation
#
#---------------------------------------------------
CFLAGS = -W -Wall -ansi -g -I$(INCLUDE_DIR)
LDFLAGS =  -lm
 
 
#---------------------------------------------------
#
#  Directives pour la compilation
#
#---------------------------------------------------
 
$(SOURCE_DIR)/.c.$(OBJECT_DIR)/.o:
	$(CC) $(CFLAGS) -c $(OBJECT_DIR)/$< $(OBJECT_DIR)/$
 
 
 
#---------------------------------------------------
#
#  Cibles
#
#---------------------------------------------------
 
 
all:: programme
 
programme::
	$(CC) $(CFLAGS) $(LDFLAGS) main.c f1.c f2.c f3.c \
	-o  $(EXEC)  
 
clean::
	rm -rf *.o $(EXEC)

**KateA** · 02/02/2010, 07h59

merci d'avoir essayé, mais aucun des 2 ne marche.
pour le 1er, l'erreur est

make: *** No rule to make target `MyLib.a', needed by `programme'. Stop.

et le 2eme
make

cd ./ ; \
gcc -W -Wall -ansi -g -I./ -c f1.c f2.c f3.c main.c \
-lm -o ./)/programme
/bin/sh: Syntax error: ")" unexpected
make: *** [programme] Error 2

**souviron34** · 02/02/2010, 13h56

j'ai corrigé les exemples dans le post ci-dessus.. Avec l'heure et la vitesse j'avais laissé des erreurs...

probleme avec make

C

Discussions similaires

Partager

Partager