CMake çıktısını temizlemek için bir 'cmake clean' komutu arıyorum

Nasıl make cleanbir makefile tarafından üretilen tüm dosyaları siler, ben de CMake ile aynı şeyi yapmak istiyorum. Çoğu zaman kendimi manuel gibi dosyaları kaldırarak dizinleri geçiyor bulmak cmake_install.cmakeve CMakeCache.txtve CMakeFilesklasörler.

cmake cleanTüm bu dosyaları otomatik olarak kaldırmak gibi bir komut var mı ? İdeal olarak bu, geçerli dizinin CMakeLists.txtdosyasında tanımlanan özyinelemeli yapıyı izlemelidir .

Yok cmake clean.

Ben genellikle projeyi "derleme" gibi tek bir klasörde oluştururum Eğer istersem make clean, yapabilirim rm -rf build.

Kök "CMakeLists.txt" ile aynı dizindeki "build" klasörü genellikle iyi bir seçimdir. Projenizi oluşturmak için cake'e CMakeLists.txt dosyasının yerini bağımsız değişken olarak vermeniz yeterlidir. Örneğin: cd <location-of-cmakelists>/build && cmake ... (@ComicSansMS'ten)

C Resmi SSS ifadelerini belirtin :

GNU otoklavları ile oluşturulan bazı yapı ağaçları, yapıyı temizleyen ve aynı zamanda Makefiles'i ve oluşturulan yapı sisteminin diğer kısımlarını kaldıran bir "belirsiz hale getirme" hedefine sahiptir. CMakeLists.txt dosyaları komut dosyalarını ve rasgele komutları çalıştırabildiğinden, CMake "belirsiz hale getir" hedefi oluşturmaz; CMake, CMake'i çalıştırmanın bir parçası olarak hangi dosyaların oluşturulduğunu tam olarak izleyemez. Belirsiz bir hedef sağlamak, kullanıcılara beklendiği gibi çalışacağı konusunda yanlış bir izlenim bırakacaktır. (CMake, derleyici ve bağlayıcı tarafından oluşturulan dosyaları kaldırmak için "temizle" hedefi oluşturur.)

"İyileştirme yap" hedefi, yalnızca kullanıcı kaynakta bir derleme gerçekleştirirse gereklidir. CMake, kaynak içi derlemeleri destekler, ancak kullanıcıları kaynak dışı derleme kavramını benimsemeleri için şiddetle teşvik ediyoruz. Kaynak ağacından ayrı bir yapı ağacı kullanmak, CMake'in kaynak ağacında herhangi bir dosya oluşturmasını engeller. CMake kaynak ağacını değiştirmediğinden, belirsiz bir hedefe gerek yoktur. Yapı ağacını silerek veya ayrı bir yapı ağacı oluşturarak yeni bir yapı başlatılabilir.

Git'in bu günlerinde her yerde, git clean -d -f -xkaynak kontrolü altında olmayan tüm dosyaları kaldıracak olan CMake'i ve kullanımını unutabilirsiniz .

Ben yarım saat gibi googled ve ben geldi tek yararlı şey findyardımcı programı çağırmak oldu :

# 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

Ayrıca, olmak emin çağırmak için make clean(veya CKağıt jeneratör kullandığınız her ne ise) önce o.

:)

Şöyle bir şey kullanabilirsiniz:

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)

Genellikle bir önceki örneğe "temiz kılmak" için bir çağrı ekleyerek bir "tüm temiz-yapmak" komutu oluşturmak:

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

"Temiz" hedefi bağımlı olarak eklemeyi denemeyin:

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

Çünkü "temiz" CMake'de gerçek bir hedef değildir ve bu işe yaramaz.

Ayrıca, bu "temiz-cmake dosyalarını" hiçbir şeye bağımlı olarak kullanmamalısınız:

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

Çünkü bunu yaparsanız, tüm CMake dosyaları clean-all tamamlanmadan silinecek ve make size "CMakeFiles / clean-all.dir / build.make" aramasında hata verecektir. Sonuç olarak, "all" komutundan önce clean-all komutunu hiçbir bağlamda kullanamazsınız:

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

Bu da işe yaramıyor.

Sadece rm CMakeCache.txtbenim için de çalışmalar yapmak.

Belki biraz modası geçmiş, ama bu google ilk hit olduğundan cmake clean, ben ekleyeceğim:

Yapı dizininde belirtilen bir hedefle bir derleme başlatabildiğiniz için

cmake --build . --target xyz

tabii ki koşabilirsin

cmake --build . --target clean

