Erstellen Sie Verzeichnisse mit make file

Ich bin sehr neu in Makefiles und ich möchte Verzeichnisse mit Makefile erstellen. Mein Projektverzeichnis ist so

+--Project  
   +--output  
   +--source  
     +Testfile.cpp  
   +Makefile  

Ich möchte alle Objekte und Ausgaben in den jeweiligen Ausgabeordner legen. Ich möchte eine Ordnerstruktur erstellen, die nach dem Kompilieren so aussehen würde.

+--Project
   +--output
     +--debug (or release)
       +--objs
         +Testfile.o
       +Testfile (my executable file)
   +--source
     +Testfile.cpp
   +Makefile

Ich habe es mit mehreren Optionen versucht, konnte aber nicht erfolgreich sein. Bitte helfen Sie mir, Verzeichnisse mit make file zu erstellen. Ich poste mein Makefile für Ihre Überlegung.

#---------------------------------------------------------------------
# Input dirs, names, files
#---------------------------------------------------------------------
OUTPUT_ROOT := output/

TITLE_NAME := TestProj 

ifdef DEBUG 
    TITLE_NAME += _DEBUG
else
ifdef RELEASE
    TITLE_NAME += _RELEASE
endif
endif


# Include all the source files here with the directory tree
SOURCES := \
        source/TestFile.cpp \

#---------------------------------------------------------------------
# configs
#---------------------------------------------------------------------
ifdef DEBUG
OUT_DIR     := $(OUTPUT_ROOT)debug
CC_FLAGS    := -c -Wall
else
ifdef RELEASE
OUT_DIR     := $(OUTPUT_ROOT)release
CC_FLAGS    := -c -Wall
else
$(error no build type defined)
endif
endif

# Put objects in the output directory.
OUT_O_DIR   := $(OUT_DIR)/objs

#---------------------------------------------------------------------
# settings
#---------------------------------------------------------------------
OBJS = $(SOURCES:.cpp=.o)
DIRS = $(subst /,/,$(sort $(dir $(OBJS))))
DIR_TARGET = $(OUT_DIR)

OUTPUT_TARGET = $(OUT_DIR)/$(TITLE_NAME)

CC_FLAGS +=   

LCF_FLAGS := 

LD_FLAGS := 

#---------------------------------------------------------------------
# executables
#---------------------------------------------------------------------
MD := mkdir
RM := rm
CC := g++

#---------------------------------------------------------------------
# rules
#---------------------------------------------------------------------
.PHONY: all clean title 

all: title 

clean:
    $(RM) -rf $(OUT_DIR)

$(DIR_TARGET):
    $(MD) -p $(DIRS)

.cpp.o: 
    @$(CC) -c $< -o $@

$(OBJS): $(OUT_O_DIR)/%.o: %.cpp
    @$(CC) -c $< -o $@

title: $(DIR_TARGET) $(OBJS)

Danke im Voraus. Bitte führe mich, wenn ich auch Fehler gemacht habe.

Dies würde es tun - unter der Annahme einer Unix-ähnlichen Umgebung.

MKDIR_P = mkdir -p

.PHONY: directories

all: directories program

directories: ${OUT_DIR}

${OUT_DIR}:
        ${MKDIR_P} ${OUT_DIR}

Dies müsste im Verzeichnis der obersten Ebene ausgeführt werden - oder die Definition von $ {OUT_DIR} müsste in Bezug auf den Ausführungsort korrekt sein. Wenn Sie den Edikten von Peter Millers Artikel " Recursive Make Considered Harmful " folgen, wird make natürlich trotzdem im Verzeichnis der obersten Ebene ausgeführt.

Ich spiele gerade damit (RMCH). Es musste ein wenig an die Software angepasst werden, die ich als Testgelände verwende. Die Suite verfügt über ein Dutzend separate Programme, deren Quellcode auf 15 Verzeichnisse verteilt ist, von denen einige gemeinsam genutzt werden. Aber mit ein bisschen Sorgfalt kann es gemacht werden. OTOH, es könnte für einen Neuling nicht geeignet sein.

Wie in den Kommentaren erwähnt, ist es falsch, den Befehl 'mkdir' als Aktion für 'Verzeichnisse' aufzulisten. Wie auch in den Kommentaren erwähnt, gibt es andere Möglichkeiten, um den daraus resultierenden Fehler "Weiß nicht, wie Ausgabe / Debugging ausgeführt werden soll" zu beheben. Eine besteht darin, die Abhängigkeit von der Zeile 'Verzeichnisse' zu entfernen. Dies funktioniert, weil 'mkdir -p' keine Fehler generiert, wenn alle Verzeichnisse, die erstellt werden sollen, bereits vorhanden sind. Der andere ist der gezeigte Mechanismus, der nur dann versucht, das Verzeichnis zu erstellen, wenn es nicht vorhanden ist. Die 'wie geändert' Version ist das, was ich letzte Nacht im Sinn hatte - aber beide Techniken funktionieren (und beide haben Probleme, wenn Ausgabe / Debug vorhanden ist, aber eher eine Datei als ein Verzeichnis ist).

