Makefile con file sorgente in diverse directory

Ho un progetto in cui la struttura delle directory è così:

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

Come dovrei scrivere un makefile che sarebbe in parte / src (o dovunque davvero) che potrebbe compilare / linkare in parte i file sorgente c / c ++? / Src?

Posso fare qualcosa come -I $ projectroot / part1 / src -I $ projectroot / part1 / inc -I $ projectroot / part2 / src ...

Se funzionasse, c'è un modo più semplice per farlo. Ho visto progetti in cui è presente un makefile in ciascuna delle parti corrispondenti? cartelle. [in questo post ho usato il punto interrogativo come nella sintassi bash]

Il modo tradizionale è quello di avere un Makefilein ciascuna delle sottodirectory ( part1, part2, ecc) che consente di costruire in modo indipendente. Inoltre, avere un Makefilenella directory principale del progetto che costruisce tutto. Il "root" Makefilesarebbe simile al seguente:

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

Poiché ogni riga in un target di make viene eseguita nella propria shell, non è necessario preoccuparsi di attraversare il backup dell'albero delle directory o verso altre directory.

Suggerisco di dare un'occhiata al manuale GNU make sezione 5.7 ; è molto utile

Se hai un codice in una sottodirectory dipendente dal codice in un'altra sottodirectory, probabilmente stai meglio con un singolo makefile al livello superiore.

Vedi Ricorsivo Rendi considerato dannoso per la logica completa, ma fondamentalmente vuoi fare in modo di avere tutte le informazioni necessarie per decidere se un file deve essere ricostruito o meno e non lo avrà se lo dici solo su un terzo di il tuo progetto.

Il link sopra sembra non essere raggiungibile. Lo stesso documento è raggiungibile qui:

• aegis.sourceforge.net
• lcgapp.cern.ch

L'opzione VPATH potrebbe rivelarsi utile, che indica quali directory cercare il codice sorgente. Tuttavia, avresti comunque bisogno di un'opzione -I per ogni percorso di inclusione. Un esempio:

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

OutputExecutable: part1api.o part2api.o part3api.o

Questo troverà automaticamente i file partXapi.cpp corrispondenti in una qualsiasi delle directory specificate da VPATH e li compilerà. Tuttavia, questo è più utile quando la directory src è suddivisa in sottodirectory. Per quello che descrivi, come altri hanno già detto, probabilmente stai meglio con un makefile per ogni parte, specialmente se ogni parte può essere isolata.

Puoi aggiungere regole al tuo Makefile di root per compilare i file cpp necessari in altre directory. L'esempio Makefile di seguito dovrebbe essere un buon inizio per portarti dove vuoi essere.

CC = g ++
TARGET = cppTest
Otherdir = .. / .. / someotherpath / in / progetto / src

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

## Termina la definizione delle fonti
INCLUDE = -I./ $ (AN_INCLUDE_DIR)  
INCLUDE = -I. $ (OTHERDIR) /../ inc
## fine include più

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

## Correggi la destinazione della dipendenza in modo che sia ../.dep relativa alla directory src
DEPENDS = $ (join $ (aggiungiuffix ../.dep/, $ (dir $ (SOURCE))), $ (notdir $ (SOURCE: .cpp = .d)))

## Regola predefinita eseguita
tutto: $ (TARGET)
        @vero

## Regola pulita
pulito:
        @ -rm -f $ (TARGET) $ (OBJ) $ (DIPENDE)


## Regola per fare il bersaglio reale
$ (TARGET): $ (OBJ)
        @echo "============="
        @echo "Collegamento dell'obiettivo $ @"
        @echo "============="
        @ $ (CC) $ (CFLAGS) -o $ @ $ ^ $ (LIBS)
        @echo - Link terminato -

## Regola di compilazione generica
% .o:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo "Compilazione $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @


## Regole per i file oggetto da file cpp
## Il file oggetto per ogni file viene inserito nella directory obj
## a un livello superiore dalla directory di origine effettiva.
../obj/%.o:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo "Compilazione $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @

# Regola per "altra directory" Ne occorrerà una per "altra" dir
$ (OTHERDIR) /../ obj /%. O:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo "Compilazione $ <"
        @ $ (CC) $ (CFLAGS) -c $ <-o $ @

## Crea regole di dipendenza
../.dep/%.d:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo Creazione del file delle dipendenze per $ *. o
        @ $ (SHELL) -ec '$ (CC) -M $ (CFLAGS) $ <| sed "s ^ $ *. o ^ .. / obj / $ *. o ^"> $ @ '

