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

कार्यक्रम:

नाम

makepp_functions--makepp में फ़ंक्शन

वर्णन

A: निरपेक्ष_फ़ाइलनाम,
निरपेक्ष_फ़ाइलनाम_नोलिंक,
Abspath,
उपसर्ग जोड़ें,
जोड़ा प्रत्यय,
तथा, B: आधार नाम, C: , फोन D: डीआईआर,
dir_noslash, E: त्रुटि, F: फाइल सबस्ट,
फिल्टर,
फिल्टर खतम हो गया,
फ़िल्टर_आउट_डीआईआर,
फ़ाइल ढूंढे,
पहले_ऊपर_खोजें,
खोज_प्रोग्राम,
फाइंडस्ट्रिंग,
खोजें_ऊपर की ओर,
प्रथम_उपलब्ध,
पहला शब्द,
प्रत्येक के लिए, I: अगर,
यदि सही,
अनुमान_लिंकर,
infer_objects,
जानकारी, J: शामिल हों, M: निर्माण,
मेकमैप,
मेकपर्ल,
नक्शा,
"एमकेटेम्प", N: नोटदिर, O: केवल_उत्पन्न,
केवल_लक्ष्य नहीं,
केवल_फोनी_लक्ष्य,
केवल_बासी,
केवल_लक्ष्य,
या,
मूल, P: पैटसबस्ट,
पर्ल,
नकली,
पूर्व निर्माण,
प्रिंट करें, R: वास्तविक पथ,
सापेक्ष_फ़ाइलनाम,
के सापेक्ष, S: खोल,
छाँटना,
पट्टी,
स्थानापन्न,
प्रत्यय, T: अस्थायी, W: चेतावनी,
वाइल्डकार्ड,
शब्द,
शब्द सूची,
शब्दों, X: xargs

"$(नाम)" प्रारूप की कोई भी अभिव्यक्ति, जहां "नाम" किसी चर का नाम नहीं है, या
"$(नाम arg1 arg2 arg3)" की व्याख्या एक फ़ंक्शन कॉल के रूप में की जाती है। नाम में अक्षर हो सकते हैं,
अंडरस्कोर, या हाइफ़न; भ्रम से बचने के लिए, आप हाइफ़न या अंडरस्कोर का उपयोग कर सकते हैं
परस्पर विनिमय के कारण, चूँकि आंतरिक रूप से हाइफ़न अंडरस्कोर में परिवर्तित हो जाते हैं। ऐसे मूल्यांकन कर रहे हैं
एक अभिव्यक्ति बस एक पर्ल सबरूटीन का आह्वान करती है। यदि "नाम" के पहले "&" आता है तो यह चलता है
मेकप प्रक्रिया के भीतर उस नाम का अंतर्निहित कमांड या स्क्रिप्ट, और मानक लौटाता है
आउटपुट. इसके लिए PerlIO के लिए पर्ल का निर्माण करना आवश्यक है। यदि नाम में किसी फ़ंक्शन का नाम नहीं है
यह कॉल के आह्वान में बदल जाता है।

वैरिएबल की तरह आपके पास "$(नाम ...)" या "${नाम ...}" का विकल्प होता है। यदि आप चाहते हैं
समान कोष्ठक एम्बेड करें, इसे युग्मित किया जाना चाहिए, अन्य कोई मायने नहीं रखता: "$(name
...(){..." या "${नाम ...{}(...}"। (हालांकि मानचित्र और पर्ल के लिए पहला समापन पैरेन समाप्त होता है
अभिव्यक्ति।) दोहरीकरण तर्कों को कई पंक्तियों तक फैलाने की अनुमति देता है। नई लाइनें हैं
फिर संभवतः "परिभाषित" को छोड़कर, रिक्त स्थान के रूप में माना जाता है। इसमें सिंटैक्स "$[name...]" भी है
या $[[नाम ...]], जिसका मूल्यांकन ग्रॉकिंग नियमों से पहले मेकफ़ाइल पढ़ते समय किया जाता है
और अन्य निर्माण।

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

सशर्त कार्य
और शर्त1[,हालत2[,हालत3...]]
और फ़ंक्शन "शॉर्ट-सर्किटिंग" AND ऑपरेशन प्रदान करता है। प्रत्येक तर्क है
विस्तारित, क्रम में। यदि कोई तर्क एक खाली स्ट्रिंग तक विस्तारित हो जाता है तो प्रोसेसिंग रुक जाती है और
विस्तार का परिणाम खाली स्ट्रिंग है। यदि सभी तर्कों का विस्तार गैर-तक होता है
खाली स्ट्रिंग तो विस्तार का परिणाम अंतिम तर्क का विस्तार है।

if स्ट्रिंग, परिणाम-यदि-स्ट्रिंग-खाली नहीं[, परिणाम-यदि-स्ट्रिंग-रिक्त]
यदि सही स्ट्रिंग, परिणाम-यदि-स्ट्रिंग-सत्य[, परिणाम-यदि-स्ट्रिंग-गलत]
"ifeq", आदि कथनों का एक विकल्प। यदि स्ट्रिंग रिक्त नहीं है (अर्थात,
शर्त सत्य है), दूसरा तर्क ("तब" खंड) लौटाया जाता है (बाद में)।
परिवर्तनशील विस्तार); यदि स्ट्रिंग रिक्त है, तो तीसरा तर्क ("अन्य" खंड) है
लौटा हुआ।

उदाहरण के लिए,

CFLAGS := $(यदि $(फ़िल्टर gcc egcc, $(CC)), -g -दीवार, -g)

यदि चर CC या तो "gcc" या "egcc", और "-g" है तो CFLAGS को "-g -Wall" के रूप में परिभाषित करता है।
अन्यथा। (डिफ़ॉल्ट बिल्ड नियम यही करते हैं।)

"iftrue" "if" के समान है, सिवाय इसके कि स्ट्रिंग 0 को रिक्त माना जाता है।

or शर्त1[,हालत2[,हालत3...]]
या फ़ंक्शन "शॉर्ट-सर्किटिंग" OR ऑपरेशन प्रदान करता है। प्रत्येक तर्क का विस्तार किया गया है,
क्रम में। यदि कोई तर्क एक गैर-रिक्त स्ट्रिंग तक विस्तारित होता है तो प्रसंस्करण रुक जाता है और
विस्तार का परिणाम वह स्ट्रिंग है। यदि, सभी तर्कों का विस्तार करने के बाद, सभी
वे झूठे (खाली) हैं, तो विस्तार का परिणाम खाली स्ट्रिंग है।

पट्टिका और फ़ाइल का नाम कार्य
निरपेक्ष_फ़ाइलनाम फ़ाइलों
एब्सपथ फ़ाइलों
सापेक्ष फ़ाइल नामों को बिना निरपेक्ष में परिवर्तित करता है . or ..। उदाहरण के लिए,
"$(absolute_filename xyz.c)" "/usr/src/our_project/subdir/xyz.c" लौटा सकता है।

