ค้นหาคำสั่ง 'cmake clean' เพื่อล้างเอาต์พุต CMake

เช่นเดียวกับการmake cleanลบไฟล์ทั้งหมดที่ makefile ได้สร้างขึ้นมาฉันต้องการทำเช่นเดียวกันกับ CMake ทั้งหมดบ่อยเกินไปฉันพบว่าตนเองต้องผ่านไดเรกทอรีที่ลบไฟล์เช่นcmake_install.cmakeและCMakeCache.txtและCMakeFilesโฟลเดอร์

มีคำสั่งที่ต้องการcmake cleanลบไฟล์เหล่านี้โดยอัตโนมัติหรือไม่? โดยหลักการแล้วสิ่งนี้ควรเป็นไปตามโครงสร้างแบบเรียกซ้ำที่กำหนดไว้ในCMakeLists.txtไฟล์ไดเรกทอรีปัจจุบัน

cmake cleanไม่มี

ฉันมักจะสร้างโครงการในโฟลเดอร์เดียวเช่น "build" ดังนั้นถ้าผมต้องการที่จะฉันสามารถเพียงmake cleanrm -rf build

โฟลเดอร์ "build" ในไดเรกทอรีเดียวกันกับรูท "CMakeLists.txt" มักเป็นตัวเลือกที่ดี เพื่อสร้างโครงการของคุณคุณเพียงแค่ให้ CMake ตำแหน่งของ CMakeLists.txt เป็นอาร์กิวเมนต์ ตัวอย่างเช่นcd <location-of-cmakelists>/build && cmake ... (จาก @ComsSansMS)

CMakeสถานะคำถามที่พบบ่อยอย่างเป็นทางการ :

โครงสร้างการสร้างบางอย่างที่สร้างด้วยเครื่องมืออัตโนมัติของ GNU มีเป้าหมาย "make distclean" ที่ทำความสะอาดโครงสร้างและลบ Makefiles และส่วนอื่น ๆ ของระบบการสร้างที่สร้างขึ้น CMake ไม่สร้างเป้าหมาย "make distclean" เนื่องจากไฟล์ CMakeLists.txt สามารถเรียกใช้สคริปต์และคำสั่งโดยพลการ CMake ไม่มีวิธีการติดตามว่าไฟล์ใดถูกสร้างขึ้นเป็นส่วนหนึ่งของการใช้งาน CMake การให้เป้าหมายที่ผิดเพี้ยนจะทำให้ผู้ใช้เกิดการแสดงผลที่ผิดพลาดตามที่คาดหวัง (CMake สร้างเป้าหมาย "ทำให้สะอาด" เพื่อลบไฟล์ที่สร้างโดยคอมไพเลอร์และลิงเกอร์)

เป้าหมาย "make distclean" จำเป็นเฉพาะในกรณีที่ผู้ใช้ทำการ build in-source CMake สนับสนุนการสร้างในแหล่งที่มา แต่เราขอแนะนำให้ผู้ใช้ยอมรับความคิดของการสร้างนอกแหล่งที่มา การใช้โครงสร้างการสร้างที่แยกต่างหากจากแหล่งต้นไม้จะป้องกัน CMake จากการสร้างไฟล์ใด ๆ ในแหล่งต้นไม้ เนื่องจาก CMake ไม่ได้เปลี่ยนแผนผังต้นกำเนิดจึงไม่จำเป็นต้องมีเป้าหมายที่บิดเบือน หนึ่งสามารถเริ่มต้นบิลด์ใหม่โดยการลบทรีบิวด์หรือสร้างทรีบิวด์แยกต่างหาก

ในยุคของ Git ในทุกที่คุณอาจลืม CMake และใช้git clean -d -f -xซึ่งจะลบไฟล์ทั้งหมดที่ไม่ได้อยู่ภายใต้การควบคุมของแหล่งที่มา

ฉัน googled มันเหมือนครึ่งชั่วโมงและสิ่งเดียวที่มีประโยชน์ที่ฉันคิดไว้คือการเรียกใช้findยูทิลิตี้:

# 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

นอกจากนี้อย่าลืมเรียกใช้make clean(หรือเครื่องกำเนิด CMake ที่คุณใช้) ก่อนหน้านั้น

:)

คุณสามารถใช้สิ่งที่ชอบ:

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)

ฉันมักจะสร้างคำสั่ง "make clean-all" เพิ่มการเรียกไปที่ "make clean" กับตัวอย่างก่อนหน้า:

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

อย่าพยายามเพิ่มเป้าหมาย "สะอาด" เป็นการพึ่งพา:

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

