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

कार्यक्रम:

नाम

मेकप_वेरिएबल्स - मेकप में वेरिएबल का उपयोग कैसे करें

वर्णन

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
? =, A: एआर,
अर्फ्लैग्स,
जैसा, C: सीसी,
सीएफएलएजीएस,
"परिवर्तित_निर्भरताएं",
परिवर्तित_इनपुट,
दही,
सीएक्सएक्स,
CXXफ़्लैग्स, D: "निर्भरताएं",
"निर्भरता", F: F77,
एफसी,
"प्रत्येक के लिए", I: इनपुट,
आदानों, L: एलडी,
लेक्स,
लिबटूल, M: बनाना,
लक्ष्य बनाएं,
मेकफ्लैग,
मेकइन्फो,
MAKEPP_DEBUG,
मेकपफ्लैग,
_मेकपफ्लैग,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
मेकप्प_सिग्नेचर_सी_फ्लैट,
"मेकप्प_सिंपल_कॉन्टेनेशन",
MAKEPP_संस्करण, O: "आउटपुट",
"आउटपुट", P: पर्ल,
लोक निर्माण विभाग, R: आरएम,
जड़, S: शंख,
"क्रमबद्ध_निर्भरताएँ",
क्रमबद्ध_इनपुट,
"तना", T: लक्ष्य,
लक्ष्य, V: वीपीएटीएच, Y: वाईएसीसी

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

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

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

परिवर्तनीय असाइनमेंट
एक वेरिएबल कई अलग-अलग तरीकों से एक मान ग्रहण कर सकता है:

· मेकफ़ाइल के अंदर एक वेरिएबल सेट किया जा सकता है। करने के कई अलग-अलग तरीके हैं
यह; नीचे देखें।

· एक वेरिएबल का मान कमांड लाइन पर इस तरह निर्दिष्ट किया जा सकता है:

मेकप्प CFLAGS=-O2 my_program

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

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

· यदि कोई वेरिएबल वातावरण में सेट किया गया है, तो इसे मेकप वेरिएबल के रूप में संदर्भित किया जा सकता है।
आम तौर पर मेकफ़ाइल के अंदर वेरिएबल्स को असाइनमेंट सेटिंग्स को ओवरराइड करता है
पर्यावरण, लेकिन आप इसे "-e" या "--environment-overrides" का उपयोग करके बदल सकते हैं
कमांड लाइन विकल्प

वेरिएबल्स को इस तरह कई असाइनमेंट एक्सप्रेशन में से एक के साथ असाइन किया गया है

एक्स = 1
मॉड्यूल:= ए बी सी डी
सीसी? = जीसीसी
CFLAGS +=-दीवार
VAR को परिभाषित करें
वर पंक्ति 1
वर पंक्ति 2
एंडडेफ़
निर्यात पथ := $(पीडब्ल्यूडी):$(पथ)
वैश्विक MYPROJECT.INFO = सभी मेकफ़ाइलों में देखी जाने वाली जानकारी

मूल्यों के इर्द-गिर्द अग्रणी और अनुगामी रिक्त स्थान को हमेशा हटा दिया जाता है।

विभिन्न असाइनमेंट ऑपरेटरों के कुछ भिन्न अर्थ होते हैं।

सरल असाइनमेंट ऑपरेटरों

=
वैरिएबल = टेक्स्ट स्ट्रिंग
VARIABLE = टेक्स्ट स्ट्रिंग को ओवरराइड करें

यह सामान्य असाइनमेंट स्टेटमेंट है जिसका सभी कार्यान्वयन समर्थन करते हैं।
दाहिनी ओर की अभिव्यक्ति का मूल्यांकन तब तक नहीं किया जाता जब तक कि "$(VARIABLE)" का मान न हो
वास्तव में कहीं उपयोग किया जाता है। इस प्रकार, यदि आप निम्नलिखित करते हैं:

एक्स = 1
वाई = $(एक्स)
एक्स = 2

फिर "$(Y)" बाद में मेकफ़ाइल में "2" का मूल्यांकन करेगा।

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

:=
परिवर्तनीय := expr
वेरिएबल को ओवरराइड करें := expr

यह "VARIABLE = expr" के समान है, सिवाय इसके कि दाईं ओर का मूल्यांकन किया जाता है
असाइनमेंट के समय एक बार और सभी के लिए। इस प्रकार यदि

एक्स := 1
वाई := $(एक्स)
एक्स := 2

फिर "$(Y)" बाद में मेकफ़ाइल में "1" का मूल्यांकन करेगा क्योंकि यही "$(X)" था
जब "$(Y)" परिभाषित किया गया था।

;=
परिवर्तनीय ;= व्यय
वेरिएबल को ओवरराइड करें ;= expr

