Tìm kiếm lệnh 'cmake clean' để xóa đầu ra CMake

Cũng giống như make cleanxóa tất cả các tệp mà makefile đã tạo, tôi muốn làm tương tự với CMake. Tôi thường thấy mình đi qua các thư mục loại bỏ các tệp như cmake_install.cmakevà CMakeCache.txtvà các CMakeFilesthư mục theo cách thủ công .

Có một lệnh như cmake cleanđể loại bỏ tất cả các tập tin tự động? Lý tưởng nhất là theo cấu trúc đệ quy được xác định trong CMakeLists.txttệp của thư mục hiện tại .

Không có cmake clean.

Tôi thường xây dựng dự án trong một thư mục duy nhất như "xây dựng". Vì vậy, nếu tôi muốn make clean, tôi có thể rm -rf build.

Thư mục "xây dựng" trong cùng thư mục với thư mục gốc "CMakeLists.txt" thường là một lựa chọn tốt. Để xây dựng dự án của bạn, bạn chỉ cần cung cấp cho cmake vị trí của CMakeLists.txt làm đối số. Ví dụ : cd <location-of-cmakelists>/build && cmake ... (Từ @ComicSansMS)

Câu hỏi thường gặp chính thức của CMake :

Một số cây xây dựng được tạo bằng autotools GNU có mục tiêu "tạo ra sự khác biệt" để dọn sạch bản dựng và cũng loại bỏ Makefiles và các phần khác của hệ thống xây dựng được tạo. CMake không tạo mục tiêu "make distclean" vì các tệp CMakeLists.txt có thể chạy các tập lệnh và các lệnh tùy ý; CMake không có cách theo dõi chính xác những tập tin nào được tạo ra như là một phần của việc chạy CMake. Cung cấp một mục tiêu không rõ ràng sẽ mang lại cho người dùng ấn tượng sai lầm rằng nó sẽ hoạt động như mong đợi. (CMake không tạo mục tiêu "làm sạch" để xóa các tệp được tạo bởi trình biên dịch và trình liên kết.)

Mục tiêu "make distclean" chỉ cần thiết nếu người dùng thực hiện xây dựng trong nguồn. CMake hỗ trợ các bản dựng trong nguồn, nhưng chúng tôi khuyến khích người dùng chấp nhận khái niệm về bản dựng ngoài nguồn. Sử dụng cây xây dựng tách biệt với cây nguồn sẽ ngăn CMake tạo bất kỳ tệp nào trong cây nguồn. Vì CMake không thay đổi cây nguồn, nên không cần mục tiêu phân biệt. Người ta có thể bắt đầu xây dựng mới bằng cách xóa cây xây dựng hoặc tạo một cây xây dựng riêng.

Trong những ngày này của Git ở mọi nơi, bạn có thể quên CMake và sử dụng git clean -d -f -x, điều đó sẽ xóa tất cả các tệp không thuộc quyền kiểm soát nguồn.

Tôi đã googled nó trong nửa giờ và điều hữu ích duy nhất tôi nghĩ ra là gọi findtiện ích:

# 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

Ngoài ra, hãy chắc chắn gọi make clean(hoặc bất kỳ trình tạo CMake nào bạn đang sử dụng) trước đó.

:)

Bạn có thể sử dụng một cái gì đó như:

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)

Tôi thường tạo một lệnh "make clean-all" thêm một lệnh gọi để "làm sạch" vào ví dụ trước:

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

Đừng cố thêm mục tiêu "sạch" như một sự phụ thuộc:

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

Bởi vì "sạch" không phải là mục tiêu thực sự trong CMake và điều này không hoạt động.

Ngoài ra, bạn không nên sử dụng "tệp sạch-cmake" này như là sự phụ thuộc của bất cứ điều gì:

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

Bởi vì, nếu bạn làm điều đó, tất cả các tệp CMake sẽ bị xóa trước khi xóa tất cả hoàn tất và sẽ khiến bạn gặp lỗi khi tìm kiếm "CMakeFiles / clean-all.dir / build.make". Do đó, bạn không thể sử dụng lệnh Clean-all trước "mọi thứ" trong bất kỳ ngữ cảnh nào:

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

Điều đó cũng không hoạt động.

Đơn giản chỉ cần phát hành rm CMakeCache.txtcông việc cho tôi quá.

Có thể nó hơi lỗi thời, nhưng vì đây là lần truy cập đầu tiên khi bạn google cmake clean, tôi sẽ thêm điều này:

Vì bạn có thể bắt đầu xây dựng trong thư mục xây dựng với một mục tiêu được chỉ định với

cmake --build . --target xyz

tất nhiên bạn có thể chạy

cmake --build . --target clean

để chạy cleanmục tiêu trong các tệp xây dựng được tạo.

