Mencari perintah 'cmake clean' untuk membersihkan output CMake

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 .

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)

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.

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.

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.

:)

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.

Cukup mengeluarkan rm CMakeCache.txtkarya untuk saya juga.

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.

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.

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

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

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

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.

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

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.

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.

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.

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

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

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.

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

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