Discussion :

[Deallyra]

Bonsoir,

Je suis à développer une petite application client serveur qui a la forme suivante :

_Trunk/
_Trunk/Client/
_Trunk/Client/client.c
_Trunk/Client/client.h
_Trunk/Client/MakeFile
_Trunk/Serveur/serveur.c
_Trunk/Serveur/serveur.h
_Trunk/Serveur/MakeFile
_Trunk/librairie.c
_Trunk/librairie.h

Mon problème actuel est le suivant. Je ne comprends pas la partie consacrée aux sous makefile dans l'Introduction à Makefile

En effet, je ne vois pas comment le makefile qui se situerait au Trunk/ pourrait savoir comment aller dans les sous dossiers Client et Serveur.
A quoi correspondrait la partie :

EXEC=$(HELLO_DIR)/hello

Parce que moi j'aurai deux exécutables que sont ./ratioClientTCP et ./ratioServeurTCP

Là, nous avons l'impression qu'il n'y aura qu'un seul exécutable de généré dans tous les cas :s


Pour les réels "sous makefile", je n'aurai juste qu'à enlever mes actuels constantes qui seront déjà définie dans le makefile principal, le makefile du Trunk/.


Merci beaucoup de toute l'aide que vous pourrez m'apporter

[jabbounet]

Tout dépend de ce que tu définit comme règles de compilation dans ton makefile

Tu as accès a tout les les commandes systèmes (cd, cp, mv, ....)
rien ne t'empêche non plus d'appeler d'autres makefile dans d'autres répertoires aussi si tu en connait le chemin, ou de générer tes cibles dans des répertoires différent de celui ou tu lance la commande.

Par défaut la commande make cherchera a exécuter la règle de compilation la plus proche du haut de ton fichier make.

s'il ne sait pas la faire, il va examiner les dépendances qui lui manquent et chercher à les résoudre. il s'agit en fait d'un parcours d'arbre ou make va analyser chaque noeud et décider de ce qui est a compiler.

par exemple

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
all: A B
 
A: E.o A.c
  gcc A.c E.o -o A 
 
B: B.c
  gcc B.c -o B 
 
E.o: E.c E.h
  gcc E.c E.h -o E.o

ici on a les arbres de dépendances suivant

Code :

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

1
2
3
4
5
6
7
8
 
A                                         B
|                                          |
+---------+                           B.c
A.c          E.o
               |
               +-------------+
              E.c                 E.h

pour construire A, make va vérifier l'arbre de dépendance de façon récursive
pour faire A make doit construire A.c et E.o

pour construire A.c pas de règle, donc vérification de l'existence du fichier et de sa date (si plus récent que A, A sera a reconstruire)

pour construire E.o un règle existe, make vérifie a nouveau les dépendances
il trouve uniquement les fichier E.C et E.h qui n'ont pas de regles, si ces derniers sont plus récent que E.o il reconstruit E.o et reconstruira pas conséquent A

une fois A.c et E.o analysé et éventuellement reconstruit si leur date de création/modification est plus récente que A ou si A n'existe pas Make exécute la commande de compilation de A (ici gcc ...)


je ne sais pas si j'ai été clair mais il s'agit du fonctionnement de make dans les grandes lignes.

quelques liens utiles sur tout ce que je viens de dire et pas mal d'autre choses.
http://cs.millersville.edu/~katz/linuxHelp/make.html
http://www.jfranken.de/homepages/joh...inhalt.en.html
http://www.ugrad.cs.ubc.ca/~cs219/Co.../multMake.html
http://www.ugrad.cs.ubc.ca/~cs219/Co.../multMake.html
https://cdcsp.univ-lyon1.fr/~kielbas.../docs/make.pdf

[Deallyra]

Bonjour,

Merci de votre réponse, je vais aller voir les liens en espérant comprendre un peu mieux.

En ce qui concerne votre question pour la teneur de mes makefiles, je peux vous montrer à quoi ressemble mes sous make file mais il ne s'agit que d'une reprise du makefile proposé dans l'introduction aux makefile (lien dans le post précédent)