यह "VARIABLE := expr" के समान है, सिवाय इसके कि दाईं ओर का मूल्यांकन किया जाता है
केवल पहले प्रयोग के समय और फिर याद आया। यह महँगे के लिए उपयोगी है
आदेश, जो हमेशा एक ही मान लौटाते हैं, लेकिन जिन्हें आप कब निष्पादित नहीं करना चाहते हैं
असंबंधित लक्ष्य बनाना:

VAR1 ;= $(perl महंगी गणना)
VAR2 ;= $(शेल बाहरी कमांड)

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

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

+=
परिवर्तनीय += व्यय
VARIABLE += expr को ओवरराइड करें

स्ट्रिंग को वेरिएबल की पिछली सामग्री में एक स्थान से अलग करके जोड़ता है। अगर
वेरिएबल को पहले ":=" के साथ असाइन किया गया था, फिर दाईं ओर का मूल्यांकन किया जाता है
जोड़ने से पहले.

&=
परिवर्तनीय &= expr
VARIABLE &= expr को ओवरराइड करें

स्ट्रिंग को वेरिएबल की पिछली सामग्री से जोड़ता है, जिसे एक स्थान से अलग किया जाता है।
यदि वेरिएबल को पहले ":=" के साथ निर्दिष्ट किया गया था, तो दाहिनी ओर है
जोड़ने से पहले मूल्यांकन किया गया।

उदाहरण के लिए, यह गारंटी देने का एक तरीका कि "CFLAGS", उपयोगकर्ता चाहे जो कुछ भी डाले,
ये दो पंक्तियाँ हमेशा "-वॉल" से शुरू होती हैं:

CFLAGS = -O2 # संभवतः कमांड लाइन पर ओवरराइड किया गया है
CFLAGS को ओवरराइड करें &= -दीवार # बिना शर्त जोड़ा गया

पुराने मेकफ़ाइल्स में आपको आम तौर पर ऐसा कुछ करना होता था, जिसमें साइड होता था
अंतहीन पुनरावृत्ति को रोकने के लिए प्रकार को ":=" पर बाध्य करने का प्रभाव:

परिवर्तनीय := expr $(परिवर्तनीय)

?=
परिवर्तनीय? = expr
VARIABLE को ओवरराइड करें? = expr # बेकार, लेकिन कानूनी

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

ifndef वैरिएबल
परिवर्तनीय = व्यय
endif

!=
परिवर्तनीय != शेल कमांड
VARIABLE != शेल कमांड को ओवरराइड करें

शेल कमांड चलाता है और कमांड के मानक आउटपुट को शामिल करने के लिए वेरिएबल सेट करता है।
यह बिलकुल इसके बराबर है

चर := $(शेल कमांड)

बहुपंक्ति चर

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

वेरिएबल को परिभाषित करें :=
वेरिएबल के मान की पहली पंक्ति
वेरिएबल के मान की दूसरी पंक्ति
वेरिएबल के मान की तीसरी पंक्ति
एंडीफ

वेरिएबल को ओवरराइड परिभाषित करें
...
एंडडेफ़

"परिभाषित" से पहले के कीवर्ड "निर्यात" या "वैश्विक" में से किसी एक का संयोजन हो सकते हैं
"ओवरराइड"।

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

COMPILE_C_PROGRAM को परिभाषित करें
@&echo "$(इनपुट) संकलित किया जा रहा है"
@$(सीसी) $(सीएफएलएजीएस) $(सीपीपीएफएलजीएस) $(शामिल) -सी $(इनपुट) -ओ $(आउटपुट)
एंडीफ

फिर आप इस मल्टी-लाइन वैरिएबल का उपयोग कई नियमों में कर सकते हैं, जैसे:

%.ओ:%.सी
$(संकलन_सी_कार्यक्रम)

$(ARCH)/%o : $(ARCH)/%c
$(संकलन_सी_कार्यक्रम)

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

COMPILE_C_PROGRAM = @echo "संकलन $(इनपुट)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(शामिल) -c $(इनपुट) -o $(आउटपुट)

समान प्रभाव होगा, सिवाय इसके कि अर्धविराम पर्ल को इसे शेल में भेजने के लिए मजबूर करता है,
कमांड को सीधे और अधिक कुशलता से निष्पादित करने के बजाय। आपको भी एक-एक लगाना होगा
अपनी स्वयं की एक पंक्ति पर निर्मित, जिसका अर्थ है कि आपको बाहरी प्रतिध्वनि पर स्विच करना होगा
अर्धविराम मामला.

