Suchen Sie nach einem Befehl 'cmake clean', um die CMake-Ausgabe zu löschen

419

So wie make cleanalle Dateien gelöscht werden, die ein Makefile erstellt hat, möchte ich dies auch mit CMake tun. Allzu oft gehe ich manuell durch Verzeichnisse und entferne Dateien wie cmake_install.cmakeund CMakeCache.txtund die CMakeFilesOrdner.

Gibt es einen Befehl cmake clean, um alle diese Dateien automatisch zu entfernen? Idealerweise sollte dies der rekursiven Struktur folgen, die in der CMakeLists.txtDatei des aktuellen Verzeichnisses definiert ist .

Bill Cheatham
quelle

Antworten:

487

Es gibt keine cmake clean.

Normalerweise baue ich das Projekt in einem einzigen Ordner wie "build". Also, wenn ich will, make cleankann ich einfach rm -rf build.

Der Ordner "build" im selben Verzeichnis wie das Stammverzeichnis "CMakeLists.txt" ist normalerweise eine gute Wahl. Um Ihr Projekt zu erstellen, geben Sie cmake einfach den Speicherort der CMakeLists.txt als Argument an. Zum Beispiel : cd <location-of-cmakelists>/build && cmake ... (Von @ComicSansMS)

zsxwing
quelle
101
Dies wird als "Out-of-Source-Build" bezeichnet und sollte der bevorzugte Weg sein. Es vermeidet Namenskonflikte und ähnliches
arne
17
+1 für Builds außerhalb der Quelle. Dies ist wichtig, wenn Sie mehrere Architekturen erstellen. Beispielsweise können Sie mit einem In-Source-Build nicht sowohl 64-Bit- als auch 32-Bit-Binärdateien erstellen, da hierfür zwei separate CMake-Cache-Hierarchien erforderlich sind.
ComicSansMS
9
Sie können den Ordner an einer beliebigen Stelle ablegen, aber ein Build-Ordner befindet sich normalerweise im selben Verzeichnis wie die Stammdatei CMakeLists.txt. Zum Erstellen geben Sie cmake einfach den Speicherort der Datei CMakeLists.txt als Argument an. Zum Beispiel:cd <location-of-cmakelists>/build && cmake ..
ComicSansMS
64
Es sollte wirklich ein cmake sauber sein. Jeder, der jemals cmake verwendet hat, auch wenn er die Gewohnheit hat, Out-of-Source-Builds auszuführen, hat cmake versehentlich im falschen Verzeichnis ausgeführt, und es ist eine große Qual, manuell aufzuräumen.
Pavon
24
@ DevSolar Aber das Gegenteil ist nicht wahr; Nur weil eine Datei nicht der Versionskontrolle unterliegt, bedeutet dies nicht, dass sie von cmake generiert wird und sicher weggeblasen werden kann. Das Heraussuchen, welche nicht versionierten Dateien in Arbeit sind, die Sie behalten müssen, und welche cmake cruft sind, ist ein Problem, insbesondere wenn viele der cmake-Dateien Kopien / ähnlich wie Ihre Dateien sind.
Pavon
84

In den offiziellen FAQ von CMake heißt es:

Einige mit GNU-Autotools erstellte Build-Bäume haben ein "make distclean" -Ziel, das den Build bereinigt und auch Makefiles und andere Teile des generierten Build-Systems entfernt. CMake generiert kein "make distclean" -Ziel, da CMakeLists.txt-Dateien Skripte und beliebige Befehle ausführen können. CMake kann nicht genau verfolgen, welche Dateien im Rahmen der Ausführung von CMake generiert werden. Das Bereitstellen eines eindeutigen Ziels würde den Benutzern den falschen Eindruck vermitteln, dass es wie erwartet funktionieren würde. (CMake generiert ein "make clean" -Ziel, um vom Compiler und Linker generierte Dateien zu entfernen.)