Meiner Meinung nach sollten Verzeichnisse weder im technischen noch im gestalterischen Sinne als Ziele Ihres Makefiles betrachtet werden. Sie sollten erstellen Dateien und wenn eine Datei erstellen ein neues Verzeichnis muss dann ruhig das Verzeichnis in der Regel für die entsprechende Datei erstellen.

Wenn Sie auf eine normale oder "gemusterte" Datei abzielen, verwenden Sie einfach die makeinterne Variable $(@D), dh "das Verzeichnis, in dem sich das aktuelle Ziel befindet" (cmp. Mit $@für das Ziel). Beispielsweise,

$(OUT_O_DIR)/%.o: %.cpp
        @mkdir -p $(@D)
        @$(CC) -c $< -o $@

title: $(OBJS)

Dann machen Sie effektiv dasselbe: Erstellen Sie Verzeichnisse für alle $(OBJS), aber Sie tun es auf weniger komplizierte Weise.

Dieselbe Richtlinie (Dateien sind Ziele, Verzeichnisse niemals) wird in verschiedenen Anwendungen verwendet. Beispielsweise gitspeichert das Revisionskontrollsystem keine Verzeichnisse.

Hinweis: Wenn Sie es verwenden möchten, kann es hilfreich sein, eine Convenience-Variable einzuführen und die makeErweiterungsregeln zu verwenden.

dir_guard=@mkdir -p $(@D)

$(OUT_O_DIR)/%.o: %.cpp
        $(dir_guard)
        @$(CC) -c $< -o $@

$(OUT_O_DIR_DEBUG)/%.o: %.cpp
        $(dir_guard)
        @$(CC) -g -c $< -o $@

title: $(OBJS)

Oder KISS.

DIRS=build build/bins

... 

$(shell mkdir -p $(DIRS))

Dadurch werden alle Verzeichnisse erstellt, nachdem das Makefile analysiert wurde.

makeIn und Off selbst werden Verzeichnisziele genauso behandelt wie Dateiziele. Es ist also einfach, Regeln wie diese zu schreiben:

outDir/someTarget: Makefile outDir
    touch outDir/someTarget

outDir:
    mkdir -p outDir

Das einzige Problem dabei ist, dass der Zeitstempel des Verzeichnisses davon abhängt, was mit den darin enthaltenen Dateien gemacht wird. Für die obigen Regeln führt dies zu folgendem Ergebnis:

$ make
mkdir -p outDir
touch outDir/someTarget
$ make
touch outDir/someTarget
$ make
touch outDir/someTarget
$ make
touch outDir/someTarget

Dies ist definitiv nicht das, was Sie wollen. Wenn Sie die Datei berühren, berühren Sie auch das Verzeichnis. Und da die Datei vom Verzeichnis abhängt, scheint die Datei veraltet zu sein, sodass sie neu erstellt werden muss.

Sie können diese Schleife jedoch leicht unterbrechen, indem Sie make anweisen, den Zeitstempel des Verzeichnisses zu ignorieren . Dies erfolgt durch Deklarieren des Verzeichnisses als Voraussetzung nur für Bestellungen:

# The pipe symbol tells make that the following prerequisites are order-only
#                           |
#                           v
outDir/someTarget: Makefile | outDir
    touch outDir/someTarget

outDir:
    mkdir -p outDir

Dies ergibt richtig:

$ make
mkdir -p outDir
touch outDir/someTarget
$ make
make: 'outDir/someTarget' is up to date.

TL; DR:

Schreiben Sie eine Regel, um das Verzeichnis zu erstellen:

$(OUT_DIR):
    mkdir -p $(OUT_DIR)

Und hängen die Ziele für das darin enthaltene Material nur von der Reihenfolge des Verzeichnisses ab:

$(OUT_DIR)/someTarget: ... | $(OUT_DIR)

Alle Lösungen, einschließlich der akzeptierten, weisen einige Probleme auf, wie in den jeweiligen Kommentaren angegeben. Die akzeptierte Antwort von @ jonathan-leffler ist bereits recht gut, berücksichtigt jedoch nicht, dass die Voraussetzungen nicht unbedingt in der richtigen Reihenfolge (während) erstellt werden müssenmake -j zum Beispiel ) erstellt werden müssen. Wenn Sie jedoch einfach die directoriesVoraussetzung von verschieben, allum programbei jedem AFAICT-Lauf Neuerstellungen zu provozieren. Die folgende Lösung hat dieses Problem nicht und AFAICS funktioniert wie beabsichtigt.

MKDIR_P := mkdir -p
OUT_DIR := build

.PHONY: directories all clean

all: $(OUT_DIR)/program

directories: $(OUT_DIR)

$(OUT_DIR):
    ${MKDIR_P} $(OUT_DIR)

$(OUT_DIR)/program: | directories
    touch $(OUT_DIR)/program

clean:
    rm -rf $(OUT_DIR)