"परिभाषित" के भीतर विस्तार करते समय एक विशेषता होती है, यानी "परिभाषित एक्स: =" या ए पर
वेरिएबल जो पहले से ही ": =", "एक्स को परिभाषित करें और =" और "एक्स + को परिभाषित करें" था। इस मामले में
"$(शेल कमांड ...)" या बिल्टइन "$(&कमांड ...)" को न्यूलाइन में परिवर्तित नहीं किया जाता है
रिक्त स्थान।

निर्यात चर सेवा मेरे उपप्रक्रियाएँ

VAR निर्यात करें...
निर्यात VAR = मूल्य
निर्यात VAR += मान को ओवरराइड करें

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

शेएर करें चर के पार मेकफ़ाइल्स

वैश्विक VAR...
वैश्विक VAR = मान
वैश्विक VAR &= मान को ओवरराइड करें

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

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

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

वैश्विक GLIBLIBS ;= $(shell pkg-config --libs glib-2.0)

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

लक्ष्य-विशेष कार्य

लक्ष्य: चर = स्ट्रिंग
लक्ष्य: चर := स्ट्रिंग
लक्ष्य: VARIABLE += स्ट्रिंग को ओवरराइड करें

चर का लक्ष्य-विशिष्ट मान सेट करता है। एक लक्ष्य-विशिष्ट मान प्रभावी है केवल
एक क्रिया में जो दिए गए लक्ष्य को उत्पन्न करता है। इसका उपयोग मुख्य रूप से जैसी चीजों के लिए किया जाता है
इस:

CFLAGS := -O2

my_prog: file1.o file2.o विशेष_file.o

विशेष_फ़ाइल.o : CFLAGS := -g

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

यहां क्या होगा कि सभी ".c" फ़ाइलें अनुकूलन ("-O2") के साथ संकलित की जाएंगी सिवाय
"special_file.c", जो डिबग मोड ("-g") में संकलित है। यह एक सुविधाजनक तरीका है
केवल कुछ फ़ाइलों के लिए अलग-अलग संकलन विकल्प निर्दिष्ट करें।

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

वाइल्डकार्ड विस्तार लक्ष्य पर किया जाता है, इसलिए आप कुछ इस तरह कर सकते हैं:

test_*.o : CFLAGS += -DTEST

जीएनयू मेक के साथ अनुकूलता के लिए, "*" के स्थान पर "%" का उपयोग किया जा सकता है।

परिवर्तनीय प्रतिस्थापन
मेकप के परिवर्तनीय प्रतिस्थापन नियम अन्य मेक के समान हैं, लेकिन कुछ हद तक
अधिक शक्तिशाली। जैसा कि सभी बनाता है, "$(CC)" या "${CC}" दोनों के मूल्य का प्रतिनिधित्व करते हैं
परिवर्तनशील सी.सी. यदि आपको शाब्दिक डॉलर चिह्न की आवश्यकता है, तो डबल डॉलर चिह्न ($$) लगाएं, जैसे
इस:

लक्ष्य: dep1 dep2 dep3 dep4
और आरएम-एफ $ (आउटपुट)
$(इनपुट) में फ़ाइल के लिए; do cat $$file >> $(आउटपुट); हो गया

इसके अतिरिक्त मेकप में एक "$[VARIABLE]" सिंटैक्स है, जो अन्य के समान ही काम करता है
दो, लेकिन इससे पहले कि मेकप कुछ और भी टटोल ले। यह संपूर्ण नियमों के लिए इसका उपयोग करने की अनुमति देता है
और/या सशर्त:

ब्रैकेट_नियम को परिभाषित करें =
ifdef SOME_VAR
ब्रैकेट:
&echo यह एक नियम है -o $(आउटपुट)
endif
एंडडेफ़

$[ब्रैकेट_नियम]

आरसी-शैली प्रतिस्थापन

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

मॉड्यूल = ए बी सी डी

mylib.a : मॉड्यूल_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(निर्भरताएं) -ओ $(लक्ष्य)

MODULES में प्रत्येक शब्द के साथ उपसर्ग "module_dir/" जुड़ा हुआ है और प्रत्यय ".o" है
प्रत्येक शब्द के साथ जोड़ा गया।

आप शब्दों की सूची को ए में डाले बिना भी आरसी-शैली प्रतिस्थापन का उपयोग कर सकते हैं
चर; वाक्यविन्यास "$( शब्द1 शब्द2)" है। कोष्ठक और के बीच के स्थान पर ध्यान दें
पहला शब्द। तो उपरोक्त उदाहरण को इस प्रकार लिखा जा सकता था:

mylib.a : मॉड्यूल_dir/$( a b c d).o $(OTHER_OBJECTS)
$(CXX) $(निर्भरताएं) -ओ $(लक्ष्य)