Ein "make distclean" -Ziel ist nur erforderlich, wenn der Benutzer einen In-Source-Build ausführt. CMake unterstützt In-Source-Builds, wir empfehlen Benutzern jedoch dringend, den Begriff eines Out-of-Source-Builds zu übernehmen. Die Verwendung eines vom Quellbaum getrennten Build-Baums verhindert, dass CMake Dateien im Quellbaum generiert. Da CMake den Quellbaum nicht ändert, ist kein eindeutiges Ziel erforderlich. Sie können einen neuen Build starten, indem Sie den Build-Baum löschen oder einen separaten Build-Baum erstellen.

Peter
quelle
Ursprünglich, wie von GNU-Autotools eingeführt und verwendet, soll das 'distclean'-Ziel den Quellbaum bereit machen, um zu tarieren und eine Teerverteilung zu erstellen. Solch eine TAR-Datei können Benutzer herunterladen und entpacken und dann 'configure' und 'make' ausführen, ohne die Autotools (aclocal, automake, autoconf usw.) zu benötigen. Wenn wir diese auf cmake extrapolieren, würde uns ein 'make distclean' sauber machen Quelle, die ohne Installation von cmake erstellt werden kann. Dies funktioniert jedoch nicht, wenn der Generator ein Einzelzielgenerator war (wie das 'make'-Ziel ist), da die Konfiguration mit cmake während
Carlo Wood
... läuft cmake. Das Erstellen einer Distribution, die nicht konfiguriert werden kann, nicht einmal Plattformtests usw. durchführt, ist nutzlos. Daher gibt es kein "distclean" -Ziel für cmake. cmake muss auf dem Computer des Endbenutzers vorhanden sein.
Carlo Wood
63

In diesen Tagen von Git überall können Sie CMake vergessen und verwenden git clean -d -f -x, wodurch alle Dateien entfernt werden, die nicht der Quellcodeverwaltung unterliegen.

Jean Davy
quelle
14
Diese -xOption jedoch. Das ist ein ausgezeichneter Trick des gitHandels. Obwohl ich persönlich immer noch zuerst einen Trockenlauf machen würde , git clean -d -f -x -n. Hin und wieder behalte ich eine Convenience-Datei, die ich für ein Projekt verwende, mit dem Projektordner unter gitKontrolle, aber ich möchte sie nicht mit anderen teilen, damit ich sie nicht git addfür das Projekt verwende. Dies würde diese Art von Datei umhauen, wenn ich nicht darauf achten würde, eine -e <pattern>Option hinzuzufügen . In diesem Sinne wäre es schön, wenn Sie giteine .gitcleanignoreDatei hätten. :)
CivFan
1
@CivFan, das Sie verwenden können chattr +i $filename(benötigt Root-Berechtigungen, erlaubt danach nicht, die Datei zu ändern). Auf diese Weise kann git diese Datei nicht entfernen, selbst wenn es versucht, dies zu tun rm -f.
Ruslan
3
Dies setzt In-Source-Builds voraus, die von sich aus zu vermeiden sind.
Slava
Dies war eine einfache Lösung (und ich kann mich nicht erinnern, was diese Flags bedeuten, aber es ist nur eine Entwicklungsmaschine lol).
Matanster
1
Ähm, aber was ist mit neu hinzugefügten Dateien, die der Benutzer vergessen hat git add?
yugr
50

Ich habe es etwa eine halbe Stunde lang gegoogelt und das einzig Nützliche, das ich mir ausgedacht habe, war das Aufrufen des findDienstprogramms:

# Find and then delete all files under current directory (.) that:
#  1. contains "cmake" (case-&insensitive) in its path (wholename)
#  2. name is not CMakeLists.txt
find . -iwholename '*cmake*' -not -name CMakeLists.txt -delete

make cleanStellen Sie außerdem sicher, dass Sie vorher (oder den von Ihnen verwendeten CMake-Generator) aufrufen .

:) :)

