CMake आउटपुट को क्लियर करने के लिए 'cmake clean' कमांड की तलाश है

Question

जिस तरह make cleanएक फाइलफिल ने सभी फाइलों को हटा दिया है, मैं सीएमके के साथ भी ऐसा ही करना चाहूंगा। सब भी अक्सर मैं अपने आप को मैन्युअल रूप से की तरह फ़ाइलों को हटाने निर्देशिका के माध्यम से जा पाते हैं cmake_install.cmakeऔर CMakeCache.txt, और CMakeFilesफ़ोल्डरों।

क्या cmake cleanइन सभी फाइलों को स्वचालित रूप से हटाने के लिए एक कमांड है ? आदर्श रूप में यह वर्तमान निर्देशिका की CMakeLists.txtफ़ाइल में परिभाषित पुनरावर्ती संरचना का पालन करना चाहिए ।

Answer 1

नहीं है cmake clean।

मैं आमतौर पर "बिल्ड" जैसे एकल फ़ोल्डर में प्रोजेक्ट का निर्माण करता हूं। इसलिए अगर मैं चाहता हूं make clean, तो मैं कर सकता हूं rm -rf build।

रूट "CMakeLists.txt" के समान निर्देशिका में "बिल्ड" फ़ोल्डर आमतौर पर एक अच्छा विकल्प है। अपनी परियोजना का निर्माण करने के लिए, आप बस CMakeLists.txt के स्थान को एक तर्क के रूप में बताएं। उदाहरण के लिए cd <location-of-cmakelists>/build && cmake ..:। (@ComicSansMS से)

Comments

इसे "आउट ऑफ सोर्स बिल्ड" कहा जाता है और इसे जाने का पसंदीदा तरीका होना चाहिए। यह नाम संघर्ष से बचा जाता है और जैसे

— आर्नी

आउट-ऑफ-सोर्स बनाता है के लिए +1। कई आर्किटेक्चर बनाते समय यह महत्वपूर्ण हो जाता है। उदाहरण के लिए, आप एक इन-सोर्स बिल्ड के साथ 64 बिट और 32 बिट दोनों बायनेरिज़ का निर्माण नहीं कर सकते हैं, क्योंकि इसके लिए दो अलग-अलग सीएमके कैश पदानुक्रमों की आवश्यकता होती है।

— कॉमिकसंस

आप कहीं भी फ़ोल्डर को अपनी इच्छानुसार रख सकते हैं, लेकिन मूल CMakeLists.txt के समान निर्देशिका में बिल्ड फ़ोल्डर आमतौर पर एक अच्छा विकल्प होता है। आप बस एक तर्क के रूप में CMakeLists.txt के स्थान cmake दे निर्माण करने के लिए। उदाहरण के लिए:cd <location-of-cmakelists>/build && cmake ..

— ComicSansMS

वहाँ वास्तव में एक cmake साफ होना चाहिए। हर कोई जो कभी भी cmake का उपयोग करता है, भले ही वे स्रोत बिल्ड से बाहर करने की आदत रखते हों, गलती से गलत डायरेक्टरी में cmake चला लेते हैं और मैन्युअल रूप से सफाई करने के लिए गधे में भारी दर्द होता है।

— पावन

@DevSolar लेकिन कायल सच नहीं है; सिर्फ इसलिए कि कोई फ़ाइल संस्करण नियंत्रण में नहीं है, इसका मतलब यह नहीं है कि यह cmake द्वारा बनाई गई है और उड़ाने के लिए सुरक्षित है। यह पता लगाने के लिए कि कौन-सी फ़ालतू फाइलें काम में हैं, जिन्हें आप रखने की ज़रूरत है और जो कि सीमेक क्रफ़्ट हैं, वे एक दर्द है, खासकर तब जब ज़्यादातर सीमेक फ़ाइलों की कॉपी / इसी तरह आपकी फ़ाइलों के नाम हों।

— पावन

Answer 2

सीएमके आधिकारिक पूछे जाने वाले प्रश्न :

