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

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 .

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)

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.

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.

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 .

:) :)

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.

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

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 .

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.

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 .

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

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.)

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.

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

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.

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.

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.

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

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

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 .

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

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