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

कार्यक्रम:

नाम

makepp_rules -- मेकप को कुछ बनाने के लिए कैसे कहें

वर्णन

?: &,
-,
@, B: :बिल्ड_कैश,
:बिल्ड_चेक, D: :प्रेषण, E: :एनवी, I: "अनदेखा_त्रुटि",
:शामिल, L: :आखिरी मौका, M: मेकपर्ल, N: "नोचो", P: : पार्सर,
"पर्ल", S: :हस्ताक्षर

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

एक नियम का सामान्य प्रारूप होता है

target_expression: निर्भरता_अभिव्यक्ति [: वैकल्पिक तर्क]
कार्रवाई

लक्ष्यों की सूची में कोई भी स्वचालित चर नहीं हो सकता है ("$(foreach)" को छोड़कर)। NS
निर्भरता सूची में लक्ष्य के संदर्भ में केवल स्वचालित चर हो सकते हैं (अर्थात,
"$(आउटपुट)", "$(आउटपुट)", या उनके समानार्थक शब्द)। कार्रवाई में कोई भी स्वचालित हो सकता है
चर।

यदि मेकप निर्णय लेता है कि नियम को निष्पादित करने की आवश्यकता है, तो नियम की प्रत्येक पंक्ति को निष्पादित किया जाता है
क्रमिक रूप से, और यदि कोई गैर-शून्य स्थिति देता है, तो शेष निष्पादित नहीं होते हैं (और
जब तक आप कमांड लाइन पर "-k" विकल्प निर्दिष्ट नहीं करते हैं, तब तक मेकप एक त्रुटि के साथ बंद हो जाता है।)
प्रत्येक क्रिया केवल एक पंक्ति की होनी चाहिए। यदि कोई क्रिया a . पर आसानी से लिखने के लिए बहुत लंबी है
सिंगल लाइन, आप इसे कई लाइनों में विभाजित कर सकते हैं और यह इंगित करने के लिए बैकस्लैश डाल सकते हैं कि
कई पंक्तियों को एक में जोड़ा जाना चाहिए।

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

· पहली क्रिया रेखा को लक्ष्य वाली रेखा से अधिक इंडेंट किया जाना चाहिए।

· यदि कोई रेखा एक टैब वर्ण या 8 रिक्त स्थान या अधिक द्वारा इंडेंट की जाती है, तो इसे माना जाता है
एक क्रिया रेखा।

· एक खाली रेखा या एक टिप्पणी पंक्ति जिसमें "#" वर्ण दाहिने हाशिये पर होता है, समाप्त होता है
नियम, जब तक कि अगली गैर-रिक्त रेखा 8 रिक्त स्थान (या एक से अधिक) से अधिक इंडेंट न हो
टैब)।

· यदि कोई रेखा पहली क्रिया रेखा से अधिक या अधिक इंडेंट की जाती है, तो वह है
एक अतिरिक्त एक्शन लाइन माना जाता है।

कुछ विशेष क्रिया आइटम हैं:

& इस प्रतीक के बाद कमांड का नाम और कितनी भी संख्या में तर्क होंगे। सीप
सिंटैक्स यहां पूरी तरह से नहीं समझा गया है, केवल सिंगल और डबल कोट्स और बैकस्लाशेड
पात्रों के भीतर, जैसा कि पूरे मेकप में है। कमांड का नाम या तो एक फंक्शन की ओर ले जाता है
"सी_नाम" शेष तारों के साथ तर्क के रूप में बुलाया जाना है। यदि ऐसा कोई कार्य कर सकता है
नहीं मिला, यह "पर्ल" ब्लॉक से "रन" को कॉल करने के समान है।

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

$(रूट)/शामिल/%.h: %.h
&ln $(इनपुट) $(आउटपुट)

नोइचो
@ आम तौर पर, प्रत्येक शेल कमांड को निष्पादित करते ही प्रिंट किया जाता है। हालाँकि, यदि पहला शब्द
कार्रवाई का "नोचो" है (या यदि यह "@" वर्ण से शुरू होता है), तो कमांड
मुद्रित नहीं है। उदाहरण के लिए,

%o: %cxx
noecho $(LIBTOOL) --mode=compile $(CC) -c $(इनपुट)

इसका मतलब यह है कि जब libtool कमांड को निष्पादित किया जाता है, तो वह प्रिंट नहीं होता है। (लिबटूल
स्वयं आमतौर पर संशोधित कमांड को प्रिंट करता है जिसे वह निष्पादित करता है, इसलिए यह बेमानी है
इसे दो बार प्रिंट करें।)