Ich habe gerade eine ziemlich vernünftige Lösung gefunden, mit der Sie die zu erstellenden Dateien definieren und Verzeichnisse automatisch erstellen lassen können. Definieren Sie zunächst eine Variable ALL_TARGET_FILES, die den Dateinamen jeder Datei enthält, die Ihr Makefile erstellen soll. Verwenden Sie dann den folgenden Code:

define depend_on_dir
$(1): | $(dir $(1))

ifndef $(dir $(1))_DIRECTORY_RULE_IS_DEFINED
$(dir $(1)):
    mkdir -p $$@

$(dir $(1))_DIRECTORY_RULE_IS_DEFINED := 1
endif
endef

$(foreach file,$(ALL_TARGET_FILES),$(eval $(call depend_on_dir,$(file))))

So funktioniert das. Ich definiere eine Funktiondepend_on_dir die einen Dateinamen annimmt und eine Regel generiert, die die Datei von dem Verzeichnis abhängig macht, in dem sie enthalten ist, und definiere dann eine Regel, um dieses Verzeichnis bei Bedarf zu erstellen. Dann benutze ich , foreachum calldiese Funktion auf jeden Dateinamen und evaldas Ergebnis.

Beachten Sie, dass Sie eine Version von GNU make benötigen, die unterstützt eval. Ich denke, es handelt sich um Versionen 3.81 und höher.

Da Sie ein Neuling sind, würde ich sagen, versuchen Sie dies noch nicht. Es ist definitiv möglich, wird aber Ihr Makefile unnötig komplizieren. Halten Sie sich an die einfachen Methoden, bis Sie sich mit make besser auskennen.

Eine Möglichkeit, ein anderes Verzeichnis als das Quellverzeichnis zu erstellen , ist VPATH . Ich bevorzuge Musterregeln

Die Unabhängigkeit des Betriebssystems ist für mich von entscheidender Bedeutung und daher mkdir -pkeine Option. Ich habe diese Reihe von Funktionen erstellt, evalmit denen Verzeichnisziele mit der Voraussetzung für das übergeordnete Verzeichnis erstellt werden. Dies hat den Vorteil, dass dies make -j 2problemlos funktioniert, da die Abhängigkeiten korrekt ermittelt werden.

# convenience function for getting parent directory, will eventually return ./
#     $(call get_parent_dir,somewhere/on/earth/) -> somewhere/on/
get_parent_dir=$(dir $(patsubst %/,%,$1))

# function to create directory targets.
# All directories have order-only-prerequisites on their parent directories
# https://www.gnu.org/software/make/manual/html_node/Prerequisite-Types.html#Prerequisite-Types
TARGET_DIRS:=
define make_dirs_recursively
TARGET_DIRS+=$1
$1: | $(if $(subst ./,,$(call get_parent_dir,$1)),$(call get_parent_dir,$1))
    mkdir $1
endef

# function to recursively get all directories 
#     $(call get_all_dirs,things/and/places/) -> things/ things/and/ things/and/places/
#     $(call get_all_dirs,things/and/places) -> things/ things/and/
get_all_dirs=$(if $(subst ./,,$(dir $1)),$(call get_all_dirs,$(call get_parent_dir,$1)) $1)

# function to turn all targets into directories
#     $(call get_all_target_dirs,obj/a.o obj/three/b.o) -> obj/ obj/three/
get_all_target_dirs=$(sort $(foreach target,$1,$(call get_all_dirs,$(dir $(target)))))

# create target dirs
create_dirs=$(foreach dirname,$(call get_all_target_dirs,$1),$(eval $(call make_dirs_recursively,$(dirname))))

TARGETS := w/h/a/t/e/v/e/r/things.dat w/h/a/t/things.dat

all: $(TARGETS)

# this must be placed after your .DEFAULT_GOAL, or you can manually state what it is
# https://www.gnu.org/software/make/manual/html_node/Special-Variables.html
$(call create_dirs,$(TARGETS))

# $(TARGET_DIRS) needs to be an order-only-prerequisite
w/h/a/t/e/v/e/r/things.dat: w/h/a/t/things.dat | $(TARGET_DIRS)
    echo whatever happens > $@

w/h/a/t/things.dat: | $(TARGET_DIRS)
    echo whatever happens > $@

Wenn Sie beispielsweise Folgendes ausführen, wird Folgendes erstellt:

$ make
mkdir w/
mkdir w/h/
mkdir w/h/a/
mkdir w/h/a/t/
mkdir w/h/a/t/e/
mkdir w/h/a/t/e/v/
mkdir w/h/a/t/e/v/e/
mkdir w/h/a/t/e/v/e/r/
echo whatever happens > w/h/a/t/things.dat
echo whatever happens > w/h/a/t/e/v/e/r/things.dat

Siehe https://www.oreilly.com/library/view/managing-projects-with/0596006101/ch12.html

REQUIRED_DIRS = ...
_MKDIRS := $(shell for d in $(REQUIRED_DIRS); \
             do                               \
               [[ -d $$d ]] || mkdir -p $$d;  \
             done)

$(objects) : $(sources)

Da ich Ubuntu verwende, musste ich dies auch oben in meinem Makefile hinzufügen:

SHELL := /bin/bash # Use bash syntax