Peter Mortensen
quelle
36
Ich würde empfehlen, diesen Ansatz nicht zu verwenden, wenn das Verzeichnis, in dem Sie arbeiten, unter Versionskontrolle steht: Als ich diesen Ansatz mit svn ausprobierte, wurden einige der Arbeitsdateien der Repositorys entfernt.
Bcumming
8
Möglicherweise gibt es andere Dateien, die mit cmake übereinstimmen. Dies ist also kein universeller Ansatz. Dies sollte Folgendes tun: rm -rf CMakeFiles; rm -rf CMakeCache.txt; rm -rf cmake_install.cmake;
honza_p
1
Ich würde -exec rm -rf {} \ + entfernen und einfach -delete verwenden.
Edgar Aroutiounian
3
Downvoted, da dieser Befehl möglicherweise einige Benutzerdateien löschen kann. Ich bevorzuge den Befehl honza_p, nicht wirklich länger, einfacher und weniger riskant.
Adrien Descamps
1
@AdrienDescamps: außer dass noch cmake-bezogener Müll in Unterverzeichnissen verbleibt. Ich tat rm -rf CMakeFiles ; rm -rf */CMakeFiles ; rm -rf */*/CMakeFiles ; rm -rf */*/*/CMakeFilesund war immer noch nicht fertig ...
SF.
35

Sie können etwas verwenden wie:

add_custom_target(clean-cmake-files
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
)

// clean-all.cmake
set(cmake_generated ${CMAKE_BINARY_DIR}/CMakeCache.txt
                    ${CMAKE_BINARY_DIR}/cmake_install.cmake
                    ${CMAKE_BINARY_DIR}/Makefile
                    ${CMAKE_BINARY_DIR}/CMakeFiles
)

foreach(file ${cmake_generated})

  if (EXISTS ${file})
     file(REMOVE_RECURSE ${file})
  endif()

endforeach(file)

Normalerweise erstelle ich einen Befehl "make clean-all" und füge dem vorherigen Beispiel einen Aufruf von "make clean" hinzu:

add_custom_target(clean-all
   COMMAND ${CMAKE_BUILD_TOOL} clean
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
)

Versuchen Sie nicht, das "saubere" Ziel als Abhängigkeit hinzuzufügen:

add_custom_target(clean-all
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
   DEPENDS clean
)

Weil "sauber" in CMake kein echtes Ziel ist und dies nicht funktioniert.

Darüber hinaus sollten Sie diese "clean-cmake-files" nicht als Abhängigkeit von irgendetwas verwenden:

add_custom_target(clean-all
   COMMAND ${CMAKE_BUILD_TOOL} clean
   DEPENDS clean-cmake-files
)

Wenn Sie dies tun, werden alle CMake-Dateien gelöscht, bevor clean-all abgeschlossen ist, und make gibt einen Fehler bei der Suche nach "CMakeFiles / clean-all.dir / build.make" aus. Infolgedessen können Sie den Befehl clean-all in keinem Kontext vor "irgendetwas" verwenden:

add_custom_target(clean-all
   COMMAND ${CMAKE_BUILD_TOOL} clean
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
)

Das funktioniert auch nicht.

Peregring-lk
quelle
Gibt es eine Möglichkeit, cmake_generated automatisch zu füllen? Vielleicht, wenn man dies mit der Antwort von yuri.makarevich kombiniert? Derzeit werden dadurch keine Dateien in den Unterverzeichnissen von $ {CMAKE_BINARY_DIR} entfernt.
Foxcub
Funktioniert nicht für Ninja oder Visual Studio. Ich würde einen solchen Ansatz nicht empfehlen.
usr1234567
23

Einfach ausgeben rm CMakeCache.txtfunktioniert auch für mich.

user1480788
quelle
1
Nur das Löschen verwandter Variablen in CMakeCache.txt funktioniert auch für mich.
Yorkwar
Das Löschen von CMakeCache.txt und das anschließende Ausführen von 'cmake --build / build-path' führt zu 'Fehler: Cache konnte nicht geladen werden'.
Nenchev
1
@nenchev müssen Sie cmake /build-patherneut ausführen .
Samaursa
@Samaursa cmake --build führt cmake bei Bedarf erneut aus. Diese Methode unterbricht das Build-Verzeichnis und cmake beschwert sich. Meine Antwort weiter unten fordert Sie auf, das Verzeichnis CMakeFiles / zu löschen, wodurch eine saubere Neuerstellung und cmake automatisch erneut ausgeführt werden.
Nenchev
2
@nenchev Ich verstehe was du meinst und ich stimme zu.
Samaursa
9

Vielleicht ist es etwas veraltet, aber da dies der erste Treffer bei Google ist cmake clean, füge ich Folgendes hinzu:

Da können Sie einen Build im Build-Verzeichnis mit einem angegebenen Ziel mit starten

cmake --build . --target xyz

du kannst natürlich rennen

cmake --build . --target clean

um das cleanZiel in den generierten Build-Dateien auszuführen .

Redleg
quelle
8

Ich bin damit einverstanden, dass der Out-of-Source-Build die beste Antwort ist. Aber für die Zeiten , wenn Sie nur müssen ein in-Source - Build tun, ich habe einen Python - Skript zur Verfügung geschrieben hier , die:

  1. Läuft "sauber machen"
  2. Entfernt bestimmte von CMake generierte Dateien im Verzeichnis der obersten Ebene, z. B. CMakeCache.txt
  3. Für jedes Unterverzeichnis, das ein CMakeFiles-Verzeichnis enthält, werden CMakeFiles, Makefile und cmake_install.cmake entfernt.
  4. Entfernt alle leeren Unterverzeichnisse.
tschutter
quelle
Dank dafür. Ich möchte Ihrem Skript eine Zeile hinzufügen, die stummgeschaltet wird, makewenn Makefileaufgrund einer vorherigen Bereinigung keine vorhanden ist (dh dieses Skript idempotent macht). Fügen Sie einfach die Zeile (mit dem richtigen Abstand) hinzu: if os.path.isfile(os.path.join(directory,'Makefile')):direkt vor Zeile 24: args = [und rücken Sie natürlich den Rest des Funktionskörpers nach der gerade hinzugefügten Zeile ein. Dies wird nur ausgeführt, make ... cleanwenn a Makefileim aktuellen zu bereinigenden Verzeichnis vorhanden ist. Ansonsten ist das Skript perfekt!
Michael Goldshteyn
4

Eine Lösung, die ich kürzlich gefunden habe, besteht darin, das Out-of-Source-Build-Konzept mit einem Makefile-Wrapper zu kombinieren.

In meiner CMakeLists.txt-Datei der obersten Ebene füge ich Folgendes hinzu, um In-Source-Builds zu verhindern:

if ( ${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR} )
    message( FATAL_ERROR "In-source builds not allowed. Please make a new directory (called a build directory) and run CMake from there. You may need to remove CMakeCache.txt." )
endif()

Dann erstelle ich ein Makefile der obersten Ebene und füge Folgendes hinzu:

# -----------------------------------------------------------------------------
# CMake project wrapper Makefile ----------------------------------------------
# -----------------------------------------------------------------------------

SHELL := /bin/bash
RM    := rm -rf
MKDIR := mkdir -p

all: ./build/Makefile
    @ $(MAKE) -C build

./build/Makefile:
    @  ($(MKDIR) build > /dev/null)
    @  (cd build > /dev/null 2>&1 && cmake ..)

distclean:
    @  ($(MKDIR) build > /dev/null)
    @  (cd build > /dev/null 2>&1 && cmake .. > /dev/null 2>&1)
    @- $(MAKE) --silent -C build clean || true
    @- $(RM) ./build/Makefile
    @- $(RM) ./build/src
    @- $(RM) ./build/test
    @- $(RM) ./build/CMake*
    @- $(RM) ./build/cmake.*
    @- $(RM) ./build/*.cmake
    @- $(RM) ./build/*.txt

ifeq ($(findstring distclean,$(MAKECMDGOALS)),)
    $(MAKECMDGOALS): ./build/Makefile
    @ $(MAKE) -C build $(MAKECMDGOALS)
endif

Das Standardziel allwird durch Eingabe aufgerufen makeund ruft das Ziel auf ./build/Makefile.

Das erste, was das Ziel ./build/Makefiletut, ist das Erstellen des buildVerzeichnisses mit $(MKDIR), das eine Variable für ist mkdir -p. In diesem Verzeichnis führen buildwir unseren Out-of-Source-Build durch. Wir liefern das Argument, -pum sicherzustellen, dass mkdirwir nicht angeschrien werden, wenn wir versuchen, ein Verzeichnis zu erstellen, das möglicherweise bereits vorhanden ist.

Das zweite Ziel ./build/Makefiledes buildVerzeichnisses ist das Ändern der Verzeichnisse in das Verzeichnis und das Aufrufen cmake.

Zurück zum allZiel rufen wir auf $(MAKE) -C build, wo $(MAKE)eine Makefile-Variable automatisch für generiert wird make. make -Cändert das Verzeichnis, bevor Sie etwas tun. Daher ist die Verwendung $(MAKE) -C buildgleichbedeutend mit der Ausführung cd build; make.

Zusammenfassend lässt sich sagen, dass das Aufrufen dieses Makefile-Wrappers mit make alloder makegleichbedeutend ist mit:

mkdir build
cd build
cmake ..
make 

Das Ziel distcleanruft cmake ..dann auf make -C build cleanund entfernt schließlich alle Inhalte aus dem buildVerzeichnis. Ich glaube, genau das haben Sie in Ihrer Frage gefordert.

Der letzte Teil des Makefiles bewertet, ob das vom Benutzer bereitgestellte Ziel ist oder nicht distclean. Wenn nicht, werden die Verzeichnisse buildvor dem Aufrufen in geändert . Dies ist sehr leistungsfähig, da der Benutzer beispielsweise make cleaneingeben kann und das Makefile dies in ein Äquivalent von umwandelt cd build; make clean.

Zusammenfassend lässt sich sagen, dass dieser Makefile-Wrapper in Kombination mit einer obligatorischen Out-of-Source-Build-CMake-Konfiguration dafür sorgt, dass der Benutzer nie mit dem Befehl interagieren muss cmake. Diese Lösung bietet auch eine elegante Methode zum Entfernen aller CMake-Ausgabedateien aus dem buildVerzeichnis.

PS Im Makefile verwenden wir das Präfix @, um die Ausgabe eines Shell-Befehls zu unterdrücken, und das Präfix @-, um Fehler eines Shell-Befehls zu ignorieren. Bei Verwendung rmals Teil des distcleanZiels gibt der Befehl einen Fehler zurück, wenn die Dateien nicht vorhanden sind (sie wurden möglicherweise bereits über die Befehlszeile mit gelöscht rm -rf buildoder wurden überhaupt nicht generiert). Dieser Rückgabefehler zwingt unser Makefile zum Beenden. Wir verwenden das Präfix @-, um dies zu verhindern. Es ist akzeptabel, wenn eine Datei bereits entfernt wurde. Wir möchten, dass unser Makefile weitergeht und den Rest entfernt.

Beachten Sie außerdem Folgendes: Dieses Makefile funktioniert möglicherweise nicht, wenn Sie beispielsweise eine variable Anzahl von CMake-Variablen zum Erstellen Ihres Projekts verwenden cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar". Bei diesem Makefile wird davon ausgegangen, dass Sie CMake auf konsistente Weise aufrufen, entweder durch Eingabe cmake ..oder durch Bereitstellung cmakeeiner konsistenten Anzahl von Argumenten (die Sie in Ihr Makefile aufnehmen können).

Schließlich Kredit, wo Kredit fällig ist. Dieser Makefile-Wrapper wurde aus dem Makefile angepasst, das von der C ++ - Anwendungsprojektvorlage bereitgestellt wird .

Hernan Villanueva
quelle
4

Out-of-Source-Builds sind natürlich die Methode für Unix-Makefiles. Wenn Sie jedoch einen anderen Generator wie Eclipse CDT verwenden, sollten Sie lieber In-Source-Builds erstellen. In diesem Fall müssen Sie die CMake-Dateien manuell löschen. Versuche dies:

find . -name 'CMakeCache.txt' -o -name '*.cmake' -o -name 'Makefile' -o -name 'CMakeFiles' -exec rm -rf {} +

Oder wenn Sie globstar mit aktiviert haben shopt -s globstar, versuchen Sie stattdessen diesen weniger ekelhaften Ansatz:

rm -rf **/CMakeCache.txt **/*.cmake **/Makefile **/CMakeFiles
Chris Watts
quelle
Meine Wahl gestern war das Klonen von Repo in einen neuen Ordner. Aktualisieren Sie CMakeLists.txt, um es aus dem Unterordner zu erstellen build. Es dauerte etwas länger als diese Befehle, aber ich musste es nur einmal tun :)
Tien Do
4

