Makefile उदाहरण

मेकफाइल लिखना कभी-कभी सिरदर्द बन जाता है। हालांकि, यदि आप देखते हैं, तो सब कुछ जगह में गिर जाता है, और मनमाने ढंग से बड़ी परियोजना के लिए एक शक्तिशाली 40-लाइन मेकफाइल लिखना त्वरित और सुरुचिपूर्ण है।



चेतावनी! जीएनयू मेक यूटिलिटी का बुनियादी ज्ञान ग्रहण किया जाता है।





हमारे पास निम्न निर्देशिका संरचना के साथ एक विशिष्ट सार परियोजना है:







मान लीजिए कि #include <dir1 / file1.h> जैसी किसी चीज़ का उपयोग स्रोत में हेडर फ़ाइलों को शामिल करने के लिए किया जाता है, अर्थात संकलन के दौरान प्रोजेक्ट / शामिल निर्देशिका को मानक बनाया जाता है।



असेंबली के बाद, यह आवश्यक है कि यह इस तरह से निकले:







अर्थात्, बिन निर्देशिका में कार्य (अनुप्रयोग) और डीबगिंग (application_debug) संस्करण हैं, प्रोजेक्ट / रिलीज़ निर्देशिका के रिलीज़ और डीबग उपनिर्देशिकाओं में प्रोजेक्ट / src निर्देशिका संरचना ऑब्जेक्ट फ़ाइलों की संबंधित स्रोत फ़ाइलों के साथ दोहराई जाती है जिसमें से बिन निर्देशिका की सामग्री की रचना होती है।



इस आशय को प्राप्त करने के लिए, प्रोजेक्ट डायरेक्टरी में निम्नलिखित सामग्री के साथ एक मेकफाइल बनाएं:

1. root_include_dir: = शामिल हैं
2. root_source_dir: = src
3. source_subdirs: = dir1 dir2
4. compile_flags: = -Wall -MD -pipe
5. link_flags: = -s -पाइप करें
6. पुस्तकालय: = -एलडीएल
8. रिश्तेदार_किसान_दार: = $ ( अतिरिक्त) .. / .., $ ( root_include_dir )
9. रिश्तेदार_स्रोत_दिर: = $ ( परिशिष्ट .. / .. / $ ( root_source_dir ) / , $ ( source_subdirs ) )
10. ऑब्जेक्ट्स_डायर: = $ ( ऐडप्रिफ़िक्स $ ( root_source_dir ) / , $ ( source_suberirs ) )
11. ऑब्जेक्ट्स: = $ ( patsubst .. / .. /% , % , $ ( वाइल्डकार्ड $ ( Adduffix / * .c * , $ ) ( relation_source_dirs ) ) )
12. ऑब्जेक्ट्स: = $ ( ऑब्जेक्ट्स: .cpp = .o )
13. ऑब्जेक्ट्स: = $ ( ऑब्जेक्ट्स: .c = .o )
15. सभी: $ ( program_name )
17. $ ( program_name ) : obj_dirs $ ( ऑब्जेक्ट्स )
18. g ++ -o $ @ $ ( ऑब्जेक्ट्स ) $ ( link_flags ) $ ( लाइब्रेरी )
20. obj_dirs:
21. mkdir -p $ ( Objects_dirs )
23. VPATH: = .. / .. /
25. % .o: % .cpp
26. g ++ -o $ @ -c $ < $ ( compile_flags ) $ ( build_flags ) $ ( addprefix -I, $ ( रिश्तेदार_कील_डीर्स ) )
28. % .o: % .सी
29. g ++ -o $ @ -c $ < $ ( compile_flags ) $ ( build_flags ) $ ( addprefix -I, $ ( रिश्तेदार_कील_डीर्स ) )
31. .PHONY: साफ
33. साफ:
34. rm -rf बिन obj
36. $ शामिल करें ( वाइल्डकार्ड $ ( अतिरिक्त) / * .d, $ ( ऑब्जेक्ट्स_डायर ) )

अपने शुद्ध रूप में, इस तरह के एक मेकफाइल केवल स्वच्छ लक्ष्य को प्राप्त करने के लिए उपयोगी है, जो बिन और obj निर्देशिकाओं को हटा देगा।

कार्य संस्करण बनाने के लिए रिलीज़ नामक एक और स्क्रिप्ट जोड़ें:

mkdir -p bin mkdir -p obj mkdir -p obj/Release make --directory=./obj/Release --makefile=../../Makefile build_flags="-O2 -fomit-frame-pointer" program_name=../../bin/application
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और डीबग संस्करण बनाने के लिए एक और डीबग स्क्रिप्ट:

 mkdir -p bin mkdir -p obj mkdir -p obj/Debug make --directory=./obj/Debug --makefile=../../Makefile build_flags="-O0 -g3 -D_DEBUG" program_name=../../bin/application_debug
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह उनमें से एक की चुनौती है कि हमारी परियोजना एक कामकाजी या डिबगिंग संस्करण में एकत्र होगी। और अब, पहली चीजें पहले।



