Discussion :

[Ruok]

Bonjour,

Je viens humblement sur ce forum quémander votre avis/aide sur un problème de récupération de dépendances dans un makefile.

Voici ma situation :
J'ai 2 types de makefiles :
1. Un makefile générique make_c.mk qui définit les règles de compilation implicites. Exemple de make_c.mk :

%.elf : $(shell cat src/$*.mk | egrep "^$*.o"| cut -d':' -f2)
[TAB]<règle de fabrication de la cible %.elf>
%.o : %.c
[TAB]<règle de fabrication de la cible %.o>

2. Un makefile spécifique boot.mk qui définit explicitement les dépendances de la cible boot.elf. Exemple de boot.mk :
include make_c.mk
boot.elf : toto.a toto2.o

La commande qui doit être lancée est : gmake make_c.mk boot.elf

Le problème est le suivant :
L'expression affichée en rouge n'est pas valorisée. La méthode n'est pas bonne mais le besoin est le suivant : J'ai besoin de déterminer automatiquement, dans le make_c.mk, les dépendances de la cible %.elf par extraction des dépendances explicites définies dans le makefile spécifique (dans notre cas : Les dépendances explicites sont représentées par l'expression en vert et le makefile spécifique est "boot.mk" dont le nom est identique (à l'extension près) au nom de la cible référencée (boot.elf ici)).

Ma question (ouf ) : Comment vous y prendriez-vous pour récupérer les dépendances ?

NB : Le makefile générique make_c.mk doit uniquement se baser sur des règles implicites.

NB 2 : Je sais qu'il est incorrect d'écrire une commande shell en lieu et place de dépendances, mais c'était pour mieux "faire passer l'idée"

Merci beaucoup à tous ceux qui ont pris la peine de lire jusque là !

[haypo]

Hum ... Je crois que tu te prends trop la tête :-)

La commande qui doit être lancée est : gmake make_c.mk boot.elf

Elle est compliquée ta commande ! Moi je tape "make" et tout est fait de manière transparente (génération des dépendances, compilation des objets et enfin liaison) !

J'ai besoin de déterminer automatiquement, dans le make_c.mk, les dépendances de la cible %.elf par extraction des dépendances explicites définies dans le makefile spécifique (dans notre cas : Les dépendances explicites sont représentées par l'expression en vert et le makefile spécifique est "boot.mk" dont le nom est identique (à l'extension près) au nom de la cible référencée (boot.elf ici)).

En français ça donne ?

Ma question (ouf ) : Comment vous y prendriez-vous pour récupérer les dépendances ?

Pour un programme en C ou C++ : il existe l'option "-MM" de GCC qui extrait les dépendances (includes, les .h). Moi je génère toutes les dépendances, et je les écris dans le fichier make.dep que j'inclue ensuite. Mon makefile type "simplifié" (dans messages textes par ex.) ... euh, je veux le découper pour plus de clareté :

1) Varibles

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#Liste des fichiers sources
SOURCES=$(sort $(wildcard *.cpp))
OBJECTS=$(patsubst %.cpp,%.o,$(SOURCES))
 
CXX=g++
BIN=wormux
CXXFLAGS=-Wall -g
LIBS=(...)
 
# Utilise les séquences d'échappement ANSI ?
UTILISE_ESC=1

2) Rêgle de compilation par défaut (make tout court)

Code :

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

all: checklib depend compile

3) Dépendances

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
# Rêgle de dépendance : écrit tout dans make.dep, puis inclu ce dernier
depend:
        @echo -n "Creation des dependances (make.dep) "
        @rm -f make.dep
        @echo -n "["
# Barre d'avancement :-)
ifdef UTILISE_ESC
        @$(foreach source,$(SOURCES), echo -n ".";)
        @echo -e -n "]\\b"
        @$(foreach source,$(SOURCES), echo -n -e "\\b";)
endif
        @$(foreach source,$(SOURCES), echo -n "*"; $(CXX) -MM $(source) >>make.d
ep;)
        @echo "]"
-include make.dep

4) Compilation des objets

Code :

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

1
2
3
# Compile les dépendances puis lie le tout ensemble
compile: $(OBJECTS)
        @$(CXX) -o $(BIN) $(CXXFLAGS) $(LIBS) $(OBJECTS)