निरपेक्ष_फ़ाइलनाम_नोलिंक फ़ाइलों
वास्तविक पथ फ़ाइलों
निरपेक्ष_फ़ाइल नाम की तरह, लेकिन यह सुनिश्चित करता है कि प्रतीकात्मक लिंक हल हो गए हैं।

बेसनाम फ़ाइल नाम
बेसनेम संपूर्ण फ़ाइल नाम (निर्देशिका के साथ) है, और के बाद टेक्स्ट को घटा देता है
अंतिम अवधि सहित. उदाहरण के लिए, "$(basename myfile/version-1.0-module.c)" है
"माईफ़ाइल/संस्करण-1.0-मॉड्यूल"

दीर फ़ाइल नाम
फ़ाइल नाम सूची में प्रत्येक फ़ाइल का निर्देशिका भाग, जिसमें अनुगामी भी शामिल है, निकालता है
काटना. यदि फ़ाइल नाम में कोई निर्देशिका नहीं है तो "./" लौटाता है।

dir_noslash फ़ाइल का नाम
"$(dir )" के समान, सिवाय इसके कि यह पिछला स्लैश नहीं लौटाता।

फाइल सबस्ट पैटर्न, विकल्प, शब्द
फ़ाइल नामों पर एक पैटर्न प्रतिस्थापन करें. यह पैटसबस्ट से भिन्न है
जब निर्देशिकाओं के लिए वैकल्पिक नाम दिए जाएंगे तो यह सही ढंग से कार्य करेगा
वे प्रतिशत चिह्न से पहले आते हैं)। उदाहरण के लिए,