एक वेरिएबल आरसी-शैली प्रतिस्थापन तभी देगा जब उसमें एक से अधिक शब्द हों।
एक शब्द में कहें तो यह पारंपरिक बनावट जैसा है। अफसोस, जब वेरिएबल खाली होता है, तो एक होता है
टकराव। पारंपरिक बनाता है बस इसे खाली स्ट्रिंग में विस्तारित करें। लेकिन जब आप सोचते हैं
इसे एक सूची के रूप में, आप चाहेंगे कि "-I$(DIRLIST)" गायब हो जाए, न कि एक अकेला "-I" दें।
समाधान यह है कि इसे एक सूची में लपेटा जाए जो एक स्थान से शुरू होती है: "-I$( $(DIRLIST))" आपको देता है
बिल्कुल उतने ही विकल्प, जितने सूची में शब्द हैं।

यदि आप एक ही शब्द में कई वेरिएबल डालते हैं जो शब्दों की सारणी में विस्तारित होते हैं, तो आरसी-शैली
प्रतिस्थापन वास्तव में कार्टेशियन उत्पाद लेता है, इसलिए आप ऐसा कुछ कर सकते हैं यदि
तुम्हें चाहिए:

डीआईआरएस = एस1 एस2
मॉड्यूल = ए बी सी
प्रत्यय = .o .c
फ़ाइलें:= $(DIRS)/$(मॉड्यूल)$(प्रत्यय)

और FILES में स्ट्रिंग होगी

एस1/एओ एस1/एसी एस1/बीओ एस1/बीसी एस1/सीओ एस1/सीसी एस2/एओ एस2/एसी एस2/बीओ एस2/बीसी एस2/सीओ एस2/सीसी

सफेद स्थान के अलावा, आरसी-शैली प्रतिस्थापन किसी भी उद्धरण, किसी भी गोल, घुंघराले या वर्ग पर रुकता है
कोष्ठक, और ", : ; = # @" में से कोई भी। ध्यान दें कि यह आश्चर्यजनक हो सकता है, और फिर इसकी आवश्यकता भी हो सकती है
एक स्पष्ट सूची. मान लें कि आप सभी निर्देशिकाओं में वाइल्डकार्ड द्वारा हेडर देखना चाहते हैं
बड़े अक्षर से शुरू करना:

बुरा := [ए-जेड]*/**/*.$( एचपीपी एच) # [ए-जेड]*/**/*.एचपीपी */**/*.एच
अच्छा := $( [ए-जेड]*/**/*.)$( एचपीपी एच) # [ए-जेड]*/**/*.एचपीपी [ए-जेड]*/**/*.एच

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

लक्ष्य: makepp_simple_conatenation = 1
को लक्ष्य:
&echo before_first$(LIST)after_last -o $(आउटपुट)

क्योंकि "$[VARIABLE]" का मूल्यांकन "$(VARIABLE)" से पहले किया जाता है, दोनों को rc में मिलाकर-
प्रतिस्थापन वह परिणाम नहीं देगा जिसकी आप अपेक्षा कर सकते हैं, जब तक कि आप इसे किसी स्पष्ट रूप में न लपेटें
सूची:

ए = ए बी
एन = 1 2
ख़राब := $(ए)$[एन]
अच्छा := $(ए)$( $[एन])

अंतिम पंक्तियाँ इस प्रकार पढ़ी जाती हैं

बुरा := $(ए)1 2 # ए1 बी1 2
अच्छा := $(ए)$( 1 2) # ए1 ए2 बी1 बी2

प्रतिस्थापन संदर्भ

एक प्रतिस्थापन संदर्भ का रूप "$(VAR:A=B)" है, जहां A मिलान करने के लिए एक पैटर्न है और B है
इसे बदलने के लिए एक पैटर्न। प्रतिस्थापन सन्दर्भ इसका संक्षिप्त रूप है
"पैटसबस्ट" फ़ंक्शन। उदाहरण के लिए:

source_files = एसी बीसी सीसी डीसी
object_files = $(source_files:%c=%o)

"$(object_files)" को "a.o b.o c.o d.o" पर सेट करेगा। "%" एक विशेष वर्ण से मेल खाता है
कोई मनमाना स्ट्रिंग. यदि ए और बी दोनों "%" से शुरू होते हैं, तो प्रतिस्थापित करते समय यह एक सामान्य मामला है
प्रत्यय, उन्हें छोड़ा जा सकता है:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # वही, क्योंकि . विशेष नहीं है

खाली स्थान के in चर

यदि आपको किसी वेरिएबल में रिक्त स्थान को नियंत्रित करने की आवश्यकता है, तो आपको (वर्तमान में) आरसी-स्टाइल को अक्षम करना होगा
प्रतिस्थापन ("makepp_simple_conatenation=1" सेट करके) और फिर इस तरह एक वाक्यविन्यास का उपयोग करें:

शून्य =
टी = -ओ $(शून्य)

या, खाली मूल्यांकन के साथ:

टी = -ओ $()

जब आप ऐसा करते हैं, तो वेरिएबल "T" में "-o" के बाद एक स्पेस होता है।

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

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

ifeq ($(ARCH),weirdarch)
ओ := /आउटपुट=
अन्य
शून्य:=
ओ := -ओ $(शून्य)
endif

%.ओ:%.सी
$(कंपाइलर) $(इनपुट) $(O)$(आउटपुट)

यदि आप वास्तव में ऐसा करना चाहते हैं तो आप मेकप्प के साथ ऐसा कर सकते हैं, लेकिन संभवतः आप पाएंगे कि यह आपका है
यदि आपके पास कम जटिल वैरिएबल है तो मेकफ़ाइलें काफी अधिक पठनीय हैं
प्रतिस्थापन, जैसे,

ifeq ($(ARCH),weirdarch)
%.ओ:%.सी
$(WEIRD_COMPILER) $(इनपुट) /आउटपुट=$(आउटपुट)
अन्य
%.ओ:%.सी
$ (सीसी) -सी $ (इनपुट) -ओ $ (आउटपुट)
endif

वैरिएबल नामों में कभी भी व्हाइटस्पेस की अनुमति नहीं है, केवल उनके मानों में। यह भिन्न है
कुछ कार्यान्वयन करते हैं।

स्वचालित चर
स्वचालित चर वे चर होते हैं जो किस नियम के आधार पर भिन्न मान ग्रहण करते हैं
उनका मूल्यांकन किया जाता है। Makepp अन्य की तुलना में अधिकांश स्वचालित चर का समर्थन करता है
उपयोग के संस्करण। इसके अलावा, इसमें अधिकांश के लिए कम गूढ़, लंबे नाम हैं
इसके बजाय आप इसका उपयोग कर सकते हैं. (लीगेसी मेकफ़ाइल्स के लिए जो इन नामों को फिर से परिभाषित करते हैं, ...
मेकफ़ाइल में परिभाषा डिफ़ॉल्ट अर्थ को ओवरराइड करती है। उदाहरण के लिए, यदि आप कहते हैं
आपके मेकफ़ाइल में "target = abc", तो "$(target)" हमेशा "abc" तक विस्तारित होगा, और नहीं होगा
अब $@ के बराबर होगा।)

मेकप द्वारा समर्थित सभी स्वचालित चरों की पूरी सूची निम्नलिखित है:

उत्पादन
लक्ष्य
$@ वर्तमान नियम का लक्ष्य. दरअसल, चूंकि मेकप कई लक्ष्यों का समर्थन करता है
कोई भी नियम, यह है प्रथम लक्ष्य। उदाहरण के लिए, निम्नलिखित नियम में

y.tab.c y.tab.h: parser.y
$(YACC) -o $(आउटपुट) $(YFLAGS) $(इनपुट)

"$(आउटपुट)" में मान होगा y.tab.c. चूँकि ये जादुई चर वास्तव में हैं
फ़ंक्शंस, आप एक इंडेक्स को तर्क के रूप में भी पास कर सकते हैं। यह 1 या पीछे से गिना जाता है
1 से। तो "$(आउटपुट 2)" या "$(आउटपुट -1)" में मान होगा वाई.टैब.एच.

हालाँकि इस चर के तीनों रूपों का मान समान है, परंतु इनमें अंतर है
बहुलक्ष्य नियमों की व्याख्या. यदि आप पुरानी शैली के गुप्त नाम $@ का उपयोग करते हैं,
मेकप इसकी व्याख्या एक आधुनिक नियम के बजाय एक पुरानी शैली के नियम सेट के रूप में करेगा
उन सभी लक्ष्यों को एक ही बार में तैयार करता है:

ए बी: # वास्तव में: ए और बी प्रत्येक के लिए एक नियम
$@ स्पर्श करें

सी डी: # त्रुटि: एमपीपी शिकायत करता है कि इसने डी का निर्माण नहीं किया
$(आउटपुट) स्पर्श करें

outputs के
लक्ष्य
वर्तमान नियम के सभी लक्ष्य. "$(लक्ष्य)" के समान, जब तक कि एक से अधिक न हों
लक्ष्य। उपरोक्त उदाहरण में, "$(आउटपुट)" y.tab.c y.tab.h होगा। आप एक पास कर सकते हैं
सूचकांक सूची, इसलिए "$(आउटपुट 2 1)" y.tab.h y.tab.c होगा।