अनदेखा_त्रुटि
- आम तौर पर, यदि शेल कमांड एक गैर-शून्य स्थिति देता है, तो मेकप बंद हो जाता है क्योंकि
आदेश विफल रहा। हालांकि, कुछ प्रोग्राम गलत तरीके से बाहर निकलने पर स्थिति सेट करते हैं, या
एक त्रुटि हो सकती है जो वास्तव में घातक नहीं है और पूरी तरह से निरस्त नहीं होनी चाहिए
संकलन आप मेकप को निर्दिष्ट करके वापसी की स्थिति को अनदेखा कर सकते हैं
"ignore_error" कमांड लाइन के पहले शब्द के रूप में (या "-" पहले अक्षर के रूप में)।
उदाहरण के लिए,

$ (फोनी वितरण):
ign_error rm -r my_program-$(VERSION) # पिछले कबाड़ से छुटकारा पाएं।
&mkdir my_program-$(संस्करण)
&सीपी $(फ़ाइलें) my_program-$(संस्करण)
टार cf my_program-$(VERSION).tar my_program-$(VERSION)

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

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

शरीर के ब्रेसिज़ लगाने की दो संभावनाओं के लिए, स्पष्टीकरण देखें
Makepp_statements में "perl_perlcode"। ध्यान दें कि तीसरा संस्करण वहां समझाया गया है
यहां कोई मतलब नहीं है, क्योंकि सभी एक्शन लाइन इंडेंट होनी चाहिए। आपको संकेत करना चाहिए
पर्ल के बयानों में विफलता, "मरने" को बुलाकर।

प्रति नियम पर्ल के बयानों का मूल्यांकन वर्तमान में एक सामान्य उपप्रक्रिया में किया जाता है, सिवाय इसके कि
खिड़कियाँ। इसका मतलब है कि उन्होंने केवल किसी भी मेकफ़ाइल वैरिएबल तक पहुंच पढ़ी है। ये भी
वह प्रक्रिया जो गैर-पर्ल क्रियाओं को निष्पादित करती है। तो निष्पादन या निकास को कॉल करना भ्रमित करेगा
मेकप लेकिन यह भविष्य में बदल सकता है। Perl . को कॉल करने के प्रभावी तरीके के लिए
स्क्रिप्ट, पिछला आइटम "&" या "रन" देखें।

$ (फोनी संस्करण):
नोइको पर्ल {{# $(target) & $(VERSION) पर्ल से:
प्रिंट करें "यह ".f_target () है।" $VERSION\n";
}}
इको आप इसे शेल कमांड के साथ मिला सकते हैं
-मेकपर्ल {प्रिंट "यह $ (लक्ष्य) $ (संस्करण) \ n"} है

कई अलग-अलग प्रकार के नियम हैं, जिनमें से प्रत्येक के अलग-अलग उद्देश्य हैं।

स्पष्ट नियम
लक्ष्य1 लक्ष्य2:निर्भरता1निर्भरता2...
की जाने वाली क्रियाएं

यह सिंटैक्स निर्दिष्ट करता है कि या तो बनाने के लिए target1 or target2, सभी फ़ाइलें
निर्भरता1, निर्भरता2, आदि, पहले से ही बनाया जाना चाहिए। तब दी गई क्रियाएं हैं
लक्ष्य बनाने के लिए खोल द्वारा निष्पादित।

फ़ाइल में पहला स्पष्ट नियम डिफ़ॉल्ट लक्ष्य है, और यदि आप निर्दिष्ट नहीं करते हैं तो इसे बनाया जाता है
कमांड लाइन पर कोई लक्ष्य।

पारंपरिक मेक प्रोग्राम के विपरीत, मेकप आमतौर पर मानता है कि कार्रवाई का एक आह्वान
सभी लक्ष्य बनाता है (जब तक कि कोई निर्भरता न हो)। उदाहरण के लिए, एक आह्वान
yacc इस नियम के लिए दोनों आउटपुट फ़ाइलें बनाता है:

y.tab.c y.tab.h: parser.y
$(YACC) -डी पार्सर.वाई

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

· नियम क्रिया में स्वचालित चर $@ का उल्लेख है। (समानार्थक शब्द "$(आउटपुट)" या
"$(target)" इस व्यवहार को ट्रिगर न करें।)

· नियम क्रिया में स्वचालित चर "$(आउटपुट)" (या इसके पर्यायवाची) का उल्लेख नहीं है
"$ (लक्ष्य)")।

· यह एक पैटर्न नियम नहीं है, और कोई foreach खंड नहीं है।

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

सभी परीक्षण स्थापित करें:
$(SUBDIRS) में उपदिर के लिए; सीडी $$ सबदिर && $(मेक) $@; सीडी ..; किया हुआ

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

यदि आप प्रत्येक लक्ष्य के लिए एक ही नियम को एक बार निष्पादित करना चाहते हैं (उदाहरण के लिए, क्योंकि लक्ष्य
समान आदेश हैं), या तो पैटर्न नियम का उपयोग करना बेहतर है (नीचे देखें) या a
"foreach" खंड। उदाहरण के लिए, यदि पारंपरिक मेक प्रोग्राम के साथ आप लिखेंगे:

ऐ बी सी डी:
do_something बनाने के लिए $@ > $@

मेकप में, आप शायद इसे इस तरह लिखना चाहेंगे:

$(foreach) : : foreach abcd
do_something बनाने के लिए $(आउटपुट) > $(आउटपुट)

जाली लक्ष्य

A जाली लक्ष्य एक लक्ष्य है जो वास्तव में कभी भी फाइल सिस्टम में मौजूद नहीं होगा; यह सिर्फ एक है
कुछ लक्ष्य बनाने और संभवतः कुछ अतिरिक्त कमांड निष्पादित करने के लिए मेकप प्राप्त करने का तरीका।

एक विशिष्ट नकली लक्ष्य "सब" है, जिसका उपयोग आमतौर पर हर उस चीज़ के लिए किया जाता है जो हो सकता है
बनाने के लिए बनाया गया है, इस तरह:

सभी: prog1 prog2 subdir/prog3 subdir2/libmine.a
@&echo "सब हो गया!"

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

मेकप को फ़ाइल की अपेक्षा रखने से रोकने के लिए ।/सब बाहर निकलने के लिए, आपको यह बताना होगा कि यह एक है
नकली लक्ष्य। बस अपने मेकफ़ाइल में निम्न की तरह एक पंक्ति डालें (इससे कोई फर्क नहीं पड़ता
कहां):

फोनी: सभी

एक समान विकल्प जो कभी-कभी अधिक सुविधाजनक होता है वह है "$(फोनी)" का उपयोग करना।
समारोह, इस तरह:

$(फोनी सभी): prog1 prog2 subdir/prog3 subdir2/libmine.a

एक मेकफ़ाइल में नकली लक्ष्य दूसरे मेकफ़ाइल में नकली लक्ष्य को संदर्भित कर सकते हैं। यह है
अक्सर "स्वच्छ" लक्ष्य के साथ किया जाता है, जैसे:

# शीर्ष स्तर की मेकफाइल:
# यहां बहुत सारे नियम और सामान
#....
$(फोनी क्लीन): सबडिर1/क्लीन सबडिर2/क्लीन
&आरएम-एफएम my_program

फिर उपनिर्देशिकाओं में, मेकफ़ाइल इस तरह पढ़ सकते हैं:

# उपनिर्देशिका में मेकफ़ाइल
#...
$ (फोनी क्लीन):
&rm -fm $(वाइल्डकार्ड *.o *.a)

लेकिन आजकल आप क्लीन टारगेट के बजाय "मेकप्पक्लीन" कमांड का इस्तेमाल करेंगे।

वाइल्डकार्ड

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

लिबमाइन.ए: *.ओ
और आरएम-एफ $ (आउटपुट)
एआर करोड़ $(आउटपुट) $(इनपुट)

यह तब भी काम करेगा जब ".o" फाइलों में से कोई भी अभी तक नहीं बनाया गया है, क्योंकि Makepp's
वाइल्डकार्ड उन फ़ाइलों से मेल खाते हैं जो अभी तक मौजूद नहीं हैं लेकिन बनाई जा सकती हैं। यह भी उठाएगा
फ़ाइलें जिनका नियम बाद में खोजा गया है (उसी मेकफ़ाइल में, या एक अभी तक पढ़ा नहीं गया है)। इसमें
अंतिम बिंदु यह "वाइल्डकार्ड" फ़ंक्शन से अलग है, जो ज्ञात नियमों तक सीमित है,
क्योंकि इसे विस्तारित होने पर अपना परिणाम वापस करना होगा।

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

Makepp के वाइल्डकार्ड उन फ़ाइलों या निर्देशिकाओं को अनदेखा कर देंगे जो मौजूद हैं लेकिन पढ़ी नहीं जा सकतीं। बाद में
सभी, ऐसी फ़ाइलों का निर्माण प्रक्रिया में वैसे भी उपयोग नहीं किया जा सकता है। अपठनीय फाइलों को एक में रखना
निर्देशिका मुख्य रूप से दी गई फ़ाइल के स्वत: आयात को रोकने के लिए उपयोगी है a
भंडार।

शुरुआती दावा था कि यह सुरक्षित है। यह इस मायने में है कि यह काम करता है कि क्या
फ़ाइलें पहले से मौजूद हैं, या पहले बनाने की आवश्यकता है। हालाँकि यह इस मायने में असुरक्षित है
कि यह अभी भी उन फाइलों से मेल खाएगा जो मेकप द्वारा बनाई गई थीं, लेकिन अब कोई नियम नहीं है (उदाहरण के लिए)
आपने हटा दिया .c फ़ाइल, लेकिन .o फ़ाइल अभी भी है।) इसे रोकने के लिए, का उपयोग करें
"--rm-stale" विकल्प।