$(filesubst ./src/%c, %o, $(वाइल्डकार्ड src/*.c))

फाइल सबस्ट के साथ काम करेगा लेकिन पैट सबस्ट के साथ नहीं।

फ़िल्टर_आउट_डीआईआर फ़ाइल नाम
उन सभी फ़ाइलनामों को लौटाता है जो निर्देशिकाओं को संदर्भित नहीं करते हैं।

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

TCL_INCLUDE := -I$(dir_noslash $(findfile tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/include \
/usr/include/tcl8.4 /usr/include/tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

यह फ़ाइल का पता लगाता है टीसीएल.एच उपरोक्त सभी निर्देशिकाओं को खोजकर। पूर्ण
फ़ाइल का पथ लौटा दिया गया है. फिर "$(dir_noslash )" उस निर्देशिका को निकालता है, और उसे
सम्मिलित पथ में डाल दिया गया है।

खोज_प्रोग्राम नाम
सूची में पहला प्रोग्राम लौटाएँ जो PATH में पाया जा सकता है। यह उपयोगी है
जब कई समतुल्य प्रोग्राम हों जिनका उपयोग किया जा सकता है, और आप बस करना चाहते हैं
उनमें से एक चुनें. उदाहरण के लिए, यहां कई सामान्य की डिफ़ॉल्ट परिभाषा दी गई है
यदि आप अपने मेकफ़ाइल में एक नहीं डालते हैं तो वे वेरिएबल जो मेकप आपूर्ति करता है:

CC = $(find_program gcc egcc pgcc c89 cc) # और अधिक, मशीन पर निर्भर करता है
F77 = $(find_program f77 g77 fort77)
CXX = $(find_program g++ c++ pg++ cxx CC aCC)

यदि कोई भी प्रोग्राम नहीं मिलता है, तो "$(find_program )" स्ट्रिंग नहीं मिला लौटाता है, और
जो नहीं मिला उसे लॉग करता है। इसका परिणाम आम तौर पर कार्यात्मक मेकफ़ाइल नहीं होगा, लेकिन यह
बेहतर त्रुटि संदेश देने की प्रवृत्ति होगी। उदाहरण के लिए, यदि आप कुछ ऐसा करते हैं
इस:

%.ओ:%.सी
$(CC) $(इनपुट) -o $(आउटपुट)

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

ऊपर की ओर खोजें फ़ाइल का नाम
निर्देशिका में दिए गए नाम की फ़ाइल की खोज करता है।, .., ../ .., ।।/../.., आदि,
जब तक फ़ाइल नहीं मिल जाती या रूट निर्देशिका तक नहीं पहुंच जाती या निर्देशिका स्थित नहीं हो जाती
किसी भिन्न फ़ाइल सिस्टम पर. (यह अंतिम आवश्यकता समस्याओं को रोकने के लिए है
ऑटोमाउंटर्स या हैंग नेटवर्क फ़ाइल सिस्टम।) यदि आपके पास ए रूटमेकप्पफाइल, वह भी है
एक बाधा जो उच्चतर खोज करने से रोकती है।

उदाहरण के लिए, यदि आपके पास उपनिर्देशिकाओं के कई स्तरों वाला एक प्रोजेक्ट है, तो आप ऐसा कर सकते हैं
इस सामान्य टुकड़े को सभी मेकफ़ाइलों में शामिल करें (उदाहरण के लिए, "शामिल करें" का उपयोग करके)
कथन):

TOP_LEVEL_INCLUDE_DIR := $(find_upwards शामिल है)
# उस निर्देशिका की खोज करता है जिसमें शामिल है
# उपनिर्देशिका शामिल है.

%.ओ:%.सी
$(CC) $(CFLAGS) -I$(TOP_LEVEL_INCLUDE_DIR) -c $(इनपुट) -o $(आउटपुट)

एक और समस्या जिसे "find_upwards" हल करने में मदद कर सकता है वह है शीर्ष-स्तरीय निर्देशिका का पता लगाना
एक निर्माण का. अक्सर किसी वेरिएबल को इस प्रकार परिभाषित करना उपयोगी होता है:

शीर्ष:= ../../..

यदि आपके पास कुछ महत्वपूर्ण जानकारी केवल शीर्ष-स्तरीय निर्देशिका में स्थित है। लेकिन
इसे बनाए रखना कठिन है, क्योंकि विभिन्न स्तरों के लिए ".." की संख्या अलग-अलग है
निर्देशिका वृक्ष का. इसके बजाय, आप फ़ाइल का पता लगाने के लिए "find_upwards" का उपयोग कर सकते हैं
केवल शीर्ष स्तरीय निर्देशिका में मौजूद होने के लिए जाना जाता है। उदाहरण के लिए, मान लीजिए कि
फ़ाइल "लाइसेंस" केवल शीर्ष स्तर निर्देशिका में स्थित है। तब आप यह कर सकते हैं:

टॉप := $(dir_noslash $(find_upwards LICENSE))

"$(find_upwards LICENSE)" लाइसेंस फ़ाइल का पूरा पथ लौटाता है;
"$(dir_noslash ...)" फ़ाइल का नाम हटा देता है, केवल निर्देशिका लौटाता है।

(ध्यान दें कि "शामिल करें" कथन स्वचालित रूप से फ़ाइलों के लिए ऊपर की ओर खोज करता है, इसलिए वहां
ऐसा कुछ करने की कोई आवश्यकता नहीं है:

$(find_upwardstop_level_rules.mk) शामिल करें

इसके बजाय, आप बस कर सकते हैं

शीर्ष_स्तर_नियम.एमके शामिल करें

और यह वैसे ही काम करेगा।)

यदि फ़ाइल नहीं मिलती है, तो "find_upwards" एक त्रुटि संदेश के साथ निर्माण को रोक देगा।

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

$(फ़ाइल_ऊपर की ओर ढूंढें फ़ाइल1 फ़ाइल2)

के बराबर है

$(फ़ाइल को ऊपर की ओर ढूंढें1) $(फ़ाइल को ऊपर की ओर ढूंढें2)

यदि आप किसी एक फ़ाइल को खोजना चाहते हैं, तो इसके बजाय "find_first_upwards" का उपयोग करें।

पहले_ऊपर_खोजें file1 file2 ...
यह फ़ंक्शन "find_upwards" की तरह व्यवहार करता है, सिवाय इसके कि यह किसी की पहली फ़ाइल लौटाता है
सूची में फ़ाइलें जो इसे मिलती हैं। विशेष रूप से, यह वर्तमान निर्देशिका की जाँच करता है
सूची में से कोई भी फ़ाइल, और पहली फ़ाइल लौटाता है जो मौजूद है या बनाई जा सकती है।
यदि उस निर्देशिका में कोई भी फ़ाइल मौजूद नहीं है या बनाई जा सकती है, तो यह जाँच करता है .., तो
../ .., आदि, जब तक कि यह या तो रूट डायरेक्टरी या किसी डायरेक्टरी तक नहीं पहुंच जाता
किसी भिन्न फ़ाइल सिस्टम पर स्थित है.

प्रथम_उपलब्ध file1 file2 ...
सूची में पहली फ़ाइल लौटाएँ जो मौजूद है या बनाई जा सकती है। इसके लिए यह उपयोगी हो सकता है
कई अलग-अलग मशीनों या नेटवर्क पर काम करने के लिए अपनी मेकफ़ाइल्स को अनुकूलित करना, जहाँ
महत्वपूर्ण फ़ाइलें विभिन्न स्थानों पर स्थित हो सकती हैं। उदाहरण के लिए, यहाँ से एक पंक्ति है
मेरी मेकफ़ाइलों में से एक:

TCL_LIB = $(first_available \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

यह लाइन उपरोक्त सभी स्थानों पर रुकते हुए टीसीएल लाइब्रेरी की जांच करेगी
पहला जो इसे मिलता है। फिर लिंक कमांड में $(TCL_LIB) शामिल होता है इसलिए हमें मिलता है
उपयुक्त टीसीएल लाइब्रेरी।

infer_linker file1 file2 ...
ऑब्जेक्ट फ़ाइलों की एक सूची दी गई है, यदि वे अभी तक नहीं बनाई गई हैं तो पहले उन्हें बनाएं। फिर ढूंढो
चाहे वे फोरट्रान, सी++ या सी स्रोत पर निर्भर हों और संबंधित लौटाएं
कंपाइलर (जो "एलडी" से बेहतर लिंक करना जानता है)।

infer_objects file1 file2 ... पैटर्न
$(infer_objects object1.o object2.o, *.o)

यदि आप हेडर फ़ाइल नामों के संबंध में मानक सम्मेलनों का उपयोग करते हैं, तो मेकप सक्षम है
यह अनुमान लगाना कि कौन सी ".o" या ".lo" फ़ाइलों को आपके प्रोग्राम से लिंक करने की आवश्यकता है। मैं इसका उपयोग करता हूं
लाइब्रेरी निर्देशिका से फ़ाइलें चुनें जिनमें कई अलग-अलग उपयोग किए गए मॉड्यूल शामिल हैं
कार्यक्रम. लाइब्रेरी ".a" फ़ाइल बनाने और लिंकर को चुनने के बजाय
प्रासंगिक मॉड्यूल, मेकप आपके लिए प्रासंगिक मॉड्यूल चुन सकता है। इस तरह, केवल
प्रासंगिक मॉड्यूल संकलित हो जाते हैं।

वस्तु निर्भरता का अनुमान लगाने के लिए मेकप का एल्गोरिदम उस परंपरा पर निर्भर करता है
हेडर फ़ाइल "xyz.h" में परिभाषित सभी वर्गों या कार्यों का कार्यान्वयन है
"xyz.o" (या "xyz.lo") नामक ऑब्जेक्ट फ़ाइल में संकलित। तो मेकप्प का एल्गोरिदम
वस्तु निर्भरता का अनुमान एक या कुछ वस्तुओं से शुरू होता है जिनके बारे में हम जानते हैं कि ऐसा होना चाहिए
कार्यक्रम से जुड़ा हुआ है। यह देखता है कि कौन सी फ़ाइलें "#include" के साथ शामिल की गई थीं
वे स्रोत, और उनमें से प्रत्येक के लिए संबंधित ऑब्जेक्ट फ़ाइलें ढूंढने का प्रयास करता है
फाइलें.

किसी प्रोग्राम की निर्भरता सूची में "$(infer_objects )" का उल्लेख किया जाना आवश्यक है, जैसे
इस:

मायप्रोग: $(infer_objects main.oother_object.o, \
**/*.o /अन्य/लाइब्रेरी/dirs/**/*.o)
$(CXX) $(इनपुट) -ओ $(आउटपुट) $(LIBS)

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

उदाहरण के लिए, मान लीजिए कि "main.o" "main.cpp" से आया है, जिसमें "my_class.h" शामिल है।
"$(infer_objects)" "my_class.o" नाम वाली फ़ाइलों की तलाश करता है। यदि बिल्कुल ऐसा ही एक
फ़ाइल मिल गई है, इसे सूची में जोड़ दिया गया है। (यदि दो ऑब्जेक्ट फ़ाइलें "my_class.o" पाई जाती हैं
विभिन्न निर्देशिकाओं में, एक चेतावनी संदेश मुद्रित होता है।) "infer_objects" भी
यह देखने के लिए "my_class.cpp" की जांच करता है कि इसमें क्या शामिल है, और कौन सी अतिरिक्त ऑब्जेक्ट फ़ाइलें हैं
निहित।

एमकेटेम्प
एमकेटेम्प उपसर्ग
एमकेटेम्प उपसर्गएरोटिक
mktemp /
एक अप्रत्याशित अस्थायी फ़ाइल नाम लौटाता है, जो वर्तमान में मौजूद नहीं है। कोई नाम नहीं
एक ही फ़ाइल की ओर इशारा करते हुए दो बार लौटाया जाता है, यहां तक ​​कि अलग-अलग सापेक्ष पथों के साथ भी,
एक मेकप रन के भीतर (संभवतः पारंपरिक पुनरावर्ती मेक को छोड़कर, या यदि पर्ल
नियम क्रिया के अंतर्गत चलने वाला कोड "f_mktemp" कहलाता है)। मेकप के अंत में सभी चलाएँ
इस फ़ंक्शन द्वारा लौटाई गई फ़ाइलें हटा दी जाती हैं, यदि वे मौजूद हैं (फिर से उन्हें छोड़कर)।
एक नियम के अंतर्गत चल रहे पर्ल कोड में इस फ़ंक्शन द्वारा लौटाया गया)।