निर्भरता
निवेश
$< नियम की पहली स्पष्ट निर्भरता। उदाहरण के लिए, इस नियम में

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

"$(input)" का नाम होगा .c फ़ाइल, चाहे कुछ भी हो .h फ़ाइलें मेकप
पता चलता है. यदि आप एक से अधिक निर्भरता निर्दिष्ट करते हैं, तो आप उन्हें पास करके प्राप्त कर सकते हैं
सूचकांक: "$(इनपुट $(INDEX))" सूचकांक निर्भरता है।

निर्भरता
निविष्टियां
$^ लक्ष्य की सभी स्पष्ट निर्भरताएँ, शामिल नहीं .h द्वारा खोजी गई फ़ाइलें
के लिए makepp_scanning शामिल है।

उदाहरण के लिए, नियम में

myprog.o : *.o
$(CC) $(CFLAGS) $(इनपुट) -o $(आउटपुट)

"$(इनपुट)" निर्देशिका में सभी .o फ़ाइलें होंगी। आप केवल वही चुन सकते हैं जो आप चाहते हैं
एक सूचकांक सूची पास करके चाहते हैं। यदि आप स्पष्ट रूप से विभिन्न प्रकार की फ़ाइलें निर्दिष्ट करते हैं,
आप उन्हें "$(इनपुट 2 3 4)" के रूप में चुन सकते हैं (लेकिन वाइल्डकार्ड के साथ यह भी नहीं है)
आशाजनक)।

क्रमबद्ध_निर्भरताएँ
क्रमबद्ध_इनपुट
$+ डुप्लिकेट हटाए जाने के साथ, क्रमबद्ध क्रम में लक्ष्य की सभी निर्भरताएँ।
"$(सॉर्ट $(इनपुट))" के बराबर।

परिवर्तित_निर्भरताएँ
परिवर्तित_इनपुट
$? लक्ष्य की निर्भरताएँ जो बदल गई हैं. इसमें केवल स्पष्ट शामिल है
निर्भरताएँ (अर्थात्, जिन्हें आप मेकफ़ाइल में सूचीबद्ध करते हैं), अंतर्निहित रूप से खोजी नहीं गई हैं
स्कैनिंग से निर्भरताएँ (जैसे .h फ़ाइलें)।

यह आमतौर पर इस तरह के कमांड में उपयोग किया जाता है:

libमाइन.ए: $(मॉड्यूल): बिल्ड_चेक इग्नोर_एक्शन
$(AR) ru $@ $?

अर्थात, ar केवल उन्हीं मॉड्यूल को बदलने के लिए कहा गया है जो बदल गए हैं। (ध्यान दें
"ignore_action" चेक नियम बनाएँ। यदि आप इसे निर्दिष्ट नहीं करते हैं, तो मेकप इसे बाध्य करेगा
जब भी इसमें परिवर्तन हो तब क्रियान्वित की जाएगी। यदि कोई निर्भरता नहीं बदली है, तो
एक्शन स्ट्रिंग "एआर आरयू लिबमाइन.ए" होगी जो संभवतः उससे भिन्न है
पिछली बार जब आपने इसे चलाया था, तो बिना "ignore_action" के मेकप इसे निष्पादित करेगा। इस में
मामले में, यह हानिरहित है, लेकिन अन्य आदेशों के साथ, यह एक समस्या हो सकती है। देखना
"ignore_action" पर विवरण के लिए makepp_build_check।)

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

तना
$* एक पैटर्न नियम में स्टेम (यानी, जो भी '%' मेल खाता हो)। वैकल्पिक रूप से, यदि यह
यह एक पैटर्न नियम नहीं है, एक्सटेंशन के बिना फ़ाइल नाम लौटाता है (यानी, यह है)।
"$(बेसनाम $(इनपुट))" के बराबर।

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

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

यह नियम लिखने का एक घटिया तरीका है. जीएनयू-मेक शैली का उपयोग करना अधिक स्पष्ट है
पैटर्न नियम, इस प्रकार:

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

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

#
# किसी प्रकार के विशेष प्रीप्रोसेसर के साथ .c फ़ाइलें बनाएं:
#
%.सी : %.के
$ (प्रीप्रोसेसर) $ (इनपुट)> $ (आउटपुट)

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

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

अधिक विवरण और उदाहरणों के लिए नियमों में फ़ोरैच क्लॉज़ पर दस्तावेज़ देखें।

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

मेरा आउटपुट:
.$/myprog >$(आउटपुट)

तर्क के रूप में पारित फ़ाइल नामों के लिए यह इतना आवश्यक नहीं है क्योंकि विंडोज़ यूनिक्स को संभाल सकता है
वहाँ वाक्यविन्यास.

