makepp_extending - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

makepp_extending -- पर्ल का उपयोग करके मेकप्प का विस्तार कैसे करें

वर्णन

Makepp आंतरिक रूप से इतना लचीला है कि आप थोड़ा सा पर्ल कोड लिखकर ऐसा कर सकते हैं
फ़ंक्शंस जोड़ें या कई अन्य ऑपरेशन करें।

सामान्य जानकारी नोट्स on लिख रहे हैं पर्ल कोड सेवा मेरे काम साथ में मेकप्प
प्रत्येक मेकफ़ाइल अपने पैकेज में रहती है। इस प्रकार एक मेकफ़ाइल में परिभाषाएँ प्रभावित नहीं होती हैं
किसी अन्य मेकफ़ाइल में परिभाषाएँ। सभी मानक सहित कार्यों का एक सामान्य सेट
जब इसे बनाया जाता है तो पाठ्य हेरफेर फ़ंक्शन को पैकेज में आयात किया जाता है।

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

प्रत्येक कथन (ifperl/ifmakeperl, perl/makeperl, उप/makesub),
फ़ंक्शन (पर्ल/मेकपरल, मैप/मेकमैप) और नियम क्रिया (पर्ल/मेकपरल) के लिए
सीधे मेकफ़ाइल में पर्ल कोड लिखना दो स्वादों में आता है। पहला बिल्कुल है
सामान्य पर्ल, जिसका अर्थ है कि आपको "f_" उपसर्ग का उपयोग करना होगा जैसा कि अगले भाग में बताया गया है, यदि
आप मेकप फ़ंक्शंस को कॉल करना चाहते हैं। दूसरा संस्करण पहले कथन को पारित करता है
मेक-स्टाइल वैरिएबल विस्तार, जिसका अर्थ है कि आपको उन "$" को दोगुना करना होगा जिन्हें आप पर्ल को दिखाना चाहते हैं।

एंड हैंडलिंग विशेष है क्योंकि मेकप का विशाल (आपके बिल्ड सिस्टम के आधार पर) डेटा है
संरचनाओं को सामान्य निकास के साथ कचरा एकत्र करने में कई सेकंड लगेंगे। तो हम ऐसा करते हैं
क्रूर बल से बाहर निकलना. मुख्य प्रक्रिया में आपके पास अभी भी "END" ब्लॉक हो सकते हैं, लेकिन यदि आपके पास कोई है
वैश्विक फ़ाइल हैंडल को फ़्लश नहीं किया जा सकता है। लेकिन आपको आधुनिक शब्दावली का प्रयोग करना चाहिए
फ़ाइलहैंडल, जो दायरे से बाहर जाने पर ठीक से बंद हो जाते हैं।

पर्ल कोड में सीधे एक नियम क्रिया के रूप में या आपके द्वारा परिभाषित कमांड के माध्यम से चलाएं, यह है
विलोम। "END" ब्लॉक नहीं चलाए जाएंगे, लेकिन वैश्विक फ़ाइल हैंडल आपके लिए फ़्लश हो जाएंगे।
वैश्विक वस्तुओं का "DESTROY" कभी नहीं चलाया जाएगा।

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

उप f_myfunc {
मेरा $तर्क = &arg; # तर्क को नाम दें.
मेरा(अनिर्धारित, $mkfile, $mkfile_line) = @_; #तर्कों को नाम दें.

...यहाँ कुछ करो

वापसी $ वापसी_मूल्य;
}

XYZ := $(myfunc मेरे func तर्क)

यदि आपका फ़ंक्शन कोई तर्क नहीं लेता है, तो करने के लिए कुछ भी नहीं है। यदि आपका कार्य एक लेता है
तर्क, जैसा कि ऊपर दिए गए उदाहरण में है, इसे प्राप्त करने के लिए सरल एक्सेसर &arg का उपयोग करें। अगर आप
अधिक तर्कों की अपेक्षा करें, आपको नीचे वर्णित अधिक जटिल एक्सेसर "आर्ग्स" की आवश्यकता है।

ये एक्सेसर्स उन्हीं तीन पैरामीटर्स को प्रोसेस करते हैं जिन्हें किसी भी "f_" को पास किया जाना चाहिए
फ़ंक्शन, अर्थात् फ़ंक्शन तर्क, मेकफ़ाइल ऑब्जेक्ट और एक लाइन डिस्क्रिप्टर
संदेश. इसलिए आप पहले मामले में कुशल &arg फॉर्म का उपयोग कर सकते हैं।