तर्क के अंत में जितने भी बड़े अक्षर "X" हों, उन्हें उतनी संख्या से बदल दिया जाता है
यादृच्छिक अक्षर और अंक. जितने अधिक होंगे, इसके टकराने की संभावना उतनी ही कम होगी
अन्य प्रक्रियाओं के साथ, इसलिए यदि आप "जैसे उपसर्ग देते हैं/टीएमपी/एबीसी.", आपके पास पर्याप्त होना चाहिए
"एक्स" एस. यदि एक से अधिक X हैं, तो पहला अक्षर प्रक्रिया आईडी से आता है। अगर
वहाँ कोई भी नहीं है, ऐसा लगता है मानो दस थे, जो कथित तौर पर पर्याप्त है (8.4e17)।
संभावनाएं या विंडोज़ पर 3.7e15)। यदि कोई तर्क नहीं है, तो उपसर्ग डिफ़ॉल्ट हो जाता है
"टीएमपी."वर्तमान निर्देशिका में.

ध्यान दें कि आप नियम लक्ष्य और निर्भरता जैसा कोई नाम नहीं देना चाहते।
परिणाम सही होगा, लेकिन जब भी आप मेकप चलाएंगे तो इसे दोबारा बनाया जाएगा।

साथ ही, चूंकि यह हमेशा अलग होता है, इसलिए आपको इसका उपयोग नियम कार्रवाई में तभी करना चाहिए जब आप इसका उपयोग करते हैं
":बिल्ड_चेक इग्नोर_एक्शन":

TMPFILE ;= $(mktemp) # 1 कॉल; "= का अर्थ होगा 3 कॉल: 3 फ़ाइलें
ए-गिनती बी-गिनती: :build_checkignore_action
उत्पादन-जैसा-और-बीएस >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o A-गिनती
&grep -c /B/ $(TMPFILE) -o B-गिनती

या आपको इसे निर्यात करना चाहिए और शेल को इसका मूल्यांकन करने देना चाहिए:

निर्यात TMPFILE ;= $(mktemp)
ए-गिनती बी-गिनती:
product-As-and-Bs >$$TMPFILE # मेकप को var मान नहीं दिखता है
fgrep -c A $$TMPFILE >A-गिनती
fgrep -c B $$TMPFILE >B-गिनती

अंतिम फॉर्म पिछले रिटर्न मान को दोहराता है, इसलिए आप इसे पैटर्न नियम में उपयोग कर सकते हैं:

%x: %y
&grep foo $(इनपुट) -o $(mktemp)
&sed bar $(mktemp /) -o $(आउटपुट) # &grep के आउटपुट पर काम करें

notdir फ़ाइल नाम
फ़ाइल नाम का गैर-निर्देशिका भाग लौटाता है, यानी, अंतिम के बाद सब कुछ
यदि कोई है तो स्लैश करें, अन्यथा संपूर्ण फ़ाइल नाम।

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

यह फ़ंक्शन स्वच्छ लक्ष्य नियमों में उपयोगी है (हालाँकि निश्चित रूप से "makeppclean" है
पसंदीदा संस्करण):

$ (फोनी क्लीन):
&rm -f $(only_generated **/*)

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

.फोनी: वितरण

वितरण:
&mkdir our_product-$(संस्करण)
&cp $(फ़िल्टर-आउट %~, $(only_nontargets *)) our_product-$(संस्करण)
टार सीएफ - our_product-$(संस्करण) | gzip -9c > our_product-$(VERSION).tar.gz

इस स्थिति में, "$(only_nontargets *)" वर्तमान निर्देशिका में प्रत्येक फ़ाइल लौटाता है
वह किसी नियम का लक्ष्य नहीं है. "$(filter_out %~, ...)" संपादक को हटा देता है
बैकअप।

"only_targets" (ऊपर देखें) के समान, "only_nontargets" केवल उन लक्ष्यों के बारे में जानता है जो
पहले ही परिभाषित किया जा चुका है। यह केवल एक समस्या है यदि आप इसका उपयोग वेरिएबल्स को परिभाषित करने के लिए करते हैं
":=" असाइनमेंट के साथ; यदि आप इसे निर्भरता सूची में या किसी के मुख्य भाग में उपयोग करते हैं
नियम, अन्य सभी नियम पहले ही देखे जा चुके होंगे।

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

यह फ़ंक्शन यह सुनिश्चित करने के लिए उपयोगी है कि ऐसी फ़ाइलों पर कोई निर्भरता नहीं है,
सभी लक्ष्यों का साफ़-सुथरा निर्माण किए बिना:

$(फनी फ्लश):
&rm -f $(only_stale **/*)