विकल्प चर
आप इन्हें ऊपर बताए गए सभी तरीकों से संशोधित करने के लिए सेट कर सकते हैं (सिवाय यदि अन्यथा कहा गया हो)।
मेकप का व्यवहार. डिफ़ॉल्ट रूप से वे सभी अपरिभाषित हैं.

MAKEPP_DEBUG
यदि आप मेकप को कॉल करने से पहले इसे सही मूल्य के साथ निर्यात करते हैं, तो आपको अधिक डिबगिंग मिलती है
जानकारी यह तब बनाई गई फ़ाइलों का "RULE_SOURCE" है, जब यह इसके अंतर्गत प्रभावी है
मेकपिनफो, एमपीआई और नीचे परिवर्तनीय विस्तार और नियम मिलान के बारे में विवरण
मेकप्लॉग, एमपीपीएल। इससे आपको यह भी पता चलेगा कि मेकप की मेमोरी खत्म हो गई है या हैंग हो गया है,
क्योंकि यह समान चरों का अंतहीन विस्तार कर रहा है:

ए = $ए # स्थगित मूल्यांकन, आवश्यकता :=
बी = $सी
सी = $बी

MAKEPP_LN_CP
&ln के अंतर्गत नोट देखें।

makepp_percent_subdirs
लक्ष्य या निर्भरता मिलान में "%" रखने के लिए इसे कुछ वास्तविक मान (जैसे 1) पर सेट करें
एक से अधिक निर्देशिका में।

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

मेकप्प_सिग्नेचर_सी_फ्लैट
यह C पर हस्ताक्षर करने का एक विकल्प है। इसे अपने इलाज के लिए कुछ सही मान (जैसे 1) पर सेट करें
स्रोत चपटे हैं, यानी सभी नई लाइनें (प्रीप्रोसेसर स्टेटमेंट को छोड़कर) हैं
व्हाइटस्पेस की तरह व्यवहार किया जाता है और "#लाइन" निर्देशों को नजरअंदाज कर दिया जाता है।

मेकप्प_सिंपल_कॉन्टेनेशन
"आरसी-शैली प्रतिस्थापन" को रोकने के लिए इसे कुछ वास्तविक मान (जैसे 1) पर सेट करें।

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

वीपथ
इस वेरिएबल को कुछ मान पर सेट करने से परोक्ष रूप से "vpath% मान" कहा जाता है।

पूर्वनिर्धारित चर
Makepp कुछ वेरिएबल्स को पूर्वनिर्धारित करता है, जिन्हें आप ओवरराइड कर सकते हैं:

AR चूक: "एआर"।

अरफ्लैग्स
चूक: "आरवी"।

AS चूक: "जैसा"।

CC चूक: सबसे पहले "gcc", "egcc", "pgcc", "c89" या "cc", या विंडोज़ पर पाया गया
इसके अतिरिक्त "सीएल" या "बीसीसी32"।

सीएफएलजीएस
चूक: यदि "$(CC)" एक GNU कंपाइलर "-g -Wall" है, यदि यह दो विंडोज़ में से एक है
कंपाइलर्स कुछ भी नहीं, अन्यथा "-जी"।

दही
वह निर्देशिका जिसमें वर्तमान मेकफ़ाइल स्थित है।

सीएक्सएक्स चूक: सबसे पहले "g++", "c++", "pg++", "cxx", "C""C" या "aCC", या पर पाया गया
विंडोज़ अतिरिक्त रूप से "सीएल" या "बीसीसी32"।

CXXफ़्लैग
चूक: यदि "$(CXX)" एक GNU कंपाइलर "-g -Wall" है, यदि यह दो विंडोज़ में से एक है
कंपाइलर्स कुछ भी नहीं, अन्यथा "-जी"।

F77 चूक: सबसे पहले "f77", "g77" या "fort77" में पाया गया।

FC चूक: "$(F77)"।

LD चूक: "एलडी"।

लेक्रस चूक: सबसे पहले "लेक्स" या "फ्लेक्स" के बीच पाया गया।

लिबटूल
चूक: "लिबटूल"।

MAKE
इस वेरिएबल के दो अलग-अलग मान हैं, जो मौजूद होने या न होने पर निर्भर करता है
"-पारंपरिक-पुनरावर्ती-बनाएँ"। Makepp पहचानता है कि इस वेरिएबल का उपयोग कब किया जाता है और
वास्तव में पुनरावृत्ति होने से पहले ही कुछ सुविधाओं को बंद कर देता है। यह हो सकता है
अवांछनीय है जबकि आप इसे धीरे-धीरे समाप्त कर रहे हैं, इसलिए पहले कॉल को एक में बदलें
मेकप विशिष्ट "$((MAKE))", जो सुविधाओं को बंद नहीं करेगा। आपको इसे सेट नहीं करना चाहिए
क्योंकि इससे हमारा स्मार्ट रिकर्सन कार्य बाधित हो जाता है।