## Regola di dipendenza per la directory "altro"
$ (OTHERDIR) /../. Dep /%. D:% .cpp
        @mkdir -p $ (dir $ @)
        @echo "============="
        @echo Creazione del file delle dipendenze per $ *. o
        @ $ (SHELL) -ec '$ (CC) -M $ (CFLAGS) $ <| sed "s ^ $ *. o ^ $ (OTHERDIR) /../ obj / $ *. o ^"> $ @ '

## Includi i file delle dipendenze
-include $ (DIPENDE)

Se i sorgenti sono distribuiti in molte cartelle e ha senso avere singoli Makefile, come suggerito prima, make ricorsivo è un buon approccio, ma per i progetti più piccoli trovo più semplice elencare tutti i file sorgente nel Makefile con il loro percorso relativo al Makefile in questo modo:

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

Posso quindi impostare in VPATHquesto modo:

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

Quindi costruisco gli oggetti:

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

Ora la regola è semplice:

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

E costruire l'output è ancora più semplice:

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

Si può anche rendere VPATHautomatizzata la generazione:

VPATH := $(dir $(COMMON_SRC))

O usando il fatto che sortrimuove i duplicati (anche se non dovrebbe importare):

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

Penso che sia meglio sottolineare che l'uso di Make (ricorsivo o no) è qualcosa che di solito potresti voler evitare, perché rispetto agli strumenti di oggi, è difficile da imparare, mantenere e ridimensionare.

È uno strumento meraviglioso ma il suo uso diretto dovrebbe essere considerato obsoleto nel 2010+.

A meno che, ovviamente, non lavori in un ambiente speciale, ad esempio con un progetto legacy, ecc.

Utilizzare un IDE, CMake o, se si è fortemente animati , gli Autotools .

(modificato a causa di downvotes, ty Honza per la precisazione)

Il post di RC è stato SUPER utile. Non ho mai pensato di usare la funzione $ (dir $ @), ma ha fatto esattamente quello di cui avevo bisogno.

In parentDir, avere un sacco di directory con i file sorgente in esse: dirA, dirB, dirC. Vari file dipendono dai file oggetto in altre directory, quindi volevo essere in grado di creare un file all'interno di una directory e fare in modo che dipendesse chiamando il makefile associato a quella dipendenza.

In sostanza, ho creato un Makefile in parentDir che aveva (tra le altre cose) una regola generica simile a quella di RC:

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

Ogni sottodirectory includeva questo makefile di livello superiore per ereditare questa regola generica. Nel Makefile di ogni sottodirectory, ho scritto una regola personalizzata per ogni file in modo da poter tenere traccia di tutto ciò da cui dipendeva ogni singolo file.

Ogni volta che dovevo creare un file, ho usato (essenzialmente) questa regola per fare in modo ricorsivo tutte le dipendenze. Perfetto!

NOTA: esiste un'utilità chiamata "makepp" che sembra svolgere questo compito in modo ancora più intuitivo, ma per motivi di portabilità e non a seconda di un altro strumento, ho scelto di farlo in questo modo.

Spero che questo ti aiuti!

Uso ricorsivo di Make

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

Ciò consente makedi suddividere in lavori e utilizzare più core

Stavo cercando qualcosa del genere e dopo alcuni tentativi ho creato il mio makefile, so che non è il "modo idiomatico" ma è un inizio per capire il make e questo funziona per me, forse potresti provare nel tuo progetto.

PROJ_NAME=mono

CPP_FILES=$(shell find . -name "*.cpp")

S_OBJ=$(patsubst %.cpp, %.o, $(CPP_FILES))

CXXFLAGS=-c \
         -g \
        -Wall

all: $(PROJ_NAME)
    @echo Running application
    @echo
    @./$(PROJ_NAME)

$(PROJ_NAME): $(S_OBJ)
    @echo Linking objects...
    @g++ -o $@ $^

%.o: %.cpp %.h
    @echo Compiling and generating object $@ ...
    @g++ $< $(CXXFLAGS) -o $@

main.o: main.cpp
    @echo Compiling and generating object $@ ...
    @g++ $< $(CXXFLAGS)

clean:
    @echo Removing secondary things
    @rm -r -f objects $(S_OBJ) $(PROJ_NAME)
    @echo Done!

So che è semplice e per alcune persone le mie bandiere sono sbagliate, ma come ho già detto questo è il mio primo Makefile per compilare il mio progetto in più dir e collegarli tutti insieme per creare il mio cestino.

Accetto le sugestions: D

Suggerisco di usare autotools:

//## Posizionare i file degli oggetti generati (.o) nella stessa directory dei loro file di origine, al fine di evitare collisioni quando si utilizza make non ricorsivo.

AUTOMAKE_OPTIONS = subdir-objects

includendolo semplicemente Makefile.amcon le altre cose abbastanza semplici.

Ecco il tutorial .