असल में, इसके बजाय शायद ऐसी स्क्रिप्ट लिखना बेहतर होगा जो उत्पन्न करने के लिए मेकप को कॉल करे
पुरानी फ़ाइलों की सूची, और फिर उस स्क्रिप्ट से सभी सूचीबद्ध फ़ाइलों को हटा दें
वर्तमान में स्रोत नियंत्रण में नहीं हैं, यदि कोई जेनरेट की गई फ़ाइल स्रोत बन जाती है
फ़ाइल। Makepp में ऐसा कोई फ़ंक्शन अंतर्निहित नहीं है क्योंकि makepp है (और शायद
स्रोत नियंत्रण के बारे में अज्ञेयवादी बने रहना चाहिए।

केवल_लक्ष्य फ़ाइल नाम
सूची में केवल वे फ़ाइल नाम लौटाता है जो वास्तव में किसी नियम के लक्ष्य हैं
(या तो स्पष्ट या पैटर्न नियम)। आप वाइल्डकार्ड निर्दिष्ट कर सकते हैं (मेकप सहित)।
फ़ाइल नाम में विशेष वाइल्डकार्ड, "**")। (अधिक जानकारी के लिए "$(वाइल्डकार्ड )" फ़ंक्शन देखें
विवरण। इसका उपयोग स्वच्छ लक्ष्य के लिए किया जा सकता है, उदाहरण के लिए:

.फोनी: साफ़

स्वच्छ:
&rm -f $(only_targets *)

अब यदि आप "मेकएप क्लीन" टाइप करते हैं, तो यह वह सब कुछ हटा देगा जो इसे बनाना आता है। लेकिन
साफ़ लक्ष्य न बनाएं, इसके बजाय "makeppclean" का उपयोग करें!

एक अन्य स्थान जहां यह उपयोगी हो सकता है वह है बासी को शामिल करने से बचना .o आपकी फ़ाइलें
निर्माण। उदाहरण के लिए, यदि आप इस तरह एक लाइब्रेरी बनाते हैं:

mylib.a: *.o
और आरएम-एफ $ (आउटपुट)
$(AR) करोड़ $(आउटपुट) $(इनपुट)

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

mylib.a: $(only_targets *.o)
और आरएम-एफ $ (आउटपुट)
$(AR) करोड़ $(आउटपुट) $(इनपुट)

तो यह समस्या उत्पन्न नहीं होगी.

ध्यान दें कि यह केवल उन फ़ाइलों को संदर्भित करता है जिन्हें लक्ष्य के रूप में जाना जाता है at la पहर इसलिए आप
आह्वान "केवल-लक्ष्य"। यदि "only_targets" निर्भरता या कार्यों में प्रकट होता है
नियम, तो सभी संभावित लक्ष्य ज्ञात होंगे क्योंकि निर्भरताएँ और क्रियाएँ नहीं हैं
नियम निष्पादित होने तक मूल्यांकन किया जाता है। हालाँकि, यदि आप मूल्यांकन करते हैं तो इसका मूल्यांकन करने का प्रयास करें
मेकफ़ाइल में पहले इस तरह एक ":=" वेरिएबल के साथ:

सभी_लक्ष्य := $(केवल_लक्ष्य *)

लक्ष्य1: निर्भरता1
कार्रवाई

लक्ष्य2: निर्भरता2
कार्रवाई

तो "only_targets" को अगले नियमों के बारे में पता नहीं चलेगा।

इसी तरह, "only_targets" को मेकफ़ाइल्स में उत्पादित लक्ष्यों के बारे में पता नहीं है
पुनरावर्ती मेक से भरा हुआ। (लेकिन आपको वैसे भी पुनरावर्ती मेक का उपयोग नहीं करना चाहिए; उपयोग करें
इसके बजाय "load_makefile" कथन या अंतर्निहित मेकफ़ाइल लोडिंग का उपयोग करें।)

सापेक्ष_फ़ाइलनाम file1 file2 फ़ाइल3[, स्लैश]
वर्तमान निर्देशिका से संबंधित उन फ़ाइलों का नाम लौटाता है (वही जो
मेकफ़ाइल अंदर है)। इसका उपयोग अनावश्यक "./" और अन्य कबाड़ को साफ करने के लिए भी किया जा सकता है
मार्ग:

डीआईआर := .
उपदिर := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/फ़ाइलें
एक्स := $(relative_filename $(FNAME))

If कड़ी आलोचना करना सत्य है (आमतौर पर 1) लौटाए गए फ़ाइल नामों में स्लैश होने की गारंटी होती है
यदि आवश्यक हो तो "./" जोड़कर, ताकि आप इसे बिना निष्पादन योग्य नाम के रूप में उपयोग कर सकें
निर्देशिका स्थान को ओवरराइड करने वाले कमांड खोज पथ के बारे में चिंता करना।

यदि पथ रूट निर्देशिका से जाता है, तो या तो आपके होम निर्देशिका का मूल या
आपके बिल्ड सिस्टम का "$(ROOT)", या विंडोज़ पर ड्राइव का रूट (पर निर्भर करता है)।
पर्यावरण के लिए भी ऐसा होता है /साइगड्राइव/सी or /c), एक पूर्ण पथ होगा
इसके बजाय लौटा दिया गया।

के सापेक्ष file1 file2 फ़ाइल3[, निर्देशिका]
निर्दिष्ट निर्देशिका से संबंधित उन फ़ाइलों का नाम लौटाता है। यह है
आम तौर पर तब उपयोगी होता है जब किसी भी कारण से आपको किसी कमांड को निष्पादित करना होता है
भिन्न निर्देशिका (डिफ़ॉल्ट वर्तमान निर्देशिका):

source_backup.tar:
सीडी .. && टार सीएफ $(सापेक्ष_से $(आउटपुट), ..) $(सापेक्ष_से ., ..)

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

उदाहरण के लिए,

$(प्रत्यय src/foo.c src-1.0/bar.c हैक्स)

परिणाम ".c .c" उत्पन्न करता है।

अस्थायी शब्द
मेकप को बताएं कि निर्दिष्ट लक्ष्य उत्पन्न होने वाले नियम द्वारा हटाए जा सकते हैं
उन्हें। "फनी" के समान, सिवाय इसके कि मेकप उस नाम की एक वास्तविक फ़ाइल की अपेक्षा करता है
नियम से प्रभावित हो सकता है. कोई नियम केवल अस्थायी होने पर निष्पादित नहीं होता है
लक्ष्य पुराने हो चुके हैं.

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

Makepp सभी सामान्य शेल वाइल्डकार्ड ("*", "?", और "[]") का समर्थन करता है। इसमें एक भी है
वाइल्डकार्ड "**" जो किसी भी संख्या में हस्तक्षेप करने वाली निर्देशिकाओं से मेल खाता है। (यह विचार था
zsh से चुराया गया।) उदाहरण के लिए, "**/*.c" सभी से मेल खाता है .c संपूर्ण स्रोत में फ़ाइलें
पेड़। "objects/**/*.o" सभी से मेल खाता है .o फ़ाइलें कहीं भी मौजूद हैं
उपनिर्देशिका वस्तुओं या इसकी कोई उपनिर्देशिका या उनकी कोई उपनिर्देशिका।
"**" वाइल्डकार्ड किसी भी स्तर पर निर्देशिकाओं के लिए सॉफ्ट लिंक का अनुसरण नहीं करेगा, न ही करेगा
उन निर्देशिकाओं को दर्ज करने का प्रयास करें जो मौजूद हैं लेकिन पढ़ी नहीं जा सकतीं। इसके अलावा फ़ाइलें और
जो निर्देशिकाएँ मौजूद हैं लेकिन पढ़ी नहीं जा सकतीं उन्हें "$(वाइल्डकार्ड)" द्वारा वापस नहीं किया जाएगा।

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