NB : Le makefile générique make_c.mk doit uniquement se baser sur des règles implicites.

Pour utiliser du shell :

Code :

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

1
2
regle:
<tab>commande shell

Et puis c'est tout !

Si tu veux te servir du résultat du shell dans ton makefile -> tu écris dans un fichier que tu inclue.

Merci beaucoup à tous ceux qui ont pris la peine de lire jusque là !

De rien.

Si t'as d'autres questions : poste les ici, je suis "averti lorsqu'une réponse est postée".

@+ Haypo

[Ruok]

Hum ... Je crois que tu te prends trop la tête :-)

Certes

Elle est compliquée ta commande ! Moi je tape "make" et tout est fait de manière transparente (génération des dépendances, compilation des objets et enfin liaison) !

Certes encore... Disons que pour de normes de codage, il m'est préférable de citer le make utilisé dans la ligne d'appel.

J'ai besoin de déterminer automatiquement, dans le make_c.mk, les dépendances de la cible %.elf par extraction des dépendances explicites définies dans le makefile spécifique (dans notre cas : Les dépendances explicites sont représentées par l'expression en vert et le makefile spécifique est "boot.mk" dont le nom est identique (à l'extension près) au nom de la cible référencée (boot.elf ici)).

En français ça donne ?

En français dans le texte, j'ai un makefile "général" en point d'entrée pour divers exécutables. Lors de l'appel a ce makefile, je dois récupérer les dépendances de l'exécutable qui m'intéresse dans un fichier externe de meme nom & d'extension .mk.

Ma question (ouf ) : Comment vous y prendriez-vous pour récupérer les dépendances ?

Pour un programme en C ou C++ : il existe l'option "-MM" de GCC qui extrait les dépendances (includes, les .h). Moi je génère toutes les dépendances, et je les écris dans le fichier make.dep que j'inclue ensuite. Mon makefile type "simplifié" (dans messages textes par ex.) ... euh, je veux le découper pour plus de clareté :

1) Varibles <Couic>
2) Rêgle de compilation par défaut (make tout court) <Couic>
3) Dépendances <Couic>
4) Compilation des objets <Couic>

Certes (ter).
Mais j'ai deux problèmes vis à vis de l'option -MM :
* Mes sources sont dans des répertoires disjoints.
* Il faudrait que je me limite à récupérer les dépendances relatives aux fichiers librairies (.o & .a), sans les .h/.i .

NB : Le makefile générique make_c.mk doit uniquement se baser sur des règles implicites.

Pour utiliser du shell :

Code :

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

1
2
regle:
<tab>commande shell

Et puis c'est tout !

Si tu veux te servir du résultat du shell dans ton makefile -> tu écris dans un fichier que tu inclue.

Je me suis mal exprimé : Je voulais simplement dire que je ne peux pas écrire de règle spécifique à une cible dans le makefile (du type toto : toto1.a toto2.o toto3.o), car mon makefile ne doit contenir qu'une régle de dépendances pour tous mes exécutables.
J'effectue donc un matching du type : %.exe : dependance1.o dependance2.o etc., mais ou je souhaite que ces dépendances soient valorisées de manière spécifique à la cible lors de l'exécution du makefile (en gros, en utilisant le contenu du fichier %.mk)

Si t'as d'autres questions : poste les ici, je suis "averti lorsqu'une réponse est postée".
@+ Haypo

Merci encore

[Ruok]

Pas de réponses ?

[karmaki]

As-tu vraiment besoin de connaitre les dépendances dans le makefile général ? Parce que sinon, tu peux très bien écrire:

Code :

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

1
2
3
4
 
%.a : %.b
        @echo "Fabriquer $@ à partir de $<"
        cp $< $@

dans le makefile général, et

Code :

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

1
2
3
 
include make_general
toto.a : toto.b toto.c

dans l'autre. Ca marche très bien. Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
$ touch toto.b toto.c
$ make
Fabriquer toto.a à partir de toto.b
cp toto.b toto.a
$ make
make: « toto.a » est à jour.
$ touch toto.c
$ make
Fabriquer toto.a à partir de toto.b
cp toto.b toto.a