Mencari perintah 'cmake clean' untuk membersihkan output CMake

419

Sama seperti make cleanmenghapus semua file yang telah dibuat makefile, saya ingin melakukan hal yang sama dengan CMake. Terlalu sering saya menemukan diri saya secara manual melalui direktori menghapus file seperti cmake_install.cmakedan CMakeCache.txt, dan CMakeFilesfolder.

Apakah ada perintah cmake cleanuntuk menghapus semua file ini secara otomatis? Idealnya ini harus mengikuti struktur rekursif yang ditentukan dalam CMakeLists.txtfile direktori saat ini .

Bill Cheatham
sumber

Jawaban:

487

Tidak ada cmake clean.

Saya biasanya membangun proyek dalam satu folder seperti "build". Jadi jika saya mau make clean, saya bisa saja rm -rf build.

Folder "build" di direktori yang sama dengan root "CMakeLists.txt" biasanya merupakan pilihan yang baik. Untuk membangun proyek Anda, Anda cukup memberikan cmake lokasi CMakeLists.txt sebagai argumen. Sebagai contoh: cd <location-of-cmakelists>/build && cmake ... (Dari @ComicSansMS)

zsxwing
sumber
101
Ini disebut "out of source build" dan harus menjadi cara yang lebih disukai. Ini menghindari bentrokan nama dan sejenisnya
Arne
17
+1 untuk bangunan di luar sumber. Ini menjadi penting ketika membangun banyak arsitektur. Misalnya, Anda tidak bisa membuat biner 64bit dan 32bit dengan in-source build, karena ini membutuhkan dua hierarki cache CMake yang terpisah.
ComicSansMS
9
Anda dapat menempatkan folder di mana pun Anda inginkan, tetapi membangun folder di direktori yang sama dengan root CMakeLists.txt biasanya merupakan pilihan yang baik. Untuk membangun Anda cukup memberikan cmake lokasi CMakeLists.txt sebagai argumen. Misalnya:cd <location-of-cmakelists>/build && cmake ..
ComicSansMS
64
Seharusnya benar-benar ada yang bersih. Setiap orang yang pernah menggunakan cmake, bahkan jika mereka terbiasa melakukan out of source build, secara tidak sengaja menjalankan cmake di direktori yang salah dan itu adalah rasa sakit yang sangat besar di pantat untuk membersihkan secara manual.
pavon
24
@DevSolar Tapi kebalikannya tidak benar; hanya karena file tidak di bawah kontrol versi tidak berarti bahwa file tersebut dibuat oleh cmake dan aman untuk dihancurkan. Memilih file tidak berversi mana yang sedang dalam proses yang perlu Anda pertahankan dan mana cmake cruft yang menyusahkan, terutama ketika sebagian besar file cmake adalah salinan / dengan nama yang sama dengan file Anda.
pavon
84

Negara bagian FAQ resmi CMake :

Beberapa build tree yang dibuat dengan autotools GNU memiliki target "make distclean" yang membersihkan build dan juga menghilangkan Makefile dan bagian lain dari sistem build yang dihasilkan. CMake tidak menghasilkan target "make distclean" karena file CMakeLists.txt dapat menjalankan skrip dan perintah sewenang-wenang; CMake tidak memiliki cara untuk melacak file mana yang dihasilkan sebagai bagian dari menjalankan CMake. Memberikan target yang jelas akan memberi pengguna kesan palsu bahwa itu akan berfungsi seperti yang diharapkan. (CMake memang menghasilkan target "bersihkan" untuk menghapus file yang dihasilkan oleh kompiler dan tautan.)

Target "make distclean" hanya diperlukan jika pengguna melakukan in-source build. CMake mendukung build in-source, tetapi kami sangat menganjurkan pengguna untuk mengadopsi gagasan build out-of-source. Menggunakan build tree yang terpisah dari tree source akan mencegah CMake menghasilkan file apa pun di tree source. Karena CMake tidak mengubah pohon sumber, tidak perlu untuk target penyaringan. Seseorang dapat memulai bangunan baru dengan menghapus pohon bangunan atau membuat pohon bangunan terpisah.