&arg एक्सेसर आपके लिए निम्नलिखित का ध्यान रखता है: यदि तर्क पहले से ही थे
विस्तारित (उदाहरण के लिए "$(my$(function) arg)" में फ़ंक्शन का नाम ढूंढने के लिए तर्क है
एक स्ट्रिंग के रूप में पारित किया गया और अभी लौटा। यदि तर्क को अभी भी विस्तार की आवश्यकता है, तो यही है
सामान्य स्थिति में, इसके बजाय यह एक स्ट्रिंग का संदर्भ है। &arg एक्सेसर आपके लिए इसका विस्तार करता है,
जिसके लिए उसे दूसरे पैरामीटर के रूप में मेकफ़ाइल ऑब्जेक्ट की आवश्यकता होती है।

यदि आप अधिक तर्कों की अपेक्षा करते हैं, संभवतः परिवर्तनीय संख्या में, तो कार्य "आर्ग्स" द्वारा किया जाता है।
यह एक्सेसर arg के समान 3 पैरामीटर, साथ ही अतिरिक्त पैरामीटर लेता है:

अधिकतम: तर्कों की संख्या (डिफ़ॉल्ट 2): अनंत के लिए ~0 (अधिकतम) दें
न्यूनतम: तर्कों की संख्या (डिफ़ॉल्ट 0 यदि अधिकतम ~0 है, अन्यथा अधिकतम के समान)
केवल_अल्पविराम: अल्पविराम के आसपास जगह न रखें, आमतौर पर गैर-फ़ाइल नाम के लिए

अधिकतम अधिकतम, लेकिन विस्तार से पहले मौजूद न्यूनतम अल्पविराम का उपयोग विभाजित करने के लिए किया जाता है
तर्क. मेकप के अंतर्निहित कार्यों से कुछ उदाहरण:

मेरा( $उपसर्ग, $पाठ ) = तर्क $_[0], $_[1], $_[2], 2, 2, 1; # उपसर्ग जोड़ें
मेरे $cond के लिए (args $_[0], undef, $_[2], ~0 ) ... # और, या
मेरे @args= args $_[0], $_[1], $_[2], ~0, 1, 1; # पुकारना
मेरा( $फ़िल्टर, $शब्द ​​) = तर्क $_[0], $_[1], $_[2]; #फ़िल्टर

फ़ंक्शन को एक स्केलर स्ट्रिंग (कोई सरणी नहीं) लौटानी चाहिए जिसे बाद में इसमें डाला जाता है
उस बिंदु पर पाठ.

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

फ़ंक्शन क्या कर सकता है, इसकी मूलतः कोई सीमा नहीं है; आप फ़ाइल तक पहुंच सकते हैं, चला सकते हैं
शेल कमांड, आदि

वर्तमान समय में निर्भरता और नियम क्रियाओं में प्रदर्शित होने वाले भावों का विस्तार हो रहा है
एक बार जबकि लक्ष्य में दिखाई देने वाले भाव दो बार विस्तारित होते हैं, इसलिए यदि आप सावधान रहें
फ़ंक्शन के दुष्प्रभाव होते हैं और यह लक्ष्य के लिए अभिव्यक्ति में मौजूद होता है।

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

उप f_foo {
...
chdir $makefile->{CWD};

... आदि।
}

लाना कार्यों में a पर्ल मॉड्यूल
यदि आप किसी सम्मिलित फ़ाइल में फ़ंक्शंस डालते हैं, तो आपके पास प्रति Makeppfile की एक प्रति होगी
इसका उपयोग करता है. इससे बचने के लिए, आप उन्हें "निर्यातक" के साथ एक सामान्य पर्ल मॉड्यूल के रूप में लिख सकते हैं
इंटरफ़ेस, और उसका उपयोग करें। यह तेजी से लोड होगा और मेमोरी बचाएगा:

पर्ल { mymodule का उपयोग करें }
पर्ल {
my::मॉड्यूल का उपयोग करें; # : को एक नई लाइन पर रखें, इसलिए इसे नियम के रूप में पार्स नहीं किया जाता है
}

यदि आपको मेकफ़ाइल में सामान्य रूप से उपलब्ध किसी फ़ंक्शन की आवश्यकता है (जैसे "f_"
फ़ंक्शंस, "आर्ग" या "आर्ग्स"), आपको यह पंक्ति अपने मॉड्यूल में डालनी होगी:

एमपीपी::सब्स का उपयोग करें;

दोष यह है कि मॉड्यूल सीधे फ़ंक्शन की तुलना में एक अलग पैकेज में होगा
मेकफ़ाइल में दिखाई दे रहा है। इसलिए आपको हर चीज़ को पैरामीटर या निर्माण के रूप में पारित करने की आवश्यकता है
पर्ल के "कॉलर" फ़ंक्शन वाले नाम।

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

&आदेश तर्क ...
यह एक नियम कार्रवाई हो सकती है. यह एक फ़ंक्शन कॉल करेगा आदेश "c_" उपसर्ग के साथ, और
इसे शेष (वैकल्पिक रूप से उद्धृत मेकप शैली) पास करें - बिल्कुल वैसा ही नहीं
शैल) तर्क। यदि ऐसा कोई फ़ंक्शन नहीं मिल पाता है, तो यह सभी स्ट्रिंग्स को पास कर देता है
"दौड़ना"।