पैटर्न नियम
एक पैटर्न नियम एक नियम है जो कुछ पाठ्य पैटर्न के आधार पर लागू होता है। यह करने के लिए प्रयोग किया जाता है
फाइलों के पूरे वर्ग पर एक ही नियम लागू करें। वाक्यविन्यास जीएनयू मेक के समान है
पैटर्न नियम:

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

यह कहता है कि वर्तमान निर्देशिका में कोई भी फ़ाइल जो "*.c" से मेल खाती है, को में परिवर्तित किया जा सकता है
दिए गए कमांड का उपयोग करके संबंधित .o फ़ाइल।

ध्यान दें कि कई पैटर्न निर्भरता की आपूर्ति की जा सकती है। उदाहरण के लिए, यदि आपका xyz.o पट्टिका
संगत पर निर्भर करता है xyz.cpp फ़ाइल, और एक फ़ाइल पर भी कहा जाता है moc_xyz.cflags कौन कौन से
संकलक विकल्प शामिल हैं, इसे इसके साथ व्यक्त किया जा सकता है:

%o: %cpp %cflags
$(CXX) `cat $(stem.cflags` -c $(inputs) -o $(output)

आपके पास कई पैटर्न लक्ष्य भी हो सकते हैं। उदाहरण के लिए,

%tab.h %tab.c : %y
yacc -d $(इनपुट)
&mv y.tab.h $(stem).tab.h
&mv y.tab.c $(stem).tab.c

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

Makepp_percent_subdirs := 1

उदाहरण के लिए आपके मेकफ़ाइल में या कमांड लाइन पर पहले पैटर्न नियम से पहले।

"%" और वाइल्डकार्ड "*" के बीच एक स्पष्ट अंतर है, हालांकि दोनों किसी से मेल खाते हैं
स्ट्रिंग: वाइल्डकार्ड उन फ़ाइलों की सूची देता है जो उस समय पूरी तरह से उपयोग की जाती हैं। इसलिए
यह सब पर निर्भर करता है .o यहाँ निर्माण योग्य फ़ाइलें:

कार्यक्रम: *.o
$(LD) $(LDFLAGS) $(इनपुट) -o $(आउटपुट)

यह "*" को "%" के साथ बदलकर हासिल नहीं किया जा सकता है, क्योंकि बाद वाला एक-एक करके है
आउटपुट के लिए इनपुट का मिलान, प्रत्येक मिलान किए गए स्टेम के लिए आंतरिक रूप से एक नियम का उत्पादन करना।

स्थिर पैटर्न नियम
एक स्थिर पैटर्न नियम एक पैटर्न नियम है जो केवल फाइलों के सीमित सेट पर लागू होता है:

$(SPECIAL_MODULES).o : %o : .cpp
$(CXX) -c $(इनपुट) -o $(आउटपुट)

यह कहता है कि पैटर्न नियम केवल "$(SPECIAL_MODULES).o" की फाइलों पर लागू होता है।

यह ज्यादातर जीएनयू मेक के साथ संगतता के लिए है; foreach नियम (नीचे देखें) अधिक हैं
एक ही काम करने का शक्तिशाली तरीका।

foreach नियम
उपरोक्त पैटर्न नियम सिंटैक्स लगभग सभी बिल्ड का समर्थन करने के लिए पर्याप्त शक्तिशाली है, लेकिन
कभी-कभी कुछ अधिक जटिल करना आवश्यक होता है। Makepp एक और अधिक प्रदान करता है
शक्तिशाली वाक्य रचना: नियम के लिए ": foreach" खंड।

टारगेट_एक्सप्रेशन: डिपेंडेंसी_एक्सप्रेशन: फॉरच फाइल-लिस्ट
कार्रवाई

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

# यहां वह नियम है जो हर चीज पर लागू होता है:
%.ओ:%.सी
$(CC) $(CFLAGS) -c $(इनपुट) -o $(आउटपुट)

%o : %c : foreach $(SPECIAL_MODULES)
$(CC) $(SPECIAL_CFLAGS) -c $(इनपुट) -o $(आउटपुट)

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

यह एक बोझिल वाक्यविन्यास है, लेकिन यह अत्यंत लचीला है, क्योंकि "$(foreach)" चर
अभिव्यक्ति में किसी भी रूप में प्रकट हो सकता है। सबसे पहले, ध्यान दें कि पैटर्न नियम वास्तव में हैं a
foreach नियमों का विशेष मामला; पैटर्न नियम

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

बिल्कुल बराबर है:

$(patsubst %.c, %.o, $(foreach)): $(foreach) : foreach *.c
$(CC) $(CFLAGS) -c $(इनपुट) -o $(आउटपुट)

(वास्तव में, यह लगभग आंतरिक रूप से परिवर्तित हो गया है।)