Versuchen Sie Folgendes zu verwenden: cmake --clean-first path-of-CMakeLists.txt-file -B Ausgabeverzeichnis

--clean-first: Erst das Ziel sauber erstellen, dann erstellen.
(Verwenden Sie zum Reinigen nur --target clean.)

赏心悦目
quelle
Dieser Screenshot zeigt nur Text . Sie machen jedoch einen Screenshot davon und brechen die Antwort für jeden, der mit einem Screenreader hierher kommt. Bitte lassen Sie das Bild fallen, kopieren / fügen Sie Text ein und verbringen Sie 1 Minute damit, diese Eingabe richtig zu formatieren.
GhostCat
3

In dem Fall, wo Sie passieren -D beim Generieren der Build-Dateien Parameter an CMake übergeben und nicht den gesamten Build / das gesamte Verzeichnis löschen möchten:

Löschen Sie einfach das Verzeichnis CMakeFiles / in Ihrem Build-Verzeichnis.

rm -rf CMakeFiles/
cmake --build .

Dadurch wird CMake erneut ausgeführt und Build-Systemdateien werden neu generiert. Ihr Build wird auch von vorne beginnen.

nenchev
quelle
1

Um die Reinigung bei Verwendung von "out of source" Build zu vereinfachen (dh Sie erstellen im buildVerzeichnis), verwende ich das folgende Skript:

$ cat ~/bin/cmake-clean-build
#!/bin/bash

if [ -d ../build ]; then
    cd ..
    rm -rf build
    mkdir build
    cd build
else
    echo "build directory DOES NOT exist"
fi

Jedes Mal, wenn Sie bereinigen müssen, sollten Sie dieses Skript aus dem buildVerzeichnis beziehen:

. cmake-clean-build
Alexander Lobov
quelle
Schön und sicher. Da das Build-Verzeichnis möglicherweise im Dateimanager geöffnet ist, empfehle ich, die cd .. ; rm ; mkdir ; cdSequenz durch zu ersetzen cd .. ; rm -rf build/*.
Mostafa Farzán
0

Wenn Sie benutzerdefinierte Definitionen haben und diese vor dem Bereinigen speichern möchten, führen Sie Folgendes in Ihrem Build-Verzeichnis aus:

sed -ne '/variable specified on the command line/{n;s/.*/-D \0 \\/;p}' CMakeCache.txt

Erstellen Sie dann ein neues Build-Verzeichnis (oder entfernen Sie das alte Build-Verzeichnis und erstellen Sie es neu) und führen cmakeSie es schließlich mit den Argumenten aus, die Sie mit dem obigen Skript erhalten.

Zouppen
quelle
0

Wenn du läufst

