बस बनाने के बारे में

मैं हमेशा अतिसूक्ष्मवाद की ओर आकर्षित रहा हूं। यह विचार कि एक काम को एक फ़ंक्शन को पूरा करना चाहिए, लेकिन साथ ही साथ इसे यथासंभव सर्वोत्तम रूप से पूरा करना चाहिए, जिसके परिणामस्वरूप UNIX का निर्माण हुआ। और यद्यपि UNIX को अब एक सरल प्रणाली नहीं कहा जा सकता है, और अतिसूक्ष्मवाद को देखना इतना आसान नहीं है, इसे कई सरल और समझ में आने वाली चीजों की मात्रा-गुणवत्ता परिवर्तन का एक अच्छा उदाहरण माना जा सकता है। इसके विकास में, बहुत कुछ इसी तरह से हुआ: सादगी और स्पष्टता, पैमाने की वृद्धि के साथ, एक भयानक राक्षस में बदल गया (अपनी भावनाओं को याद रखें जब आपने पहली बार मेकफाइल खोला था)।

लंबे समय तक बनाने के लिए मेरी लगातार अनदेखी, इस्तेमाल की गई आईडीई की सुविधा और इस 'अतीत के अवशेष' (अनिवार्य रूप से आलस्य) को समझने की अनिच्छा के कारण थी। हालाँकि, ये सभी कष्टप्रद बटन, मेनू इत्यादि। विभिन्न स्टूडियो की विशेषताओं ने मुझे उस कार्य पद्धति के विकल्प की तलाश की जो मैंने अब तक अभ्यास की है। नहीं, मैं एक गुरु नहीं बना था, लेकिन मैंने जो ज्ञान प्राप्त किया वह मेरी छोटी परियोजनाओं के लिए काफी है। यह लेख उन लोगों के लिए है, जो हाल ही में खुद को पसंद करते हैं, कोजिक विंडो की दासता को तपस्वी से मुक्त करना चाहते हैं, लेकिन मुक्त खोल दुनिया में।

बनाओ- बुनियादी जानकारी

एक फाइल को एक फॉर्म से दूसरे में बदलने के लिए डिज़ाइन की गई उपयोगिता है। परिवर्तन नियमों को मेकफाइल नामक एक स्क्रिप्ट में सेट किया गया है, जिसे परियोजना की कार्यशील निर्देशिका की जड़ में स्थित होना चाहिए। स्क्रिप्ट में स्वयं नियमों का एक सेट होता है, जो बदले में वर्णित हैं:

1) लक्ष्य (यह नियम क्या करता है);
2) अपेक्षित (नियम को पूरा करने और लक्ष्यों को प्राप्त करने के लिए क्या आवश्यक है);
3) टीमों (रूपांतरण डेटा प्रदर्शन)।

सामान्य तौर पर, मेकफाइल सिंटैक्स को निम्नानुसार दर्शाया जा सकता है:

#       , #      <>: <> < #1> ... < #n> 

अर्थात्, नियम तीन प्रश्नों का उत्तर है:

 {  ? ()} ---> [ ? ()] ---> { ? ()} 

यह नोटिस करना आसान है कि इस योजना पर अनुवाद और संकलन प्रक्रिया बहुत अच्छी तरह से फिट हैं:

 { } ---> [] ---> { } 

 { } ---> [] ---> { } 

सबसे सरल मेकअप

मान लें कि हमारे पास एक प्रोग्राम है जिसमें केवल एक फ़ाइल है:

 /* * main.c */ #include <stdio.h> int main() { printf("Hello World!\n"); return 0; } 

एक बहुत ही सरल मेकफाइल इसे संकलित करने के लिए पर्याप्त है:

 hello: main.c gcc -o hello main.c 

इस मेकफाइल में एक नियम होता है, जिसमें बदले में एक लक्ष्य होता है - "हैलो", सहारा - "main.c", और एक कमांड - "gcc -o hello main.c"। अब, संकलन के लिए यह कार्य निर्देशिका में मेक कमांड देने के लिए पर्याप्त है। डिफ़ॉल्ट रूप से, यदि निष्पादन लक्ष्य स्पष्ट रूप से कॉल में निर्दिष्ट नहीं किया गया था, तो पहले नियम को निष्पादित करेगा:

  $ make <> 

कई स्रोतों से संकलन

मान लें कि हमारे पास एक प्रोग्राम है जिसमें 2 फाइलें हैं:
main.c

 /* * main.c */ int main() { hello(); return 0; } 

और नमस्ते

 /* * hello.c */ #include <stdio.h> void hello() { printf("Hello World!\n"); } 

इस कार्यक्रम का संकलन इस तरह दिख सकता है:

 hello: main.c hello.c gcc -o hello main.c hello.c 

यह पूरी तरह कार्यात्मक है, लेकिन इसमें एक महत्वपूर्ण दोष है: जो एक - हम आगे खोलेंगे।