เพราะ "สะอาด" ไม่ใช่เป้าหมายที่แท้จริงใน CMake และนี่ไม่ได้ผล

นอกจากนี้คุณไม่ควรใช้ "clean-cmake-files" นี้เพื่อพึ่งพาอะไร:

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

เพราะหากคุณทำเช่นนั้นไฟล์ CMake ทั้งหมดจะถูกลบก่อนที่จะล้างข้อมูลทั้งหมดเสร็จสิ้นและทำให้จะทำให้เกิดข้อผิดพลาดในการค้นหา "CMakeFiles / clean-all.dir / build.make" ดังนั้นคุณไม่สามารถใช้คำสั่ง clean-all ก่อน "อะไร" ในบริบทใด ๆ :

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

ไม่ได้ผลเช่นกัน

เพียงแค่ออกrm CMakeCache.txtผลงานให้ฉันด้วย

อาจจะล้าสมัยนิดหน่อย แต่เนื่องจากนี่เป็นเพลงฮิตครั้งแรกเมื่อคุณ google cmake cleanฉันจะเพิ่มสิ่งนี้:

เนื่องจากคุณสามารถเริ่มต้นบิลด์ใน build dir ด้วยเป้าหมายที่ระบุด้วย

cmake --build . --target xyz

คุณสามารถวิ่งได้แน่นอน

cmake --build . --target clean

เพื่อรันcleanเป้าหมายในไฟล์บิลด์ที่สร้างขึ้น

ฉันยอมรับว่าการสร้างนอกแหล่งที่มาเป็นคำตอบที่ดีที่สุด แต่สำหรับเวลาที่คุณต้องทำ build in-source ฉันได้เขียนสคริปต์ Python ที่นี่ซึ่ง:

1. ทำงาน "ทำความสะอาด"
2. ลบไฟล์ที่สร้างโดย CMake เฉพาะในไดเรกทอรีระดับบนสุดเช่น CMakeCache.txt
3. สำหรับแต่ละไดเรกทอรีย่อยที่มีไดเรกทอรี CMakeFiles จะลบ CMakeFiles, Makefile, cmake_install.cmake
4. ลบไดเรกทอรีย่อยที่ว่างเปล่าทั้งหมด

วิธีแก้ปัญหาที่ฉันพบเมื่อเร็ว ๆ นี้คือการรวมแนวคิดการสร้าง out-of-source กับตัวห่อ Makefile

ในไฟล์ CMakeLists.txt ระดับบนสุดของฉันฉันรวมสิ่งต่อไปนี้เพื่อป้องกันการสร้างในแหล่งที่มา:

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

จากนั้นฉันสร้าง Makefile ระดับบนสุดและรวมสิ่งต่อไปนี้:

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

เป้าหมายเริ่มต้นallถูกเรียกโดยการพิมพ์และเรียกเป้าหมายmake./build/Makefile

สิ่งแรกที่เป้าหมาย./build/Makefileไม่สามารถที่จะสร้างbuildไดเรกทอรีใช้ซึ่งเป็นตัวแปรสำหรับ$(MKDIR) mkdir -pไดเรกทอรีbuildเป็นที่ที่เราจะดำเนินการสร้างนอกแหล่งที่มาของเรา เราให้ข้อโต้แย้ง-pเพื่อให้แน่ใจmkdirว่าไม่ได้กรีดร้องที่เราสำหรับการสร้างไดเรกทอรีที่อาจมีอยู่แล้ว

สิ่งที่สองเป้าหมาย./build/Makefileไม่สามารถที่จะไดเรกทอรีเปลี่ยนแปลงไดเรกทอรีและเรียกbuildcmake

กลับไปที่allเป้าหมายที่เราเรียก$(MAKE) -C buildที่$(MAKE)เป็นตัวแปร Makefile makeสร้างโดยอัตโนมัติสำหรับ make -Cเปลี่ยนไดเรกทอรีก่อนทำอะไร ดังนั้นการใช้เทียบเท่ากับการทำ$(MAKE) -C buildcd build; make

ในการสรุปการโทร Makefile wrapper นี้ด้วยmake allหรือmakeเทียบเท่ากับการทำ:

mkdir build
cd build
cmake ..
make 

เป้าหมายdistcleanจะเรียกใช้cmake ..จากนั้นmake -C build cleanและสุดท้ายจะลบเนื้อหาทั้งหมดออกจากbuildไดเรกทอรี ฉันเชื่อว่านี่เป็นสิ่งที่คุณต้องการในคำถามของคุณ