Peter
sumber
Awalnya, seperti yang diperkenalkan dan digunakan oleh autotools GNU, target 'distclean' dimaksudkan untuk membuat pohon sumber siap untuk tar dan membuat distribusi tar. Pengguna file tar seperti itu dapat mengunduh dan menghapus, lalu menjalankan 'configure' dan 'make' tanpa perlu autotool (aclocal, automake, autoconf, dll.) sumber yang dapat dibangun tanpa menginstal cmake. Namun, ini tidak berfungsi ketika generator adalah generator target tunggal (seperti target 'make'), karena konfigurasi dengan cmake terjadi sementara
Carlo Wood
... menjalankan cmake. Membuat distribusi yang tidak dapat dikonfigurasi, bahkan tidak melakukan tes platform dll, tidak berguna. Karenanya tidak ada target 'distclean' untuk cmake. cmake harus ada pada mesin pengguna akhir.
Carlo Wood
63

Di hari-hari ini di mana-mana Git, Anda mungkin lupa CMake dan gunakan git clean -d -f -x, yang akan menghapus semua file yang tidak di bawah kendali sumber.

Jean Davy
sumber
14
Itu -xpilihan meskipun. Itu trik yang sangat baik dari gitperdagangan. Meskipun saya pribadi masih akan melakukan dry-run dulu git clean -d -f -x -n,. Kadang-kadang saya menyimpan file kenyamanan yang saya gunakan untuk proyek dengan folder proyek di bawah gitkendali, tapi itu bukan sesuatu yang ingin saya bagikan dengan orang lain jadi saya tidak git addmembawanya ke proyek. Ini akan menghapus file semacam itu jika saya tidak berhati-hati untuk menambahkan -e <pattern>opsi. Pada catatan itu, alangkah baiknya jika gitmemiliki .gitcleanignorefile. :)
CivFan
1
@CivFan Anda dapat mencoba menggunakan chattr +i $filename(memerlukan izin root, tidak diizinkan untuk memodifikasi file setelah ini). Dengan cara ini git tidak akan dapat menghapus file itu bahkan jika ia mencoba melakukannya seperti rm -f.
Ruslan
3
Itu mengasumsikan in-source build, yang harus dihindari dengan sendirinya.
Slava
ini adalah solusi sederhana (dan saya tidak ingat apa artinya bendera-bendera itu, tapi itu hanya mesin dev lol).
matanster
1
Um, tetapi bagaimana dengan file yang baru ditambahkan yang pengguna lupa git add?
yugr
50

Saya meng-google-nya selama setengah jam dan satu-satunya hal berguna yang saya dapatkan adalah menjalankan findutilitas:

# 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

Juga, pastikan untuk memanggil make clean(atau generator CMake apa pun yang Anda gunakan) sebelumnya itu.

:)

