probleme avec make

Version imprimable

probleme avec make

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:

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

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:

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

31/01/2010, 19h24
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 ?
31/01/2010, 19h28
ok.Idriss
Citation:

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:

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 ?
31/01/2010, 19h30
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.

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:

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:

1 2 cible: dépendances commandes
Avec ce projet un comme le tient un, un Makefile minimal donnerait :
Code:

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:

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 ?

31/01/2010, 21h09
KateA

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...
31/01/2010, 22h29
ok.Idriss

Citation:

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) ...
01/02/2010, 12h55
KateA

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)

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:

1 2 3 4 5 6 #--------------------------------------------------- # # Definiton des outils # #--------------------------------------------------- CC = /usr/bin/gcc
(par exemple, sur unixoide)
Code:

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:

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:

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:

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:

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:

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

01/02/2010, 19h17
KateA

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) ?

Exemple 1, avec une bibliothèque :

Code:

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:

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)

02/02/2010, 07h59
KateA

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

Citation:

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

et le 2eme
make

Citation:

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
02/02/2010, 13h56
souviron34

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