ชิ้นสุดท้ายของ Makefile distcleanประเมินถ้าเป้าหมายที่ผู้ใช้ให้เป็นหรือไม่ ถ้าไม่มันจะเปลี่ยนไดเรกทอรีเป็นbuildก่อนที่จะเรียกมัน นี้จะมีประสิทธิภาพมากเพราะผู้ใช้สามารถพิมพ์ตัวอย่างเช่นmake cleanและ Makefile cd build; make cleanจะเปลี่ยนที่เป็นเทียบเท่าของ

สรุปนี้เสื้อคลุม Makefile ในการรวมกันกับออกจากแหล่งที่มาของการสร้างการกำหนดค่า CMake cmakeบังคับให้มันเพื่อให้ผู้ใช้ไม่เคยมีการโต้ตอบกับคำสั่ง โซลูชันนี้ยังให้วิธีการที่ยอดเยี่ยมในการลบไฟล์เอาต์พุต CMake ทั้งหมดออกจากbuildไดเรกทอรี

PS ใน Makefile เราใช้ส่วนนำหน้า@เพื่อยับยั้งเอาต์พุตจากคำสั่งเชลล์และส่วนนำหน้า@-เพื่อละเว้นข้อผิดพลาดจากคำสั่งเชลล์ เมื่อใช้rmเป็นส่วนหนึ่งของdistcleanเป้าหมายคำสั่งจะส่งคืนข้อผิดพลาดหากไม่มีไฟล์อยู่ (ไฟล์เหล่านั้นอาจถูกลบไปแล้วโดยใช้บรรทัดคำสั่งด้วยrm -rf buildหรือไม่เคยถูกสร้างขึ้นมาก่อน) ข้อผิดพลาดในการส่งคืนนี้จะบังคับให้ Makefile ของเราออก เราใช้ส่วนนำหน้า@-เพื่อป้องกันสิ่งนั้น เป็นที่ยอมรับหากไฟล์ถูกลบไปแล้ว เราต้องการให้ Makefile ของเราดำเนินต่อไปและนำส่วนที่เหลือออกไป

อีกสิ่งหนึ่งที่จะต้องทราบ: นี่ Makefile อาจไม่ทำงานถ้าคุณใช้จำนวนตัวแปรของตัวแปร CMake cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar"ที่จะสร้างโครงการของคุณตัวอย่างเช่น Makefile นี้สมมติว่าคุณเรียกใช้ CMake ด้วยวิธีที่สอดคล้องกันไม่ว่าจะโดยการพิมพ์cmake ..หรือโดยcmakeระบุจำนวนอาร์กิวเมนต์ที่สอดคล้องกัน (ซึ่งคุณสามารถรวมไว้ใน Makefile ของคุณ)

ในที่สุดเครดิตที่ครบกำหนดเครดิต นี้เสื้อคลุม Makefile ดัดแปลงมาจาก Makefile ที่มีให้โดยโปรแกรมประยุกต์ c ++ โครงการแม่แบบ

แน่นอนว่าการ build แบบ out-of-source เป็นวิธีการไปสู่ ​​Unix Makefiles แต่ถ้าคุณใช้ตัวสร้างอื่นเช่น Eclipse CDT มันจะแนะนำให้คุณสร้างแหล่งที่มา ในกรณีนี้คุณจะต้องทำการล้างไฟล์ CMake ด้วยตนเอง ลองสิ่งนี้:

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

หรือถ้าคุณเปิดใช้งาน globstar ด้วยshopt -s globstarลองใช้วิธีที่น่าขยะแขยงน้อยกว่าแทน:

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

ลองใช้: cmake - ทำความสะอาดเส้นทางแรกของ CMakeLists.txt-file -B output-dir

- ล้างก่อน: สร้างเป้าหมายที่สะอาดก่อนจากนั้นสร้าง
(ในการทำความสะอาดเท่านั้นใช้ - ทำความสะอาดเป้าหมาย)

ในกรณีที่คุณผ่าน -Dพารามิเตอร์ไปยัง CMake เมื่อสร้างไฟล์บิลด์และไม่ต้องการลบไฟล์ build / directory ทั้งหมด:

เพียงลบไดเรกทอรี CMakeFiles / ภายในไดเรกทอรีสร้างของคุณ

rm -rf CMakeFiles/
cmake --build .

ซึ่งทำให้ CMake รันใหม่และสร้างไฟล์ระบบใหม่ งานสร้างของคุณจะเริ่มตั้งแต่เริ่มต้น