Peter Mortensen
sumber
36
Saya akan merekomendasikan untuk tidak menggunakan pendekatan ini jika direktori tempat Anda bekerja berada di bawah kontrol versi: ketika saya mencoba pendekatan ini dengan svn menghapus beberapa repositori yang berfungsi file.
dimulai
8
Mungkin ada file lain yang cocok dengan cmake jadi ini benar-benar bukan pendekatan universal. Ini harus dilakukan: rm -rf CMakeFiles; rm -rf CMakeCache.txt; rm -rf cmake_install.cmake;
honza_p
1
Saya akan menghapus -exec rm -rf {} \ + dan hanya menggunakan -delete.
Edgar Aroutiounian
3
Diturunkan, karena perintah ini berpotensi menghapus beberapa file pengguna. Saya lebih suka perintah honza_p, tidak terlalu lama, lebih sederhana dan tidak terlalu berisiko.
Adrien Descamps
1
@AdrienDescamps: kecuali masih meninggalkan sampah terkait cmake di subdirektori. Saya sedang melakukan rm -rf CMakeFiles ; rm -rf */CMakeFiles ; rm -rf */*/CMakeFiles ; rm -rf */*/*/CMakeFilesdan masih belum selesai ...
SF.
35

Anda dapat menggunakan sesuatu seperti:

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)

Saya biasanya membuat perintah "make clean-all" menambahkan panggilan ke "make clean" untuk contoh sebelumnya:

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

Jangan mencoba menambahkan target "bersih" sebagai ketergantungan:

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

Karena "bersih" bukanlah target nyata di CMake dan ini tidak berhasil.

Selain itu, Anda tidak boleh menggunakan "clean-cmake-file" ini sebagai ketergantungan apa pun:

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

Karena, jika Anda melakukannya, semua file CMake akan dihapus sebelum clean-all selesai, dan make akan membuat Anda mengalami kesalahan saat mencari "CMakeFiles / clean-all.dir / build.make". Karena itu, Anda tidak dapat menggunakan perintah clean-all sebelum "apapun" dalam konteks apa pun:

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

Itu juga tidak berhasil.

Peregring-lk
sumber
Apakah ada cara untuk mengisi cmake_generated secara otomatis? Mungkin, menggabungkan ini dengan jawaban yuri.makarevich? Saat ini, ini tidak akan menghapus file di subdirektori dari $ {CMAKE_BINARY_DIR}.
foxcub
Tidak berfungsi untuk Ninja atau Visual studio. Saya tidak akan merekomendasikan pendekatan seperti itu.
usr1234567
23

Cukup mengeluarkan rm CMakeCache.txtkarya untuk saya juga.

pengguna1480788
sumber
1
Hanya menghapus variabel terkait di CMakeCache.txt juga berfungsi untuk saya.
Yorkwar
Menghapus CMakeCache.txt dan kemudian menjalankan 'cmake --build / build-path' menyebabkan 'Kesalahan: tidak dapat memuat cache'.
nenchev
1
@nenchev Anda harus lari cmake /build-pathlagi.
Samaursa
@Samaursa cmake --build jalankan kembali cmake bila diperlukan, metode ini memecah direktori build dan cmake mengeluh. Jawaban saya lebih jauh ke bawah memberitahu Anda untuk menghapus direktori CMakeFiles /, yang menyebabkan pembangunan kembali bersih dan cmake secara otomatis dijalankan kembali.
nenchev
2
@nenchev Saya mengerti maksud Anda dan saya setuju.
Samaursa
9

Mungkin agak ketinggalan jaman, tetapi karena ini adalah hit pertama ketika Anda google cmake clean, saya akan menambahkan ini:

Karena Anda dapat memulai membangun di dir membangun dengan target yang ditentukan dengan

cmake --build . --target xyz

Anda tentu saja bisa lari

cmake --build . --target clean

untuk menjalankan cleantarget di file build yang dihasilkan.

tebus
sumber
8

Saya setuju bahwa build out-of-source adalah jawaban terbaik. Tetapi untuk saat-saat ketika Anda harus melakukan in-source build, saya telah menulis skrip Python yang tersedia di sini , yang:

  1. Menjalankan "bersihkan"
  2. Menghapus file yang dihasilkan CMake tertentu di direktori tingkat atas seperti CMakeCache.txt
  3. Untuk setiap subdirektori yang berisi direktori CMakeFiles, ia menghapus CMakeFiles, Makefile, cmake_install.cmake.
  4. Menghapus semua subdirektori kosong.
tschutter
sumber
Terima kasih untuk itu. Saya ingin menambahkan baris ke skrip Anda yang hening makeketika tidak ada Makefilehadiah karena pembersihan sebelumnya (yaitu, buat skrip ini idempoten). Cukup tambahkan baris (diberi spasi dengan benar): if os.path.isfile(os.path.join(directory,'Makefile')):tepat sebelum baris 24: args = [dan tentu saja indentasi seluruh fungsi tubuh setelah baris baru ditambahkan. Ini hanya akan melakukan a make ... cleanjika Makefileada dalam direktori saat ini sedang dibersihkan. Kalau tidak, skripnya sempurna!
Michael Goldshteyn
4

Solusi yang saya temukan baru-baru ini adalah menggabungkan konsep build out-of-source dengan wrapper Makefile.

Dalam file CMakeLists.txt tingkat atas, saya menyertakan yang berikut untuk mencegah build in-source:

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

Lalu, saya membuat Makefile tingkat atas, dan termasuk yang berikut:

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

Target default alldipanggil dengan mengetik make, dan memanggil target./build/Makefile .

Hal pertama yang dilakukan target ./build/Makefileadalah membuat builddirektori menggunakan $(MKDIR), yang merupakan variabel untuk mkdir -p. Direktori buildadalah tempat kami akan melakukan pembangunan di luar sumber kami. Kami memberikan argumen -puntuk memastikan bahwa mkdirtidak berteriak kepada kami untuk mencoba membuat direktori yang mungkin sudah ada.

Hal kedua yang dilakukan target ./build/Makefileadalah mengubah direktori ke builddirektori dan menjalankannya cmake.

Kembali ke alltarget, kami memohon $(MAKE) -C build, di mana $(MAKE)variabel Makefile dihasilkan secara otomatis make. make -Cmengubah direktori sebelum melakukan apa pun. Karena itu, menggunakan $(MAKE) -C buildsama dengan melakukan cd build; make.

Untuk meringkas, memanggil pembungkus Makefile ini dengan make allatau makesetara dengan melakukan:

mkdir build
cd build
cmake ..
make 

Target distcleanmemanggil cmake .., lalu make -C build clean, dan akhirnya, menghapus semua konten dari builddirektori. Saya percaya ini adalah persis apa yang Anda minta dalam pertanyaan Anda.

Bagian terakhir dari Makefile mengevaluasi apakah target yang disediakan pengguna adalah atau tidak distclean. Jika tidak, itu akan mengubah direktori buildsebelum memanggilnya. Ini sangat kuat karena pengguna dapat mengetik, misalnya make clean, dan Makefile akan mengubahnya menjadi setaracd build; make clean .

Kesimpulannya, pembungkus Makefile ini, dalam kombinasi dengan konfigurasi CMake out-of-source wajib, membuatnya agar pengguna tidak perlu berinteraksi dengan perintah cmake. Solusi ini juga menyediakan metode yang elegan untuk menghapus semua file output CMake dari builddirektori.

PS Di Makefile, kami menggunakan awalan @untuk menekan output dari perintah shell, dan awalan @-untuk mengabaikan kesalahan dari perintah shell. Saat menggunakan rmsebagai bagian dari distcleantarget, perintah akan mengembalikan kesalahan jika file tidak ada (mereka mungkin sudah dihapus menggunakan baris perintah dengan rm -rf build, atau mereka tidak pernah dihasilkan di tempat pertama). Kesalahan pengembalian ini akan memaksa Makefile kami untuk keluar. Kami menggunakan awalan @-untuk mencegahnya. Dapat diterima jika file sudah dihapus; kami ingin Makefile kami terus berjalan dan menghapus sisanya.

Hal lain yang perlu diperhatikan: Makefile ini mungkin tidak berfungsi jika Anda menggunakan sejumlah variabel variabel CMake untuk membangun proyek Anda, misalnya cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar",. Makefile ini mengasumsikan Anda memanggil CMake dengan cara yang konsisten, baik dengan mengetik cmake ..atau dengan memberikan cmakesejumlah argumen yang konsisten (yang dapat Anda sertakan dalam Makefile Anda).

Akhirnya, kredit di mana kredit jatuh tempo. Wrapper Makefile ini diadaptasi dari Makefile yang disediakan oleh Template Proyek Aplikasi C ++ .

Hernan Villanueva
sumber
4

Tentu saja, build out-of-source adalah metode masuk ke Unix Makefiles, tetapi jika Anda menggunakan generator lain seperti Eclipse CDT, ia lebih suka Anda membangun in-source. Dalam hal ini, Anda harus membersihkan file CMake secara manual. Coba ini:

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

Atau jika Anda telah mengaktifkan globstar shopt -s globstar, coba pendekatan yang kurang menjijikkan ini sebagai gantinya:

rm -rf **/CMakeCache.txt **/*.cmake **/Makefile **/CMakeFiles
Chris Watts
sumber
Pilihan saya kemarin adalah kloning repo ke folder baru, perbarui CMakeLists.txt untuk membangun dari subfolder build. Butuh waktu sedikit lebih lama daripada perintah-perintah itu tetapi saya harus melakukannya sekali saja :)
Tien Do
4