एक उदाहरण के रूप में आप ":foreach" क्लॉज का उपयोग कैसे करेंगे, जहां एक पैटर्न नियम नहीं है
पर्याप्त, मान लीजिए कि आपके पास कुछ है .c फ़ाइलें जो किसी प्रकार के प्रीप्रोसेसर का उपयोग करके बनाई गई हैं
जो इनपुट फाइलों के रूप में लेता है a .k विस्तार। आप उनको संकलित करना चाहते हैं .c के साथ फ़ाइलें
सामान्य से अलग संकलन विकल्पों का सेट .c फ़ाइलें जो सामान्य स्रोत हैं
फ़ाइलें। आप ऐसा कुछ कर सकते हैं:

# साधारण .c फाइलों के लिए नियम:
%.ओ:%.सी
$(CC) $(CFLAGS) -c $(इनपुट) -o $(आउटपुट)

# .k फाइलों से .c फाइल बनाने का नियम:
%.सी : %.के
$ (प्रीप्रोसेसर) $ (इनपुट)> $ (आउटपुट)

# .c फाइलों के लिए विशेष बिल्ड नियम जो .k फाइलों से बने हैं:
$(foreach:%.k=%.o): $(foreach:%.c=%.k): foreach *.k
$(CC) $(SPECIAL_CFLAGS) -c $(इनपुट) -o $(आउटपुट)

(यह कॉल करने के बजाय थोड़ा अधिक संक्षिप्त प्रतिस्थापन संदर्भ सिंटैक्स का उपयोग करता है
"patsubst" स्पष्ट रूप से।)

ध्यान दें कि यदि आप केवल एक चर के मान को बदलना चाहते हैं ("CFLAGS" इसमें)
मामला) लक्ष्य-विशिष्ट चर का उपयोग करना कभी-कभी अधिक सुविधाजनक होता है।

विरासत प्रत्यय नियम
पिछड़ी संगतता के लिए, मेकप पुरानी शैली के प्रत्यय नियमों का समर्थन करता है।

.प्रत्यय1.प्रत्यय2:
कार्रवाई

के बराबर है

%.suffix2: %.प्रत्यय1
कार्रवाई

लेकिन याद रखना बहुत कठिन है। (कौन सा प्रत्यय पहले आता है?) आमतौर पर, एक नियम दिखाई देगा
इस तरह एक विरासत मेकफ़ाइल में:

.सह:
$(CC) $(CFLAGS) -c $*.c -o $*.o

जो बिल्कुल के बराबर है

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

विरोधी नियम
जब फ़ाइल बनाने के एक से अधिक तरीके होते हैं, तो मेकप एक सरल प्रक्रिया का उपयोग करता है
निर्धारित करें कि किस नियम का उपयोग करना है।

फ़ाइल बनाने के लिए परस्पर विरोधी स्पष्ट नियमों का होना एक त्रुटि है।

· वाइल्डकार्ड के साथ पैटर्न नियम और foreach नियम कभी भी स्पष्ट नियमों को ओवरराइड नहीं करते हैं। इस प्रकार
पैटर्न नियमों के अपवादों को निर्दिष्ट करने के लिए स्पष्ट नियमों का उपयोग किया जा सकता है। (ध्यान दें कि बस
": foreach" क्लॉज का उपयोग करने से कुछ पैटर्न नियम नहीं बनता है। इसमें एक होना चाहिए
वाइल्डकार्ड (जैसे "*" या "?") ": foreach" खंड में फ़ाइल नाम के हिस्से के रूप में। अगर यह होता है
फाइलों की सिर्फ एक स्पष्ट सूची, इसे उनमें से प्रत्येक के लिए एक स्पष्ट नियम के रूप में माना जाता है
फ़ाइलें।)

· जब परस्पर विरोधी पैटर्न नियम अलग-अलग मेकफाइल्स से आते हैं, तो नियम "निकटतम" से आते हैं
मेकफ़ाइल्स "आगे" मेकफ़ाइल से नियमों को ओवरराइड करते हैं। "निकटतम" का अर्थ है कि मेकफ़ाइल
निर्देशिका पदानुक्रम में लक्ष्य के करीब स्थित है (यानी, फ़ाइल का नाम)
जिस निर्देशिका से मेकफ़ाइल चलाया जाता है, उसके सापेक्ष लक्ष्य छोटा होता है)। अगर यह
मेकफ़ाइल को अलग नहीं करता है, फिर मेकफ़ाइल से नियम जो लोड होता है
नवीनतम प्रयोग किया जाता है।

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