उप c_mycmd { मेरा @args = @_; ... }

$(फोनी कॉलसीएमडी):
&mycmd 'arg with space' arg2 "arg3" # कॉल c_mycmd

%।में बाहर
&myscript -o $(आउटपुट) $(इनपुट) # बाहरी myscript को कॉल करता है

आप अपने कमांड को बिल्टिन के ढांचे के भीतर लिख सकते हैं, जिससे आपको उपयोग करने की अनुमति मिलती है
वही मानक विकल्प जो उनके पास हैं, और जो I/O प्रबंधन वे देते हैं।

ब्लॉक ऑपरेटर "Mpp::Cmds::frame" के बाद एकल अक्षर विकल्प सूची आती है
बिल्टिंस (अधिकतम "qw(f i I o O r s)")। भले ही आप अपना स्वयं का विकल्प निर्दिष्ट करें
इनमें से किसी एक को ओवरराइड करते हुए, आप अभी भी मानक विकल्प का एक अक्षर देते हैं।

प्रत्येक विकल्प को "[qw(n name)" के रूप में निर्दिष्ट किया गया है। \$संदर्भ, तर्क, विषय]". पहले दो
तत्व छोटे और लंबे नाम हैं, इसके बाद चर संदर्भ और वैकल्पिक रूप से हैं
तर्क लेना है या नहीं इसके लिए एक बूलियन। बिना तर्क के, वेरिएबल है
हर बार विकल्प दिए जाने पर वृद्धि होती है, अन्यथा विकल्प का मूल्य इसमें संग्रहीत हो जाता है।

उप c_my_ocmd { # विशिष्ट आउटपुट केस
स्थानीय @ARGV = @_;
एमपीपी::सीएमडी::फ़्रेम {

... यहां @ARGV के साथ कुछ प्रिंट करें, विकल्प पहले से ही स्वचालित रूप से हटा दिए गए हैं

} 'एफ', क्यूडब्ल्यू(ओ ओ);
}

उप c_my_icmd { # 2 विकल्पों के साथ विशिष्ट इनपुट केस
स्थानीय @ARGV = @_;
मेरा ($छोटा, $लंबा );
एमपीपी::सीएमडी::फ़्रेम {

...यहां <> के साथ कुछ करें

} qw(i I r s), # s केवल --विभाजक निर्दिष्ट करता है, -s नहीं
[qw(s छोटा), \$छोटा], # कोई विकल्प arg नहीं -> $छोटा == 1
[qw(l लंबा), \$लंबा, 1, उप {चेतावनी "गॉट आर्ग $लंबा"}];
}