जीएनयू ऑटोटूल के साथ बनाए गए कुछ बिल्ड पेड़ों में "मेक डिस्टक्लेन" लक्ष्य होता है जो बिल्ड को साफ करता है और मेकफाइल्स और उत्पन्न बिल्ड सिस्टम के अन्य हिस्सों को भी हटा देता है। CMake "डिस्टेकलियन" लक्ष्य उत्पन्न नहीं करता है क्योंकि CMakeLists.txt फाइलें स्क्रिप्ट और मनमाना कमांड चला सकती हैं; CMake के पास ट्रैकिंग का कोई तरीका नहीं है कि कौन सी फाइलें रनिंग CMake के हिस्से के रूप में उत्पन्न होती हैं। डिस्टलियन लक्ष्य प्रदान करने से उपयोगकर्ताओं को यह गलत धारणा मिलेगी कि यह अपेक्षा के अनुरूप काम करेगा। (संकलक कंपाइलर और लिंकर द्वारा उत्पन्न फाइलों को हटाने के लिए "सीक क्लीन" लक्ष्य उत्पन्न करता है।)

यदि उपयोगकर्ता इन-सोर्स बिल्ड करता है, तो "मेक डिस्टक्लाइन" लक्ष्य केवल आवश्यक है। सीएमके इन-सोर्स बिल्ड का समर्थन करता है, लेकिन हम उपयोगकर्ताओं को आउट-ऑफ-सोर्स बिल्ड की धारणा को अपनाने के लिए दृढ़ता से प्रोत्साहित करते हैं। स्रोत ट्री से अलग एक बिल्ड ट्री का उपयोग करने से सीएमके को सोर्स ट्री में किसी भी फाइल को बनाने से रोका जा सकेगा। क्योंकि सीएमके स्रोत के पेड़ को नहीं बदलता है, इसलिए एक लक्ष्य लक्ष्य की आवश्यकता नहीं है। एक बिल्ड बिल्ड को हटाकर या एक अलग बिल्ड ट्री बनाकर एक नया निर्माण शुरू कर सकते हैं।

Comments

मूल रूप से, जैसा कि जीएनयू ऑटोटूलस द्वारा पेश और उपयोग किया जाता है, 'डिस्टलियन' लक्ष्य का उद्देश्य स्रोत पेड़ को टार वितरण करने और टार वितरण बनाने के लिए तैयार करना है। ऐसे टार फ़ाइल उपयोगकर्ता डाउनलोड कर सकते हैं और अनटार्ट कर सकते हैं और फिर ऑटोटूल (aclocal, automake, autoconf, इत्यादि) की आवश्यकता के बिना 'कॉन्फ़िगर' और 'मेक' चला सकते हैं। यदि हम उस सीमेक को एक्सट्रपलेट करते हैं तो एक 'डिस्टक्लाइन' हमें एक साफ सुथरा बना देगा। स्रोत जो बिना cmake स्थापित किए बनाया जा सकता है। हालाँकि, यह तब काम नहीं करता है जब जनरेटर एकल-लक्ष्य जनरेटर था (जैसा कि 'मेक' टारगेट है), क्योंकि सेमीक के साथ कॉन्फ़िगरेशन होता है जबकि

— कार्लो वुड

... cmake चल रहा है। ऐसा वितरण करना जो कॉन्फ़िगर नहीं किया जा सकता है, प्लेटफ़ॉर्म परीक्षण आदि भी नहीं करता है, बेकार है। इसलिए सीमेके के लिए 'डिस्टेंकियन' लक्ष्य मौजूद नहीं है। अंतिम उपयोगकर्ता की मशीन पर मौजूद होने के लिए cmake की आवश्यकता होती है।

— कार्लो वुड

Answer 3

हर जगह गिट के इन दिनों में, आप सीएमके को भूल सकते हैं और उपयोग कर सकते हैं git clean -d -f -x, जो सभी फाइलों को स्रोत नियंत्रण में नहीं हटा देगा।

Comments