cleanoluşturulan derleme dosyalarında hedefi çalıştırmak için .

Kaynak dışı derlemenin en iyi yanıt olduğunu kabul ediyorum. Ama sadece kaynak içi bir yapı yapmanız gerektiğinde, burada bulunan bir Python betiği yazdım :

1. "Temiz" çalışır
2. CMakeCache.txt gibi üst düzey dizinde CMake'nin oluşturduğu belirli dosyaları kaldırır
3. CMakeFiles dizini içeren her alt dizin için CMakeFiles, Makefile, cmake_install.cmake öğesini kaldırır.
4. Tüm boş alt dizinleri kaldırır.

Son zamanlarda bulduğum bir çözüm, kaynak dışı derleme konseptini Makefile sarıcı ile birleştirmektir.

Üst düzey CMakeLists.txt dosyamda, kaynak içi derlemeleri önlemek için aşağıdakileri ekliyorum:

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

Sonra, bir üst düzey Makefile oluşturmak ve aşağıdakileri dahil:

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

Varsayılan hedef allyazılarak makeçağrılır ve hedefi çağırır ./build/Makefile.

Hedefin ./build/Makefileyaptığı ilk şey, değişken olan builddizini oluşturmaktır . Dizin , kaynak dışı derlememizi gerçekleştireceğimiz yerdir. Zaten var olabilecek bir dizin oluşturmaya çalıştığımız için bize çığlık atmamasını sağlamak için argüman sağlıyoruz .$(MKDIR)mkdir -pbuild-pmkdir

Hedefin ./build/Makefileyaptığı ikinci şey, dizinleri dizine değiştirmek buildve çağırmaktır cmake.

allHedefe geri dönersek $(MAKE) -C build, $(MAKE)otomatik olarak oluşturulan bir Makefile değişkeni nerede olur make. make -Cherhangi bir şey yapmadan önce dizini değiştirir. Bu nedenle, kullanmak $(MAKE) -C buildyapmakla eşdeğerdir cd build; make.

Özetlemek gerekirse, bu Makefile sarmalayıcısını make allveya makeile eşdeğer olarak adlandırmak:

mkdir build
cd build
cmake ..
make 

Hedef distcleançağırır cmake .., sonra make -C build cleanve son olarak, tüm içerikleri kaldırır builddizine. Sorunuzda tam olarak istediğiniz bu olduğuna inanıyorum.

Makefile'nin son parçası, kullanıcı tarafından sağlanan hedefin olup olmadığını değerlendirir distclean. Değilse, buildçağırmadan önce dizinleri değiştirir . Bu çok güçlü çünkü kullanıcı örneğin yazabilir make cleanve Makefile bunu eşdeğerine dönüştürecektir cd build; make clean.

Sonuç olarak, bu Makefile sarıcı, zorunlu bir kaynak dışı derleme CMake yapılandırması ile birlikte, kullanıcının komutla asla etkileşime girmemesi için bunu yapar cmake. Bu çözüm ayrıca tüm CMake çıktı dosyalarını dizinden kaldırmak için zarif bir yöntem sağlar build.

PS Makefile'de, @bir kabuk komutundan çıktıyı bastırmak için önekini ve bir kabuk komutundan @-hataları yoksaymak için önekini kullanırız. Hedefin bir rmparçası olarak kullanıldığında distclean, dosyalar yoksa komut bir hata döndürür (komut satırı kullanılarak zaten silinmiş olabilir rm -rf buildveya ilk etapta hiç oluşturulmamış olabilir). Bu dönüş hatası Makefile'mızı çıkmaya zorlayacaktır. Bunu @-önlemek için öneki kullanıyoruz . Bir dosyanın zaten kaldırılmış olması kabul edilebilir; Makefile'mizin devam etmesini ve gerisini kaldırmasını istiyoruz.

Dikkat edilmesi gereken başka bir şey: Örneğin, projenizi oluşturmak için değişken sayıda CMake değişkeni kullanırsanız bu Makefile çalışmayabilir cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar". Bu Makefile, CMake'i yazarak cmake ..veya cmaketutarlı sayıda argüman (Makefile'nize ekleyebileceğiniz) sağlayarak tutarlı bir şekilde çağırdığınızı varsayar .

Son olarak, kredi vadesi gelen kredi. Bu Makefile sarmalayıcısı, C ++ Application Project Template tarafından sağlanan Makefile'den uyarlanmıştır .