मॉड्यूल:= ए बी सी डी
X_OLD_STYLE := $(addprefix $(OBJDIR)/, $(addsuffix .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # क्या इसे पढ़ना आसान नहीं है?

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

X_OLD_STYLE := $(addsuffix .o, $(MODULES))
X_NEW_STYLE := $(मॉड्यूल).o

कॉल चर[, शब्द]...
फ़ंक्शन "कॉल" इस मायने में अद्वितीय है कि इसका उपयोग सम्मान के लिए किया जा सकता है परिवर्तनशील एक के रूप में
पैरामीटरयुक्त फ़ंक्शन. आप एक जटिल अभिव्यक्ति निर्दिष्ट कर सकते हैं परिवर्तनशील और उपयोग करें
इसकी सामग्री को पैरामीटरयुक्त विभिन्न मानों तक विस्तारित करने के लिए "कॉल करें"। शब्द बाद में। में
अन्य मेक सिस्टम, एक वेरिएबल जिसका उपयोग मुख्य रूप से विस्तार के उद्देश्य से किया जाता है
"कॉल" कहा जाता है मैक्रो.

मैक्रो के विस्तार के दौरान, अस्थायी चर $1, $2, "..." को देखें
इसके आह्वान के दौरान "कॉल" करने के लिए दिए गए तर्क। परिवर्तनशील $0 तक विस्तारित किया जाएगा
मैक्रो का नाम (अर्थात्) परिवर्तनशील) वह "कॉल" वर्तमान में विस्तारित हो रहा है।

किसी मैक्रो को कितने तर्कों के साथ "कॉल" किया जा सकता है या कितने तर्क दिए जा सकते हैं, इसकी कोई सीमा नहीं है
एक मैक्रो जिन मापदंडों की अपेक्षा कर सकता है। यदि आप मैक्रो के रूप में "कॉल" करने के लिए अधिक तर्क पारित करते हैं
आवश्यकता, सभी अतिरिक्त तर्क खारिज कर दिए जाएंगे। यदि आप a से कम तर्क पारित करते हैं
मैक्रो अपेक्षा, सभी अतिरिक्त पैरामीटर खाली स्ट्रिंग में ढह जाते हैं।

सबसे पहले एक सरल उदाहरण:

बाकी = $(शब्दसूची 2, $(शब्द $(1)),$(1))
सूची = ए बी सी डी ई
लेकिन पहले := $(बाकी को कॉल करें,$(सूची))

यहां, वेरिएबल "$(butfirst)" में "B C D E" सूची शामिल होगी।

और अब एक अधिक जटिल उदाहरण के लिए यह दिखाने के लिए कि क्या संभव है:

बाकी = $(शब्दसूची 2,$(शब्द $(1)),${1})
मायमैप = $(यदि $2,$(कॉल $1,$(फर्स्टवर्ड $2)) $(कॉल $0,$1,$(कॉल बाकी,$2)))
डाउनकेस = ${मेकपरल एलसी('$1')}

UCशब्द = ये सभी शब्द अपकेस हैं
DCWORDS := $(कॉल mymap,downcase,$(UCWORDS))

अब "$(DCWORDS)" में "ये सभी शब्द upcase हैं"। वैसे: यह नहीं बनाता है
अंतर, चाहे हम तर्कों तक पहुँचें $1, "${1}" or "$(1)" एक मैक्रो के भीतर.

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

चर्चा = $0 $1 $2 में बदल गया।
प्रत्यक्ष = $(चर्चा और तर्क)
बुलाया = $(कॉल चर्चा, एक, तर्क)

यह बहस का विषय लग सकता है कि क्या "$[call]" को मैक्रो के "$[]" का भी विस्तार करना चाहिए
अभिव्यक्तियाँ, या क्या किसी फ़ंक्शन को हमेशा एक ही काम करना चाहिए, चाहे वह कैसा भी हो
कहा जाता है। बाद वाले को चुना गया, क्योंकि सामान्य मेक सिंटैक्स के साथ यह होगा
"$[1], $[2]..." को एक वेरिएबल में लाना असंभव है (उन्हें किसी भी चीज़ से प्रतिस्थापित नहीं किया जाएगा,
असाइनमेंट पूरा होने से पहले ही।) इसलिए, यदि आपके पास परिभाषित करने के लिए एक मैक्रो है
नियम, आप चाहते हैं कि नियम के पार्स होने पर "$(आउटपुट)" जैसे भाव दिखें, इसलिए
आपको उन्हें "कॉल" से बचाना होगा:

मायरूल को परिभाषित करें
$2: $1
मायकमांड $$(इनपुट) -ओ $$(आउटपुट)
एंडीफ
$[मायरूल मायइनपुट,मायआउटपुट]

फ़िल्टर पैटर्न, शब्द
सूची में पैटर्न से मेल खाने वाले सभी शब्द लौटाता है। पैटर्न बिल्कुल अलग हो सकते हैं
शब्द, या फ़ाइल नाम वाइल्डकार्ड (यानी, "*", "?", और "[ए-जेड]" पहचाने जाते हैं), या वे हो सकते हैं
एक "%" वर्ण है, जिसका अर्थ उस बिंदु पर किसी भी स्ट्रिंग से मेल खाना है ("*" के समान)।

फिल्टर खतम हो गया पैटर्न, शब्द
सूची के सभी शब्द लौटाता है जो पैटर्न से मेल नहीं खाते। पैटर्न बस हो सकते हैं
अन्य शब्द, या फ़ाइल नाम वाइल्डकार्ड (यानी, "*", "?", और "[ए-जेड]" पहचाने जाते हैं), या
उनमें "%" वर्ण हो सकता है, जिसका अर्थ उस बिंदु पर किसी भी स्ट्रिंग से मेल खाना है (जैसा कि)।
"*").

उदाहरण के लिए:

libproduction.a: $(filter_out test_*, $(वाइल्डकार्ड *.o))

सब डाल देंगे .o ऐसी फ़ाइलें जो मौजूद हैं या बनाई जा सकती हैं, सिवाय शुरुआत वाली फ़ाइलों के परीक्षण_,
में libproduction.a.

फाइंडस्ट्रिंग पाना, in
वापसी खोज, यदि यह का एक उपस्ट्रिंग है in.

पहला शब्द शब्द
पहला शब्द लौटाएं.

नक्शा शब्दों, पर्लकोड
मेकमैप शब्दों, पर्लकोड
इसी तरह पर्ल के मानचित्र पर भी लागू होता है पर्लकोड प्रत्येक शब्द को बारी-बारी से लौटाता है
परिणाम। पहला संस्करण सादा पर्ल कोड है, जबकि दूसरा संस्करण पहले पास होता है
मेक-स्टाइल वैरिएबल विस्तार के माध्यम से पर्लकोड। दोनों में शब्दों का विस्तार है
मामलों।

शब्द $_ में हैं और जब तक आप $_ को अनडिफ नहीं करते तब तक वापस आ जाते हैं। इसके लिए अभिप्रेत है
संशोधनों को "पैटसबस्ट" द्वारा आसानी से नियंत्रित नहीं किया जा सकता। केवल पहला अल्पविराम विभाजक है,
किसी अन्य को इसका हिस्सा माना जाता है पर्लकोड.