वह -xविकल्प हालांकि। यह व्यापार की एक उत्कृष्ट चाल है git। हालांकि मैं व्यक्तिगत रूप से अभी भी एक सूखी रन पहले, होगा git clean -d -f -x -n। हर एक बार थोड़ी देर में मैं एक परियोजना के लिए एक सुविधा फ़ाइल का उपयोग करता हूं जिसे मैं प्रोजेक्ट फ़ोल्डर के साथ gitनियंत्रण में रखता हूं, लेकिन यह ऐसा कुछ नहीं है जिसे मैं दूसरों के साथ साझा करना चाहता हूं इसलिए मैं git addइस परियोजना के लिए नहीं । अगर मैं एक -e <pattern>विकल्प जोड़ने के लिए सावधान नहीं था तो यह उस तरह की फ़ाइल को उड़ा देगा । कि नोट पर, यह अच्छा होगा अगर gitएक था .gitcleanignoreफ़ाइल। :)

— CivFan

@CivFan का उपयोग करके आप कोशिश कर सकते हैं chattr +i $filename(रूट अनुमतियों की आवश्यकता है, इसके बाद फ़ाइल को संशोधित करने की अनुमति नहीं देता है)। इस तरह git उस फ़ाइल को हटाने में सक्षम नहीं होगा, भले ही वह इसे करने की कोशिश करे rm -f।

— रुस्लान

इन-सोर्स बनाता है, जो खुद से बचा जाना है।

— स्लाव

यह एक सरल समाधान था (और मुझे उन झंडों का मतलब नहीं है, लेकिन यह सिर्फ एक देव यंत्र है)।

— मैटैनस्टर

उम, लेकिन उन नई जोड़ी गई फ़ाइलों के बारे में जो उपयोगकर्ता भूल गए git add?

— युगर

Answer 4

मैंने इसे आधे घंटे तक गुज़ारा और एकमात्र उपयोगी चीज़ जो मैं लेकर आया था, 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(या जो भी सीएमके जनरेटर आप उपयोग कर रहे हैं) से पहले आह्वान करना सुनिश्चित करें ।

:)

Comments

यदि आप जिस निर्देशिका में काम कर रहे हैं वह इस संस्करण के नियंत्रण के तहत है, तो मैं इस दृष्टिकोण का उपयोग करने की सलाह दूंगा: जब मैंने svn के साथ इस दृष्टिकोण की कोशिश की तो इसमें कुछ रिपोजिटरी काम करने वाली फाइलों को हटा दिया गया।

— bcumming

Cmake से मेल खाने वाली अन्य फाइलें हो सकती हैं इसलिए यह वास्तव में एक सार्वभौमिक दृष्टिकोण नहीं है। यह करना चाहिए: rm -rf CMakeFiles; rm -rf CMakeCache.txt; rm -rf cmake_install.cmake;

— ०४

मैं -exec rm -rf {} \ + निकाल दूंगा और केवल -delete का उपयोग करूंगा।

— एडगर अरौटियूनियन

डाउनवोट किया गया है, क्योंकि यह कमांड संभावित रूप से कुछ उपयोगकर्ता फ़ाइलों को हटा सकता है। मैं honza_p कमांड पसंद करता हूं, वास्तव में लंबा नहीं, सरल और कम जोखिम भरा।

— एड्रियन डेसकम्प्स