coba gunakan: cmake --clean-first path-of-CMakeLists.txt-file -B output-dir

--clean-first: Bangun target bersihkan dulu, lalu bangun.
(Untuk membersihkan saja, gunakan --target bersih.)

赏心悦目
sumber
Cuplikan layar itu hanya menampilkan teks . Namun Anda mengambil tangkapan layar itu, memecahkan jawaban bagi siapa saja yang datang ke sini dengan pembaca layar. Silakan jatuhkan gambar itu, dan lakukan salin / tempel teks, dan luangkan 1 menit untuk memformat input itu dengan benar.
GhostCat
3

Dalam kasus di mana Anda meneruskan -Dparameter ke CMake saat membuat file build dan tidak ingin menghapus seluruh direktori build /:

Hapus saja direktori CMakeFiles / di dalam direktori build Anda.

rm -rf CMakeFiles/
cmake --build .

Ini menyebabkan CMake untuk menjalankan kembali, dan membangun file sistem dibuat ulang. Bangunan Anda juga akan mulai dari awal.

nenchev
sumber
1

Untuk menyederhanakan pembersihan saat menggunakan build "out of source" (yaitu Anda membuat dalam builddirektori), saya menggunakan skrip berikut:

$ 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

Setiap kali Anda perlu membersihkan, Anda harus mengambil skrip ini dari builddirektori:

. cmake-clean-build
Alexander Lobov
sumber
Bagus dan aman. Seperti saya, Anda mungkin memiliki direktori build dibuka di manajer file, saya sarankan mengganti cd .. ; rm ; mkdir ; cdurutan dengan cd .. ; rm -rf build/*.
Mostafa Farzán
0

Jika Anda memiliki definisi kustom dan ingin menyimpannya sebelum membersihkan, jalankan yang berikut di direktori build Anda:

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

Kemudian buat direktori build baru (atau hapus direktori build lama dan buat kembali) dan akhirnya jalankan cmakedengan argumen yang akan Anda dapatkan dengan script di atas.

Zouppen
sumber
0

Jika Anda berlari

cmake .

itu akan membuat ulang file CMake. Yang diperlukan jika Anda menambahkan file baru ke folder sumber yang dipilih oleh * .cc, misalnya.

Meskipun ini bukan "bersih" per se, itu "membersihkan" file CMake dengan membuat ulang cache.

Homer6
sumber
Itu tidak membersihkan wrt. status kompilasi: Jika 500 dari 1.200 file telah dikompilasi, setelah "cmake." itu hanya akan melanjutkan dengan 700 file terakhir.
Peter Mortensen
0

Saya menggunakan skrip shell berikut untuk tujuan tersebut:

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

Jika Anda menggunakan Windows maka gunakan Cygwin untuk skrip ini.

yanpa
sumber
0

Sangat lucu melihat pertanyaan ini mendapat begitu banyak perhatian dan solusi rumit, yang memang menunjukkan rasa sakit untuk tidak memiliki metode bersih dengan cmake.

Nah, Anda pasti bisa cd buildmengerjakannya, lalu lakukan rm -rf *ketika Anda perlu membersihkan. Namun, rm -rf *ini adalah perintah yang berbahaya mengingat banyak orang yang sering tidak tahu di mana mereka berada.

Jika Anda cd .., rm -rf builddan kemudian mkdir builddan kemudian cd build, itu terlalu banyak mengetik.

Jadi solusi yang baik adalah dengan tetap keluar dari folder build dan beri tahu cmake path:
untuk mengkonfigurasi: cmake -B build
untuk membangun: cmake --build build
untuk membersihkan: rm -rf build
untuk membuat ulang folder build: Anda bahkan tidak perlu mkdir build, cukup konfigurasikan dengan cmake -B builddan cmake akan membuatnya

jujur
sumber
0

cmakesebagian besar memasak Makefile, salah satu bisa menambahkan rmke palsu bersih .

Sebagai contoh,

[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
sumber
-1

Saya memiliki ini di file rc shell saya ( .bashrc, .zshrc):

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

Anda seharusnya menggunakannya hanya untuk build out-of-source. Katakanlah Anda memiliki direktori bernama build/untuk tujuan ini. Maka Anda hanya perlu lari t-cmake-cleandari dalamnya.

thiagowfx
sumber
-3

Saya menggunakan jawaban zsxwing dengan sukses untuk memecahkan masalah berikut:

Saya memiliki sumber yang saya bangun di beberapa host (di papan Raspberry Pi Linux, di mesin virtual VMware Linux, dll.)

Saya memiliki skrip Bash yang membuat direktori sementara berdasarkan nama host mesin seperti ini:

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

Buat direktori bangunan sementara, misalnya, build_cmake ,. Karenanya semua file build Anda akan berada di dalam folder ini.

Kemudian di file CMake utama Anda tambahkan perintah di bawah ini.

add_custom_target(clean-all
    rm -rf *
)

Oleh karena itu saat kompilasi lakukan

cmake ..

Dan untuk membersihkan lakukan:

make clean-all
Natesh
sumber
11
cara yang bagus untuk menghapus semua proyek Anda jika seseorang secara tidak sengaja membangun in-source alih-alih-out-source
3
Iya. metode ini harus digunakan hanya dengan "out of source build"
Natesh
6
Rekomendasi yang mengerikan. Seharusnya tidak ada sebagai jawaban.
Anne van Rossum
@AnnevanRossum setuju
zevarito