# शब्द बदलें. डबल पैरेन, पर्लकोड में पैरेन को अनुमति देने के लिए, या ${} का उपयोग करें:
एक्स = $((मानचित्र $(मान), s/(.+)-(.+)/$2-$1/))
# आप मेक एक्सप्रेशन का उपयोग कर सकते हैं, लेकिन फिर आपको पर्ल $ के लिए $$ का उपयोग करना होगा:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ या $$_ = 'असफल')
# आप उम्मीदवारों को हटा सकते हैं:
Y = $(मानचित्र $(मान), अपरिभाषित $_ यदि /नहीं_अच्छा/)

में शामिल होने शब्द1, शब्द2
पहले शब्द और दूसरे शब्द को जोड़ीवार जोड़ें।

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

OBJS = $(patsubst %c, object_dir/%.o, $(C_SOURCES))

प्रत्येक फ़ाइल को C_SOURCES में लेता है और ऑब्जेक्ट फ़ाइल का नाम object_dir में लौटाता है।
कभी-कभी प्रतिस्थापन संदर्भ का उपयोग करना अधिक संक्षिप्त होता है, उदाहरण के लिए, उपरोक्त हो सकता है
के रूप में लिखा गया है

OBJS = $(C_SOURCES:%.c=object_dir/%o)

तरह word1 word2 word3 ...
शब्दों को शाब्दिक क्रम में क्रमबद्ध करता है और डुप्लिकेट हटा देता है।

पट्टी स्ट्रिंग
स्ट्रिंग से अग्रणी और अनुगामी रिक्त स्थान को हटाता है और प्रत्येक आंतरिक को प्रतिस्थापित करता है
एक ही स्थान के साथ एक या अधिक रिक्त स्थान वर्णों का अनुक्रम। इस प्रकार, "$(स्ट्रिप ए बी
c )" का परिणाम "a b c" होता है।

subst से, तक, पाठ
पाठ पाठ पर एक पाठ्य प्रतिस्थापन करता है: से की प्रत्येक घटना को प्रतिस्थापित किया जाता है
करने से। परिणाम को फ़ंक्शन कॉल के लिए प्रतिस्थापित किया गया है। उदाहरण के लिए,

$(विकल्प ईई,ईई,सड़क पर पैर)

स्ट्रिंग "fEEt on the strEEt" को प्रतिस्थापित करता है।

शब्द एन,पाठ
लौटता है nका वां शब्द टेक्स्ट. के वैध मूल्य n शुरुआत में 1 से शुरू करें
या अंत में -1 से पीछे की ओर। अगर n शब्दों की संख्या से बड़ा है टेक्स्ट,
मान रिक्त है.

शब्द सूची अनुक्रमणिका सूची, शब्द
शब्द सूची प्रथमसूचकांक, अंतिमसूचकांक, शब्द
पहले फॉर्म में आप सूचकांकों की एक सूची प्रदान करते हैं (शुरुआत में 1 से गिनती करते हुए)।
अपने इच्छित शब्दों का चयन करने के लिए अंत में -1 से पीछे की ओर) का उपयोग करें। दूसरे रूप में आप
उन शब्दों की श्रेणी निर्दिष्ट करें जिन्हें आप लौटाना चाहते हैं।

शब्द टेक्स्ट
शब्दों की संख्या लौटाता है टेक्स्ट.

कई तरह का कार्य
प्रत्येक के लिए var, सूची, पाठ
पहले दो तर्क, था और सूची, कुछ भी करने से पहले विस्तारित किया जाता है; टिप्पणी
अंतिम तर्क, पाठ, एक ही समय में विस्तारित नहीं होता है। फिर प्रत्येक शब्द के लिए
सूची का विस्तारित मान, var के विस्तारित मान द्वारा नामित चर को सेट किया गया है
वह शब्द, और पाठ का विस्तार होता है। संभवतः पाठ में उस चर के संदर्भ शामिल हैं,
इसलिए इसका विस्तार हर बार अलग होगा।

यह सरल उदाहरण वेरिएबल सेट करता है फ़ाइलों की सभी फ़ाइलों की सूची में
सूची में निर्देशिकाएँ dirs:

dirs := abcd
फ़ाइलें := $(foreach dir,$(dirs),$(वाइल्डकार्ड $(dir)/*))

यहां टेक्स्ट "$(वाइल्डकार्ड $(dir)/*)" है। पहली पुनरावृत्ति में dir के लिए मान "a" मिलता है,
इसलिए यह "$(वाइल्डकार्ड ए/*)" जैसा ही परिणाम देता है; दूसरी पुनरावृत्ति उत्पन्न होती है
"$(वाइल्डकार्ड बी/*)" का परिणाम; और तीसरा, "$(वाइल्डकार्ड c/*)" का।

इस उदाहरण का परिणाम निम्नलिखित उदाहरण के समान है ("डीआईआर" सेट करने के अलावा):

फ़ाइलें := $(वाइल्डकार्ड ए/* बी/* सी/* डी/*)

जब पाठ जटिल हो, तो आप उसे एक नाम देकर पठनीयता में सुधार कर सकते हैं
अतिरिक्त चर:

find_files = $(वाइल्डकार्ड $(dir)/*)
dirs := abcd
फ़ाइलें := $(foreach dir,$(dirs),$(find_files))

यहां हम वेरिएबल find_files का उपयोग इस प्रकार करते हैं। हम a को परिभाषित करने के लिए सादे "=" का उपयोग करते हैं
पुनरावर्ती-विस्तारित चर, ताकि इसके मान में वास्तविक फ़ंक्शन कॉल शामिल हो
foreach के नियंत्रण में पुनः विस्तारित किया जाए; एक साधारण-विस्तारित चर काम नहीं करेगा,
चूंकि वाइल्डकार्ड को find_files को परिभाषित करने के समय केवल एक बार कॉल किया जाएगा।

नोट: इसे "$(foreach)" विशेष चर के साथ भ्रमित न करें।

पता टेक्स्ट
चेतावनी टेक्स्ट
त्रुटि टेक्स्ट
आउटपुट टेक्स्ट कुछ भी नहीं लौटा रहा है। पहला STDOUT को जाता है, दूसरा STDERR को,
तीसरा अतिरिक्त रूप से प्रसंस्करण को रोक देता है।

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

फ़ाइल_सूची:
# शेल प्रोग्राम में डालने के लिए फ़ाइलों की सूची की गणना करने का आदेश देता है

my_program : $(&cat $(prebuild file_list))

यदि आपको एक से अधिक नियमों में सूची की आवश्यकता है, तो इसका उपयोग करना अधिक कुशल होगा
अधिकतम एक बार चर का विस्तार करें:

फ़ाइल_सूची ;= $(&cat $(प्रीबिल्ड फ़ाइल_सूची))

my_program1 : ao $(file_list)

my_program2 : bo $(file_list)

यदि इसके बजाय आपने केवल "$(&cat file_list)" निर्दिष्ट किया है, तो मेकप बाध्य नहीं करेगा
शेल कमांड निष्पादित करने से पहले फ़ाइल_लिस्ट को अद्यतित होना चाहिए। "$(प्रीबिल्ड )" का उपयोग करना
इस समस्या को हल करने का सबसे अच्छा तरीका है. आप अन्य चीज़ों को आज़माने के लिए प्रलोभित हो सकते हैं, जैसे
इस:

मेरा_प्रोग्राम: फ़ाइल_सूची $(&cat फ़ाइल_सूची)

लेकिन यह काम नहीं करेगा क्योंकि मेकप के प्रयास से पहले "$(&cat file_list)" का मूल्यांकन किया जाता है
"फ़ाइल_सूची" बनाएँ।

केवल_फोनी_लक्ष्य नामों
सूची में केवल उन्हीं नामों को लौटाता है जो किसी नियम (या तो) के नकली लक्ष्य हैं
स्पष्ट या पैटर्न नियम)। आप वाइल्डकार्ड निर्दिष्ट कर सकते हैं (मेकप के विशेष सहित)।
फ़ाइल नाम में वाइल्डकार्ड, "**")। (अधिक जानकारी के लिए "$(वाइल्डकार्ड )" फ़ंक्शन देखें।
इसका उपयोग लक्ष्यों को समूहीकृत करने के लिए किया जा सकता है, उदाहरण के लिए:

$(नकली परीक्षण): $(only_phony_targets */**/परीक्षण)

मूल परिवर्तनशील
किसी वेरिएबल का नाम दिया जाना आपको बताता है कि इसका मान कहां से आता है।

पर्ल पर्लकोड
मेकपरली पर्लकोड
किसी ब्लॉक में पर्लकोड का मूल्यांकन करता है और परिणाम लौटाता है। पहला संस्करण सादा पर्ल है
कोड, जबकि दूसरा वैरिएंट पहले मेक-स्टाइल वेरिएबल के माध्यम से पर्लकोड को पास करता है
विस्तार।

ध्यान दें, कि, सभी फ़ंक्शंस की तरह, उपयोग किया गया फ़ंक्शन डिलीमिटर भीतर दिखाई नहीं दे सकता है
सिंगल या डबल उद्धृत स्ट्रिंग्स के बाहर पर्लकोड। लेकिन आप इसे दोगुना कर सकते हैं
अंतिम उदाहरण:

वीएआर = 1
VAR1 = ${perl ($VAR + 1) * 3}
VAR2 = $(perl do { $VAR *= 3; यदि $VAR है तो $VAR + 1 } लौटाएँ)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # एक मेक var और एक पर्ल var
VAR = $((perl if( ... ) {... }))

जाली शब्द
इंगित करता है कि शब्दों की सूची वास्तव में नकली लक्ष्य हैं, और की सूची लौटाता है
लक्ष्य. इसे इस प्रकार उपयोग करने का इरादा है:

$(सभी नकली): my_program

$ (फोनी क्लीन):
&rm -f *.o my_program

आप कहीं भी इस तरह की एक पंक्ति के साथ एक या अधिक लक्ष्यों को नकली घोषित कर सकते हैं
आपकी मेकफ़ाइल:

.फोनी: सब साफ़

छाप टेक्स्ट
टेक्स्ट को आउटपुट करता है और उसे लौटाता है। यह अधिकतर डिबगिंग के लिए उपयोगी होता है, जब आप ऐसा नहीं करते
समझें कि परिवर्तनीय प्रतिस्थापन का परिणाम वैसा क्यों होता है जैसा कि होता है। उदाहरण के लिए,

XYZ := $(प्रिंट $(patsubst %c, %o, $(SOURCE_FILES)))

"पैटसबस्ट" कॉल का परिणाम प्रिंट कर लेगा।

XYZ := $(patsubst %c, %o, $(प्रिंट $(SOURCE_FILES)))

"पैटसबस्ट" कॉल के अंतिम तर्क को प्रिंट करेगा।

खोल शेल-कमांड
दिए गए शेल कमांड से आउटपुट लौटाता है, जिसमें रिक्त स्थान के स्थान पर नई लाइनें होती हैं।

ध्यान दें, कि, सभी फ़ंक्शंस की तरह, उपयोग किया गया फ़ंक्शन डिलीमिटर भीतर दिखाई नहीं दे सकता है
सिंगल या डबल उद्धृत स्ट्रिंग्स के बाहर शेल-कमांड। लेकिन आप इसे दोगुना कर सकते हैं
जैसा कि दूसरे उदाहरण में है:

दिनांक = $(शेल दिनांक) # बेहतर: $(पर्ल स्केलर स्थानीय समय)
VAR = ${{शेल f() { इको हैलो; }; एफ}}

xargs आदेश, तर्क[,प्रत्यय[,लंबाई]]
आदेशों की एक नई पंक्ति-पृथक सूची लौटाता है, जिनमें से प्रत्येक निर्दिष्ट से शुरू होती है
आदेश दें, और सूची के यथासंभव अधिक से अधिक तत्वों के साथ समाप्त करें, बिना आगे बढ़े
लंबाई (डिफ़ॉल्ट 1000) वर्ण.

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

$ (फोनी क्लीन):
$(xargs $(RM), $(only_targets **/*))

इसका एक दुष्परिणाम यह भी है कि सूची में कोई भी आदेश उत्पन्न नहीं होता है
खाली होता है. लेकिन इस मामले में बिल्टिन &rm का उपयोग करना बेहतर होगा,
क्योंकि अंतर्निहित कमांड के तर्क केवल पर्ल की मेमोरी द्वारा सीमित हैं:

$ (फोनी क्लीन):
&rm -f $(only_targets **/*)

यदि कोई तीसरा तर्क निर्दिष्ट किया गया है, तो इसका उपयोग प्रत्येक कमांड को पोस्टफ़िक्स करने के लिए किया जाता है। यह है
पुनर्निर्देशकों को निर्दिष्ट करने के लिए उपयोगी, उदा. (हालांकि यहां फिर से &echo मदद करेगा):

घोषणापत्र:
&rm -f $@
&स्पर्श करें $@
$(xargs प्रतिध्वनि, $(only_nontargets **/*), >> $@)

इनमें से कुछ दस्तावेज़ GNU मेक दस्तावेज़ पर आधारित हैं।

कृपया ध्यान दें कि यदि मेकफ़ाइल आरंभीकरण के दौरान कोई फ़ंक्शन कॉल किया जाता है, उदाहरण के लिए।
निर्यात चर, त्रुटि या चेतावनी संदेशों का विस्तार लाइन नंबर 0 की रिपोर्ट करेगा।

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