Tôi đồng ý rằng bản dựng ngoài nguồn là câu trả lời tốt nhất. Nhưng đối với những lần bạn chỉ cần thực hiện một bản dựng trong nguồn, tôi đã viết một tập lệnh Python có sẵn ở đây , trong đó:

1. Chạy "làm sạch"
2. Xóa các tệp do CMake tạo cụ thể trong thư mục cấp cao nhất, chẳng hạn như CMakeCache.txt
3. Đối với mỗi thư mục con chứa thư mục CMakeFiles, nó sẽ loại bỏ CMakeFiles, Makefile, cmake_install.cmake.
4. Loại bỏ tất cả các thư mục con trống.

Một giải pháp mà tôi tìm thấy gần đây là kết hợp khái niệm xây dựng ngoài nguồn với trình bao bọc Makefile.

Trong tệp CMakeLists.txt cấp cao nhất của tôi, tôi bao gồm các mục sau để ngăn các bản dựng trong nguồn:

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

Sau đó, tôi tạo một Makefile cấp cao nhất và bao gồm các mục sau:

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

Mục tiêu mặc định allđược gọi bằng cách gõ makevà gọi mục tiêu ./build/Makefile.

Điều đầu tiên mà mục tiêu ./build/Makefilethực hiện là tạo buildthư mục bằng cách sử dụng $(MKDIR), đây là một biến cho mkdir -p. Thư mục buildlà nơi chúng tôi sẽ thực hiện việc xây dựng ngoài nguồn. Chúng tôi cung cấp đối số -pđể đảm bảo rằng mkdirkhông hét lên với chúng tôi vì đã cố gắng tạo một thư mục có thể đã tồn tại.

Điều thứ hai mục tiêu ./build/Makefilelàm là thay đổi thư mục vào buildthư mục và gọi cmake.

Quay lại allmục tiêu, chúng tôi gọi $(MAKE) -C build, $(MAKE)biến Makefile được tạo tự động ở đâu make. make -Cthay đổi thư mục trước khi làm bất cứ điều gì. Do đó, sử dụng $(MAKE) -C buildlà tương đương với làm cd build; make.

Để tóm tắt, hãy gọi trình bao bọc Makefile này bằng make allhoặc maketương đương với việc thực hiện:

mkdir build
cd build
cmake ..
make 

Mục tiêu distcleangọi cmake .., sau đó make -C build clean, và cuối cùng, loại bỏ tất cả nội dung khỏi buildthư mục. Tôi tin rằng đây chính xác là những gì bạn yêu cầu trong câu hỏi của bạn.

Phần cuối cùng của Makefile sẽ đánh giá xem mục tiêu do người dùng cung cấp có hay không distclean. Nếu không, nó sẽ thay đổi thư mục thành buildtrước khi gọi nó. Điều này rất mạnh bởi vì người dùng có thể gõ, ví dụ make clean, và Makefile sẽ biến nó thành tương đương cd build; make clean.

Tóm lại, trình bao bọc Makefile này, kết hợp với cấu hình CMake xây dựng ngoài nguồn bắt buộc, làm cho nó để người dùng không bao giờ phải tương tác với lệnh cmake. Giải pháp này cũng cung cấp một phương thức thanh lịch để loại bỏ tất cả các tệp đầu ra CMake khỏi buildthư mục.

PS Trong Makefile, chúng tôi sử dụng tiền tố @để chặn đầu ra từ lệnh shell và tiền tố @-để bỏ qua lỗi từ lệnh shell. Khi sử dụng rmnhư một phần của distcleanmục tiêu, lệnh sẽ trả về lỗi nếu các tệp không tồn tại (chúng có thể đã bị xóa bằng cách sử dụng dòng lệnh với rm -rf buildhoặc chúng không bao giờ được tạo ở vị trí đầu tiên). Lỗi trả về này sẽ buộc Makefile của chúng ta thoát. Chúng tôi sử dụng tiền tố @-để ngăn chặn điều đó. Có thể chấp nhận nếu một tệp đã bị xóa; chúng tôi muốn Makefile của chúng tôi tiếp tục và loại bỏ phần còn lại.

Một điều cần lưu ý: Makefile này có thể không hoạt động nếu bạn sử dụng một số lượng biến CMake khác nhau để xây dựng dự án của bạn, ví dụ , cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar". Makefile này giả định rằng bạn gọi CMake theo cách nhất quán, bằng cách nhập cmake ..hoặc bằng cách cung cấp cmakemột số lượng đối số nhất quán (mà bạn có thể đưa vào Makefile của mình).

Cuối cùng, tín dụng nơi tín dụng đến hạn. Trình bao bọc Makefile này được điều chỉnh từ Makefile được cung cấp bởi Mẫu dự án ứng dụng C ++ .

