Makefiles avec des fichiers sources dans différents répertoires

Question

J'ai un projet dont la structure de répertoire est la suivante :

                         $projectroot
                              |
              +---------------+----------------+
              |               |                |
            part1/          part2/           part3/
              |               |                |
       +------+-----+     +---+----+       +---+-----+
       |      |     |     |        |       |         |
     data/   src/  inc/  src/     inc/   src/       inc/

Comment puis-je écrire un makefile qui serait dans part/src (ou n'importe où en fait) qui pourrait compléter/lien sur les fichiers sources c/c++ dans part?/src ?

Puis-je faire quelque chose comme -I$projectroot/part1/src -I$projectroot/part1/inc -I$projectroot/part2/src ...

Si cela fonctionne, y a-t-il un moyen plus simple de le faire ? J'ai vu des projets où il y a un makefile dans chacun des dossiers part ? correspondants. [dans ce post, j'ai utilisé le point d'interrogation comme dans la syntaxe bash].

Answer 1

La méthode traditionnelle consiste à avoir un Makefile dans chacun des sous-répertoires ( part1 , part2 ) vous permettant de les construire indépendamment. En outre, disposez d'un Makefile dans le répertoire racine du projet qui construit tout. Le répertoire "Root" Makefile ressemblerait à ce qui suit :

all:
    +$(MAKE) -C part1
    +$(MAKE) -C part2
    +$(MAKE) -C part3

Puisque chaque ligne d'une cible make est exécutée dans son propre shell, il n'y a pas besoin de se soucier de remonter dans l'arborescence des répertoires ou dans d'autres répertoires.

Je suggère de jeter un coup d'œil à la Manuel GNU make section 5.7 ; c'est très utile.

Answer 2

Si vous avez du code dans un sous-répertoire qui dépend du code dans un autre sous-répertoire, il est probablement préférable d'avoir un seul makefile au niveau supérieur.

Voir La fabrication récursive est considérée comme nuisible pour le raisonnement complet, mais en gros vous voulez que make ait toutes les informations dont il a besoin pour décider si oui ou non un fichier doit être reconstruit, et il ne les aura pas si vous ne lui parlez que d'un tiers de votre projet.

Le lien ci-dessus semble ne pas être accessible. Le même document est accessible ici :

• aegis.sourceforge.net (archivé)
• lcgapp.cern.ch

Answer 3

L'option VPATH, qui indique à make dans quels répertoires chercher le code source, peut s'avérer utile. Vous aurez toujours besoin d'une option -I pour chaque chemin d'inclusion, cependant. Un exemple :

CXXFLAGS=-Ipart1/inc -Ipart2/inc -Ipart3/inc
VPATH=part1/src:part2/src:part3/src

OutputExecutable: part1api.o part2api.o part3api.o

Ceci trouvera automatiquement les fichiers partXapi.cpp correspondants dans n'importe lequel des répertoires spécifiés dans le VPATH et les compilera. Cependant, ceci est plus utile lorsque votre répertoire src est divisé en sous-répertoires. Pour ce que vous décrivez, comme d'autres l'ont dit, vous êtes probablement mieux avec un makefile pour chaque partie, surtout si chaque partie peut être autonome.

Answer 4

Vous pouvez ajouter des règles à votre Makefile racine afin de compiler les fichiers cpp nécessaires dans d'autres répertoires. L'exemple de Makefile ci-dessous devrait être un bon début pour vous amener là où vous voulez être.

CC=g++
TARGET=cppTest
OTHERDIR=../../someotherpath/in/project/src

SOURCE = cppTest.cpp
SOURCE = $(OTHERDIR)/file.cpp

## End sources definition
INCLUDE = -I./ $(AN\_INCLUDE\_DIR)  
INCLUDE = -I.$(OTHERDIR)/../inc
## end more includes

VPATH=$(OTHERDIR)
OBJ=$(join $(addsuffix ../obj/, $(dir $(SOURCE))), $(notdir $(SOURCE:.cpp=.o))) 

## Fix dependency destination to be ../.dep relative to the src dir
DEPENDS=$(join $(addsuffix ../.dep/, $(dir $(SOURCE))), $(notdir $(SOURCE:.cpp=.d)))

## Default rule executed
all: $(TARGET)
        @true

## Clean Rule
clean:
        @-rm -f $(TARGET) $(OBJ) $(DEPENDS)

## Rule for making the actual target
$(TARGET): $(OBJ)
        @echo "============="
        @echo "Linking the target $@"
        @echo "============="
        @$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
        @echo -- Link finished --

## Generic compilation rule
%.o : %.cpp
        @mkdir -p $(dir $@)
        @echo "============="
        @echo "Compiling $<"
        @$(CC) $(CFLAGS) -c $< -o $@

## Rules for object files from cpp files
## Object file for each file is put in obj directory
## one level up from the actual source directory.
../obj/%.o : %.cpp
        @mkdir -p $(dir $@)
        @echo "============="
        @echo "Compiling $<"
        @$(CC) $(CFLAGS) -c $< -o $@

# Rule for "other directory"  You will need one per "other" dir
$(OTHERDIR)/../obj/%.o : %.cpp
        @mkdir -p $(dir $@)
        @echo "============="
        @echo "Compiling $<"
        @$(CC) $(CFLAGS) -c $< -o $@

## Make dependancy rules
../.dep/%.d: %.cpp
        @mkdir -p $(dir $@)
        @echo "============="
        @echo Building dependencies file for $\*.o
        @$(SHELL) -ec '$(CC) -M $(CFLAGS) $< | sed "s^$\*.o^../obj/$\*.o^" > $@'

## Dependency rule for "other" directory
$(OTHERDIR)/../.dep/%.d: %.cpp
        @mkdir -p $(dir $@)
        @echo "============="
        @echo Building dependencies file for $\*.o
        @$(SHELL) -ec '$(CC) -M $(CFLAGS) $< | sed "s^$\*.o^$(OTHERDIR)/../obj/$\*.o^" > $@'

## Include the dependency files
-include $(DEPENDS)

Answer 5

Si les sources sont réparties dans de nombreux dossiers, et qu'il est logique d'avoir des Makefiles individuels, alors comme suggéré précédemment, le make récursif est une bonne approche, mais pour les petits projets, je trouve plus facile de lister tous les fichiers sources dans le fichier Makefile avec leur chemin relatif vers le Makefile comme ça :

# common sources
COMMON_SRC := ./main.cpp \
              ../src1/somefile.cpp \
              ../src1/somefile2.cpp \
              ../src2/somefile3.cpp \

Je peux alors mettre VPATH de cette façon :

VPATH := ../src1:../src2

Ensuite, je construis les objets :

COMMON_OBJS := $(patsubst %.cpp, $(ObjDir)/%$(ARCH)$(DEBUG).o, $(notdir $(COMMON_SRC)))

La règle est simple :

# the "common" object files
$(ObjDir)/%$(ARCH)$(DEBUG).o : %.cpp Makefile
    @echo creating $@ ...
    $(CXX) $(CFLAGS) $(EXTRA_CFLAGS) -c -o $@ $<

Et la construction de la sortie est encore plus facile :

# This will make the cbsdk shared library
$(BinDir)/$(OUTPUTBIN): $(COMMON_OBJS)
    @echo building output ...
    $(CXX) -o $(BinDir)/$(OUTPUTBIN) $(COMMON_OBJS) $(LFLAGS)

On peut même faire le VPATH génération automatisée par :

VPATH := $(dir $(COMMON_SRC))

Ou en utilisant le fait que sort supprime les doublons (bien que cela ne devrait pas avoir d'importance) :

VPATH := $(sort  $(dir $(COMMON_SRC)))