@ AdrienDescamps: सिवाय इसके अभी भी उपनिर्देशिका में cmake- संबंधित कबाड़ छोड़ देता है। मैं कर रहा था rm -rf CMakeFiles ; rm -rf */CMakeFiles ; rm -rf */*/CMakeFiles ; rm -rf */*/*/CMakeFilesऔर अभी भी नहीं किया गया था ...

— एस एफ।

Answer 5

आप कुछ का उपयोग कर सकते हैं जैसे:

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)

मैं आमतौर पर एक "क्लीन-ऑल" कमांड बनाता हूं, जो पिछले उदाहरण के लिए "क्लीन बनाने" के लिए कॉल जोड़ता है:

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
)

क्योंकि सीएमके में "क्लीन" वास्तविक लक्ष्य नहीं है और यह काम नहीं करता है।

इसके अलावा, आपको इस "क्लीन-सेमी-फाइल्स" का उपयोग किसी भी चीज की निर्भरता के रूप में नहीं करना चाहिए:

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

क्योंकि, यदि आप ऐसा करते हैं, तो सभी सीएमके फाइलें साफ होने से पहले ही मिटा दी जाएंगी-सब पूरा हो गया है, और आपको "CMakeFiles / clean-all.dir / build.make" की खोज करने में त्रुटि हो जाएगी। परिणाम में, आप किसी भी संदर्भ में "कुछ भी" से पहले क्लीन-ऑल कमांड का उपयोग नहीं कर सकते हैं:

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

वह भी काम नहीं करता है।

Comments

क्या cmake_generated को स्वचालित रूप से भरने का एक तरीका है? शायद, इसे यूरी.मकरैविच के जवाब के साथ जोड़ दिया जाए? वर्तमान में, यह $ {CMAKE_BINARY_DIR} के उपनिर्देशिकाओं में फ़ाइलों को नहीं निकालेगा।

— foxcub

निंजा या विज़ुअल स्टूडियो के लिए काम नहीं करता है। मैं इस तरह के दृष्टिकोण की सिफारिश नहीं करूंगा।

— usr1234567

Answer 6

बस rm CMakeCache.txtमेरे लिए भी काम जारी करता है।

Comments

केवल CMakeCache.txt में संबंधित चर को हटाना मेरे लिए भी काम करता है।

— यॉर्कवार

CMakeCache.txt को हटाना और फिर 'cmake --build / build-path' चलाने के कारण 'त्रुटि: कैश लोड नहीं कर सका'।

— नन्हेंहेव

@nenchev आपको cmake /build-pathफिर से चलाने की आवश्यकता है ।

— समरसा

@Samaursa cmake - जरूरत पड़ने पर reruns cmake का निर्माण करते हैं, यह विधि बिल्ड डायरेक्टरी को तोड़ती है और cmake शिकायत करती है। मेरा उत्तर आगे आपको CMakeFiles / निर्देशिका को हटाने के लिए कहता है, जो फिर से साफ करने के लिए एक साफ पुनर्निर्माण और cmake का कारण बनता है।

— nenchev

@nenchev मैं देख रहा हूं कि आपका क्या मतलब है और मैं सहमत हूं।

— समरसा

Answer 7

हो सकता है कि यह थोड़ा पुराना हो, लेकिन जब से यह पहली हिट है जब आप Google cmake clean, मैं इसे जोड़ूंगा:

चूंकि आप एक निर्दिष्ट लक्ष्य के साथ बिल्ड डीआईआर में एक निर्माण शुरू कर सकते हैं

cmake --build . --target xyz

आप बेशक दौड़ सकते हैं

cmake --build . --target clean

cleanउत्पन्न बिल्ड फ़ाइलों में लक्ष्य को चलाने के लिए ।

Answer 8

मैं मानता हूं कि आउट-ऑफ-सोर्स बिल्ड सबसे अच्छा जवाब है। लेकिन उस समय के लिए जब आपको बस एक इन-सोर्स बिल्ड करना होगा, मैंने यहां उपलब्ध पायथन स्क्रिप्ट लिखी है , जो:

1. रन "साफ करें"
2. CMakeCache.txt जैसे शीर्ष-स्तरीय निर्देशिका में विशिष्ट CMake-जनरेट की गई फ़ाइलों को निकालता है
3. प्रत्येक उपनिर्देशिका जिसमें CMakeFiles निर्देशिका है, के लिए यह CMakeFiles, Makefile, cmake_install.cmake को हटा देता है।
4. सभी खाली उपनिर्देशिकाओं को निकालता है।

Comments

उसके लिए धन्यवाद। मैं आपकी स्क्रिप्ट में एक पंक्ति जोड़ना चाहूंगा कि makeजब कोई Makefileपूर्व स्वच्छ होने के कारण उपस्थित नहीं होता है, तो मौन रहता है (यानी, इस स्क्रिप्ट को सुखद बनाता है)। बस लाइन जोड़ें (ठीक से फैला हुआ): if os.path.isfile(os.path.join(directory,'Makefile')):लाइन 24 से ठीक पहले: args = [और निश्चित रूप से लाइन के बाद फ़ंक्शन के बाकी हिस्से को जोड़ दें। यह केवल एक ही प्रदर्शन करेगा make ... cleanयदि Makefileवर्तमान निर्देशिका में मौजूद है साफ किया जा रहा है। अन्यथा, स्क्रिप्ट एकदम सही है!

— माइकल गोल्डसेन

Answer 9

एक समाधान जो मैंने हाल ही में पाया है वह मेकफाइल आवरण के साथ आउट-ऑफ-सोर्स बिल्ड अवधारणा को संयोजित करना है।

मेरे शीर्ष-स्तरीय 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()

फिर, मैं एक शीर्ष-स्तरीय मेकफाइल बनाता हूं, और इसमें निम्नलिखित शामिल हैं:

# -----------------------------------------------------------------------------
# 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यह है कि निर्देशिका को निर्देशिका में बदलना buildऔर आह्वान करना है cmake।

allलक्ष्य पर वापस , हम आह्वान करते हैं $(MAKE) -C build, जहां $(MAKE)एक मेकफाइल चर स्वचालित रूप से के लिए उत्पन्न होता है make। make -Cकुछ भी करने से पहले निर्देशिका को बदल देता है। इसलिए, का उपयोग करने $(MAKE) -C buildके बराबर है cd build; make।

संक्षेप में, इस मेकफाइल रैपर को कॉल करना make allया करने makeके बराबर है:

mkdir build
cd build
cmake ..
make 

लक्ष्य distcleanका आह्वान cmake ..है, तो make -C build clean, और अंत में, से सभी सामग्री को हटा buildनिर्देशिका। मेरा मानना ​​है कि यह वही है जो आपने अपने प्रश्न में अनुरोध किया था।

Makefile का अंतिम टुकड़ा मूल्यांकन करता है कि उपयोगकर्ता द्वारा प्रदान किया गया लक्ष्य है या नहीं distclean। यदि नहीं, तो यह buildलागू करने से पहले निर्देशिकाओं को बदल देगा । यह बहुत शक्तिशाली है क्योंकि उपयोगकर्ता टाइप कर सकता है, उदाहरण के लिए make clean, और मेकफाइल इसे एक समकक्ष में बदल देगा cd build; make clean।

अंत में, यह मेकफाइल रैपर एक अनिवार्य आउट-ऑफ-सोर्स बिल्ड सीएमके कॉन्फ़िगरेशन के साथ संयोजन में बनाता है, ताकि उपयोगकर्ता को कमांड के साथ कभी भी बातचीत न करनी पड़े cmake। यह समाधान buildनिर्देशिका से सभी CMake आउटपुट फ़ाइलों को हटाने के लिए एक सुरुचिपूर्ण विधि भी प्रदान करता है ।

PS मेकफाइल में, हम @शेल कमांड से आउटपुट को दबाने के लिए उपसर्ग का उपयोग करते हैं , और @-शेल कमांड से त्रुटियों को अनदेखा करने के लिए उपसर्ग । लक्ष्य के rmहिस्से के रूप में उपयोग करते समय distclean, कमांड एक त्रुटि लौटाएगा यदि फाइलें मौजूद नहीं हैं (वे कमांड लाइन का उपयोग करके पहले ही हटा दिया गया हो सकता है rm -rf build, या वे पहली बार में उत्पन्न नहीं हुए थे)। यह वापसी त्रुटि हमारे Makefile को बाहर निकलने के लिए मजबूर करेगी। @-इसे रोकने के लिए हम उपसर्ग का उपयोग करते हैं । यह स्वीकार्य है यदि एक फ़ाइल पहले ही हटा दी गई थी; हम चाहते हैं कि हमारा मेकफाइल चलता रहे और बाकी को हटाया जाए।

एक और बात ध्यान दें: यदि आप अपनी परियोजना का निर्माण करने के लिए सीएमके चर का एक चर संख्या का उपयोग करते हैं, तो यह मेकफाइल काम नहीं कर सकता है, उदाहरण के लिए cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar"। यह मेकफाइल आपको सीएमके को सुसंगत तरीके से, या तो टाइप करके cmake ..या cmakeलगातार तर्क प्रदान करके मानता है (जिसे आप अपने मेकफाइल में शामिल कर सकते हैं)।

अंत में, क्रेडिट जहां क्रेडिट देय है। यह Makefile आवरण C ++ अनुप्रयोग प्रोजेक्ट टेम्पलेट द्वारा प्रदान किए गए Makefile से अनुकूलित किया गया था ।

Answer 10

बेशक, यूनिक्स मेकफाइल्स के लिए आउट-ऑफ-सोर्स बिल्ड गो-टू विधि है, लेकिन यदि आप किसी अन्य जनरेटर जैसे कि एक्लिप्स सीडीटी का उपयोग कर रहे हैं, तो यह आपको स्रोत बनाने के लिए पसंद करता है। जिस स्थिति में, आपको मैन्युअल रूप से CMake फ़ाइलों को शुद्ध करना होगा। इसे इस्तेमाल करे:

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

या यदि आपने ग्लोबस्टार को सक्षम किया है shopt -s globstar, तो इसके बजाय कम घृणित दृष्टिकोण का प्रयास करें:

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

Comments

मेरी पसंद कल एक नए फ़ोल्डर में रेपो क्लोनिंग कर रहा था, सबफ़ोल्डर से बनाने के लिए CMakeLists.txt को अपडेट करें build। उन आदेशों की तुलना में थोड़ा अधिक समय लगा, लेकिन मुझे इसे केवल एक बार करना पड़ा :)

— टीएन डू

Answer 11

उपयोग करने का प्रयास करें: cmake --clean-first पथ-की-सीएमके लेलिस्ट। txt-file -B output-dir

-क्लाइन-फर्स्ट: टारगेट क्लीन क्लीन पहले, फिर बिल्ड।
(केवल साफ करने के लिए, उपयोग करें --target clean।)

Comments

वह स्क्रीन शॉट केवल टेक्स्ट दिखाता है । फिर भी आप इसका एक स्क्रीन शॉट लेते हैं, जो भी स्क्रीनरीडर के साथ यहां आता है, उसके जवाब को तोड़ देता है। कृपया उस चित्र को छोड़ दें, और पाठ की एक कॉपी / पेस्ट करें, और उस इनपुट को ठीक से प्रारूपित करने के लिए 1 मिनट का समय दें।

— घोस्टकट

Answer 12

उस स्थिति में जहां आप -Dबिल्ड फ़ाइलों को बनाते समय सीएमके में पैरामीटर पास करते हैं और संपूर्ण बिल्ड / निर्देशिका को हटाना नहीं चाहते हैं:

बस अपनी बिल्ड डायरेक्टरी के अंदर CMakeFiles / डायरेक्टरी को डिलीट करें।

rm -rf CMakeFiles/
cmake --build .

यह सीएमके को फिर से चलाने, और सिस्टम फ़ाइलों का निर्माण करने का कारण बनता है। आपका निर्माण भी खरोंच से शुरू होगा।

Answer 13

"आउट ऑफ सोर्स" बिल्ड का उपयोग करते समय सफाई को आसान बनाने के लिए (यानी आप 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

Comments

अच्छा और सुरक्षित है। जैसा कि आपके पास फ़ाइल प्रबंधक में निर्मित निर्देशिका हो सकती है, मैं सुझाव देता हूं कि cd .. ; rm ; mkdir ; cdअनुक्रम को प्रतिस्थापित करना है cd .. ; rm -rf build/*।

— मुस्तफा फरज़ान

Answer 14

यदि आपके पास कस्टम परिभाषित है और सफाई से पहले उन्हें सहेजना चाहते हैं, तो अपनी बिल्ड निर्देशिका में निम्नलिखित को चलाएँ:

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

फिर एक नई बिल्ड निर्देशिका बनाएं (या पुरानी बिल्ड निर्देशिका को हटा दें और इसे फिर से बनाएँ) और अंत cmakeमें उन तर्कों के साथ चलें जो आपको ऊपर की स्क्रिप्ट के साथ मिलेंगे।

Answer 15

अगर तुम दौड़ते हो

cmake .

यह CMake फ़ाइलों को पुन: उत्पन्न करेगा। यदि आप उदाहरण के लिए, .cc द्वारा चयनित स्रोत फ़ोल्डर में एक नई फ़ाइल जोड़ते हैं, जो आवश्यक है।

हालांकि, यह "साफ" प्रति सेशन नहीं है, लेकिन यह सीचेस फाइलों को कैश को पुन: उत्पन्न करके "क्लीन" करता है।

Comments

यह wrt को साफ़ नहीं करता है। संकलन स्थिति: यदि "cmake" के बाद, 1200 में से 500 फाइलों को संकलित किया गया है। यह केवल अंतिम 700 फाइलों के साथ जारी रहेगा।

— पीटर मोर्टेंसन

Answer 16

मैं ऐसे उद्देश्यों के लिए निम्नलिखित शेल स्क्रिप्ट का उपयोग करता हूं:

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

यदि आप विंडोज का उपयोग कर रहे हैं तो इस स्क्रिप्ट के लिए सिगविन का उपयोग करें।

Answer 17

यह देखना मज़ेदार है कि इस प्रश्न को इतने सारे ध्यान और जटिल समाधान मिलते हैं, जो वास्तव में सीमेक के साथ एक साफ विधि नहीं करने के लिए दर्द को दर्शाता है।

ठीक है, आप निश्चित रूप cd buildसे आपको काम करने के लिए कर सकते हैं, फिर rm -rf *जब आपको सफाई करने की आवश्यकता होती है। हालांकि, rm -rf *यह एक खतरनाक आदेश है कि कई लोग अक्सर इस बात से अवगत नहीं होते हैं कि वे किस दिशा में हैं।

यदि आप cd .., rm -rf buildऔर फिर mkdir buildऔर फिर cd build, यह बहुत अधिक टाइपिंग है।

इसलिए एक अच्छा उपाय यह है कि आप केवल बिल्ड फोल्डर से बाहर रहें और cmake को रास्ता बताएं:
कॉन्फ़िगर cmake -B build
करने के लिए: cmake --build build
to build: to : to clean: rm -rf build
to build बिल्ड फोल्डर: आपको इसकी आवश्यकता नहीं है mkdir build, बस इसे कॉन्फ़िगर करें cmake -B buildऔर cmake इसे बनाएंगे

Answer 18

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

Answer 19

मेरी शेल आरसी फ़ाइल में यह है ( .bashrc, .zshrc):

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

आप इसे केवल आउट-ऑफ-सोर्स बिल्ड के लिए उपयोग करने वाले हैं । मान लीजिए कि आपके पास build/इस उद्देश्य के लिए एक निर्देशिका है । फिर आपको बस उसके t-cmake-cleanभीतर से भागना है।

Answer 20

मैंने निम्नलिखित समस्या को हल करने के लिए सफलतापूर्वक zsxwing के उत्तर का उपयोग किया :

मेरे पास स्रोत है जो मैं कई होस्ट्स पर बनाता हूं (एक रास्पबेरी पाई लिनक्स बोर्ड पर, एक वीएमवेयर लिनक्स वर्चुअल मशीन, आदि पर)

मेरे पास एक बैश स्क्रिप्ट है जो मशीन के होस्टनाम के आधार पर इस तरह अस्थायी निर्देशिका बनाता है:

# 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

Answer 21

उदाहरण के लिए, एक अस्थायी निर्माण निर्देशिका बनाएँ, build_cmake । इसलिए आपकी सभी बिल्ड फाइलें इस फ़ोल्डर के अंदर होंगी।

फिर अपने मुख्य CMake फ़ाइल में नीचे कमांड जोड़ें।

add_custom_target(clean-all
    rm -rf *
)

इसलिए संकलन करते समय

cmake ..

और साफ करने के लिए:

make clean-all

Comments

अगर आपकी कोई गलती गलती से आउट-ऑफ-सोर्स के बजाय इन-सोर्स का निर्माण करने का अच्छा तरीका है

हाँ। इस विधि का उपयोग केवल "आउट ऑफ सोर्स बिल्ड" के साथ किया जाना चाहिए

— नटेश

भयानक सिफारिश। उत्तर के रूप में मौजूद नहीं होना चाहिए।

— ऐनी वैन रोसुम

@AnnevanRossum सहमत

— zevarito