वृद्धिशील संकलन

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

अब स्रोत फ़ाइलों में से एक को बदलने के बाद, इसका अनुवाद करना और सभी ऑब्जेक्ट फ़ाइलों को लिंक करना पर्याप्त है। उसी समय, हम परिवर्तनों से प्रभावित विवरणों के अनुवाद के चरण को छोड़ देते हैं, जिससे संकलन का समय कम हो जाता है। इस दृष्टिकोण को वृद्धिशील संकलन कहा जाता है। इसका समर्थन करने के लिए, लक्ष्यों को बदलने के समय और उनके विवरण (फाइल सिस्टम के डेटा का उपयोग करके) की तुलना करें, धन्यवाद जिससे यह स्वतंत्र रूप से निर्णय लेता है कि किन नियमों का पालन किया जाना चाहिए और किन लोगों की उपेक्षा की जा सकती है:

 main.o: main.c gcc -c -o main.o main.c hello.o: hello.c gcc -c -o hello.o hello.c hello: main.o hello.o gcc -o hello main.o hello.o 

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

मेक शुरू करने के बाद, यह तुरंत हैलो लक्ष्य प्राप्त करने की कोशिश करेगा, लेकिन इसे बनाने के लिए, main.o और hello.o फ़ाइलों की आवश्यकता होती है, जो अभी तक उपलब्ध नहीं हैं। इसलिए, नियम के निष्पादन में देरी होगी और लापता नियमों की प्राप्ति का वर्णन करने वाले नियमों की तलाश करेगी। एक बार सभी विवरण प्राप्त हो जाने के बाद, आस्थगित लक्ष्य के निष्पादन में वापस आ जाएगा। यह निम्नानुसार है कि नियमों को पुनरावर्ती रूप से निष्पादित करता है।

काल्पनिक लक्ष्य

वास्तव में, केवल वास्तविक फाइलें ही लक्ष्य बनाने का कार्य नहीं कर सकती हैं। स्रोत कोड से कार्यक्रमों को संकलित करने वाले प्रत्येक व्यक्ति को UNIX दुनिया में दो मानक कमांडों से परिचित होना चाहिए:

  $ make $ make install 

मेक कमांड प्रोग्राम को संकलित करता है, मेक कमांड स्थापित करता है। यह दृष्टिकोण बहुत सुविधाजनक है, क्योंकि लक्ष्य प्रणाली पर आवेदन के निर्माण और तैनाती के लिए आवश्यक सभी चीजें एक फ़ाइल में शामिल हैं (थोड़ी देर के लिए कॉन्फ़िगर स्क्रिप्ट के बारे में भूल जाएं)। कृपया ध्यान दें कि पहले मामले में, हम उद्देश्य को निर्दिष्ट नहीं करते हैं, और दूसरे में, लक्ष्य बिल्कुल स्थापित फ़ाइल बनाने के लिए नहीं है, लेकिन सिस्टम पर एप्लिकेशन इंस्टॉल करने की प्रक्रिया है। इस तरह के ट्रिक्स हमें तथाकथित फोनी गोल करने की अनुमति देते हैं। यहाँ मानक लक्ष्यों की एक छोटी सूची है:

• सभी - यह डिफ़ॉल्ट डिफ़ॉल्ट लक्ष्य है। जब मेकअप लगाया जाता है, तो इसे स्पष्ट रूप से छोड़ा जा सकता है।
• संकलन के परिणामस्वरूप प्राप्त सभी फाइलों से निर्देशिका को साफ करें।
• स्थापित करें - स्थापित करें
• अनइंस्टॉल करें - और उसके अनुसार स्थापना रद्द करें।

ऐसे नामों वाली फ़ाइलों की तलाश न करने के लिए, उन्हें .PHONY निर्देश का उपयोग करके मेकफाइल में परिभाषित किया जाना चाहिए। निम्न सभी के उद्देश्यों के लिए एक उदाहरण है Makefile, क्लीन, इनस्टॉल और अनइंस्टॉल:

 .PHONY: all clean install uninstall all: hello clean: rm -rf hello *.o main.o: main.c gcc -c -o main.o main.c hello.o: hello.c gcc -c -o hello.o hello.c hello: main.o hello.o gcc -o hello main.o hello.o install: install ./hello /usr/local/bin uninstall: rm -rf /usr/local/bin/hello 

अब हम अपने कार्यक्रम का निर्माण कर सकते हैं, इसे स्थापित / अनइंस्टॉल कर सकते हैं, और इसके लिए मानक बनाने के लक्ष्यों का उपयोग करके कामकाजी निर्देशिका को भी साफ़ कर सकते हैं।