लक्ष्य बनाएं
यह वेरिएबल सेट है लेकिन मेकप द्वारा उपयोग नहीं किया जाता है। आप उससे कुछ करने के लिए तभी पूछ सकते हैं जब
एक निश्चित लक्ष्य का अनुरोध किया गया था.

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

ifneq $(फ़िल्टर विशेष-लक्ष्य, $(MAKECMDGOALS))
# विशेष-लक्ष्य वर्तमान स्पष्ट लक्ष्यों में से एक है
अन्यथा ifeq $(MAKECMDGOALS)
# कोई स्पष्ट लक्ष्य नहीं
endif

मेकफ्लैग्स (निर्यात)
वे मानक विकल्प जिनके साथ मेकप को कॉल किया गया था। जिनका एक अक्षर होता है
फॉर्म को शुरुआत में बिना किसी अग्रणी "-" के संयोजित किया जाता है (स्वर्ग जानता है कि gmake ने क्यों चुना
"-" को छोड़ने के लिए).

मेकनफो
चूक: "मेकइन्फो"।

मेकपफ्लैग (निर्यात)
इसे MAKEFLAGS के समान मान पर सेट किया गया है, लेकिन केवल तभी जब यह वेरिएबल मौजूद हो
मेकप का वातावरण।

_MAKEPPFLAGS (निर्यातित)
POSIX/gmake संगतता के लिए आवश्यक makepp विशिष्ट विकल्प, जिसके साथ makepp
बुलाया गया। ये एक अलग वेरिएबल में हैं इसलिए लीगेसी मेकफ़ाइल टूट नहीं सकती
MAKEFLAGS को अनसेट करके अनुकूलता। यह केवल इसके साथ सेट है
"-पारंपरिक-पुनरावर्ती-बनाएँ"।

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

चूक: वही मान "makepp --version" द्वारा प्रदर्शित होता है

PWD "CURDIR" का उपनाम।

RM चूक: "आरएम-एफ"। यह लीगेसी मेकफ़ाइल्स के लिए है। नए के लिए अधिमानतः उपयोग करें
अंतर्निहित &rm कमांड सीधे। यदि आप एक नकली स्वच्छ नियम लिखना चाहते हैं, तो देखें
इसके बजाय "makeppclean -r" कमांड।

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

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

चूक: सबसे पहले "/usr/xpg4/bin/sh" (जैसे सोलारिस) या "/sbin/xpg4/sh" के बीच पाया गया
(उदा. रिलायंट यूनिक्स) या "/ बिन / श".

वाईएसीसी
चूक: सबसे पहले "बाइसन -वाई" या "याक" के बीच पाया गया।

चर और पर्ल
परिवर्तनीय मान सामान्य पर्ल स्केलर के रूप में संग्रहीत किए जाते हैं, ताकि आप उन तक सीधे पहुंच सकें
यदि आपको उनके साथ कोई जटिल हेरफेर करने की आवश्यकता है तो पर्ल कोड; makepp_extending देखें
ब्योरा हेतु।

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

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

सीधी पहुंच के साथ आप इन चरों के विस्तार को भी बायपास कर सकते हैं, यदि वे प्रकार के हों
"=" या ";="। विशेष वैरिएबल जैसे "$(CC)" फ़ंक्शन के रूप में शुरू होते हैं, जब तक कि वे न हों
को सौंपना। इसलिए कई मामलों में आपको उनका मूल्य नहीं दिखेगा.

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

मेकपरल { $$current_value = '$(MAKEFILE_VAR)' }

यदि आपको मेकफ़ाइल पर्ल ब्लॉक में एक वेरिएबल की आवश्यकता है तो यह पर्ल वेरिएबल के माध्यम से प्राप्त किया जाता है
$makefile इस प्रकार है:

पर्ल { $current_value = $makefile->expand_variable( 'MAKE_VAR' ) }

फ़ंक्शंस हमेशा मेकफ़ाइल ऑब्जेक्ट को दूसरे तर्क के रूप में पास करते हैं $_[1]:

उप f_f { $current_value = $_[1]->expand_variable( 'MAKE_VAR' ) }

कमांड को एक नियम कार्रवाई के भीतर बुलाया जाना चाहिए, जहां मेकफ़ाइल ऑब्जेक्ट है
"$Mpp::Subs::rule->{MAKEFILE}" के माध्यम से पहुंच योग्य:

उप c_cmd { $current_value = $Mpp::Subs::rule->{MAKEFILE}->expand_variable( 'MAKE_VAR' ) }

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