मान लें कि आपको एक डीबग संस्करण बनाने की आवश्यकता है। प्रोजेक्ट डायरेक्टरी पर जाएं और कॉल करें। पहली तीन लाइनें डायरेक्टरी बनाती हैं। प्रोजेक्ट / obj / डीबग बनाने वाली उपयोगिता की चौथी पंक्ति को स्टार्टअप पर वर्तमान निर्देशिका बनाया जाना चाहिए, इसके सापेक्ष, मेकाइल के लिए रास्ता पास किया जाता है और दो स्थिरांक सेट किए जाते हैं: build_flags (यह डीबग संस्करण के लिए महत्वपूर्ण संकलन झंडे को सूचीबद्ध करता है) और program_name (डीबग संस्करण के लिए) यह application_debug) है।



अगला, GNU मेक प्ले में आता है। मेकफाइल की प्रत्येक पंक्ति पर टिप्पणी करें:



1: शीर्ष लेख फ़ाइलों की जड़ निर्देशिका के नाम के साथ एक चर घोषित किया जाता है।



2: स्रोत रूट निर्देशिका के नाम के साथ एक चर घोषित किया जाता है।



3: स्रोत रूट निर्देशिका की उपनिर्देशिकाओं के नाम के साथ एक चर घोषित किया जाता है।



4: आम संकलन झंडे के साथ एक चर घोषित किया जाता है। -MD कंपाइलर को प्रत्येक स्रोत के लिए एक्सटेंशन .d के साथ एक ही नाम की एक निर्भरता फ़ाइल उत्पन्न करने के लिए मजबूर करता है। प्रत्येक ऐसी फाइल एक नियम के रूप में दिखती है, जहां लक्ष्य स्रोत का नाम है, और निर्भरताएं सभी स्रोत और हेडर फाइलें हैं, जिसमें यह #include निर्देश के साथ शामिल है। -पाइप ध्वज कंपाइलर को फाइल सिस्टम के बजाय आईपीसी का उपयोग करने के लिए मजबूर करता है, जो कुछ हद तक संकलन को गति देता है।



5: सामान्य लेआउट के झंडे के साथ एक चर घोषित किया जाता है। -s लिंकर को .symtab, .strtab को हटाने के लिए बाध्य करता है, और परिणामी ELF फ़ाइल से .debug * जैसे नामों का एक गुच्छा होता है, जो इसके आकार को काफी कम कर देता है। बेहतर डिबगिंग के लिए इस कुंजी को हटाया जा सकता है।



6: एक चर को लेआउट कुंजियों के रूप में उपयोग किए जाने वाले पुस्तकालयों के नामों के साथ घोषित किया जाता है।



8: मानक हेडर फ़ाइलों के साथ रिश्तेदार निर्देशिका नामों वाला एक चर घोषित किया जाता है। फिर ऐसे नामों को सीधे संकलक को भेज दिया जाता है, जो कि -I स्विच से पहले होता है। हमारे मामले के लिए, यह पता चलेगा ../../include, क्योंकि हमारे पास ऐसी एक निर्देशिका है। Addprefix फ़ंक्शन अपने पहले तर्क को उन सभी लक्ष्यों को जोड़ता है जो दूसरा तर्क सेट करता है।



9: एक चर को स्रोत रूट निर्देशिका के सभी उपनिर्देशिकाओं के सापेक्ष नामों से युक्त घोषित किया जाता है। नतीजतन, हमें मिलता है: ../../src/। ../../src/dir1 ../../src/dir1



10: एक चर को वर्तमान परियोजना / obj / डिबग के सापेक्ष परियोजना / obj / Debug / src निर्देशिका के उप-नाम से युक्त घोषित किया गया है। यही है, इसके द्वारा हम प्रोजेक्ट / src डायरेक्टरी स्ट्रक्चर की कॉपी को एन्यूमरेट करते हैं। परिणामस्वरूप, हमें मिलता है: / src / dir1 src / dir2।



