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


419

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 .

Odpowiedzi:


487

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)


101
Nazywa się to „kompilacją źródłową” i powinno być preferowaną drogą. To pozwala uniknąć konfliktów nazw i tym podobne
Arne

17
+1 za kompilacje spoza źródła. Staje się to niezbędne przy budowaniu wielu architektur. Na przykład, nie można zbudować zarówno 64-bitowych, jak i 32-bitowych plików binarnych za pomocą kompilacji źródłowej, ponieważ wymaga to dwóch oddzielnych hierarchii pamięci podręcznej CMake.
ComicSansMS

9
Możesz umieścić folder w dowolnym miejscu, ale folder kompilacji w tym samym katalogu co katalog główny CMakeLists.txt jest zwykle dobrym wyborem. Aby zbudować, po prostu podaj cmake lokalizację pliku CMakeLists.txt jako argument. Na przykład:cd <location-of-cmakelists>/build && cmake ..
ComicSansMS

64
Naprawdę powinien być czysty cmake. Każdy, kto kiedykolwiek używał cmake, nawet jeśli ma zwyczaj wykonywania kompilacji źródłowych, przypadkowo uruchomił cmake w niewłaściwym katalogu i ręczne czyszczenie jest ogromnym problemem.
pavon

24
@DevSolar Ale rozmowa nie jest prawdziwa; sam fakt, że plik nie podlega kontroli wersji, nie oznacza, że ​​jest generowany przez cmake i można go bezpiecznie zdmuchnąć. Wybranie, które niewersjonowane pliki są w trakcie pracy, a które są cmake cruft, jest uciążliwe, szczególnie gdy większość plików cmake jest kopiowana / podobnie nazywana do twoich plików.
pavon,

84

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.


Pierwotnie, jak wprowadzono i wykorzystano w automatycznych narzędziach GNU, celem „distclean” jest przygotowanie drzewa źródłowego do przyspieszenia i utworzenia dystrybucji tar. Tacy użytkownicy pliku tar mogą pobrać i rozpakować, a następnie uruchomić „konfiguruj” i „ twórz ” bez potrzeby korzystania z narzędzi automatycznych (aclocal, automake, autoconf itp.) Jeśli ekstrapolujemy to do cmake, wtedy „make distclean” pozostawiłby nam czystą źródło, które można zbudować bez zainstalowanego cmake. Nie działa to jednak, gdy generator był generatorem z jednym celem (ponieważ jest to cel „make”), ponieważ konfiguracja z cmake odbywa się podczas
Carlo Wood,

... uruchomiony cmake. Tworzenie dystrybucji, której nie można skonfigurować, nie wykonuje nawet testów platformy itp., Jest bezużyteczne. Stąd nie istnieje cel „distclean” dla cmake. cmake musi istnieć na komputerze użytkownika końcowego.
Carlo Wood,

63

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.


14
Ta -xopcja jednak. To doskonała sztuczka w githandlu. Chociaż ja osobiście nadal robić sucho pierwszy git clean -d -f -x -n. Co jakiś czas przechowuję plik wygody, którego używam dla projektu w folderze projektu pod gitkontrolą, ale nie chcę tego udostępniać innym, więc nie przesyłam git addgo do projektu. Spowodowałoby to zniszczenie tego rodzaju pliku, gdybym nie ostrożnie dodawał -e <pattern>opcji. Przy tej notatce byłoby miło, gdyby gitmiał .gitcleanignoreplik. :)
CivFan

1
@CivFan, którego możesz spróbować użyć chattr +i $filename(wymaga uprawnień roota, nie pozwala na modyfikację pliku po tym). W ten sposób git nie będzie w stanie usunąć tego pliku, nawet jeśli spróbuje to zrobić w podobny sposób rm -f.
Ruslan

3
Zakłada to kompilacje źródłowe, których należy unikać samodzielnie.
Slava,

to było proste rozwiązanie (i nie pamiętam, co oznaczają te flagi, ale to tylko maszyna deweloperska lol).
Matanster

1
Um, ale co z nowo dodanymi plikami, o których użytkownik zapomniał git add?
yugr

50

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.

:)


36
Odradzam stosowanie tego podejścia, jeśli katalog, w którym pracujesz, jest pod kontrolą wersji: kiedy wypróbowałem to podejście z svn, usunęło to niektóre pliki robocze repozytoriów.
bcumming

