Poszukuję polecenia „cmake clean”, aby wyczyścić dane wyjściowe CMake

Podobnie jak make cleanusuwa wszystkie pliki utworzone przez plik makefile, chciałbym zrobić to samo z CMake. Zbyt często ręcznie przeglądam katalogi usuwając pliki takie jak cmake_install.cmakei CMakeCache.txtoraz CMakeFilesfoldery.

Czy istnieje polecenie, cmake cleanaby automatycznie usunąć wszystkie te pliki? Najlepiej byłoby, gdyby podążała za strukturą rekurencyjną zdefiniowaną w CMakeLists.txtpliku bieżącego katalogu .

Nie ma cmake clean.

Zwykle buduję projekt w jednym folderze, takim jak „build”. Więc jeśli chcę make clean, mogę po prostu rm -rf build.

Folder „build” w tym samym katalogu co katalog główny „CMakeLists.txt” jest zwykle dobrym wyborem. Aby zbudować projekt, wystarczy podać cmake lokalizację pliku CMakeLists.txt jako argument. Na przykład: cd <location-of-cmakelists>/build && cmake ... (Od @ComicSansMS)

Oficjalne FAQ CMake stanowi:

Niektóre drzewa kompilacji utworzone za pomocą autotoolów GNU mają cel „make distclean”, który czyści kompilację, a także usuwa Makefile i inne części generowanego systemu kompilacji. CMake nie generuje celu „make distclean”, ponieważ pliki CMakeLists.txt mogą uruchamiać skrypty i dowolne polecenia; CMake nie ma możliwości śledzenia, które pliki są generowane w ramach działania CMake. Podanie dokładnego celu dałoby użytkownikom fałszywe wrażenie, że zadziałałoby zgodnie z oczekiwaniami. (CMake generuje cel „make clean” do usuwania plików generowanych przez kompilator i linker).

Cel „make distclean” jest konieczny tylko wtedy, gdy użytkownik wykona kompilację źródłową. CMake obsługuje kompilacje in-source, ale zdecydowanie zachęcamy użytkowników do przyjęcia koncepcji kompilacji poza-source. Użycie drzewa kompilacji oddzielnego od drzewa źródłowego uniemożliwi CMake generowanie jakichkolwiek plików w drzewie źródłowym. Ponieważ CMake nie zmienia drzewa źródłowego, nie jest potrzebny cel dystclean. Można rozpocząć nową kompilację, usuwając drzewo kompilacji lub tworząc osobne drzewo kompilacji.

W dzisiejszych czasach Gita wszędzie możesz zapomnieć o CMake i użyciu git clean -d -f -x, który usunie wszystkie pliki nie będące pod kontrolą źródła.

Przeglądałem go przez około pół godziny i jedyną przydatną rzeczą, jaką wymyśliłem, było wywołanie findnarzędzia:

# 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

Należy także pamiętać, aby wywołać make clean(lub cokolwiek CUpewnij generator używasz) przed tym.

:)

Możesz użyć czegoś takiego jak:

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)

Zwykle tworzę polecenie „make clean-all”, dodając wywołanie „make clean” do poprzedniego przykładu:

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

Nie próbuj dodawać „czystego” celu jako zależności:

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

Ponieważ „czyste” nie jest prawdziwym celem w CMake i to nie działa.

Co więcej, nie powinieneś używać tych „czystych cmake-plików” jako zależności czegokolwiek:

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

Ponieważ jeśli to zrobisz, wszystkie pliki CMake zostaną usunięte przed zakończeniem czyszczenia, a make wyświetli błąd podczas wyszukiwania „CMakeFiles / clean-all.dir / build.make”. W związku z tym nie można użyć polecenia wyczyść wszystko przed „niczym” w dowolnym kontekście:

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

To też nie działa.

Po prostu wydawanie rm CMakeCache.txtdziała również dla mnie.

Może to trochę przestarzałe, ale ponieważ jest to pierwszy hit, gdy google cmake clean , dodam to:

Ponieważ możesz rozpocząć kompilację w katalogu kompilacji z określonym celem za pomocą

cmake --build . --target xyz

oczywiście możesz biegać

cmake --build . --target clean

aby uruchomić cleancel w wygenerowanych plikach kompilacji.