11: एक चर को मौजूदा निर्देशिका की परवाह किए बिना समान नाम की * .c * (.cpp_ .c) फ़ाइलों के आधार पर पाए जाने वाले स्रोतों के नामों से युक्त घोषित किया जाता है। हम चरणों में देखते हैं: Adduffix का परिणाम होगा ../../src/./*.* ../../src/dir1/*.* ../../src/dir2/*.*। वाइल्डकार्ड फ़ंक्शन वास्तविक फ़ाइल नाम के लिए तारांकन के साथ पैटर्न का विस्तार करेगा: ..//src/./main.pp ../../src/dir1/file1. ../../src/dir1-file2.pp ../../src/dir2/file3.c ../../src/dir2/file4.c। Patsubsb फ़ंक्शन फ़ाइल नामों से ../../ उपसर्ग को हटा देगा (यह दूसरे तर्क में पैटर्न के साथ पहले तर्क द्वारा निर्दिष्ट पैटर्न को बदल देता है, और% वर्णों की किसी भी संख्या को दर्शाता है)। परिणामस्वरूप, हमें मिलता है: src /./ main.pp src / dir1 / file1. src / dir1 / file2.pp src / dir2 / file3. src / dir2 / file4.।



12: चर में .cpp के स्रोत नामों के साथ .o द्वारा प्रतिस्थापित किया जाता है।



13: चर के स्रोत नामों के साथ चर में .c को .o के साथ बदल दिया जाता है।



15: पहला नियम घोषित किया गया - इसका लक्ष्य पूरी परियोजना का लक्ष्य बन गया। एक निर्भरता कार्यक्रम के नाम से युक्त एक स्थिर (../../bin/application_debug है जब हमने इसे स्क्रिप्ट से बनाया है)।



17: प्रमुख उद्देश्य का विवरण। निर्भरताएं भी स्पष्ट हैं: परियोजना / obj / डीबग में बनाई गई एक उपनिर्देशिका की उपस्थिति जो परियोजना / src निर्देशिका की संरचना को दोहराती है और उनमें बहुत सारी ऑब्जेक्ट फाइलें होती हैं।



18: ऑब्जेक्ट फ़ाइलों को लक्ष्य से जोड़ने के लिए कार्रवाई का वर्णन करता है।



20: एक नियम जिसमें लक्ष्य परियोजना / obj / Debug / src निर्देशिका और उसके उपनिर्देशिका हैं।



21: लक्ष्य प्राप्त करने की क्रिया संगत निर्देशिका src /।, Src / dir1 और src / dir2 बनाना है। Mkdir उपयोगिता का -p स्विच त्रुटि को अनदेखा करता है, यदि कोई निर्देशिका बनाते समय, पहले से मौजूद है।



23: VPATH चर मान लेता है ../../। यह निम्नलिखित नियम टेम्पलेट्स के लिए आवश्यक है।



25: नियमों के एक सेट का वर्णन किया गया है, जिसके लिए कोई भी लक्ष्य% .o पैटर्न से मेल खाते हुए लक्ष्य हैं (यानी, इनो को समाप्त करने वाले नाम), और इन उद्देश्यों के लिए निर्भरता% .cpp पैटर्न से मेल खाने वाले एक ही नाम के लक्ष्य हैं (यानी, नाम समाप्त होने वाले) सीपीपी)। इस स्थिति में, समान नाम का अर्थ न केवल एक सटीक मिलान है, बल्कि अगर निर्भरता का नाम भी VPATH चर की सामग्री से पहले है। उदाहरण के लिए, नाम src / dir1 / file2 और ../..src/dir1/file2 मेल करेंगे, क्योंकि VPATH में ../../ शामिल हैं।



26: C ++ स्रोत को ऑब्जेक्ट फ़ाइल में बदलने के लिए एक कंपाइलर कॉल।



28: नियमों के एक सेट का वर्णन किया गया है, जिसके लिए कोई भी लक्ष्य% .o पैटर्न से मेल खाते हुए लक्ष्य हैं। यानी, इन उद्देश्यों के लिए समाप्त होने वाले नाम), और इन उद्देश्यों के लिए निर्भरता% .c पैटर्न से मेल खाने वाले एक ही नाम के लक्ष्य हैं (अर्थात, नाम समाप्त होने वाले) ग)। रेखा 23 में समाई।



29: C स्रोत को ऑब्जेक्ट फ़ाइल में बदलने के लिए कंपाइलर को कॉल करना।



31: कुछ साफ लक्ष्य को सार घोषित किया गया है। एक सार लक्ष्य प्राप्त करना हमेशा होता है और एक ही नाम की फ़ाइल के अस्तित्व पर निर्भर नहीं करता है।



32: अमूर्त लक्ष्य को साफ घोषित करना।



33: इसे प्राप्त करने की कार्रवाई परियोजना / बिन और परियोजना / obj निर्देशिकाओं को उनकी सभी सामग्रियों के साथ नष्ट करना है।



36: वर्तमान निर्देशिका के उपनिर्देशिकाओं में स्थित सभी निर्भरता फ़ाइलों (एक्सटेंशन .d) के साथ सामग्री का समावेश। मेक यूटिलिटी पार्सिंग की शुरुआत में यह क्रिया करती है। हालाँकि, निर्भरता फ़ाइलें केवल संकलन के बाद बनाई जाती हैं। इसलिए, पहली बिल्ड के दौरान ऐसी कोई फाइल शामिल नहीं होगी। लेकिन यह डरावना नहीं है। इन फ़ाइलों को शामिल करने का उद्देश्य संशोधित हेडर फ़ाइल के आधार पर स्रोतों का पुन: संयोजन करना है। दूसरे और बाद के बिल्ड में, उपयोगिता में सभी निर्भरता फ़ाइलों में वर्णित नियम शामिल होंगे और यदि आवश्यक हो, तो संशोधित हेडर फ़ाइल पर निर्भर सभी लक्ष्यों को प्राप्त करें।



सौभाग्य है