Pour le client :

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
 
CC=gcc
CFLAGS=-Wall -Wextra -O -Wstrict-prototypes -Wunreachable-code -g
LDFLAGS=
EXEC=chatTCP_client
SRC= $(wildcard *.c)
OBJ= $(SRC:.c=.o)
 
all: $(EXEC)
 
chatTCP_client: $(OBJ)
	@$(CC) -o $@ $^ $(LDFLAGS)
 
main.o: client.h
 
%.o: %.c
	@$(CC) -o $@ -c $< $(CFLAGS)
 
.PHONY: clean mrproper
 
clean:
	rm -rf *.o
 
mrproper: clean
	rm -rf $(EXEC)

Pour le serveur :

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
 
CC=gcc
CFLAGS=-Wall -Wextra -O -Wstrict-prototypes -Wunreachable-code -g
LDFLAGS=
EXEC=ratioTCP_serveur
SRC= $(wildcard *.c)
OBJ= $(SRC:.c=.o)
 
all: $(EXEC)
 
ratioTCP_serveur: $(OBJ)
	@$(CC) -o $@ $^ $(LDFLAGS)
 
%.o: %.c
	@$(CC) -o $@ -c $< $(CFLAGS)
 
main.o: serveur.h
 
.PHONY: clean mrproper
 
clean:
	rm -rf *.o
 
mrproper: clean
	rm -rf $(EXEC)

______

Cela vous semble-t-il correct ?

Trunk/Makefile

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
 
export CC=gcc
export CFLAGS=-Wall -Wextra -O -Wstrict-prototypes -Wunreachable-code -g
export LDFLAGS=
CLIENT_DIR=Client
SERVEUR_DIR=Serveur
EXEC=$(CLIENT_DIR)/ratioTCP_Client $(SERVEUR_DIR)/ratioTCP_Serveur
 
all: $(EXEC)
 
$(EXEC):
	@(cd $(CLIENT_DIR) && $(MAKE))
	@(cd $(SERVEUR_DIR) && $(MAKE))
 
.PHONY: clean mrproper $(EXEC)
 
clean:
	@(cd $(CLIENT_DIR) && $(MAKE) $@)
	@(cd $(SERVEUR_DIR) && $(MAKE) $@)
 
mrproper: clean
	@(cd $(CLIENT_DIR) && $(MAKE) $@)
	@(cd $(SERVEUR_DIR) && $(MAKE) $@)

Trunk/Client/Makefile

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
 
EXEC=ratioTCP_client
SRC= $(wildcard *.c)
OBJ= $(SRC:.c=.o)
 
all: $(EXEC)
 
ratioTCP_client: $(OBJ)
	@$(CC) -o $@ $^ $(LDFLAGS)
 
main.o: client.h
 
%.o: %.c
	@$(CC) -o $@ -c $< $(CFLAGS)
 
.PHONY: clean mrproper
 
clean:
	rm -rf *.o
 
mrproper: clean
	rm -rf $(EXEC)

Trunk/Serveur/Makefile

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
 
EXEC=ratioTCP_serveur
SRC= $(wildcard *.c)
OBJ= $(SRC:.c=.o)
 
all: $(EXEC)
 
ratioTCP_serveur: $(OBJ)
	@$(CC) -o $@ $^ $(LDFLAGS)
 
%.o: %.c
	@$(CC) -o $@ -c $< $(CFLAGS)
 
main.o: serveur.h
 
.PHONY: clean mrproper
 
clean:
	rm -rf *.o
 
mrproper: clean
	rm -rf $(EXEC)

Merci,

[jabbounet]

je n'ai pas de shell sous la main, mais le principe me semble correct,

cependant tu peux peu être utiliser des include des tes sous makefile dans ton makefile principal.


http://www.gnu.org/software/make/man...e.html#Include

[Deallyra]

Merci de vos réponses

[jabbounet]

aucun soucis