%o : %c : foreach **/*.c
$(CC) $(CFLAGS) -c $(इनपुट) -o $(आउटपुट)

और आपके पास उपनिर्देशिकाओं में से एक में मेकफ़ाइल हो सकता है जो कहता है:

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

· पैटर्न नियम जिनमें अनुमान की एक छोटी श्रृंखला होती है, उन्हें अन्य पैटर्न की तुलना में प्राथमिकता दी जाती है
नियम। उदाहरण के लिए, यदि आपके पास निम्नलिखित नियम थे (से एक उदाहरण के आधार पर
लिनक्स कर्नेल):

%।अनुसूचित जाति
$(CC) -s $(इनपुट) -o $(आउटपुट)

%o: %s
$(एएस) $(इनपुट) -ओ $(आउटपुट)

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

यदि हमें "xyz.o" बनाने की आवश्यकता है, तो हम या तो मध्यवर्ती ".s" फ़ाइल बना सकते हैं और फिर
पहले दो नियमों का उपयोग करके इसे असेंबलर के माध्यम से चलाएं, या हम सीधे जा सकते हैं a
अंतिम नियम का उपयोग करके ".o" फ़ाइल। अंतिम नियम को प्राथमिकता दी जाती है क्योंकि कम हैं
अनुमान की श्रृंखला में कदम (दो के बजाय एक)।

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

%.o: %.c # सामान्य संकलन नियम।
कार्य

विशेष_%.o: विशेष_%.c # फ़ाइलों के लिए विशेष नियम a
भिन्न क्रिया # "विशेष_" उपसर्ग।

नियम विकल्पों
कभी-कभी मेकप के निष्पादन के तरीके को संशोधित करने के लिए अतिरिक्त विकल्पों की आपूर्ति करना आवश्यक होता है
नियम। इन विकल्पों को ":optionname value" के रूप में निर्दिष्ट किया जाता है, या तो उस लाइन पर होता है
निर्भरता, या अगली पंक्ति पर।

अलग-अलग लाइनों पर विकल्पों की आपूर्ति करने से आपके लिए इसका उपयोग करना संभव हो सकता है
मेकफ़ाइल मेकप और एक पारंपरिक मेक के साथ। उदाहरण के लिए,

लक्ष्य: निर्भरता
: हस्ताक्षर target_newer
कार्रवाई

पारंपरिक यूनिक्स मेक के साथ ठीक काम करेगा, क्योंकि यह ": सिग्नेचर" लाइन की व्याख्या करता है
शेल कमांड के रूप में, और कोलन से शुरू होने वाला कमांड कुछ भी नहीं करता है।

:बिल्ड_कैश /पथ/से/बिल्ड/कैश
लक्ष्य: निर्भरता
: बिल्ड_कैश/पुट/कैश/फाइलें/ओवर/वहां
कार्रवाई

इस नियम द्वारा निर्मित फ़ाइलों के लिए उपयोग किए जाने वाले बिल्ड कैश का पथ निर्दिष्ट करता है। इस
"बिल्ड_कैश" कथन या "--बिल्ड-कैश" कमांड के प्रभाव को ओवरराइड करता है
इस नियम के लिए लाइन विकल्प, यदि कोई हो। बिल्ड के बारे में विवरण के लिए makepp_build_cache देखें
कैश

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

:बिल्ड_चेक बिल्ड_चेक_विधि
लक्ष्य: निर्भरता
: बिल्ड_चेक लक्ष्य_नया
कार्रवाई

यह मेकप को बताता है कि लक्ष्यों को फिर से बनाने की आवश्यकता है या नहीं, यह तय करने के लिए किस एल्गोरिदम का उपयोग करना है।
अधिक जानकारी के लिए makepp_build_check देखें। यह के प्रभाव को ओवरराइड करता है
"बिल्ड_चेक" कथन या "--बिल्ड-चेक-विधि" कमांड लाइन विकल्प, यदि कोई हो, के लिए
यह नियम।

env परिवर्तनशील ...
नामित पर्यावरण चर के मूल्यों पर निर्भरता जोड़ें। यदि उनमें से कोई
पिछले निर्माण से भिन्न है, तो लक्ष्य पुराने माने जाते हैं, यदि
build_check विधि तो निर्देशित करती है। (सभी अंतर्निहित बिल्ड चेक विधियों को छोड़कर
target_newer इसका सम्मान करें।)

VARIABLE "PATH_VARIABLE में फ़ाइल नाम" (उद्धरणों में) के रूप में हो सकता है, जिस स्थिति में
लक्ष्य पुराने माने जाते हैं यदि कोलन-सीमांकित से पहली निर्देशिका
PATH_VARIABLE का मान जिसमें फ़ाइल नाम मौजूद है, पिछले बिल्ड से अलग है।
इसका उपयोग लक्ष्यों के पुनर्निर्माण से बचने के लिए किया जा सकता है जब PATH_VARIABLE एक में बदलता है
अप्रासंगिक तरीका।

:प्रेषण आदेश ...
"sh -c '...'" में प्रत्येक शेल एक्शन (लेकिन पर्ल एक्शन और न ही पर्ल कमांड) संलग्न करें।
और इसे कमांड के साथ उपसर्ग करें, लेकिन मान लें कि लक्ष्य कमांड पर निर्भर नहीं है।
यह उपयोगी है यदि आप कार्य कतार प्रणाली को क्रियाएँ भेजना चाहते हैं, लेकिन परिणाम है
क्यूइंग पैरामीटर से स्वतंत्र माना जाता है, साथ ही साथ क्यूइंग
सिस्टम का बिल्कुल उपयोग किया जाता है।

:शामिल फ़ाइल_या_पैटर्न
नियम संकलक के आधार पर भिन्न होता है:

%.ओ:%.सी
: %.d शामिल करें: हस्ताक्षर सी
जीसीसी-एमडी-सी ...

%.ओ:%.सी
: %.u शामिल करें: हस्ताक्षर सी # आईबीएम एक अलग प्रत्यय का उपयोग करता है
एक्सएलसी-एम-सी ...

सब डिपेंडिफाइ {# माइक्रोसॉफ्ट के चैटर को उपयोगी फॉर्मेट में बदलें
एस/\$/\$\$/जी;
s/(नोट: फ़ाइल सहित: *)?(.+?)\r?\n/$1 ? "'$2' " : "'.f_output()."': "/e;
}
%.ओ:%.सी
: %.d शामिल करें: हस्ताक्षर सी
cl -शो में -c ... >$(stem).d . शामिल है
&sed &निर्भर -o +<$(stem).d

कुछ कंपाइलर (इंटेल का आईसीसी ऊपर जीसीसी की तरह, या आईबीएम का एक्सएलसी) निर्भरता उत्पन्न कर सकता है
मक्खी पर फ़ाइलें। यही है, जब वे संकलित करते हैं, तो वे एक मेकफ़ाइल लिखते हैं जो मेकप कर सकता है
शामिल। मेकप के स्कैनर पर लाभ यह है कि यह 100% होने की गारंटी है
सही है, जहां हम केवल करीब आ सकते हैं।

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

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

जब आप "#include" कथन हटाते हैं तो एक पकड़ होती है और संबंधित फ़ाइल:
यह अभी भी निर्भरता फ़ाइल में पिछली बार से उल्लेख किया जाएगा, जब यह था
आवश्यकता है। ऐसे में आपको डिपेंडेंसी को हटाने के लिए डिपेंडेंसी फाइल को एडिट करना होगा
जो अब पूरा नहीं हो पा रहा है।

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

यदि आप अपनी रिपॉजिटरी में निर्माण करते हैं, तो Makepp निर्भरता फ़ाइल को से उठाएगा
पहला भंडार जिसमें एक होता है। यह अन्य फाइलों के विपरीत है, जहां यह 1
अपेक्षित हस्ताक्षर के साथ। यह कैश बनाने के लिए बेहतर है, जहां की कमी के लिए
हस्ताक्षर, यह फ़ाइल भी नहीं ढूंढ सकता है।

:आखिरी मौका
ओपन-एंडेड नियम सक्षम करें, जैसे

%.फू फू%.बार: :last_chance
&गूंज $@ -o $@
&सीपी $(आउटपुट)

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

":last_chance" विकल्प का उद्देश्य के विशेष व्यवहार की ओर ध्यान आकर्षित करना है
वाइल्डकार्ड मिलान के संबंध में नियम।

पार्सर पार्सर
यह मेकप को फाइलों का पता लगाने (शामिल करने) के लिए कमांड को पार्स करने का तरीका बताता है। आमतौर पर,
मेकप यह अनुमान लगाता है कि कमांड में ही शब्दों के आधार पर इसे कैसे करना है (देखें
विवरण के लिए makepp_scanning)। हालांकि, अगर मेकप गलत अनुमान लगाता है, तो आप शायद
इस तरह पार्सर को स्पष्ट रूप से इंगित करें:

%o: %abc
: पार्सर c_compilation
यहां कार्रवाई

यह मेकप को उसी पार्सिंग और स्कैनिंग को करने का कारण बनता है जो वह सी/सी ++ के लिए करता है
कमांड बनाएं, भले ही वह सी संकलन के रूप में कार्रवाई को नहीं पहचानता हो।

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

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

%.o: %.c : पार्सर c-संकलन
@echo 'बिल्डिंग $ (आउटपुट)'
@funny_cc...

यह "इको" को एक कंपाइलर के रूप में भी व्याख्यायित करेगा और इसके तर्क 'बिल्डिंग' को घटाएगा
mymodule.o' एक निहित निर्भरता के रूप में। इससे यह शिकायत आएगी कि यह
ऐसी फाइल बनाने का तरीका नहीं जानता। इस मामले में आप के साथ बेहतर होगा
"रजिस्टर_पार्सर"। वहां आपको एक स्पष्टीकरण मिलता है कि कैसे पार्सर या तो एक के रूप में दिया जा सकता है
क्लासनाम या फ़ंक्शन नाम के रूप में।

:हस्ताक्षर हस्ताक्षर_विधि
लक्ष्य: निर्भरता
: हस्ताक्षर md5
कार्रवाई

यह मेकप को बताता है कि निर्भरताएं बदल गई हैं या नहीं यह निर्धारित करने के लिए किस एल्गोरिदम का उपयोग करना है।
अधिक जानकारी के लिए makepp_signatures देखें। हस्ताक्षर विधियाँ जो के साथ शामिल हैं
मेकप वितरण "सादा", "md5", "C" या "c_compilation_md5" हैं, और
"साझा_ऑब्जेक्ट"। यह "-m" या . के साथ निर्दिष्ट किसी भी हस्ताक्षर विधि को ओवरराइड करता है
"--हस्ताक्षर-विधि" कमांड लाइन विकल्प, या "हस्ताक्षर" कथन के साथ।

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

ए: चीज़: बी: चीज़ # यह एक सिंटैक्स त्रुटि है
और बिल्ली $ (इनपुट) -ओ $ (आउटपुट)

क्योंकि मेकप को पता नहीं चलेगा कि कौन से कोलन निर्भरता से लक्ष्य को अलग करते हैं और कौन से हैं
फ़ाइल नाम का हिस्सा। इसके बजाय, बस नाम को उद्धरणों में इस तरह संलग्न करें:

"ए: थिंग": "बी: थिंग"
और बिल्ली $ (इनपुट) -ओ $ (आउटपुट)

अब नियम स्पष्ट है।

मेकप का उद्धरण सिंटैक्स शेल के समान ही है। उदाहरण के लिए, आप सिंगल का उपयोग कर सकते हैं
दोहरे उद्धरण चिह्नों के बजाय उद्धरण, या आप बैकस्लैश के साथ विशेष वर्णों से बच सकते हैं:

एक \: बात: 'बी: बात'
और बिल्ली $ (इनपुट) -ओ $ (आउटपुट)

मान लीजिए, उदाहरण के लिए, आपका फ़ाइल नाम "'"!;\$" है। अब आप ऐसा फ़ाइल नाम क्यों चाहते हैं
मुझे नहीं पता, लेकिन यहां कई तरीके हैं जिनसे आप इसे मेकप (और खोल) में निर्दिष्ट कर सकते हैं:

\''"!;\$$'
"'\"!;\\$$"

ध्यान दें कि मेकप स्ट्रिप्स कब उद्धरण देता है और शेल कब करता है। मेकप देखता है
केवल निम्नलिखित मामलों में उद्धरण:

परीक्षणों के "ifeq" परिवार में

· नियम कोलन के पहले और बाद में

· एक मेकप बिलिन कमांड में

एक समारोह में जो फाइलों से संबंधित है

शेल के विपरीत, मेकप एक चर को निर्दिष्ट करते समय उद्धरणों का विस्तार नहीं करता है। इस प्रकार
निम्नलिखित नियम समान हैं:

FILE = 'रिक्त स्थान के साथ नाम'
x := $(print $(FILE)) # सिर्फ यह जांचने के लिए कि उद्धरण अभी भी मौजूद हैं
$(FILE): # मेकप द्वारा छीनी गई एकल फ़ाइल के आसपास उद्धरण
&echo hello -o$(FILE) # मेकप द्वारा छीनी गई सिंगल फाइल के आसपास के उद्धरण
वहाँ गूंज >>$(फ़ाइल) # शेल द्वारा छीनी गई एकल फ़ाइल के आसपास उद्धरण
'रिक्त स्थान के साथ नाम':
&गूंज हैलो-ओ'नाम रिक्त स्थान के साथ'
वहाँ गूंज >>'$(आउटपुट)' # उद्धरण ऊपर छीन लिए गए थे, उन्हें फिर से जोड़ें

ध्यान दें कि (शैल के विपरीत) "$" से शुरू होने वाले चर एकल के अंदर भी विस्तारित होते हैं
उल्लेख। डॉलर के संकेतों को उद्धरण या बैकस्लैश द्वारा संरक्षित नहीं किया जा सकता है। एक शाब्दिक पाने के लिए
डॉलर चिह्न, दोहरे डॉलर चिह्न का उपयोग करें, उदाहरण के लिए,

$ (सभी नकली):
@&echo यह एक डॉलर का चिह्न है: $$
एबीसीडी में @for वैल; गूंज $$ वैल; किया हुआ

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

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

"रिक्त स्थान के साथ एक फ़ाइल नाम":
गूंज "विशेष सामग्री"> "$@"

यदि आप उद्धरणों को $@ के आसपास नहीं डालते हैं, तो शेल कमांड को देखेगा

इको "विशेष सामग्री"> रिक्त स्थान के साथ एक फ़ाइल नाम

जो फ़ाइल में "स्पेस के साथ विशेष सामग्री फ़ाइल नाम" स्ट्रिंग लिखता है a.
शायद यही वह नहीं है जो आप चाहते हैं।

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