यहां एक सरल कमांड आती है जो प्रत्येक इनपुट के केवल पहले अक्षर को ऊपर उठाती है
रिकॉर्ड ("&sed '$$_ = "\u\L$$_"'' के बराबर):

उप c_uc {
स्थानीय @ARGV = @_;
एमपीपी::सीएमडी::फ़्रेम {
"\u\L$_" प्रिंट करें जबकि <>;
} 'एफ', क्यूडब्ल्यू(आई आई ओ ओ आर एस);
}

फ़्रेम द्वारा प्रबंधित ब्लॉक के भीतर, आपके पास महत्वपूर्ण प्रदर्शन के लिए नेस्टेड ब्लॉक हो सकते हैं
संचालन, जैसे अन्य फ़ाइलें खोलना।

Mpp::Cmds::perform {... } 'संदेश';

यदि यह "--verbose" (जिसे प्रत्येक कमांड स्वीकार करता है) के साथ संदेश आउटपुट करेगा
कमांड सफलतापूर्वक चलायी गयी है. लेकिन यदि ब्लॉक का मूल्यांकन गलत के रूप में किया जाता है, तो यह समाप्त हो जाता है
नकारा संदेश.

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

पर्ल { mylib का उपयोग करें } # उन सभी नियमों में शामिल हो जाता है जिन्हें दोबारा पार्स करने की आवश्यकता नहीं होती है

%।में बाहर
मेकपरल {रन qw'myscript -o $(आउटपुट) $(इनपुट)' }

यदि स्क्रिप्ट "बाहर निकलें" कहती है, तो मानक फ़ाइल डिस्क्रिप्टर को बंद कर देती है या सिस्टम पर निर्भर हो जाती है
इसके बाद साफ़ करने के लिए (फ़ाइलें खोलें, मेमोरी...), यह "रन" के साथ एक समस्या हो सकती है। अगर
आप स्टेटमेंट या पर्ल फ़ंक्शन के भीतर "रन" कहते हैं, मेकप परेशान हो सकता है या
सफ़ाई केवल मेकप के अंत में होती है।

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

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

इसे कई तरीकों से पूरा किया जा सकता है। सबसे आसान तरीका है अपना खुद का नया बनाना
हस्ताक्षर विधि (चलिए इसे "shared_object" कहते हैं)। आप इस हस्ताक्षर विधि का उपयोग करेंगे
केवल उन नियमों पर जो बायनेरिज़ को जोड़ते हैं, जैसे:

मायप्रोग्राम: *.o lib1/lib1.so lib2/lib2.so
: हस्ताक्षर साझा_ऑब्जेक्ट
$(CC) $(इनपुट) -o $(आउटपुट)

अब हमें सिग्नेचर मेथड बनाना है।

सभी हस्ताक्षर विधियों का अपना वर्ग होना चाहिए, और वर्ग में कुछ विशेष शामिल होने चाहिए
आइटम (विवरण के लिए वितरण में Mpp/Signature.pm देखें)। कक्षा का नाम होना चाहिए
"Mpp::Signature::" के उपसर्ग में, इसलिए इस मामले में हमारी कक्षा को बुलाया जाना चाहिए
"एमपीपी::हस्ताक्षर::साझा_ऑब्जेक्ट"। हमें एक फाइल बनानी है जिसका नाम है share_object.pm और रखें
यह एक में एमपीपी::हस्ताक्षर पर्ल में कहीं निर्देशिका में पथ शामिल है; सबसे आसान जगह
में हो सकता है एमपीपी/हस्ताक्षर मेकप इंस्टॉलेशन में निर्देशिका (उदाहरण के लिए,
/usr/local/share/makepp/Mpp/Signature या जहाँ भी आपने इसे स्थापित किया है)।

इस कक्षा में क्या जाना है, इसके बारे में सटीक विवरण के लिए, आपको ध्यान से देखना चाहिए
फ़ाइल Mpp/Signature.pm और शायद भी Mpp/हस्ताक्षर/exact_match.pm मेकप में
वितरण। लेकिन हमारे मामले में, हम बस इतना करना चाहते हैं कि इसमें एक बहुत छोटा सा बदलाव किया जाए
मौजूदा हस्ताक्षर तंत्र; यदि फ़ाइल एक साझा लाइब्रेरी है, तो हम एक स्थिरांक रखना चाहते हैं
हस्ताक्षर, जबकि यदि फ़ाइल कुछ और है, तो हम मेकप के सामान्य पर भरोसा करना चाहते हैं
हस्ताक्षर तंत्र. ऐसा करने का सबसे अच्छा तरीका विरासत से प्राप्त करना है
"Mpp::Signature::c_compilation_md5", जो हस्ताक्षर विधि है जिसे आमतौर पर चुना जाता है
जब मेकप एक लिंक कमांड को पहचानता है।

तो फ़ाइल Mpp/हस्ताक्षर/shared_object.pm इसमें निम्नलिखित शामिल हो सकते हैं:

सख्त उपयोग करें;
पैकेज Mpp::हस्ताक्षर::shared_object;
Mpp::Signature::c_compilation_md5 का उपयोग करें;
हमारा @ISA = qw(Mpp::Signature::c_compilation_md5); #विरासत का संकेत दें.
हमारा $shared_object = आशीर्वाद \@ISA; # जादू का एक टुकड़ा जो मेकप को ढूंढने में मदद करता है
# इस विधि के लिए सबरूटीन्स. सभी
# हस्ताक्षर विधियों में इनमें से एक होना चाहिए।
# मान का उपयोग नहीं किया जाता है, बस किसी वस्तु का उपयोग किया जाता है।
# अब यहां वह विधि है जिसे तब कॉल किया जाता है जब हमें हस्ताक्षर की आवश्यकता होती है
# कोई भी लक्ष्य या निर्भरता जिसके लिए यह हस्ताक्षर विधि सक्रिय है:
उप हस्ताक्षर {
मेरा ($स्वयं, # यह $shared_object के समान होगा।
$finfo) = @_; # एक विशेष संरचना जिसमें सब कुछ समाहित है
# मेकप्प को इस फाइल के बारे में पता है। देखना
विवरण के लिए # Mpp/File.pm.

यदि ($finfo->{NAME} =~ /\.s[oa]$/) { # क्या फ़ाइल का नाम .so या .sa में समाप्त होता है?
$finfo->file_exists लौटाएँ? 'मौजूद' : '';
# यदि फ़ाइल हो तो हमेशा वही हस्ताक्षर लौटाएँ
# मौजूद। इस मामले में, हस्ताक्षर है
# स्ट्रिंग "मौजूद है"।
}

एमपीपी::हस्ताक्षर::c_संकलन_md5::हस्ताक्षर;
# यदि फ़ाइल .so या .sa में समाप्त नहीं होती,
# मेकप की सामान्य हस्ताक्षर विधि को सौंपें।
}

यह फ़ाइल कुछ अतिरिक्त के साथ, मेकप वितरण में एक उदाहरण के रूप में प्रदान की गई है
टिप्पणी.

संयोगवश, हम इसे डिफ़ॉल्ट क्यों नहीं बनाते? खैर, ऐसे भी समय होते हैं जब कोई परिवर्तन होता है
साझा लाइब्रेरी के लिए आपके प्रोग्राम को पुनः लिंक करने की आवश्यकता होगी। यदि आप कभी भी इनमें से किसी एक को बदलते हैं
वे प्रतीक जिन्हें एक साझा लाइब्रेरी परिभाषित करती है, या वे प्रतीक जिन्हें वह अन्य पुस्तकालयों पर निर्भर करती है
क्योंकि, दोबारा लिंक करना कभी-कभी आवश्यक हो सकता है।

उदाहरण के लिए, मान लीजिए कि साझा लाइब्रेरी आपके प्रोग्राम के कुछ सबरूटीन्स को आमंत्रित करती है
प्रदान करता है. उदाहरण के लिए, मान लीजिए कि आप साझा लाइब्रेरी को बदलते हैं तो यह अब एक बाहरी कॉल करता है
सबरूटीन "xyz()"। जब तक आप लिंकर के लिए "-E" या "--export-dynamic" विकल्प का उपयोग नहीं करते
(जीएनयू बिनुटिल्स के लिए; अन्य लिंकर्स के पास अलग-अलग विकल्प नाम हैं), प्रतीक "xyz()" नहीं हो सकता है
रन-टाइम लिंकर तक पहुंच योग्य रहें, भले ही वह आपके प्रोग्राम में मौजूद हो।

इससे भी बदतर, मान लीजिए कि आपने किसी अन्य लाइब्रेरी में "xyz()" परिभाषित किया है (इसे कॉल करें)। libxyz), इस कदर:

मेरा_प्रोग्राम: main.o lib1/lib1.so xyz/libxyz.a

चूँकि "libxyz" एक है .a फ़ाइल और नहीं एक .so फ़ाइल, तो "xyz()" को अंदर नहीं खींचा जा सकता है
से सही ढंग से libxyz.a जब तक आप अपनी बाइनरी को पुनः लिंक नहीं करते।

Mpp::हस्ताक्षर विधियाँ न केवल उस स्ट्रिंग को नियंत्रित करती हैं जिसका उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या
फ़ाइल बदल गई है, लेकिन एल्गोरिदम जिसका उपयोग स्ट्रिंग्स की तुलना करने के लिए किया जाता है। उदाहरण के लिए,
मेकप वितरण में हस्ताक्षर विधि "target_newer" के लिए केवल यह आवश्यक है कि
लक्ष्य निर्भरताओं से नए होंगे, जबकि हस्ताक्षर विधि "exact_match" (और
वह सब कुछ जो इस पर निर्भर करता है, जैसे कि "md5" और "c_compilation_md5") के लिए आवश्यक है कि
फ़ाइल में अंतिम बिल्ड के समान ही हस्ताक्षर हैं।

यहां कुछ अन्य प्रकार की हस्ताक्षर विधियां दी गई हैं जो आपको समझने में मदद करने के लिए उपयोगी हो सकती हैं
संभावनाएं। यदि सामान्य उद्देश्य पर्याप्त हो, तो इनमें से कुछ अंततः हो सकते हैं
मेकप में शामिल:

· साझा पुस्तकालयों के लिए एक हस्ताक्षर विधि जो सभी निर्यातित वस्तुओं का चेकसम लौटाती है
प्रतीक, और वे सभी प्रतीक जिनकी उसे अन्य पुस्तकालयों से आवश्यकता है। यह हल करता है
उपरोक्त उदाहरण में समस्या है, और सभी परिस्थितियों में सही लिंक की गारंटी देता है।
मेकप वितरण में ऐसा करने का एक प्रायोगिक प्रयास किया गया है (देखें)।
Mpp/हस्ताक्षर/shared_object.pm), लेकिन यह केवल GNU बिनुटिल्स और ELF के साथ काम करेगा
इस समय पुस्तकालय.

· एक हस्ताक्षर विधि जो किसी फ़ाइल में लिखी गई दिनांक मोहर को अनदेखा करती है। उदाहरण के लिए, यदि आप
उत्पन्न करें .c कुछ प्रोग्राम का उपयोग करके स्वचालित रूप से फ़ाइल करें जो एक स्ट्रिंग डालने पर जोर देता है
इस प्रकार:

स्थिर वर्ण * दिनांक_स्टाम्प = "01 अप्रैल 2004 को किसी के द्वारा स्वचालित रूप से उत्पन्न नहीं हुआ";

आप एक हस्ताक्षर विधि लिख सकते हैं जो विशेष रूप से दिनांक टिकटों में परिवर्तनों को अनदेखा करती है।
इस प्रकार यदि दिनांक स्टाम्प ही एकमात्र चीज़ है जो बदल गई है, तो मेकप पुनर्निर्माण नहीं करेगा।

· एक हस्ताक्षर विधि जो हस्ताक्षरों की सामान्य तरीके से गणना करती है, लेकिन इसे अनदेखा कर देती है
पुनर्निर्माण करना है या नहीं, यह तय करते समय वास्तुकला पर निर्भरता। यह इसके लिए उपयोगी हो सकता है
वास्तव में वास्तुकला-स्वतंत्र फ़ाइलें; वर्तमान में यदि आप एक वास्तुकला पर निर्माण करते हैं,
जब आप स्विच करेंगे तो मेकप आर्किटेक्चर-स्वतंत्र फ़ाइलों के पुनर्निर्माण पर भी जोर देगा
एक अलग वास्तुकला के लिए.

· एक हस्ताक्षर विधि जो लेटेक्स फ़ाइलों में टिप्पणियों को अनदेखा करना जानती है
"c_compilation_md5" विधि C फ़ाइलों में टिप्पणियों को अनदेखा करना जानती है।

· स्वचालित दस्तावेज़ निष्कर्षण के लिए एक हस्ताक्षर विधि जो केवल चेकसम को जोड़ती है
टिप्पणियाँ जो एक दस्तावेज़ निकालने वाले को चाहिए और स्रोत में अन्य परिवर्तनों को अनदेखा कर देता है
फ़ाइल.

अधूरा
यह दस्तावेज़ अभी ख़त्म नहीं हुआ है. इसमें यह शामिल होना चाहिए कि अपने स्वयं के स्कैनर कैसे लिखें
फ़ाइलें और उस जैसी चीज़ें शामिल करें।

onworks.net सेवाओं का उपयोग करके ऑनलाइन makepp_extending का उपयोग करें