ध्यान दें कि सभी लक्ष्यों के लिए कोई लक्ष्य निर्दिष्ट नहीं किया गया है; सभी की जरूरत है कि वह हेलो प्रॉप्स प्राप्त करे। बनाने की पुनरावर्ती प्रकृति को देखते हुए, यह अनुमान लगाना आसान है कि यह स्क्रिप्ट कैसे काम करेगी। आपको इस तथ्य पर भी विशेष ध्यान देना चाहिए कि यदि हेलो फ़ाइल पहले से मौजूद है (पिछले संकलन के बाद बनी हुई है) और उसके विवरण को नहीं बदला गया है, तो मेक कमांड कुछ भी फिर से नहीं करेगा । यह एक क्लासिक मेक रेक है। उदाहरण के लिए, हेडर फ़ाइल को बदलकर जिसे गलती से विवरण की सूची में शामिल नहीं किया गया है, आप लंबे समय तक सिरदर्द प्राप्त कर सकते हैं। इसलिए, परियोजना के पूर्ण पुनर्निर्माण की गारंटी देने के लिए, आपको पहले कार्यशील निर्देशिका को साफ़ करना होगा:

  $ make clean $ make 

इंस्टॉल / अनइंस्टॉल लक्ष्यों को पूरा करने के लिए, आपको sudo का उपयोग करना होगा।

चर

डीआरवाई (खुद को दोहराएं नहीं) नियम से परिचित सभी लोगों ने शायद देखा कि कुछ गलत था, अर्थात्, हमारे मेकफाइल में बड़ी संख्या में दोहराए गए टुकड़े होते हैं, जो इसे विस्तार या बदलने के बाद के प्रयासों के दौरान भ्रम पैदा कर सकता है। इन भाषाओं के लिए, इन उद्देश्यों के लिए, हमारे पास चर और स्थिरांक हैं; मेक भी समान उपकरण है। मेक इन वेरिएबल को स्ट्रिंग्स नाम दिया गया है और इसे बहुत सरलता से परिभाषित किया गया है:

  <VAR_NAME> = <value string> 

एक अलिखित नियम है जिसके अनुसार ऊपरी मामले में चर का नाम दिया जाना चाहिए, उदाहरण के लिए:

  SRC = main.c hello.c 

इसलिए हमने स्रोत फ़ाइलों की एक सूची को परिभाषित किया। एक चर के मूल्य का उपयोग करने के लिए, $ (<VAR_NAME>) निर्माण का उपयोग करके इसका नाम बदला जाना चाहिए; इस तरह के उदाहरण के लिए:

  gcc -o hello $(SRC) 

निम्नलिखित एक मेकफाइल है जो दो चर का उपयोग करता है: लक्ष्य - निर्धारित करने के लिए लक्ष्य कार्यक्रम का नाम और PREFIX - सिस्टम पर प्रोग्राम को स्थापित करने के लिए पथ का निर्धारण करने के लिए।

 TARGET = hello PREFIX = /usr/local/bin .PHONY: all clean install uninstall all: $(TARGET) clean: rm -rf $(TARGET) *.o main.o: main.c gcc -c -o main.o main.c hello.o: hello.c gcc -c -o hello.o hello.c $(TARGET): main.o hello.o gcc -o $(TARGET) main.o hello.o install: install $(TARGET) $(PREFIX) uninstall: rm -rf $(PREFIX)/$(TARGET) 

यह पहले से ही प्रचलित है। मुझे लगता है कि अब उपरोक्त उदाहरण को आपके लिए विशेष टिप्पणियों की आवश्यकता नहीं है।

स्वचालित चर

स्वचालित चर को मेकफाइल्स को सरल बनाने के लिए डिज़ाइन किया गया है, लेकिन मेरी राय में वे अपनी पठनीयता को नकारात्मक रूप से प्रभावित करते हैं। जैसा कि हो सकता है, मैं यहां कुछ सबसे अधिक इस्तेमाल किए जाने वाले चर दे दूंगा, और आपको क्या करना चाहिए (और क्या करना है) आप पर निर्भर है:

• $ @ नियम का लक्षित नाम संसाधित किया जा रहा है
• $ <प्रक्रिया के शासन की पहली निर्भरता का नाम
• $ ^ संसाधित होने वाले नियम की सभी निर्भरताओं की सूची

अगर कोई भी अपनी स्क्रिप्ट को पूरी तरह से बाधित करना चाहता है, तो यहां प्रेरणा प्राप्त करें:
स्वचालित चर

निष्कर्ष

इस लेख में, मैंने मेकअप के साथ लिखने और काम करने की मूल बातें विस्तार से समझाने की कोशिश की। मुझे आशा है कि यह आपको इस समय-परीक्षणित उपकरण को बनाने और शीघ्रता से समझने में मदद करेगा।

---

गीथूब पर सभी उदाहरण

उन लोगों के लिए जिन्होंने स्वाद लिया है:
ओपननेट मेकफाइल मिनी HOWTO
GNU मेक रिचर्ड एम। स्टेलमैन और रोलैंड मैकग्राथ, अनुवाद © व्लादिमीर इग्नाटोव, 2000
जीएनयू मेक का प्रभावी उपयोग