Tất nhiên, các bản dựng ngoài nguồn là phương thức dành cho Unix Makefiles, nhưng nếu bạn đang sử dụng một trình tạo khác như Eclipse CDT, thì nó thích bạn xây dựng trong nguồn hơn. Trong trường hợp đó, bạn sẽ cần phải lọc các tệp CMake theo cách thủ công. Thử cái này:

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

Hoặc nếu bạn đã kích hoạt toàn cầu shopt -s globstar, thay vào đó, hãy thử phương pháp ít kinh tởm này:

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

thử sử dụng: cmake --clean-first path-of-CMakeLists.txt-file -B output-dir

--clean-first: Xây dựng mục tiêu sạch trước, sau đó xây dựng.
(Để chỉ dọn dẹp, hãy sử dụng --target sạch.)

Trong trường hợp bạn chuyển -Dtham số vào CMake khi tạo tệp xây dựng và không muốn xóa toàn bộ thư mục build /:

Chỉ cần xóa thư mục CMakeFiles / trong thư mục bản dựng của bạn.

rm -rf CMakeFiles/
cmake --build .

Điều này khiến CMake chạy lại và xây dựng các tệp hệ thống được tạo lại. Bản dựng của bạn cũng sẽ bắt đầu từ đầu.

Để đơn giản hóa việc dọn dẹp khi sử dụng bản dựng "ngoài nguồn" (tức là bạn xây dựng trong buildthư mục), tôi sử dụng tập lệnh sau:

$ 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

Mỗi khi bạn cần dọn dẹp, bạn nên lấy tập lệnh này từ buildthư mục:

. cmake-clean-build

Nếu bạn có định nghĩa tùy chỉnh và muốn lưu chúng trước khi dọn dẹp, hãy chạy phần sau trong thư mục bản dựng của bạn:

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

Sau đó tạo thư mục xây dựng mới (hoặc xóa thư mục bản dựng cũ và tạo lại thư mục đó) và cuối cùng chạy cmakevới các đối số bạn sẽ nhận được với tập lệnh ở trên.

Nếu bạn chạy

cmake .

nó sẽ tạo lại các tập tin CMake. Điều này là cần thiết nếu bạn thêm một tệp mới vào thư mục nguồn được chọn bởi * .cc chẳng hạn.

Mặc dù đây không phải là "sạch" theo từng se, nhưng nó sẽ "dọn sạch" các tệp CMake bằng cách tạo lại bộ đệm.

Tôi sử dụng kịch bản shell sau đây cho các mục đích như vậy:

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

Nếu bạn đang sử dụng Windows thì hãy sử dụng Cygwin cho tập lệnh này.

Thật buồn cười khi thấy câu hỏi này nhận được rất nhiều sự quan tâm và giải pháp phức tạp, điều này thực sự cho thấy một nỗi đau khi không có một phương pháp sạch với cmake.

Vâng, bạn chắc chắn có thể cd buildlàm bạn làm việc, sau đó làm một rm -rf *khi bạn cần làm sạch. Tuy nhiên, rm -rf *là một lệnh nguy hiểm được đưa ra mà nhiều người thường không biết họ đang ở đâu.

Nếu bạn cd .., rm -rf buildvà sau đó mkdir buildvà sau đó cd build, đó chỉ là quá nhiều gõ.

Vì vậy, một giải pháp tốt là chỉ cần ở ngoài thư mục xây dựng và nói với cmake đường dẫn:
to configure: cmake -B build
to build: cmake --build build
to clean: rm -rf build
để tạo lại thư mục build: bạn thậm chí không cần mkdir build, chỉ cần cấu hình với cmake -B buildvà cmake sẽ tạo ra nó

cmakechủ yếu là nấu một Makefile, người ta có thể thêm rmvào PHONY sạch .

Ví dụ,

[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

Tôi có cái này trong tập tin shell shell của tôi ( .bashrc, .zshrc):

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

Bạn có nghĩa vụ phải sử dụng nó chỉ cho out-of-nguồn xây dựng. Giả sử bạn có một thư mục được đặt tên build/cho mục đích này. Sau đó, bạn chỉ cần chạy t-cmake-cleantừ bên trong nó.

Tôi đã sử dụng câu trả lời của zsxwing thành công để giải quyết vấn đề sau:

Tôi có nguồn mà tôi xây dựng trên nhiều máy chủ (trên bo mạch Raspberry Pi Linux, trên máy ảo VMware Linux, v.v.)

Tôi có một tập lệnh Bash tạo các thư mục tạm thời dựa trên tên máy chủ của máy như thế này:

# 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

Tạo một thư mục xây dựng tạm thời, ví dụ , build_cmake. Do đó tất cả các tệp xây dựng của bạn sẽ nằm trong thư mục này.

Sau đó, trong tệp CMake chính của bạn thêm lệnh dưới đây.

add_custom_target(clean-all
    rm -rf *
)

Do đó trong khi biên dịch làm

cmake ..

Và để làm sạch:

make clean-all