Tabii ki, kaynak dışı derlemeler Unix Makefiles için go-to yöntemidir, ancak Eclipse CDT gibi başka bir jeneratör kullanıyorsanız, kaynakta inşa etmenizi tercih eder. Bu durumda, CMake dosyalarını manuel olarak temizlemeniz gerekir. Bunu dene:

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

Veya globstar'ı ile etkinleştirdiyseniz shopt -s globstar, bunun yerine bu daha az iğrenç yaklaşımı deneyin:

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

kullanmaya çalışın: cmake - CMakeLists.txt dosyasının file-bean-first yolu -B output-dir

--clean-first: Önce temiz hedef oluşturun, sonra oluşturun.
(Yalnızca temizlemek için --target clean kullanın.)

Geçtiğiniz durumda -D yapı dosyaları üretmek ve tüm yapı / dizini silmek istemiyorsanız CMake içine parametreleri:

Yapı dizininizdeki CMakeFiles / dizinini silmeniz yeterlidir.

rm -rf CMakeFiles/
cmake --build .

Bu CMake'nin yeniden çalışmasına neden olur ve derleme sistem dosyaları yeniden oluşturulur. Yapınız sıfırdan başlayacak.

"Kaynak dışı" yapı (yani, builddizinde oluşturmak ) kullanırken temizleme kolaylaştırmak için aşağıdaki komut dosyası kullanın:

$ 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

Her temizlemeniz gerektiğinde, bu komut dosyasını dizinden kaynaklamalısınız build:

. cmake-clean-build

Özel tanımlarınız varsa ve temizlemeden önce bunları kaydetmek istiyorsanız, derleme dizininizde aşağıdakileri çalıştırın:

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

Ardından yeni bir derleme dizini oluşturun (veya eski derleme dizinini kaldırın ve yeniden oluşturun) ve son olarak cmakeyukarıdaki komut dosyasıyla alacağınız bağımsız değişkenlerle çalıştırın .

Eğer koşarsan

cmake .

CMake dosyalarını yeniden oluşturur. Örneğin, * .cc tarafından seçilen bir kaynak klasöre yeni bir dosya eklerseniz bu gereklidir.

Bu kendi başına bir "temiz" olmasa da, önbellekleri yeniden oluşturarak CMake dosyalarını "temizler".

Bu tür amaçlar için aşağıdaki kabuk komut dosyası kullanın:

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

Windows kullanıyorsanız, bu komut dosyası için Cygwin'i kullanın.

Bu sorunun çok fazla dikkat ve karmaşık çözümler aldığını görmek komik, bu da cmake ile temiz bir yönteme sahip olmamak için acı çekiyor.

Peki, kesinlikle işinizi yapabilir cd build, sonra rm -rf *temizlemeniz gereken bir zaman yapabilirsiniz . Ancak,rm -rf * birçok insanın hangi direkte bulunduğunun farkında olmadığı göz önüne alındığında tehlikeli bir komuttur.

Eğer cd .., rm -rf builddaha sonra mkdir buildve daha sonracd build , bu sadece çok fazla yazarak bu.

Bu yüzden iyi bir çözüm sadece derleme klasöründen uzak durup cmake yoluna:
yapılandırmak için: derlemek: derlemek cmake -B build
: cmake --build build
temizlemek: rm -rf build
derlemek klasörü yeniden oluşturmak: hatta gerek yok mkdir build, sadece yapılandırın cmake -B buildve cmake oluşturacak

cmakeçoğunlukla aşçılar Makefile, tek ekleyebilir rmiçin temiz sahte .

Örneğin,

[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

Bu benim kabuk rc dosya ( .bashrc, .zshrc) var:

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

Yalnızca kaynak dışı derlemeler için kullanmanız gerekir . Diyelim ki build/bu amaçla bir dizininiz var . O zaman sadece t-cmake-cleaniçinden kaçmak zorundasın .

Kullandığım en zsxwing cevabı şu sorunu çözmek için başarıyla:

Birden fazla ana bilgisayarda oluşturduğum bir kaynağım var (Raspberry Pi Linux panosunda, VMware Linux sanal makinesinde, vb.)

Bu gibi makinenin ana bilgisayar adına dayalı geçici dizinler oluşturan bir Bash komut dosyası var:

# 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

Örneğin, geçici bir oluşturma dizini oluşturun build_cmake . Bu nedenle tüm derleme dosyalarınız bu klasörün içinde olacaktır.

Daha sonra ana CMake dosyanıza aşağıdaki komutu ekleyin.

add_custom_target(clean-all
    rm -rf *
)

Böylece derleme yapmak

cmake ..

Ve temizlemek için:

make clean-all