เพื่อให้การทำความสะอาดง่ายขึ้นเมื่อใช้ build "out of source" (เช่นคุณสร้างในbuildไดเรกทอรี) ฉันใช้สคริปต์ต่อไปนี้:

$ 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

ทุกครั้งที่คุณต้องการล้างข้อมูลคุณควรแหล่งสคริปต์นี้จากbuildไดเรกทอรี:

. cmake-clean-build

หากคุณมีกำหนดเองและต้องการบันทึกก่อนที่จะทำความสะอาดเรียกใช้ต่อไปนี้ในไดเรกทอรีสร้างของคุณ:

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

จากนั้นสร้างไดเรกทอรีการสร้างใหม่ (หรือลบไดเรกทอรีการสร้างเก่าและสร้างใหม่) และในที่สุดก็รันcmakeด้วยอาร์กิวเมนต์ที่คุณจะได้รับจากสคริปต์ด้านบน

ถ้าคุณวิ่ง

cmake .

มันจะสร้างไฟล์ CMake ขึ้นมาใหม่ ซึ่งจำเป็นถ้าคุณเพิ่มไฟล์ใหม่ลงในโฟลเดอร์ซอร์สที่เลือกโดย * .cc ตัวอย่างเช่น

แม้ว่าสิ่งนี้จะไม่ "สะอาด" ต่อ se แต่จะ "ล้าง" ไฟล์ CMake ด้วยการสร้างแคชใหม่

ฉันใช้เชลล์สคริปต์ต่อไปนี้เพื่อวัตถุประสงค์ดังกล่าว:

#!/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 ให้ใช้ Cygwin สำหรับสคริปต์นี้

เป็นเรื่องตลกที่เห็นคำถามนี้ได้รับความสนใจและการแก้ปัญหาที่ซับซ้อนซึ่งแสดงให้เห็นถึงความเจ็บปวดที่ไม่มีวิธีการที่สะอาดด้วย cmake

คุณสามารถทำงานได้แน่นอนcd buildและทำrm -rf *เมื่อคุณต้องการทำความสะอาด อย่างไรก็ตามrm -rf *เป็นคำสั่งที่อันตรายเพราะหลายคนมักไม่ทราบว่าพวกเขาเป็นใคร

หากคุณcd .., rm -rf buildและจากนั้นmkdir buildแล้วcd buildว่าเป็นเพียงการพิมพ์มากเกินไป

ดังนั้นทางออกที่ดีคืออยู่ห่างจากโฟลเดอร์ build และบอก cmake เส้นทาง:
เพื่อกำหนดค่า: cmake -B build
เพื่อ build: cmake --build build
ทำความสะอาด: rm -rf build
เพื่อสร้างโฟลเดอร์ build ใหม่: คุณไม่จำเป็นต้องใช้mkdir buildเพียงแค่กำหนดค่าด้วยcmake -B buildและ cmake จะสร้างมันขึ้นมา

cmakeส่วนใหญ่พ่อครัวMakefileหนึ่งสามารถเพิ่มrmไปยังปลอมสะอาด

ตัวอย่างเช่น,

[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

ฉันมีสิ่งนี้ในไฟล์ shell rc ของฉัน ( .bashrc, .zshrc):

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

คุณควรจะใช้มันเฉพาะสำหรับการสร้างนอกแหล่งที่มา สมมติว่าคุณมีไดเรกทอรีชื่อbuild/เพื่อจุดประสงค์นี้ จากนั้นคุณก็ต้องวิ่งหนีt-cmake-cleanจากภายใน

ฉันใช้คำตอบของ zsxwingสำเร็จเพื่อแก้ปัญหาต่อไปนี้:

ฉันมีแหล่งที่ฉันสร้างขึ้นบนโฮสต์หลายแห่ง (บนกระดาน Raspberry Pi Linux, บนเครื่องเสมือน VMware Linux และอื่น ๆ )

ฉันมีสคริปต์ Bash ที่สร้างไดเรกทอรีชั่วคราวโดยใช้ชื่อโฮสต์ของเครื่องดังนี้:

# 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

สร้างไดเรกทอรีสร้างชั่วคราวตัวอย่างเช่น build_cmakeสร้างการสร้างไดเรกทอรีชั่วคราวตัวอย่างเช่นดังนั้นไฟล์บิลด์ทั้งหมดของคุณจะอยู่ในโฟลเดอร์นี้

จากนั้นในไฟล์ CMake หลักของคุณเพิ่มคำสั่งด้านล่าง

add_custom_target(clean-all
    rm -rf *
)

ดังนั้นในขณะที่รวบรวมทำ

cmake ..

และทำความสะอาดทำได้

make clean-all