Zgadzam się, że najlepsza odpowiedź to wersja spoza źródła. Ale w czasach, gdy musisz po prostu zbudować kompilację źródłową, napisałem dostępny tutaj skrypt w języku Python , który:

1. Uruchamia „make clean”
2. Usuwa określone pliki wygenerowane przez CMake w katalogu najwyższego poziomu, takim jak CMakeCache.txt
3. Dla każdego podkatalogu zawierającego katalog CMakeFiles usuwa pliki CMakeFiles, Makefile, cmake_install.cmake.
4. Usuwa wszystkie puste podkatalogi.

Rozwiązaniem, które ostatnio znalazłem, jest połączenie koncepcji kompilacji poza źródłami z pakietem Makefile.

Do mojego najwyższego poziomu pliku CMakeLists.txt dołączam następujące elementy, aby zapobiec kompilacjom źródłowym:

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

Następnie tworzę plik Makefile najwyższego poziomu i dołączam następujące elementy:

# -----------------------------------------------------------------------------
# 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

Domyślny cel alljest wywoływany przez wpisanie makei wywołuje cel./build/Makefile .

Pierwszą rzeczą, którą ./build/Makefilerobi cel , jest utworzenie buildkatalogu $(MKDIR), który jest zmienną dla mkdir -p. Katalog buildjest miejscem, w którym wykonamy naszą kompilację poza źródłami. Podajemy argument, -paby upewnić się, że mkdirnie krzyczy na nas próba stworzenia katalogu, który może już istnieć.

Drugą rzeczą, którą ./build/Makefilerobi cel , jest zmiana katalogów do buildkatalogu i wywołanie cmake.

Wracamy do allcelu, $(MAKE) -C buildgdzie wywołujemy $(MAKE)zmienną Makefile , dla której jest automatycznie generowana make. make -Czmienia katalog przed zrobieniem czegokolwiek. Dlatego używanie $(MAKE) -C buildjest równoważne działaniucd build; make .

Podsumowując, wywołanie tego opakowania Makefile za pomocą make alllub makejest równoważne z:

mkdir build
cd build
cmake ..
make 

Cel distcleanwywołuje cmake .., a następnie make -C build cleanostatecznie usuwa całą zawartość z buildkatalogu. Uważam, że dokładnie o to prosiłeś w swoim pytaniu.

Ostatni fragment pliku Makefile ocenia, czy podany przez użytkownika cel jest, czy nie distclean. Jeśli nie, zmieni katalogi na buildprzed wywołaniem. Jest to bardzo potężne, ponieważ użytkownik może na przykład pisać make clean, a Makefile przekształci go w odpowiednik cd build; make clean.

Podsumowując, to opakowanie Makefile w połączeniu z obowiązkową konfiguracją CMake kompilacji poza źródłami sprawia, że ​​użytkownik nigdy nie musi wchodzić w interakcje z poleceniem cmake. To rozwiązanie zapewnia również elegancką metodę usuwania wszystkich plików wyjściowych CMake z buildkatalogu.

PS W pliku Makefile używamy prefiksu, @aby ukryć dane wyjściowe polecenia powłoki, a prefiksu, @-aby ignorować błędy polecenia powłoki. Podczas używania rmjako elementu distcleandocelowego polecenie zwróci błąd, jeśli pliki nie istnieją (mogły zostać usunięte już przy użyciu wiersza polecenia z rm -rf buildlub nigdy nie zostały wygenerowane). Ten błąd powrotu zmusi nasz Makefile do wyjścia. Używamy przedrostka, @-aby temu zapobiec. Dopuszczalne jest, jeśli plik został już usunięty; chcemy, aby nasz Makefile kontynuował pracę i usunął resztę.

Kolejna rzecz do zapamiętania: ten plik Makefile może nie działać, jeśli na przykład używasz zmiennej liczby zmiennych CMake do zbudowania projektu cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar". Ten Makefile zakłada, że ​​wywołujesz CMake w spójny sposób, wpisując cmake ..lub podając cmakestałą liczbę argumentów (które możesz dołączyć do swojego Makefile).

Wreszcie kredyt, w którym kredyt jest należny. To opakowanie Makefile zostało zaadaptowane z pliku Makefile dostarczonego przez szablon projektu aplikacji C ++ .

Oczywiście, kompilacje poza źródłami są metodą przejścia do Uniksowych Makefile, ale jeśli używasz innego generatora, takiego jak Eclipse CDT, preferujesz kompilację w źródle. W takim przypadku musisz ręcznie wyczyścić pliki CMake. Spróbuj tego:

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

