Discussion :

[bouba82]

Bonjour,

Je suis confronté à un problème intéressant. Je travaille sur un projet pour lequel le makefile contient autant de règles que de fichier à compiler. J'aimerais bien le simplifier en les remplaçant pas une ligne du genre:

%.o : %.c

$(CC) $(OPTIONS) $(INCLUDE) -o $@ -c $<

C'est là que ça se complique:

• Tous les objets doivent aller dans le même répertoire
• Les fichiers source ne se trouvent pas tous au même endroit. Pas de possibilité de makefiles récursifs car je n'ai pas accès en écriture sur certains des répertoires.
• Les dépendance entre les fichiers entêtes et les fichiers sources ne sont pas triviales.
• La variable $< n'est pas positionnée si un chemin précède le fichier source (ce qui est toujours le cas).

Voici quelques exemples de regles de mon makefile:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
$(D_OBJ)/comm.o : $(COMM)/comm.c $(COMM)/comm.h
	$(CC) $(OPTIONS) $(INCLUDE)-o $(D_OBJ)/infra_comm.o  -c $(COMM)/comm.c
 
$(D_OBJ)/checksum.o: $(D_AUTRES)/checksum.c $(D_AUTRES)/checksum.inc
	$(CC) $(OPTIONS) $(INCLUDE)-o $(D_OBJ)/checksum.o  -c $(D_AUTRES)/checksum.c
 
$(D_OBJ)/task.o: $(D_TIMER)/src/task.cpp $(D_TIMER)/inc/task.hpp
	$(CC) $(OPTIONS) $(INCLUDE)-o $(D_OBJ)/task.o  -c $(D_TIMER)/src/task.cpp
 
$(D_OBJ)/xml_tree.o: $(D_SRC)/xml_tree.cpp $(D_INC)/xml_tree.hpp $(D_INC)/header.hpp
	$(CC) $(OPTIONS) $(INCLUDE) -c -o $(D_OBJ)/xml_tree.o $(D_SRC)/xml_tree.cpp

Ces quelques lignes représentent assez bien la "biodiversité" des règles de mon makefile. C'est bien sympa, par contre c'est in-maintenable. Il y a au total 27 règles différentes, et 3 répertoires dans lesquels on va chercher les fichiers. Pour le moment, là seule optimisation que j'ai pu faire, c'est de remplace le "-o $(D_OBJ)/xml_tree.o" par "-o $@" pour toutes les règles.

J'aimerais essayer de regrouper mes regèles par répertoires pour avoir qu'une seule commande par répertoire. Je ne sais pas trop ce qui est faisable et ce qui ne l'ai pas.

Toute suggestion est la bienvenue, quelle qu'elle soit.

Merci!!!

[poulacou]

Moi je ferai un Makefile générique à la racine de ton projet
avec des regles %.o: %.c
$(CC) $(CFLAGS).....

puis dans dans chaque sous repertoire, tu crées un Makefile qui inclue ton Makefile racine et si pour un fichier précis tu as besoin d'une régle précise tu l'a redeini dans ce sous Makefile apres le include ../MonMakefileGeneral
mon_fichier.o : mon_fichier.c
$(CC) $(CFLAGS -o $@ fichier_necessaire.o

[bouba82]

Salut!

Merci pour ton conseil. Le seul problème c'est que je n'est pas le droit en écriture sur la majorité des répertoires. Finalement j'ai fait une règle par répertoire. Voici ce que ça donne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
${D_OBJ}/%.o : ${D_SRC}/%.cpp
        @echo "*** Building \"`basename $@`\" ***"
        @${CC} ${OPTIONS} ${INCLUDE} -c $? -o $@
 
${D_OBJ}/%.o : ${D_P1ALLV5}/%.c
        @echo "*** Building \"`basename $@`\" ***"
        @${CC} ${OPTIONS} ${INCLUDE} -c $? -o $@
 
${D_OBJ}/%.o : ${D_AUTRES}/%.c
        @echo "*** Building \"`basename $@`\" ***"
        @${CC} ${OPTIONS} ${INCLUDE} -c $? -o $@

Disons qu'avec les cartes que j'ai, c'est ce que je peux faire de mieux je crois.

[domiq44]

Bonjour,

Ce sujet m'intéresse particulièrement.

La solution utilisée par « bouba82 » est élégante et fonctionne bien pour moi sous AIX.

Mais je veux aller plus loin.

Je ne veux pas dans mon makefile, indiquer à la fois les sources ${SRCS} et les objets ${OBJS}.

Code :

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

1
2
3
 
SRCS ==> ${D_SRC}/pipo.cpp ${D_SRC}/toto.cpp ${D_SRC}/dudu.cpp
OBJS ==> ${D_OBJ}/pipo.o ${D_OBJ}/toto.o ${D_OBJ}/dudu.o

Je veux ne déclarer que les sources comme cela :

Code :

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

1
2
3
4
 
SRCS=${D_SRC}/pipo.cpp \
    ${D_SRC}/toto.cpp \
    ${D_SRC}/dudu.cpp

et déduire les objets un peu colmme ceci :

Code :

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

1
2
 
D_OBJ=${D_SRC:.cpp:.o}

Or cela ne fonctionne que si les fichiers sont dans le même répertoire

C'est-à-dire que j'obtiens cela :

Code :

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

1
2
 
OBJS ==> ${D_SRC}/pipo.o ${D_SRC}/toto.o ${D_SRC}/dudu.o

au lieu de cela :

Code :

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

1
2
 
OBJS ==> ${D_OBJ}/pipo.o ${D_OBJ}/toto.o ${D_OBJ}/dudu.o

Alors : comemnt faire

Merci.

[bouba82]

Bonjour,

domiq44, j'ai une solution à te proposer. Que dirais tu de ne pas indiquer les sources, mais plutôt les objets à la place?

Dans mon cas, je ne précise que les objets:

Code :

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

1
2
3
4
 
LIST_OBJ      = $(D_OBJ)/toto.o\
		  $(D_OBJ)/tata.o\
		  $(D_OBJ)/tutu.o

et la directive de compilation:

Code :

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

1
2
3
4
 
${D_OBJ}/%.o : ${D_SRC}/%.cpp
	@echo "*** Building \"`basename $@`\" ***"
	@${CC} ${OPTIONS} ${INCLUDE} -c $? -o $@

Si ta directive de compilation est la même que la mienne, je comprends pas trop pourquoi ça ne marche pas... Sinon, mets la voir stp, j'aurais peu être une idée lumineuse mais je te promets rien, surtout le lundi matin! Dans tous les cas, si la solution que je propose fonctionne aussi chez toi, tiens moi au courant...

bye!

[domiq44]

Effectivement, ça marche

Merci.

Pourquoi je veux indiquer la liste des sources ?
Parce que mes programmes sont en majorité écrits en Oracle Pro*C (Emmbedded SQL).

Avec les règles suivantes :

• .pc -> .c et .lis
• .c -> .o
• .o -> .exe ou .lib si c'est une librairie

Et je veux créer une règle « clean » qui m'efface les .c uniquement s'ils sont issus de .pc, et qui efface aussi les .lis.
Et surtout pas effacer les .c si c'est du C ordinaire.