cmake .

Die CMake-Dateien werden neu generiert. Dies ist erforderlich, wenn Sie einem Quellordner, der beispielsweise von * .cc ausgewählt wird, eine neue Datei hinzufügen.

Dies ist zwar an sich keine "Bereinigung", bereinigt jedoch die CMake-Dateien, indem die Caches neu generiert werden.

Homer6
quelle
Es reinigt nicht wrt. Kompilierungsstatus: Wenn 500 von 1200 Dateien nach "cmake" kompiliert wurden. Es wird nur mit den letzten 700 Dateien fortgesetzt.
Peter Mortensen
0

Ich benutze das folgende Shell-Skript für solche Zwecke:

#!/bin/bash

for fld in $(find -name "CMakeLists.txt" -printf '%h ')
do
    for cmakefile in CMakeCache.txt cmake_install.cmake CTestTestfile.cmake CMakeFiles Makefile
    do
        rm -rfv $fld/$cmakefile
    done
done

Wenn Sie Windows verwenden, verwenden Sie Cygwin für dieses Skript.

Yanpas
quelle
0

Es ist lustig zu sehen, dass diese Frage so viele Aufmerksamkeiten und komplizierte Lösungen erhält, was in der Tat den Schmerz zeigt, keine saubere Methode mit cmake zu haben.