Lub jeśli włączyłeś globstar z shopt -s globstar, spróbuj zamiast tego mniej obrzydliwego podejścia:

rm -rf **/CMakeCache.txt **/*.cmake **/Makefile **/CMakeFiles

spróbuj użyć: cmake --clean-first path-of-CMakeLists.txt-file -B output-dir

--clean-first: najpierw buduj cel, a potem buduj.
(Tylko do czyszczenia użyj --target clean.)

W przypadku, gdy przekazujesz -Dparametry do CMake podczas generowania plików kompilacji i nie chcesz usuwać całego katalogu kompilacji /:

Po prostu usuń katalog CMakeFiles / z katalogu kompilacji.

rm -rf CMakeFiles/
cmake --build .

Powoduje to ponowne uruchomienie CMake i generowanie plików systemowych. Twoja kompilacja rozpocznie się również od zera.

Aby uprościć czyszczenie podczas korzystania z kompilacji „poza źródłem” (tj. Kompilujesz w buildkatalogu), używam następującego skryptu:

$ 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

Za każdym razem, gdy musisz wyczyścić, skrypt powinien pochodzić z buildkatalogu:

. cmake-clean-build

Jeśli masz niestandardowe definicje i chcesz je zapisać przed czyszczeniem, uruchom następujące polecenie w katalogu kompilacji:

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

Następnie utwórz nowy katalog kompilacji (lub usuń stary katalog kompilacji i utwórz go ponownie), a na koniec uruchom cmakez argumentami, które otrzymasz za pomocą powyższego skryptu.

Jeśli uciekniesz

cmake .

zregeneruje pliki CMake. Jest to konieczne, jeśli dodasz nowy plik do folderu źródłowego wybranego na przykład przez * .cc.

Chociaż samo w sobie nie jest to „czyste”, „oczyszcza” pliki CMake poprzez regenerację pamięci podręcznej.

Używam następującego skryptu powłoki do takich celów:

#!/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

Jeśli używasz systemu Windows, użyj Cygwin dla tego skryptu.

Zabawnie jest widzieć, że to pytanie zyskuje tak wiele uwagi i skomplikowanych rozwiązań, co w rzeczywistości pokazuje ból z powodu braku czystej metody z cmake.

Cóż, na pewno cd buildmożesz wykonać swoją pracę, a następnie zrobić to, rm -rf *kiedy musisz wyczyścić. Jednak rm -rf *jest to niebezpieczne polecenie podano, że wiele osób często nie są świadomi, które są w dir.

Jeśli ciebie cd .., rm -rf builda potem mkdir build, a potem cd build, że jest po prostu zbyt dużo typowania.

Dobrym rozwiązaniem jest po prostu pozostanie poza folderem kompilacji i poinformowanie cmake o ścieżce:
do skonfigurowania: cmake -B build
do kompilacji: cmake --build build
do czyszczenia: rm -rf build
do odtworzenia folderu kompilacji: nawet nie potrzebujesz mkdir build, po prostu skonfiguruj go, cmake -B builda cmake go utworzy

cmakegłównie gotuje Makefile, można dodać rmdo czystego PHONY .

Na przykład,

[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

Mam to w moim pliku rc powłoki ( .bashrc, .zshrc):

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

Powinieneś go używać tylko do kompilacji spoza źródła. Załóżmy, że masz katalog nazwany build/w tym celu. Musisz po prostu uciec t-cmake-cleanz tego.

Kiedyś zsxwing na odpowiedź z powodzeniem rozwiązać następujący problem:

Mam źródło, które buduję na wielu hostach (na płycie Raspberry Pi Linux, na maszynie wirtualnej VMware Linux itp.)

Mam skrypt Bash, który tworzy katalogi tymczasowe na podstawie nazwy hosta komputera w następujący sposób:

# 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

Utwórz tymczasowy katalog kompilacji, na przykład build_cmake . Dlatego wszystkie pliki kompilacji będą znajdować się w tym folderze.

Następnie w głównym pliku CMake dodaj poniższe polecenie.

add_custom_target(clean-all
    rm -rf *
)

Stąd podczas kompilacji

cmake ..

I do czyszczenia wykonaj:

make clean-all