8
Mogą istnieć inne pliki pasujące do cmake, więc tak naprawdę nie jest to uniwersalne podejście. Powinno to zrobić: rm -rf CMakeFiles; rm -rf CMakeCache.txt; rm -rf cmake_install.cmake;
honza_p,

1
Chciałbym usunąć -exec rm -rf {} \ + i po prostu użyć -delete.
Edgar Aroutiounian

3
Przegłosowano, ponieważ to polecenie może potencjalnie usunąć niektóre pliki użytkownika. Wolę polecenie honza_p, nie dłuższe, prostsze i mniej ryzykowne.
Adrien Descamps

1
@AdrienDescamps: tyle, że wciąż pozostawia śmieci związane z cmake w podkatalogach. Robiłem rm -rf CMakeFiles ; rm -rf */CMakeFiles ; rm -rf */*/CMakeFiles ; rm -rf */*/*/CMakeFilesi wciąż nie skończyłem ...
SF.

35

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.


Czy istnieje sposób na automatyczne wypełnienie cmake_generated? Być może, łącząc to z odpowiedzią yuri.makarevich? Obecnie nie spowoduje to usunięcia plików z podkatalogów $ {CMAKE_BINARY_DIR}.
foxcub

Nie działa w Ninja ani Visual Studio. Nie poleciłbym takiego podejścia.
usr1234567

23

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


1
Tylko usuwanie powiązanych zmiennych w pliku CMakeCache.txt również działa dla mnie.
Yorkwar

Usunięcie pliku CMakeCache.txt, a następnie uruchomienie polecenia „cmake --build / build-path” powoduje „Błąd: nie można załadować pamięci podręcznej”.
nenchev

1
@nenchev musisz uruchomić cmake /build-pathponownie.
Samaursa

@Samaursa cmake - build uruchamia ponownie cmake w razie potrzeby, ta metoda psuje katalog kompilacji i cmake narzeka. Moja odpowiedź w dalszej części mówi o usunięciu katalogu CMakeFiles /, co powoduje czystą przebudowę i automatyczne ponowne uruchomienie cmake.
nenchev

2
@nenchev Rozumiem, co masz na myśli i zgadzam się.
Samaursa

9

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.


8

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.

Dziękuję za to. Chciałbym dodać wiersz do skryptu, który ucisza się, makegdy nie ma go z Makefilepowodu wcześniejszego wyczyszczenia (tzn. Czyni ten skrypt idempotentnym). Wystarczy dodać linię (właściwie rozmieszczoną): if os.path.isfile(os.path.join(directory,'Makefile')):tuż przed linią 24: args = [i oczywiście wciąć resztę funkcji po dodanej właśnie linii. Wykona to tylko make ... cleanwtedy, gdy a Makefilejest obecny w czyszczonym katalogu bieżącym. W przeciwnym razie skrypt jest idealny!
Michael Goldshteyn,

4

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


4

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

Wczoraj mój wybór polegał na klonowaniu repozytorium do nowego folderu, zaktualizuj plik CMakeLists.txt, aby budować z podfolderu build. Trwało to trochę dłużej niż te polecenia, ale musiałem to zrobić tylko raz :)
Tien Do

4

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


Ten zrzut ekranu pokazuje tylko tekst . Ale robisz zrzut ekranu, łamiąc odpowiedź dla każdego, kto przychodzi tutaj z czytnikiem ekranu. Upuść to zdjęcie, zrób kopię / wklej tekst i poświęć 1 minutę na prawidłowe sformatowanie tego wpisu.
GhostCat

3

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.


1

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

Ładnie i bezpiecznie. Ponieważ mogę mieć otwarty katalog kompilacji w menedżerze plików, sugeruję zamianę cd .. ; rm ; mkdir ; cdsekwencji na cd .. ; rm -rf build/*.
Mostafa Farzán

0

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.


0

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.


Nie czyści wrt. stan kompilacji: Jeśli skompilowano 500 z 1200 plików, po „cmake”. będzie po prostu kontynuować z ostatnimi 700 plikami.
Peter Mortensen,

0

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.


0

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


0

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

-1

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.


-3

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

-8

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

11
dobry sposób na usunięcie całego projektu, jeśli ktoś przypadkowo zbuduje in-source zamiast out-of-source

3
tak. z tej metody należy korzystać tylko w przypadku kompilacji „poza źródłem”
Natesh,

6
Straszna rekomendacja. Nie powinien istnieć jako odpowiedź.
Anne van Rossum

@AnnevanRossum zgadzają się
zevarito
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.