Nun, Sie können definitiv cd buildIhre Arbeit erledigen und dann eine, rm -rf *wenn Sie reinigen müssen. Dies rm -rf *ist jedoch ein gefährlicher Befehl, da viele Menschen oft nicht wissen, in welcher Richtung sie sich befinden.

Wenn Sie cd .., rm -rf buildund dann mkdir buildund danncd build , das ist einfach zu viel Tipparbeit .

Eine gute Lösung ist es also, sich aus dem Build-Ordner herauszuhalten und cmake den Pfad mitzuteilen:
zu konfigurieren: cmake -B build
zu erstellen: cmake --build build
zu bereinigen: rm -rf build
Build-Ordner neu zu erstellen: Sie brauchen ihn nicht einmal mkdir build, konfigurieren Sie ihn einfach mit cmake -B buildund cmake erstellt ihn

frank
quelle
0

cmakeMeistens kocht ein Makefile, man könnte rmdem sauberen PHONY hinzufügen .

Zum Beispiel,

[root@localhost hello]# ls
CMakeCache.txt  CMakeFiles  cmake_install.cmake  CMakeLists.txt  hello  Makefile  test
[root@localhost hello]# vi Makefile
clean:
        $(MAKE) -f CMakeFiles/Makefile2 clean
        rm   -rf   *.o   *~   .depend   .*.cmd   *.mod    *.ko   *.mod.c   .tmp_versions *.symvers *.d *.markers *.order   CMakeFiles  cmake_install.cmake  CMakeCache.txt  Makefile
LinconFive
quelle
-1

Ich habe dies in meiner Shell RC-Datei ( .bashrc, .zshrc):

t-cmake-clean() {
    local BUILD=$(basename $(pwd))
    cd ..
    rm -rf $BUILD
    mkdir $BUILD && cd $BUILD
}

Sie sollten es nur für Builds außerhalb der Quelle verwenden. Angenommen, Sie haben ein Verzeichnis mit build/diesem Namen . Dann musst du nur noch t-cmake-cleanvon innen rennen .

thiagowfx
quelle
-3

Ich habe die Antwort von zsxwing erfolgreich verwendet, um das folgende Problem zu lösen:

Ich habe eine Quelle, die ich auf mehreren Hosts aufbaue (auf einer Raspberry Pi Linux-Karte, auf einer virtuellen VMware Linux-Maschine usw.)

Ich habe ein Bash-Skript, das temporäre Verzeichnisse basierend auf dem Hostnamen des Computers wie folgt erstellt:

# Get hostname to use as part of directory names
HOST_NAME=`uname -n`

# Create a temporary directory for cmake files so they don't
# end up all mixed up with the source.

TMP_DIR="cmake.tmp.$HOSTNAME"

if [ ! -e $TMP_DIR ] ; then
  echo "Creating directory for cmake tmp files : $TMP_DIR"
  mkdir $TMP_DIR
else
  echo "Reusing cmake tmp dir : $TMP_DIR"
fi

# Create makefiles with CMake
#
# Note: switch to the temporary dir and build parent 
#       which is a way of making cmake tmp files stay
#       out of the way.
#
# Note 2: to clean up cmake files, it is OK to
#        "rm -rf" the temporary directories

echo
echo Creating Makefiles with cmake ...

cd $TMP_DIR

cmake ..

# Run makefile (in temporary directory)

echo
echo Starting build ...

make
Asantanna
quelle
-8

Erstellen Sie ein temporäres Erstellungsverzeichnis, z. build_cmake . Daher befinden sich alle Ihre Build-Dateien in diesem Ordner.

Fügen Sie dann in Ihrer CMake-Hauptdatei den folgenden Befehl hinzu.

add_custom_target(clean-all
    rm -rf *
)

Daher beim Kompilieren tun

cmake ..

Und zu reinigen tun:

make clean-all
Natesh
quelle
11
Gute Möglichkeit, Ihr gesamtes Projekt zu entfernen, wenn jemand versehentlich In-Source statt Out-of-Source erstellt
3
Ja. Diese Methode sollte nur mit "Out-of-Source-Build" verwendet werden
Natesh
6
Schreckliche Empfehlung. Sollte nicht als Antwort existieren.
Anne van Rossum
@ AnnevanRossum zustimmen
Zevarito