मेटाकॉन्फ़िग - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

मेटाकॉन्फिग - एक कॉन्फिगर स्क्रिप्ट जनरेटर

SYNOPSIS

मेटाकॉन्फिग [-dhkmostvwGMV ] [-L दीर ]

वर्णन

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

मेटाकॉन्फ़िग के सेट से संचालित होता है इकाइयों जो मेटाकॉन्फिग के बारे में जो कुछ भी जानता है उसे परिभाषित करता है
सुवाह्यता. प्रत्येक इकाई स्व-निहित है, और उसे कहीं भी पंजीकृत होने की आवश्यकता नहीं है
सार्वजनिक यू निर्देशिका या आपकी निजी यू निर्देशिका में शामिल करने के अलावा। अगर
डिस्ट पैकेज (जिसका मेटाकॉन्फिग एक हिस्सा है) एलआईबी में स्थापित किया गया है, फिर सार्वजनिक यू
निर्देशिका LIB/dist/mcon/U है। इस मशीन पर, LIB निर्देशिका /usr/share/dist है। आपका
निजी यू निर्देशिका, यदि आपके पास एक है, तो आपके पैकेज की शीर्ष स्तरीय निर्देशिका में है।
इससे पहले कि आप दौड़ सकें मेटाकॉन्फिग आपको कई चीज़ें करनी होंगी:

· पैकेज की शीर्ष स्तरीय निर्देशिका में चलाकर एक .package फ़ाइल बनाएं पैकिनिट.
यह प्रोग्राम आपसे आपके पैकेज के बारे में पूछेगा और आप जो बताएंगे उसे याद रखेगा ताकि
जिले के सभी प्रोग्राम स्मार्ट हो सकते हैं।

· शब्दावली (LIB/dist/mcon में) से परामर्श लें और अपनी शेल स्क्रिप्ट और C प्रोग्राम लिखें
उन प्रतीकों के संदर्भ में जिन्हें मेटाकॉन्फिग परिभाषित करना जानता है। आपको बताने की जरूरत नहीं है
मेटाकॉन्फिग आपने कौन से प्रतीकों का उपयोग किया है, क्योंकि मेटाकॉन्फिग आपके लिए इसका पता लगा लेगा।

· मेकफ़ाइल्स या शेल स्क्रिप्ट लिखने के लिए आवश्यक कोई भी .SH स्क्रिप्ट तैयार करें जो निर्भर करेगी
कॉन्फिगर द्वारा परिभाषित मूल्यों पर। नामक एक प्रोग्राम है मेकएसएच वह आपकी मदद करेगा
एक सादे स्क्रिप्ट को स्क्रिप्ट.एसएच टेम्पलेट में परिवर्तित करें; कुछ संपादन अभी भी करने की आवश्यकता होगी
परिवर्तनीय कॉन्फ़िगरेशन भाग को स्थानांतरित करने के लिए परिणामी .SH फ़ाइल पर प्रदर्शन किया गया
स्क्रिप्ट का शीर्ष भाग (इनलाइन टिप्पणियाँ देखें)। मेकएसएच आपके .SH के भीतर
फ़ाइल).

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

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

· किसी भी .U फ़ाइल को अपनी निजी U निर्देशिका में कॉपी करें जिसे आप संशोधित करना चाहते हैं। कोई भी .U फ़ाइलें
आपकी निजी यू निर्देशिका में सार्वजनिक यू की तुलना में प्राथमिकता में उपयोग किया जाएगा
निर्देशिका। उदाहरण के लिए, किसी भी इकाई को जबरन शामिल करने का एक तरीका End.U की प्रतिलिपि बनाना है
अपनी .U निर्देशिका में फ़ाइल करें और उस इकाई का नाम जोड़ें जिस पर आप निर्भरता के रूप में चाहते हैं
?MAKE: पंक्ति का अंत। कुछ इकाइयों को केवल इस तरह से मजबूर किया जा सकता है, अर्थात्
Warn_*.U और Chk_*.U फॉर्म वाले। आप कुछ डिफ़ॉल्ट को कस्टमाइज़ भी कर सकते हैं
Myinit.U को अपने पैकेज की निजी U निर्देशिका में कॉपी करके वेरिएबल कॉन्फ़िगर करें
उस इकाई में चर सेट करना।

अब आप दौड़ने के लिए तैयार हैं मेटाकॉन्फिग. वह एक निर्माण करेगा कॉन्फ़िगर फ़ाइल, और वैकल्पिक रूप से a
config_h.SH फ़ाइल (यदि आपके स्रोत सी प्रतीकों का कोई उपयोग करते हैं)। जेनरेट की गई फ़ाइलें होंगी
यदि आवश्यक हो तो स्वचालित रूप से आपके MANIFEST.new में जोड़ा जाएगा। अपना अपडेट करना न भूलें
हालाँकि मैनिफ़ेस्ट फ़ाइल।

नई इकाइयाँ बनाने के लिए, निम्नलिखित कार्य करें:

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

· आप जो चाहते हैं उसे करने के लिए नई .U फ़ाइल संपादित करें। पहली ?MAKE: पंक्ति इंगित करती है
निर्भरताएँ; अंतिम सूची से पहले इस इकाई द्वारा परिभाषित सभी चरों को कोलन करें, और
अंतिम कोलन के बाद वे सभी चर (या अन्य इकाइयाँ) जिन पर यह इकाई निर्भर करती है।
यह बहुत महत्वपूर्ण है कि ये सूचियाँ सटीक हों। यदि कोई निर्भरता वैकल्पिक है और a
डिफ़ॉल्ट मान का उपयोग किया जा सकता है, आपको निर्भरता के पहले '+' चिह्न लगाना चाहिए।
जब तक वास्तव में आवश्यकता न हो, प्रतीक की गणना करने के लिए संबंधित इकाई को लोड नहीं किया जाएगा
किसी अन्य इकाई द्वारा.

· जहां तक ​​संभव हो, अपनी इकाई को परिभाषित शेल वेरिएबल के आधार पर पैरामीटराइज़ करें
?INIT: पंक्तियाँ. यह परिवर्तनीय परिभाषाओं को Init.U इकाई तक ले जाएगा, जहां
उन्हें Myinit.U में परिभाषाओं द्वारा ओवरराइड किया जा सकता है, जो Init.U के बाद शामिल है।

· किसी भी वांछित C प्रतीकों की परिभाषा को ?H: रेखाओं के रूप में जोड़ें। से शुरू होने वाली एक पंक्ति
?H:?%<: .U फ़ाइल में अंतिम config.h फ़ाइल में जोड़ा जाएगा यदि और केवल यदि
मेटाकॉन्फिग निर्णय लेता है कि इस इकाई की आवश्यकता है। %< इकाई के नाम को दर्शाता है,
यदि आपने इसका अनुसरण किया है तो यह फ़ाइल का नाम भी होगा (.U के बिना)।
सम्मेलन। चर में से किसी एक के मामले में हमेशा प्रत्येक ?H: पंक्ति पर एक टिप्पणी डालें
लाइन पर पहले प्रतिस्थापन एक टिप्पणी को समाप्त किए बिना शुरू करता है। कोई भी खोल
d_ से शुरू होने वाला वेरिएबल ऐसा कर सकता है, इसलिए सावधान रहें। यदि आप ?%<: को छोड़ देते हैं, तो
मेटाकॉन्फ़िग उस प्रतीक को अंतर्निहित करने का प्रयास करेगा जिसकी परिभाषा किसी से पहले आवश्यक है
config.h में शामिल करना।

· शब्दावली परिभाषाएँ जोड़ें जैसे ?S: शेल वेरिएबल्स के लिए पंक्तियाँ और ?C: C के लिए पंक्तियाँ
प्रीप्रोसेसर चर। उदाहरण के लिए वर्तमान इकाई देखें. यह बहुत महत्वपूर्ण है
प्रत्येक प्रविष्टि को बाएँ उचित प्रतीक नाम से प्रारंभ करें, और प्रत्येक प्रविष्टि को ?C: से समाप्त करें। या
?एस:। रेखा। एल्गोरिथ्म जो C प्रीप्रोसेसर प्रतीक प्रविष्टियों का अनुवाद करता है
config.h के लिए टिप्पणियों में शब्दावली इस पर निर्भर करती है।

· अपने सभी का ऑर्डर सुनिश्चित करें? पंक्तियाँ सही हैं. सही क्रम है:

?RCS: और ?X: मूलतः केवल टिप्पणियाँ
?बनाएँ: मेटाकॉन्फिग निर्भरताएँ
?Y: इकाई लेआउट निर्देश
?एस: शब्दावली शैल परिभाषाएँ
?सी: शब्दावली सी परिभाषाएँ
?H: config.h परिभाषाएँ
?M: confmagic.h परिभाषाएँ
?डब्ल्यू: प्रतीक चाहता था
?V: दृश्य प्रतीक
?F: इस इकाई द्वारा बनाई गई फ़ाइलें
?T: अस्थायी शेल प्रतीकों का उपयोग किया गया
?D: वैकल्पिक निर्भरताएँ डिफ़ॉल्ट मान
?O: अप्रचलित इकाइयों को चिह्नित करने के लिए उपयोग किया जाता है
?LINT: मेटलिंट संकेत
?INIT: शेल प्रतीक आरंभीकरण

यहां पंक्तियों के क्रम और अनुमत विभिन्न प्रारूपों को दिखाने के लिए एक उदाहरण दिया गया है:

?आरसीएस: $आरसीएस-आईडी$
?आरसीएस: कॉपीराइट जानकारी
?आरसीएस: $आरसीएस-लॉग$
?एक्स:
?एक्स: एक मनगढ़ंत उदाहरण
?एक्स:
?बनाएँ:d_एक दो: तीन +चार पाँच
?बनाएं: - $@ % जोड़ें चुनें
?Y:डिफ़ॉल्ट
?S:d_one:
?एस: पहला शेल प्रतीक, सशर्त रूप से एक को परिभाषित करता है।
?एस:।
?एस:दो:
?एस: दूसरा शेल प्रतीक, दो के लिए मान।
?एस:।
?सी:एक:
?सी: पहला सी प्रतीक।
?सी:।
?सी:दो:
?सी: दूसरा सी प्रतीक।
?सी:।
?H:#$d_one एक /**/
?H:#दो परिभाषित करें "$दो"
?H:#$d_one ONE_TWO "$two"
?एच:।
?एम:फ्लिप: HAS_FLIP
?M:#ifndef HAS_FLIP
?M:#फ्लिप(x) फ्लॉप(x) को परिभाषित करें
?M:#endif
?एम:।
?W:%<:one_two
वी:p_एक p_दो:p_तीन
?F:फ़ाइल ./ftest !tmp
?T:tmp संस्करण
?डी:दो='अनिर्धारित'
?LINT: तीन बदलें
?INIT:two_init='2'
: यूनिट को लागू करने वाला शेल कोड इस प्रकार है
p_one='एक'
p_two='दो'
p_तीन=””

मैं इसे एक बार और बता दूं: उपरोक्त इकाई परिभाषा एक है उल्लू बनाना केवल दिखाने के लिए एक
विभिन्न संभावनाएँ. ऐसी इकाई वैसे भी बहुत कम उद्देश्य पूरा करेगी... कुछ और
उन्नत सुविधाओं का वर्णन यहां नहीं किया गया है. कृपया देखें संदर्भ अधिक के लिए अनुभाग
पूरी जानकारी।

· इकाई को सार्वजनिक या निजी यू निर्देशिका में उचित रूप में रखें।

· पुनः चलाएँ मेटाकॉन्फिग.

· अपनी यूनिट को यहां भेजें [ईमेल संरक्षित] (राफेल मैनफ्रेडी) मास्टर कॉपी में शामिल करने के लिए,
यदि आपको लगता है कि यह सामान्य हित का है।

स्थित होने के लिए एक नया प्रोग्राम जोड़ने के लिए:

· Loc.U संपादित करें, और प्रोग्राम का नाम ?MAKE: लाइन (के बीच) में जोड़ें
दो कोलन) और या तो लोकलिस्ट या ट्राइलिस्ट (इस पर निर्भर करता है कि प्रोग्राम है या नहीं
अनिवार्य है या नहीं)।

· मेटाकॉन्फिग को पुनः चलाएँ।

· यदि आपको लगता है कि यह सामान्य है तो मास्टर कॉपी में शामिल करने के लिए अपनी यूनिट मुझे भेजें
ब्याज.

.U फ़ाइलें लिखने के लिए नोट्स:

* हमेशा "आरएम-एफ" का उपयोग करें क्योंकि ऐसे सिस्टम हैं जहां आरएम डिफ़ॉल्ट रूप से इंटरैक्टिव है।

* "सेट--..." का प्रयोग न करें क्योंकि '--' हर शेल के साथ काम नहीं करता है। "सेट x ... का प्रयोग करें;
बदलाव"।

* "अनसेट ईएनवी" का उपयोग न करें क्योंकि अनसेट पूरी तरह से पोर्टेबल नहीं है। इसके बजाय "ENV=''" कहें।

* यूनिस सिस्टम के कारण हमेशा इको " " (स्पेस के साथ) का उपयोग करें।

* केवल उपयोग करें परीक्षण -r, -w, -f या -d के साथ क्योंकि ये एकमात्र पोर्टेबल स्विच हैं। में
विशेष रूप से, "परीक्षण -x" से बचें।

* केवल V7 के साथ आए प्रोग्राम का उपयोग करें, ताकि आप जान सकें कि वे सभी के पास हैं।

* जब आप सशर्त रूप से grep करना चाहते हैं तो $contains का उपयोग करें, क्योंकि सभी greps a नहीं लौटाते हैं
उचित स्थिति. '>/dev/null' का उपयोग करके आउटपुट को /dev/null पर रीडायरेक्ट करना सुनिश्चित करें
2>&1'.

* "यदि [...]" के बजाय "यदि परीक्षण" का प्रयोग करें क्योंकि प्रत्येक व्यक्ति बाद वाले निर्माण को नहीं जानता है।

* इनपुट के लिए मायरीड स्क्रिप्ट का उपयोग करें ताकि वे शेल एस्केप और डिफॉल्ट कर सकें
मूल्यांकन। सामान्य रूप है

केस "$गंभीर" में
'') dflt=452;;
*) dflt='$ग्रिम्बल';;
esac
आरपी='तुम्हारे पास कितने दुख हैं?'
. ./मायरीड
गंभीर='$ans'

* वैकल्पिक रखने के लिए फ़ाइल पथनाम मांगते समय गेटफ़ाइल स्क्रिप्ट का उपयोग करें
~नाम विस्तार और विवेक जांच। संपूर्ण विवरण के लिए Getfile.U इकाई देखें।

*हमेशा एक लगाएं

$स्टार्टश

प्रत्येक जेनरेट की गई स्क्रिप्ट के शीर्ष पर जिसे लॉन्च या स्रोत किया जाने वाला है
कॉन्फ़िगर.

* कभी भी सामान्य UNIX-आइएमएस को इस तथ्य की तरह न मानें कि एक ऑब्जेक्ट फ़ाइल एक के साथ समाप्त होती है .o और
लाइब्रेरी का नाम किसके साथ समाप्त होता है .a। उपयोग $_ओ और $_a इसके बजाय चर (देखें)
यूनिक्स.यू).

* संकलन-लिंक-निष्पादित परीक्षण करते समय, इसे हमेशा इस प्रकार लिखें:

$cc $ccflags $ldflags Try.c -o $libs आज़माएं

क्योंकि कुछ प्रणालियों के लिए आवश्यक है कि लिंकिंग फ़्लैग को संकलित करने से पहले निर्दिष्ट किया जाए
लक्ष्य (अनुगामी लिंकिंग पुस्तकालयों के अपवाद के साथ)।

* आउटपुट को पुनर्निर्देशित करने के लिए '>&4' का उपयोग करके फ़ाइल डिस्क्रिप्टर #4 पर महत्वपूर्ण संदेश जारी करें।
केवल वही संदेश दिखाई देंगे जब -s स्विच दिया गया है कॉन्फ़िगर पर
कमांड लाइन (साइलेंट मोड)।

* हमेशा यह निर्धारित करने का प्रयास करें कि क्या कोई सुविधा सबसे विशिष्ट तरीके से मौजूद है--नहीं
जब आप libc को grep कर सकते हैं तो "if bsd" कहें। वहाँ कई हाइब्रिड प्रणालियाँ हैं, और
प्रत्येक सुविधा को अपने आप खड़ा या गिरना चाहिए।

* हमेशा यह निर्धारित करने का प्रयास करें कि क्या कोई सुविधा सबसे सामान्य तरीके से मौजूद है, ताकि
अन्य पैकेज आपकी इकाई का उपयोग कर सकते हैं।

* जब संदेह हो, तो डिफ़ॉल्ट सेट करें और पूछें। कुछ भी मत मानिए.

* यदि आपको लगता है कि उपयोगकर्ता गलत है, तो इस तथ्य को स्वीकार करें कि वह सही हो सकता है। के लिए
उदाहरण के लिए, हो सकता है कि वह कॉन्फिगर को उसके उपयोग से भिन्न सिस्टम पर चला रहा हो
अंतिम उत्पाद पर.

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

.MT/*
कॉन्फ़िगर
जरूरत है
अप्रचलित
कॉन्फ़िगर
config_h.SH
confmagic.h
यू/*
प्रकट.नया

इसके अतिरिक्त, कॉन्फिगर इन नामों को उस निर्देशिका में बंद कर सकता है जिसमें इसे चलाया जाता है:

तुम तुम/*
config.श
कॉन्फ़िग.एच

विकल्प

निम्नलिखित विकल्पों द्वारा मान्यता प्राप्त है मेटाकॉन्फिग:

-d डिबग मोड चालू करें. जब तक आप डिबगिंग नहीं कर रहे हों तब तक यह वास्तव में उपयोगी नहीं है मेटाकॉन्फिग
ही.

-h सहायता संदेश प्रिंट करें और बाहर निकलें।

-k अस्थायी निर्देशिका रखें, ताकि आप उपयोग की गई कार्यशील फ़ाइलों की जांच कर सकें
मेटाकॉन्फिग अपने निर्माण के लिए कॉन्फ़िगर लिखी हुई कहानी। केवल डिबगिंग करते समय उपयोगी
इकाइयों.

-m ढेर सारी मेमोरी ग्रहण करें और स्थान बदलें। इससे प्रतीक खोज में तेजी आएगी
मेमोरी की कीमत पर, काफी समय तक फ़ाइलें स्रोत करें
उपभोग...

-o अप्रचलित प्रतीकों को नए पर मानचित्रित करें। यदि आपके पास अभी भी कुछ है तो इस स्विच का उपयोग करें
आपके स्रोत कोड में अप्रचलित प्रतीक हैं और वे हटाना नहीं चाहते (या नहीं हटा सकते)।
उन्हें अभी के लिए. हालाँकि, अप्रचलित प्रतीकों को अन्यथा नजरअंदाज कर दिया जाता है
से आपको चेतावनी देगा मेटाकॉन्फिग.

-s साइलेंट मोड चालू करें.

-t प्रतीकों को वैसे ही ट्रेस करें जैसे वे पाए जाते हैं।

-v वर्बोज़ मोड चालू करें.

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

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

-L दीर डिफ़ॉल्ट लाइब्रेरी स्थान को ओवरराइड करें। आम तौर पर केवल मेटाकॉन्फिग के लिए उपयोगी है
अनुरक्षकों को इसके बजाय विकसित की जा रही इकाइयों का स्थानीय रूप से उपयोग करना चाहिए
सार्वजनिक रूप से उपलब्ध हैं। दीर निर्दिष्ट वह है जिसमें इकाइयाँ शामिल हैं
U निर्देशिका.

-M के उत्पादन की अनुमति दें confmagic.h स्वचालित रूप से कुछ अच्छी तरह से रीमैप करने के लिए फ़ाइल करें-
किसी अन्य विकल्प के लिए ज्ञात प्रतीक, जैसे bcopy() पुनः मैप किया जा रहा है
पारदर्शी रूप से memcpy() जब उपलब्ध न हो. यह विकल्प चालू है
स्वचालित रूप से जब ए confmagic.h फ़ाइल शीर्ष-स्तरीय निर्देशिका में मौजूद है।
यदि आप इस विकल्प को स्थायी रूप से अक्षम करना चाहते हैं तो बस उस फ़ाइल को हटा दें।

-V संस्करण संख्या प्रिंट करें और बाहर निकलें।

ट्यूटोरियल

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

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

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

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

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

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

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

चिह्न
इसमें प्रतीक सबसे महत्वपूर्ण चीज हैं मेटाकॉन्फिग दुनिया। वे सबसे छोटे हैं
मान्यता प्राप्त इकाई, आमतौर पर एक शब्द, और कॉन्फिगर के अंत में एक मान दिया जा सकता है
कार्यान्वयन। उदाहरण के लिए, C प्री-प्रोसेसर प्रतीक HAS_RENAME एक मेटाकॉन्फिग उसका प्रतीक
परिभाषित किए जाने की गारंटी है यदि, और केवल यदि, नाम बदलें () सिस्टम कॉल मौजूद है. वैसे ही,
la $ranlib शेल वैरिएबल या तो ':' या 'रैनलिब' पर सेट किया जाएगा, यह इस पर निर्भर करता है कि क्या
को कॉल करें रैनलिब लाइब्रेरी फ़ाइल को ऑर्डर करने के लिए प्रोग्राम की आवश्यकता होती है। यह कैसे काम करता है यह नहीं है
अभी के लिए, जो महत्वपूर्ण है वह यह समझना है कि उन प्रतीकों को दिया गया है जिंदगी
(अर्थात् एक मान) पर कॉन्फ़िगर निष्पादन।

प्रतीकों का उपयोग करना अपेक्षाकृत सरल है। C स्रोत फ़ाइल में, आप बस प्रतीक का उपयोग करते हैं
मान, प्री-प्रोसेसर निर्देश के रूप में (उदाहरण के लिए: #ifdef HAS_RENAME) या, यदि प्रतीक
मान एक स्ट्रिंग है, सीधे तौर पर जैसे आप सी में मैक्रो का उपयोग करेंगे और शेल फ़ाइल या ए में
मेकफ़ाइल, आप सीधे शेल प्रतीक का संदर्भ दे सकते हैं।

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

स्रोत फ़ाइलें
प्रतीक केवल स्रोत फ़ाइलों के सीमित सेट में ही दिखाई दे सकते हैं, क्योंकि मेटाकॉन्फिग केवल होगा
ज्ञात प्रतीकों की तलाश करते समय उन्हें स्कैन करें, यह पता लगाने का प्रयास करें कि उसे किन इकाइयों की आवश्यकता होगी।
आप C स्रोत फ़ाइलों में C प्रतीकों का उपयोग कर सकते हैं, अर्थात a वाली फ़ाइलें .c, .h, .y or .l विस्तार, और
शेल प्रतीकों को केवल .SH फ़ाइलों में देखा जाता है।

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

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

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

var='पहला'
टार='दूसरा'
प्रतिध्वनि "--> पहले यहां दस्तावेज़:"
बिल्ली <
var='$var'
टार='$टार'
EOM
प्रतिध्वनि "--> दूसरा दस्तावेज़ यहाँ:"
बिल्ली <<'ईओएम'
प्रतिध्वनि $var
प्रतिध्वनि $tar
EOM
प्रतिध्वनि "-->अंत।"

शेल के माध्यम से चलाने पर उत्पादन होगा:

--> सबसे पहले यहां दस्तावेज़:
var='पहला'
टार='दूसरा'
--> दूसरा दस्तावेज़ यहाँ:
प्रतिध्वनि $var
प्रतिध्वनि $tar
-->समाप्त.

यहां पहले दस्तावेज़ की सामग्री की व्याख्या की गई है, जबकि दूसरे का आउटपुट यथावत है।
दोनों .SH स्क्रिप्ट में उपयोगी हैं, जैसा कि हम देखने वाले हैं।

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

#!/ बिन / श
intsize='4'
इको "इस मशीन पर, int प्रकार $intsize बाइट्स है"

चलो भागते हैं मेकएसएच उस पर ' टाइप करकेमेकएसएच intsize'. हमें एक सिंगल मिलता है intsize.SH उसे फ़ाइल करें
इस तरह दिखता है:

केस $CONFIG में
'')
यदि परीक्षण -f config.sh; फिर टॉप=.;
एलिफ़ टेस्ट -f ../config.sh; फिर टॉप=..;
एलिफ़ परीक्षण -f ../../config.sh; फिर टॉप=../ ..;
एलिफ़ परीक्षण -f ../../../config.sh; फिर टॉप=../../..;
एलिफ़ परीक्षण -f ../../../../config.sh; फिर टॉप=../../../..;
अन्य
इको "config.sh नहीं मिल सका"; बाहर निकलें 1
fi
. $TOP/config.sh
;;
esac
: यह SH फ़ाइलों को SH फ़ाइल के समान निर्देशिका में लक्ष्य बनाने के लिए बाध्य करता है।
: ऐसा इसलिए है ताकि मेक डिपेंड को हमेशा पता रहे कि एसएच डेरिवेटिव कहां ढूंढना है।
मामला "$ 0" में
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac
इको "इंटसाइज़ निकालना (परिवर्तनीय प्रतिस्थापन के साथ)"
: फ़ाइल के इस अनुभाग में परिवर्तनीय प्रतिस्थापन किए जाएंगे।
: ऐसी किसी भी चीज़ को !NO!SUBS से हटाएं जिसके लिए कॉन्फिग सब्सक्रिप्शन की आवश्यकता है! अनुभाग से !GROK!यह!.
: किसी भी डॉलर चिह्न और बैकटिक्स को सुरक्षित रखें जिनकी आप व्याख्या नहीं करना चाहते हैं
: सामने बैकस्लैश लगाकर. आप इन टिप्पणियों को हटा सकते हैं.
$स्पिटशेल >इंटसाइज <
$स्टार्टश
!ग्रोक!यह!

: निम्नलिखित में डॉलर और बैकटिक्स को अतिरिक्त बैकस्लैश की आवश्यकता नहीं है।
$स्पिटशेल >>इंटसाइज <<'!नहीं!SUBS!'
intsize='4'
इको "इस मशीन पर, int प्रकार $intsize बाइट्स है"
!नहीं!उप!
chmod 755 इंटसाइज
$eunicefix intsize

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

एक बार config.श फ़ाइल स्रोत रही है, सभी शेल प्रतीकों द्वारा परिभाषित कॉन्फ़िगर रहे
तय करना। हम जानते हैं कि दूसरे केस स्टेटमेंट तक पहुंचने के लिए वर्तमान निर्देशिका को बदलने के लिए उपयोग किया जाना चाहिए
इस प्रोग्राम तक पहुंचने के लिए पथ का उपयोग किया जाना चाहिए (उदाहरण के लिए यदि हमने कहा 'sh ../स्क्रिप्ट/intsize.SH', हम
पहले चलेंगे'cd ../स्क्रिप्ट' जारी रखने से पहले)। अगर आप ये नहीं समझते तो मत समझिए
इसके बारे में चिंता करें।

यहाँ दिलचस्प चीजें आती हैं। यह स्क्रिप्ट इसका उपयोग करती है $स्पिटशेल परिवर्तनशील, और यह नहीं है
कुछ ऐसा जिसके बारे में हम अभी भी जानते हैं। यदि आप शब्दावली फ़ाइल को देखेंगे, तो आप उसे देखेंगे
यह एक वेरिएबल है जिसे जाना जाता है मेटाकॉन्फिग. यदि आप इस फ़ाइल को अपने वितरण का हिस्सा बनाते हैं
(इसे MANIFEST.new फ़ाइल में शामिल करके, हम बाद में उस पर वापस आएंगे) और चलाएँ
मेटाकॉन्फिग, फिर कॉन्फ़िगर स्क्रिप्ट इस चर के लिए उपयुक्त मान निर्धारित करेगी
और इसे सेट कर दिया जाएगा config.श. वही बात लागू होती है $स्टार्टश और रहस्यमय $eunicefix at
समाप्त। एक उचित प्रणाली पर, के प्रासंगिक भाग config.श इस तरह दिखेगा:

स्पिटशेल='बिल्ली'
स्टार्टश='#!/ बिन / श'
यूनिसफिक्स=':'

आह! हम वहां पहुंच रहे हैं. अब यह परिचित लग रहा है. हम एक अकेले का सामना कर रहे हैं बिल्ली आज्ञा किसकी
इनपुट एक वैरिएबल-इंटरपोलेटेड दस्तावेज़ से आता है और जिसका आउटपुट रीडायरेक्ट किया जाता है
intsize. का मान होगा $स्टार्टश, अर्थात '#!/ बिन / श'. अब तक ठीक है.

फिर हम शेष स्क्रिप्ट प्राप्त करने के लिए यहां दूसरे दस्तावेज़ विस्तार पर पहुंचते हैं। यह
समय, यहां दस्तावेज़ प्रतीक सिंगल कोट्स से घिरा हुआ है इसलिए सामग्री होगी
के साथ शब्दशः जोड़ा गया intsize फ़ाइल। तो, दौड़कर'sh intsize.SH', हमें मिलता है
निम्नलिखित आउटपुट:

अंतर आकार निकालना (चर प्रतिस्थापन के साथ)

और निर्मित इंटसाइज़ फ़ाइल को देखकर, हम देखते हैं:

#!/ बिन / श
intsize='4'
इको "इस मशीन पर, int प्रकार $intsize बाइट्स है"

जो बिल्कुल वैसा ही है जैसा हमारे पास शुरुआत में था। अब तक, यह एक नो-ऑपरेशन प्रक्रिया है...
लेकिन, कितना अद्भुत! ऐसा होता है (शुद्ध संयोग, मेरा विश्वास करो!), कि मेटाकॉन्फिग जानता है
के बारे में $intsize शैल प्रतीक. Intsize के आरंभीकरण को वेरिएबल में ले जाकर-
.SH स्क्रिप्ट का प्रक्षेपित क्षेत्र और इसे इसके साथ प्रारंभ करना कॉन्फ़िगर-गणना मूल्य,
और अब जोड़ी गई बेकार टिप्पणियों को हटा रहा हूँ मेकएसएच, हम पाते हैं:

केस $CONFIG में
'')
यदि परीक्षण -f config.sh; फिर टॉप=.;
एलिफ़ टेस्ट -f ../config.sh; फिर टॉप=..;
एलिफ़ परीक्षण -f ../../config.sh; फिर टॉप=../ ..;
एलिफ़ परीक्षण -f ../../../config.sh; फिर टॉप=../../..;
एलिफ़ परीक्षण -f ../../../../config.sh; फिर टॉप=../../../..;
अन्य
इको "config.sh नहीं मिल सका"; बाहर निकलें 1
fi
. $TOP/config.sh
;;
esac
मामला "$ 0" में
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac
इको "इंटसाइज़ निकालना (परिवर्तनीय प्रतिस्थापन के साथ)"
$स्पिटशेल >इंटसाइज <
$स्टार्टश
intsize='$intsize'
!ग्रोक!यह!

$स्पिटशेल >>इंटसाइज <<'!नहीं!SUBS!'
इको "इस मशीन पर, int प्रकार $intsize बाइट्स है"
!नहीं!उप!
chmod 755 इंटसाइज
$eunicefix intsize

बेशक, इस स्क्रिप्ट को एक शेल के माध्यम से चलाने से फिर से वही स्क्रिप्ट आउटपुट होगी। लेकिन अगर
हम चलाते हैं कॉन्फ़िगर एक मशीन पर जहां एक int 64 बिट्स मात्रा के रूप में संग्रहीत है, config.श मर्जी
सेट intsize 8 करने के लिए और intsize स्क्रिप्ट सही मान धारण करेगी और प्रिंट करेगी:

इस मशीन पर, int प्रकार 8 बाइट्स है

कौन सा सही है। बधाई हो! हमने अभी एक शेल स्क्रिप्ट कॉन्फ़िगर की है!!

उत्पादन कॉन्फ़िग.एच
अब हम रास्ता देख सकते हैं कॉन्फ़िग.एच से उत्पादित होता है config_h.SH। हम जानते हैं कि
दौड़ना कॉन्फ़िगर उत्पादन करता है config.श स्क्रिप्ट (वास्तव में यह कैसे किया जाता है यह कड़ाई से नहीं बताया गया है
यहां प्रासंगिक है, लेकिन जिज्ञासुओं के लिए, यह यहां एक और दस्तावेज़ प्रतिस्थापन है
कॉन्फ़िगर अपने आप)। config_h.SH स्वयं द्वारा निर्मित है मेटाकॉन्फिग एक ही समय में
कॉन्फ़िगर है, बशर्ते आप अपने स्रोतों में कम से कम एक सी प्रतीक का उपयोग करें।

आइये कुछ यादृच्छिक पर एक नजर डालते हैं config_h.SH वास्तव में क्या होता है यह देखने के लिए फ़ाइल करें:

केस $CONFIG में
'')
यदि परीक्षण -f config.sh; फिर टॉप=.;
एलिफ़ टेस्ट -f ../config.sh; फिर टॉप=..;
एलिफ़ परीक्षण -f ../../config.sh; फिर टॉप=../ ..;
एलिफ़ परीक्षण -f ../../../config.sh; फिर टॉप=../../..;
एलिफ़ परीक्षण -f ../../../../config.sh; फिर टॉप=../../../..;
अन्य
इको "config.sh नहीं मिल सका"; बाहर निकलें 1
fi
. $TOP/config.sh
;;
esac
मामला "$ 0" में
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac
प्रतिध्वनि "config.h निकालना (चर प्रतिस्थापन के साथ)"
सेड < config.h -e 's!^#undef!/define!' -e 's!^#un-def!#undef!'
/*
* यह फ़ाइल config_h.SH स्क्रिप्ट को चलाकर बनाई गई थी, जो
* इसके मान config.sh से प्राप्त होते हैं, जो आम तौर पर निर्मित होता है
* कॉन्फ़िगर चल रहा है।
*
* आवश्यकता पड़ने पर बेझिझक इनमें से कुछ भी संशोधित कर सकते हैं। हालाँकि, ध्यान दें,
* वह config.h.SH फिर से चलने से आपके द्वारा किए गए सभी परिवर्तन मिट जाएंगे।
* अधिक स्थायी परिवर्तन के लिए config.sh को संपादित करें और config.h.SH को पुनः चलाएँ।
*/

/* कॉन्फ़िगरेशन समय: $cf_time
* द्वारा विन्यस्त: $cf_by
* लक्ष्य प्रणाली: $myuname
*/

#ifndef _config_h_
#डिफाइन_कॉन्फिग_एच_

/* बीकॉपी:
* यदि bcopy() रूटीन नहीं है तो यह प्रतीक memcpy में मैप किया जाता है
* स्ट्रिंग्स की प्रतिलिपि बनाने के लिए उपलब्ध।
*/
/* HAS_BCOPY:
* यदि bcopy() रूटीन उपलब्ध है तो यह प्रतीक परिभाषित किया गया है
* मेमोरी के ब्लॉक कॉपी करें। आपको इस चिन्ह का प्रयोग नीचे नहीं करना चाहिए
* सामान्य परिस्थितियाँ और इसके बजाय सीधे bcopy() का उपयोग करें, जो
* यदि bcopy उपलब्ध नहीं है तो memcpy() पर मैप किया जाएगा।
*/
#$d_bcopy HAS_BCOPY /**/
#ifndef में_बीसीओपीवाई है
#ifdef बीकॉपी
#अन-डिफ बीकॉपी
#endif
#bcopy(s,d,l) memcpy((d),(s),(l)) को परिभाषित करें /* memcpy पर मैप किया गया */
#endif

/* HAS_DUP2:
* यह प्रतीक, यदि परिभाषित किया गया है, तो इंगित करता है कि dup2 रूटीन है
* डुप्लिकेट फ़ाइल डिस्क्रिप्टर के लिए उपलब्ध।
*/
#$d_dup2 HAS_DUP2 /**/

/* I_STRING:
* यह प्रतीक, यदि परिभाषित किया गया है, तो सी प्रोग्राम को इंगित करता है कि इसे होना चाहिए
* शामिल करना (यूएसजी सिस्टम) के बजाय (बीएसडी सिस्टम)।
*/
#$i_string I_STRING /**/

#endif
!ग्रोक!यह!

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

अब हम अग्रणी टिप्पणी पर पहुँचते हैं, और फ़ाइल को कॉन्फ़िगरेशन समय के साथ टैग किया जाता है
लक्ष्य प्रणाली, आदि... (वे चर स्रोत से आ रहे हैं config.श फ़ाइल हो गई है
द्वारा गठित कॉन्फ़िगर). उस टिप्पणी शीर्षलेख के बाद सुरक्षा के लिए '#ifndef' सुरक्षा दी गई है
इस फ़ाइल में एकाधिक समावेशन के विरुद्ध। फिर फ़ाइल का हृदय आता है...

यह जानने में मदद करता है $d_* और $i_* चर या तो 'पर सेट हैंपरिभाषित''यूएनडीईएफ' द्वारा
कॉन्फ़िगर, यह इस पर निर्भर करता है कि कोई फ़ंक्शन या सम्मिलित फ़ाइल सिस्टम पर मौजूद है या नहीं
नहीं। इसका मतलब है:

#$d_bcopy HAS_BCOPY /**/

लाइन का विस्तार इनमें से किसी एक तक किया जाएगा:

#परिभाषित करें HAS_BCOPY /**/

यदि $d_bcopy वैरिएबल 'परिभाषित' पर सेट है या:

#अनिर्धारित HAS_BCOPY /**/

यदि $d_bcopy को 'undef' पर सेट किया गया था, क्योंकि यह सुविधा वहां नहीं थी। हालाँकि, ऐसा नहीं है
में क्या लिखा जाता है कॉन्फ़िग.एच फ़ाइल के कारण प्यास फ़िल्टर हम पहले ही देख चुके हैं,
जो दूसरे फॉर्म को इसमें बदल देगा:

/*#परिभाषित करें HAS_BCOPY /**/

बाद में संपादन के लिए यह एक उपयोगी रूप है कॉन्फ़िग.एच क्योंकि आपको केवल हटाने की आवश्यकता है
यदि आप ओवरराइड करना चाहते हैं तो अग्रणी '/*' कॉन्फ़िगरकी पसंद. इसी तरह, आप एक भी जोड़ सकते हैं
किसी विशेष प्रतीक की परिभाषा से बचने के लिए '#define' लाइन की शुरुआत में '/*'।
यही कारण है कि प्रत्येक प्रतीक परिभाषा को अग्रणी को बंद करने के लिए अनुगामी '/**/' द्वारा संरक्षित किया जाता है
टिप्पणी '/*' द्वारा खोली गई (टिप्पणियाँ C में नेस्टेड नहीं हैं)।

अब '#undef' को '/*#define' में बदलना अच्छा है, लेकिन अगर हम वास्तव में लिखना चाहते हैं
'#undef', हम अटके हुए हैं... जब तक हम इसे '#un-def' के रूप में नहीं लिखते और जाने नहीं देते प्यास इसे '#undef' पर ठीक करें
उत्पादन करते समय कॉन्फ़िग.एच, जो वास्तव में यहाँ किया गया है।

उसी प्रकार का तर्क उन दो पंक्तियों पर लागू होता है:

#$d_dup2 HAS_DUP2 /**/
#$i_string I_STRING /**/

और मान रहा हूँ config.श परिभाषित करता है:

d_dup2='परिभाषित करें'
i_string='अनडिफ़'

हम उत्पादित में मिलेंगे कॉन्फ़िग.एच:

#परिभाषित HAS_DUP2 /**/
/*#परिभाषित करें I_STRING /**/

बहते पानी की तरह साफ़? अच्छा!

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

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

यदि कोई MANIFEST.new फ़ाइल नहीं है, मेटाकॉन्फिग इसके बजाय मैनिफ़ेस्ट फ़ाइल का उपयोग करने का प्रयास करेंगे,
सुविधा के लिए। जहां भी हम MANIFEST.new का उल्लेख करते हैं, इसे MANIFEST के रूप में समझा जा सकता है
बशर्ते आपके पैकेज के मूल में कोई MANIFEST.new फ़ाइल न मिले।

यह मानते हुए कि आपकी MANIFEST.new फ़ाइल ठीक से सेट है और उन सभी स्रोत फ़ाइलों को सूचीबद्ध करती है जिन्हें आप चाहते हैं
कॉन्फ़िगर करें, और जिसे आपने चलाया है पैकिंट बनाने के लिए अपनी रूट सोर्स निर्देशिका में
.पैकेज फ़ाइल, आप चला सकते हैं मेटाकॉन्फिग और आपको निम्नलिखित मिलेगा:

$ मेटाकॉन्फिग
इकाइयों का पता लगाना...
312 इकाइयों से निर्भरता सूचियाँ निकाली जा रही हैं...
MANIFEST.new से फ़ाइल नाम (*.[chyl] और *.SH) निकाला जा रहा है...
एक वांटेड फ़ाइल का निर्माण...
प्रतीकों के लिए .[chyl] फ़ाइलों को स्कैन किया जा रहा है...
प्रतीकों के लिए .SH फ़ाइलें स्कैन की जा रही हैं...
इष्टतम निर्भरता ग्राफ की गणना...
निजी मेक फ़ाइल का निर्माण...
लोड करने योग्य इकाइयों का निर्धारण...
मेक फ़ाइल अपडेट हो रही है...
इकाइयों के लिए सही क्रम निर्धारित करना...
कॉन्फिगर बनाया जा रहा है...
दान.

पहला चरण सार्वजनिक निर्देशिका में सभी यूनिट फ़ाइलों (.U के साथ समाप्त होने वाली) की तलाश करता है
पहले, फिर अपने अकेले में। यदि आप किसी सार्वजनिक फ़ाइल को अपनी निजी यू निर्देशिका में कॉपी करते हैं
(यानी आपके पैकेज के शीर्ष स्तर पर यू नाम की एक निर्देशिका), यह जनता को ओवरराइड कर देगी
संस्करण। एक बार जब इसके पास सभी उपलब्ध इकाइयों की सूची हो जाती है, तो यह उन्हें पार्स करता है और सभी को निकालता है
?MAKE: निर्भरताओं और ज्ञात शेल प्रतीकों के बारे में जानने के लिए पंक्तियाँ। यह भी
C प्रतीकों के बारे में जानने के लिए ?H: रेखाओं पर ध्यान केंद्रित करता है और कौन से शेल प्रतीकों की आवश्यकता होती है
उस सी प्रतीक के लिए उचित मूल्य प्राप्त करने के लिए गणना की गई (इसलिए हमारे पास निर्भरता का एक और स्तर है
यहाँ)।

इसके बाद, MANIFEST.new फ़ाइलों से उचित फ़ाइल नाम निकाले जाते हैं और a जरूरत है फ़ाइल है
निर्मित: वह फ़ाइल उस पैकेज के लिए आवश्यक सभी सी प्रतीकों और शेल प्रतीकों को सूचीबद्ध करती है। हम
पहले सी प्रतीकों के लिए सी-प्रकार की फाइलों को स्कैन करें, फिर उनकी निर्भरता का प्रचार करें
संबद्ध शैल प्रतीक (?H: रेखाओं से एकत्रित)। आगे .SH फ़ाइलें स्कैन की जाती हैं और अंत में
सभी शैल प्रतीक ज्ञात हैं।

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

कन्वेंशनों
पूरी प्रक्रिया को सुदृढ़ बनाने के लिए उचित परंपराओं का पालन किया जाना आवश्यक है। एक मामला है
इकाइयों के लिए परिपाटी और एक चर नामकरण परिपाटी।

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

गैर-विशेष इकाइयाँ फिर दो अलग-अलग समूहों में विभाजित हो जाती हैं: चर को परिभाषित करने वाली इकाइयाँ
सी प्रतीक और अपने स्वयं के शेल चर को परिभाषित करने वाली इकाइयों से संबंधित। पहला समूह
फ़ाइलों को शामिल करने से संबंधित वेरिएबल्स में विभाजित किया गया है (उनका नाम इससे शुरू होता है)। i_) और
अन्य परिभाषाओं से संबंधित चर (से शुरू होने वाला नाम)। d_). दूसरे समूह के पास है
उदाहरण के लिए, नाम स्वयं के लिए खड़े होते हैं सी.सी.यू परिभाषित करता है $सीसी शेल वैरिएबल जिसका मान है
C कंपाइलर का उपयोग किया जाना है।

विशेष इकाइयाँ कभी-कभी अपने लिए कुछ पूर्व-परिभाषित चर आरक्षित रखती हैं और "परिणाम" लौटाती हैं
अन्य प्रसिद्ध चर में। उदाहरण के लिए, myread स्क्रिप्ट Myread.U द्वारा निर्मित है
शीघ्र आने की अपेक्षा करता है $आरपी, डिफ़ॉल्ट उत्तर $dflt और उपयोगकर्ता के उत्तर को इसमें रखता है $ans.
यह इस मैनुअल पेज में प्रलेखित नहीं है: आपको जाकर यूनिट को ही देखना होगा
समझें कि कौन से चर का उपयोग किया जाता है और इकाई का उपयोग कैसे किया जाना है।

का प्रयोग RSI शब्दकोष
शब्दावली फ़ाइल स्वचालित रूप से निर्मित होती है मेकग्लॉस स्क्रिप्ट, जो निकालती है
?S:, ?C: और ?MAKE: से जानकारी को पंक्तिबद्ध करें और उन्हें वर्णानुक्रम में पुन: स्वरूपित करें
क्रमबद्ध शब्दावली. आप कौन से प्रतीक हैं, इसके बारे में जानने के लिए शब्दावली पढ़ना महत्वपूर्ण है
उपयोग करने की अनुमति दी गई। हालाँकि, शब्दावली आपको यह नहीं बताएगी कि उनका उपयोग कैसे करें। आमतौर पर, यही है
आप पर निर्भर करता है।

एक दिन, आप संभवतः अपनी स्वयं की इकाइयाँ लिखेंगे और आपको इसके बारे में पर्याप्त जानकारी होगी मेटाकॉन्फिग
ऐसा जल्दी और कुशलता से करने के लिए। हालाँकि, अपने काम का उचित दस्तावेजीकरण करना कभी न भूलें
?S: और ?C: लाइनें, या अन्य लोग इसका पुन: उपयोग नहीं कर पाएंगे। के बारे में याद रखें
वह समय जब आपके पास आरंभ करने के लिए केवल शब्दावली और यह मैनुअल पृष्ठ था।

निष्कर्ष
अब आप जानते हैं कि मेटाकॉन्फिग मूल बातें, आपको पढ़ना चाहिए वर्णन अनुभाग, फिर
पर छोड़ें संदर्भ अनुमति जैसे सभी रक्तरंजित विवरणों के बारे में जानने के लिए अनुभाग
यूनिट नियंत्रण लाइनों ('?' से शुरू होने वाली लाइनें) या विशिष्ट MAKE कमांड के लिए सिंटैक्स
आपको उपयोग करने की अनुमति है.

संदर्भ

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

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

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

निम्नलिखित प्रत्येक नियंत्रण रेखा का औपचारिक विवरण है। बिना कहे
अन्यथा, इस प्रस्तुति का क्रम इकाई के भीतर उपयोग किया जाने वाला क्रम है।

?आरसीएस: मुक्त टेक्स्ट
इकाई के शीर्ष पर, आरसीएस टिप्पणियों के लिए उपयोग किया जाना है।

?एक्स: कोई टेक्स्ट
सामान्य प्रयोजन टिप्पणियाँ. इकाई में कहीं भी प्रकट हो सकता है लेकिन उसे उचित ही छोड़ा जाना चाहिए।
आरसीएस टिप्पणियों के लिए, कृपया ?आरसीएस: टिप्पणी फॉर्म का उपयोग करें।

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

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

?Y:ख़ाका
इस इकाई के लिए एक लेआउट निर्देश घोषित करें। वह निर्देश स्ट्रिंग में से एक हो सकता है
ऊपर का, चूक or तल (मामला कोई मायने नहीं रखता, अनुशंसित शैली उन्हें स्पष्ट करने की है
अपरकेस्ड)। यदि छोड़ दिया जाए, चूक माना जाता है।

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

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

?एस:प्रतीक_नाम [(अप्रचलित प्रतीक सूची)]:
एक शैल प्रतीक का परिचय देता है. यह पहली पंक्ति प्रतीक को नाम देती है, इसके बाद वैकल्पिक रूप से a आता है
कोष्ठक और अप्रचलित समकक्ष देने के बीच संलग्न सूची। वे अप्रचलित
प्रतीकों को नए सिरे से मैप किया जाएगा प्रतीक_नाम अगर -o का विकल्प दिया गया है
मेटाकॉन्फिग.

?एस:कोई पाठ, एसटी शब्दकोष
मूल रूप से शेल प्रतीक का वर्णन करने वाली एक टिप्पणी, जिसे निकाला जाएगा मेकग्लॉस
शब्दावली फ़ाइल में.

?एस:। शेल प्रतीक टिप्पणी बंद कर देता है.

?सी:प्रतीक_नाम [~ उर्फ] [(अप्रचलित प्रतीक सूची)]:
एक नया C प्रतीक प्रस्तुत करता है। उर्फ नाम वह नाम है जिसके अंतर्गत C चिन्ह होगा
नियंत्रित किया जाए, यानी यदि उर्फ सिंबल चाहिए तो वह सी सिंबल लिखा जाएगा
में config_h.SH फ़ाइल। आमतौर पर, उपनाम केवल '%<' होता है (इकाई के नाम को दर्शाता है)
और एक ?W: लाइन भी है जो C प्रतीक को मैप करती है उर्फ. साथ ही प्रासंगिक भाग भी
?H: लाइनें स्पष्ट रूप से '?%<' स्थिति द्वारा संरक्षित हैं। प्रतीक देखें
अधिक जानकारी के लिए उपनाम पैराग्राफ। पंक्ति का शेष भाग वैकल्पिक है
अप्रचलित प्रतीक सूची, जो नए के लिए पुराने समकक्षों को सूचीबद्ध करता है प्रतीक_नाम.

?सी:कोई पाठ, एसटी शब्दकोष और config_h.SH
मूल रूप से सी प्रतीक का वर्णन करने वाली एक टिप्पणी, जिसे इसके द्वारा निकाला जाएगा मेकग्लॉस
शब्दावली फ़ाइल में और द्वारा मेटाकॉन्फिग में config_h.SH यदि प्रतीक है तो फ़ाइल करें
वांछित (या यदि इसका उपनाम वांछित है जब प्रतीक उपनाम का उपयोग किया जाता है)।

?सी:। C प्रतीक टिप्पणी बंद कर देता है.

?एच:?प्रतीक:config_h.SH सामग्री
यह इसमें सामान्य समावेशन अनुरोध है config_h.SH. लाइन तभी लिखी जाती है जब
रखवाली प्रतीक वास्तव में वांछित है. C प्रतीक होने पर इस सामान्य रूप की आवश्यकता होती है
अलियासिंग का प्रयोग किया गया। अन्यथा, यदि आप अन्य "मानक" प्रपत्रों में से किसी एक का उपयोग करते हैं, तो
रखवाली स्वचालित रूप से की जाती है मेटाकॉन्फिग ही.

?एच:#$d_var वर "$वर"
सशर्त रूप से परिभाषित करता है वर C प्रतीक में $वर 'पर कब सेट किया गया हैपरिभाषित'. तात्पर्य ए
'?वर:' रखवाली की स्थिति, और मेटाकॉन्फिग स्वचालित रूप से लिंक हो जाता है वर इसके दो खोल के लिए
परिवर्तनीय निर्भरताएँ (अर्थात् दोनों $d_var और $वर के रूप में चिह्नित किया जाएगा जरूरत है if वर is
सी स्रोतों में प्रयुक्त)।

?H:#परिभाषित वर [वैकल्पिक टेक्स्ट]
हमेशा परिभाषित करता है वर कुछ मान के लिए C प्रतीक. 'का तात्पर्य है?वर:' रखवाली की स्थिति.
यूनिट पर ही एक स्वचालित शेल निर्भरता बनाई जाती है।

?H:#परिभाषित वीएआर(एक्स,वाई,जेड) $वर
हमेशा मैक्रो को परिभाषित करता है वर का मान होना $वर चर। यह तक है
सुनिश्चित करने के लिए इकाई $वर एक समझदार मूल्य रखता है. सी के बीच एक स्वचालित निर्भरता
मैक्रो वर और शेल वैरिएबल स्थापित है, और पूरी लाइन एक द्वारा संरक्षित है
अंतर्निहित '?वर:'.

?एच:#$d_var वर
सशर्त रूप से परिभाषित करता है वर if $d_var इसके लिए सेट है 'परिभाषित'. 'का तात्पर्य है?वर:' रखवाली करना
स्थिति। की ओर एक स्वचालित शेल निर्भरता उत्पन्न होती है $d_war.

?H:#परिभाषित वर "$वर"
को एक कॉन्फ़िगर मान निर्दिष्ट करता है वर सी प्रतीक. 'का तात्पर्य है?वर:' संरक्षक स्थिति.
लिंक करने के लिए एक स्वचालित शेल निर्भरता उत्पन्न होती है वर और $वर.

?एच:। को बंद कर देता है config_h.SH समावेशन अनुरोध.

?एम:C प्रतीक: C निर्भरता
सी प्रतीक से संबंधित जादुई परिभाषा का परिचय देता है confmagic.h, और परिभाषित करता है
शेष ?M: परिभाषाओं के लिए सुरक्षा प्रतीक। यह पंक्ति मौन भाव से संकेत करती है
'?डब्ल्यू:%<:C प्रतीक', यानी यदि सी प्रतीक दिखाई देता है तो यूनिट को कॉन्फिगर में लोड किया जाएगा
सी स्रोतों के भीतर, जादू का उपयोग किया जाता है या नहीं। C निर्भरताएँ सक्रिय हैं
जब जादू का उपयोग उनकी परिभाषा को लागू करने के लिए किया जाता है config_h.SH। हालांकि, यदि
जादू है नहीं उपयोग किया गया है लेकिन C प्रतीक आवश्यक C के बिना स्रोत में दिखाई देता है
निर्भरताएँ, आपको हर बार वांटेड फ़ाइल बनने पर चेतावनी दी जाएगी, क्योंकि ऐसा हो सकता है
एक पोर्टेबिलिटी समस्या (और इसलिए भी क्योंकि यूनिट को बिना शर्त लोड किया गया है
जब भी C प्रतीक का उपयोग किया जाता है, तो अन्य ?C: रेखाओं की परवाह किए बिना कॉन्फ़िगर करें
इकाई)।

?एम:सीपीपी डीएफएस
जब भी संबंधित हो, confmagic.h में पेश की जाने वाली मैजिक सीपीपी मैपिंग को परिभाषित करता है
प्रतीक का प्रयोग किया जाता है. वहाँ एक निहितार्थ है '?प्रतीक'कहां रखवाली कर रहे हैं प्रतीक प्रतीक नाम है
अग्रणी ?M: पंक्ति द्वारा परिभाषित।

?एम:। को बंद कर देता है confmagic.h शामिल करने का अनुरोध.

?डब्ल्यू:खोल प्रतीक सूची:C प्रतीक सूची
शेल प्रतीकों की नियति को C प्रतीकों के साथ जोड़ता है: यदि C में से कोई है
सूचीबद्ध प्रतीक वांछित है, तो सभी शैल प्रतीकों को वांछित के रूप में चिह्नित किया गया है। के लिए उपयोगी
कुछ सी की उपस्थिति होने पर एक इकाई (शेल प्रतीक सूची '%<' पर सेट) को बलपूर्वक शामिल करना
प्रतीक का पता चला है. साइड से लाभ पाने के लिए शेल प्रतीक सूची को खाली छोड़ा जा सकता है
बिल्ट-इन प्री-प्रोसेसर के भीतर सी प्रतीक स्थान का प्रभाव (प्रतीक जा रहा है)। परिभाषित
उस प्री-प्रोसेसर के लिए यदि स्रोत में स्थित है)। एक स्थान के साथ पैटर्न देखने के लिए
उनमें, आपको सी प्रतीकों को सरल उद्धरण चिह्नों के भीतर उद्धृत करना होगा, जैसा कि 'संरचना' में है
समय क्षेत्र'।

?वी:केवल पढ़ने के लिए प्रतीकों:पढ़ना लिखना प्रतीकों
यह एक है मेटलिंट संकेत और इसका उपयोग केवल कुछ शेल निर्यात करने वाली विशेष इकाइयों में किया जाना चाहिए
चर। मध्य ':' से पहले के वेरिएबल केवल-पढ़ने के लिए निर्यात किए जाते हैं (उन्हें बदलते हुए)।
एक चेतावनी जारी करेगा), जबकि अन्य प्रतीकों को स्वतंत्र रूप से पढ़ा और बदला जा सकता है।

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

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

?डी:प्रतीक='मूल्य'
सशर्त निर्भरता के रूप में उपयोग किए जाने वाले प्रतीकों के लिए आरंभीकरण मूल्य। यदि नहीं ?D: लाइन है
पाया जाता है, तो इसके स्थान पर शून्य मान का उपयोग किया जाता है। मेटलिंट प्रोग्राम आपको चेतावनी देगा यदि a
प्रतीक का उपयोग सशर्त निर्भरता के रूप में कम से कम एक बार किया जाता है और इसमें कोई उचित नहीं होता है
?D: आरंभीकरण. उन पंक्तियों को शून्य के लिए भी जोड़ना एक अच्छा अभ्यास है
आरंभीकरण क्योंकि यह किसी प्रतीक की संभावित वैकल्पिक प्रकृति पर जोर देता है।

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

?लिंट:मेटलिंट संकेत
देखना मेटलिंट विशिष्ट संकेतों की व्याख्या के लिए मैनुअल पेज जो हो सकता है
उपयोग किया गया।

?इस में:आरंभीकरण कोड
इस पंक्ति द्वारा निर्दिष्ट आरंभीकरण कोड को शीर्ष पर लोड किया जाएगा
कॉन्फ़िगर स्क्रिप्ट प्रदान की गई इकाई की आवश्यकता है।

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

D_const.U इकाई यह निर्धारित करने का प्रयास करती है कि आपके C कंपाइलर को इसके बारे में पता है या नहीं const
कीवर्ड. यदि ऐसा नहीं होता है तो हम उस कीवर्ड को एक शून्य स्ट्रिंग में रीमैप करना चाहते हैं, ताकि ऐसा हो सके
प्रोग्राम संकलन. इसके अलावा, हम परीक्षण को स्वचालित रूप से ट्रिगर करना चाहते हैं जब const शब्द
प्रयोग किया जाता है।

यहां d_const.U इकाई के प्रासंगिक भाग दिए गए हैं:

?MAKE:d_const: cat cc ccflags Setvar
?बनाएं: - $@ % जोड़ें चुनें
?S:d_const:
?S: यह चर सशर्त रूप से HASCONST प्रतीक को परिभाषित करता है, जो
?एस: सी प्रोग्राम को इंगित करता है कि यह सी कंपाइलर इसके बारे में जानता है
?एस: स्थिरांक प्रकार.
?एस:।
?सी:हैस्कॉन्स्ट ~ %<:
?सी: यह प्रतीक, यदि परिभाषित किया गया है, तो इंगित करता है कि यह सी कंपाइलर इसके बारे में जानता है
?सी: स्थिरांक प्रकार। वास्तव में उस प्रतीक का परीक्षण करने की कोई आवश्यकता नहीं है
?सी: आपके कार्यक्रमों के भीतर। केवल "कॉन्स्ट" कीवर्ड का उपयोग होगा
?सी: आवश्यक परीक्षण ट्रिगर करें।
?सी:।
?H:?%<:#$d_const HASCONST /**/
?H:?%<:#ifndef HASCONST
?H:?%<:#define const
?H:?%<:#endif
?एच:।
?W:%<:const
?LINT:d_const सेट करें
?LINT:ज्ञात स्थिरांक
: const कीवर्ड की जाँच करें
प्रतिध्वनि " "
इको 'यह देखने के लिए जांच की जा रही है कि क्या आपका सी कंपाइलर "कॉन्स्ट" के बारे में जानता है...' >&4
/बिन/बिल्ली >const.c <<'EOCP'
मुख्य()
{
स्थिरांक चार *फू;
}
ईओसीपी
यदि $cc -c $ccflags const.c >/dev/null 2>&1 ; तब
वैल='$परिभाषित करें'
प्रतिध्वनि "हाँ, ऐसा होता है।"
अन्य
val='$undef'
प्रतिध्वनि "नहीं, ऐसा नहीं है।"
fi
d_const सेट करें
eval $setvar

सबसे पहले हम एक ?W: लाइन के उपयोग पर ध्यान देते हैं, जो मूल रूप से कहती है: "यह इकाई तब चाहिए जब
const C फ़ाइल में कीवर्ड का उपयोग किया जाता है। सशर्त रूप से रीमैप करने के लिए const एक शून्य के लिए
स्ट्रिंग इन कॉन्फ़िग.एच, मैंने सशर्त परिभाषित करना चुना HASCONST के माध्यम से $d_const.

हालाँकि, यह एक समस्या खड़ी करता है, क्योंकि HASCONST में प्रतीक का प्रयोग नहीं किया जाएगा
स्रोत, केवल const टोकन है. और ?H: रेखा परिभाषित करती है HASCONST निःसंदेह है
'?HASCONST' द्वारा संरक्षित। इसलिए, हमें बताने के लिए स्पष्ट '?%<' बाधा जोड़नी होगी
मेटाकॉन्फिग कि उन पंक्तियों को शामिल किया जाए config_h.SH जब भी '%<' प्रतीक
वांछित हो जाता है (%< यहां इकाई के नाम को संदर्भित करता है d_const).

यह लगभग सही है, क्योंकि ?W: लाइन चाहेगी d_const जब कभी const तब प्रयोग किया जाता है
?H: लाइनें इसमें शामिल हो जाएंगी config_h.SH फ़ाइल। हालाँकि, प्रमुख टिप्पणी (?C:
पंक्तियाँ) से जुड़ी हुई हैं HASCONST द्वारा स्वयं भी संरक्षित है HASCONST, यानी इसमें एक निहितार्थ है
'?HASCONST' बाधा. इसलिए इसकी आवश्यकता है अलियासिंग la HASCONST '%<' का प्रतीक।

इकाई का शेष भाग (शेल भाग) वास्तव में सीधा है। यह बस
का उपयोग करके एक नमूना C प्रोग्राम संकलित करने का प्रयास करता है const कीवर्ड. अगर यह हो सकता है, तो यह होगा
परिभाषित $d_const के माध्यम से $सेटवार फ़ंक्शन (द्वारा परिभाषित) सेट्वर.यू इकाई)। पैराग्राफ देखें
अधिक जानकारी के लिए विशेष इकाइयों के बारे में।

बनाना कमानों
?MAKE: कमांड लाइन पर, आप जैसा है वैसा निष्पादित करने के लिए एक शेल कमांड लिख सकते हैं
विशेष -चुनना आदेश जो फंस गया है मेटाकॉन्फिग और यह देखने के लिए विश्लेषण किया गया कि क्या होना चाहिए
हो गया। अग्रणी '-' केवल रोकने के लिए है बनाना आदेश वापस आने पर विफल होने से
एक गैर-शून्य स्थिति - इसकी वास्तव में आवश्यकता नहीं है क्योंकि हम 'का उपयोग करते हैंबनाना -n' को हल करने के लिए
निर्भरताएँ, लेकिन मैं आपको सलाह देता हूँ कि यदि भविष्य के संस्करणों में यह अनिवार्य हो जाए तो इसे अपने पास रखें।
का वाक्यविन्यास चुनना आदेश है:

-चुनना सीएमडी $@ लक्ष्य फाइल

जहां $@ मेकफ़ाइल्स के भीतर वर्तमान लक्ष्य (नाम) के लिए मानक मैक्रो है
निर्मित की जा रही इकाई का, अंतिम .U एक्सटेंशन हटा दिया गया है)। सीएमडी भाग है
वास्तविक मेटाकॉन्फिग चलाने के लिए आदेश, और लक्ष्य फाइल एक और पैरामीटर है, जिसका
व्याख्या निर्भर करती है सीएमडी अपने आप। इसका अंतिम .U एक्सटेंशन भी हटा दिया गया है
आम तौर पर एक यूनिट फ़ाइल को संदर्भित करता है, जब तक कि यह './' से शुरू न हो, ऐसी स्थिति में यह एक को संदर्भित करता है
का मेटाकॉन्फिग 'में फ़ाइलों को नियंत्रित करें.एमटी निर्देशिका.

उपलब्ध आदेश हैं:

जोड़ें जोड़ता है लक्ष्य फाइल सेवा मेरे कॉन्फ़िगर.

जोड़ें.Config_sh
के उस हिस्से को भरता है कॉन्फ़िगर उत्पादन कर रहा है config.श फ़ाइल। केवल प्रयोग किया जाता है
चर जोड़े जाते हैं, सशर्त (सशर्त निर्भरता से) जोड़े जाते हैं
छोड़ दिया

add.Null एक खाली स्ट्रिंग में उपयोग किए गए सभी शेल वेरिएबल्स को प्रारंभ करने वाला अनुभाग जोड़ता है।

c_h_weed का उत्पादन करता है config_h.SH फ़ाइल। केवल आवश्यक पंक्तियाँ ही मुद्रित की जाती हैं।

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

बंद करें.Config_sh
यहां दस्तावेज़ को समाप्त करने के लिए अंतिम 'ईओटी' प्रतीक को एक पंक्ति में स्वयं जोड़ता है
का निर्माण करें config.श फ़ाइल.

प्रीपेन्ड लक्ष्य की सामग्री को प्रीपेन्ड करता है लक्ष्य फाइल यदि वह फ़ाइल खाली नहीं है.

खरपतवार इकाई को जोड़ता है कॉन्फ़िगर की तरह जोड़ना आदेश दें, लेकिन कुछ अतिरिक्त परीक्षण करें
' को हटाने के लिए?प्रतीक' और '%प्रतीक' से पंक्तियाँ लक्ष्य फाइल अगर प्रतीक
वांछित या सशर्त वांछित नहीं है। '%' फॉर्म का उपयोग केवल आंतरिक रूप से किया जाता है
मेटाकॉन्फिग 'में अपनी स्वयं की .U फ़ाइलें बनाते समय.एमटी' निर्देशिका।

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

अलग नोट के रूप में, मेटाकॉन्फिग एक उत्पन्न करता है -कंड सशर्त से निपटने के लिए आंतरिक रूप से आदेश दें
निर्भरताएँ आपको इसे स्वयं उपयोग नहीं करना चाहिए, लेकिन स्कैन करने पर आप इसे देखेंगे
उत्पन्न makefile में .एमटी निर्देशिका.

Hardwired मैक्रोज़
निम्नलिखित मैक्रोज़ द्वारा पहचाने जाते हैं पोंछ में शामिल करने से पहले कमांड और प्रतिस्थापित किया गया
कॉन्फ़िगर:

पैकेज का आधार संशोधन क्रमांक, से प्राप्त हुआ .पैकेज.

वर्तमान तिथि.


इस पैकेज के अनुरक्षक का ई-मेल पता, आपसे प्राप्त हुआ
.पैकेज.


पैकेज का नाम, जैसा कि आपसे लिया गया है .पैकेज फ़ाइल.


का पैच स्तर मेटाकॉन्फिग कार्यक्रम (के पक्ष में बहिष्कृत) ).


का एसवीएन संशोधन स्तर मेटाकॉन्फिग कार्यक्रम.

का संस्करण क्रमांक मेटाकॉन्फिग कार्यक्रम.

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

हाल का मेटाकॉन्फिग संस्करण फ़ॉर्म के अधिक सामान्य सिंटैक्स को समझते हैं:

<$चर>

जिसे कॉन्फिगर-जेनरेशन समय पर के मान से बदल दिया जाता है परिवर्तनशील आपसे लिया गया
.पैकेज फ़ाइल। अंततः, पुराना हार्डवेयर्ड मैक्रो प्रारूप गायब हो जाएगा, और <$baserev>
बदल देगें सभी आपूर्ति इकाइयों में.

विशिष्ट इकाइयों
निम्नलिखित विशेष इकाइयों का उपयोग कोड को गुणनखंडित करने और उच्च स्तर प्रदान करने के लिए किया जाता है
कार्यक्षमताएँ वे या तो एक शेल स्क्रिप्ट तैयार करते हैं जिसे सोर्स किया जा सकता है या एक शेल
परिवर्तनशील जो हो सकता है विकसित करना'ईडी। पैरामीटर पासिंग या तो अच्छी तरह से ज्ञात चर के माध्यम से किया जाता है
नामित या अज्ञात जैसे $1, $2, आदि... (जिसे शेल के माध्यम से आसानी से सेट किया जा सकता है सेट
ऑपरेटर)। कब कॉन्फ़िगर निष्पादित करता है, यह बनाता है और एक में चला जाता है UU निर्देशिका, तो हर
उत्पादित स्क्रिप्ट वहीं निहित है और आपके पैकेज की फ़ाइलों में हस्तक्षेप नहीं करती है।

यहां विशेष इकाइयां हैं जिनके बारे में आपको पता होना चाहिए, और उनका उपयोग करने का तरीका भी बताया गया है।

Cppsym.U
यह इकाई एक शेल स्क्रिप्ट तैयार करती है जिसे कहा जाता है सी.पी.पी.एस.आई.एम, जिसका उपयोग निर्धारित करने के लिए किया जा सकता है
क्या किसी सूची में कोई प्रतीक आपके पास मौजूद सी प्रीप्रोसेसर या सी कंपाइलर द्वारा परिभाषित किया गया है
निर्दिष्ट. यह किसी भी प्रतीक की स्थिति निर्धारित कर सकता है, भले ही उसमें मौजूद प्रतीक हों
(विशेषता सूची) अधिक आसानी से निर्धारित होते हैं।

Csym.U
यह $csym शेल वैरिएबल सेट करता है, जिसका उपयोग आंतरिक रूप से किया जाता है कॉन्फ़िगर यह जांचने के लिए कि क्या ए
दिया गया C प्रतीक परिभाषित है या नहीं। एक सामान्य उपयोग है:

प्रतीक परिणाम सेट करें [-fva] [पिछला]
eval $csym

वह सेट हो जाएगा परिणाम यदि फ़ंक्शन [-f], वेरिएबल [-v] या है, तो वेरिएबल को 'सही' कर दें
सरणी [-ए] परिभाषित है, अन्यथा 'गलत'। यदि पिछला मान दिया गया है और -r
को स्विच प्रदान किया गया कॉन्फ़िगर (देखें कॉन्फ़िगर ऑप्शंस पैराग्राफ), फिर वह
मूल्य का बिना किसी प्रश्न के पुन: उपयोग किया जाता है।

यह गणना किस प्रकार की जाती है यह उपयोगकर्ता द्वारा प्रश्न के उत्तर पर निर्भर करता है
कॉन्फ़िगर इस बारे में पूछेगा कि क्या उसे प्रदर्शन करना चाहिए nm निकासी या नहीं. यदि
निष्कर्षण किया गया था, इकाई केवल प्रतीक सूची को देखती है, अन्यथा
यह एक संकलन-लिंक परीक्षण करता है, जब तक कि -r पहले से गणना किए गए को पुन: उपयोग करने के लिए दिया गया था
मूल्य, स्वाभाविक रूप से...

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

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

exp_name=`./fileexp $name`

विस्तारित फ़ाइल नाम निर्दिष्ट करने के लिए exp_name.

Findhdr.U
यह इकाई एक का उत्पादन करती है ढूंढेंhdr स्क्रिप्ट जिसका उपयोग हेडर फ़ाइलों का पता लगाने के लिए किया जाता है
$usrinc या सीपीपी क्षमताओं का उपयोग करके अन्य अजनबी स्थान। स्क्रिप्ट एक दी गई है
फ़ाइल आधार नाम जैसे 'stdio.h' या 'sys/file.h' शामिल करें और यह पूरा पथ लौटाता है
इसमें शामिल फ़ाइल और यदि पाया जाए तो एक शून्य स्थिति, या एक खाली स्ट्रिंग और एक गैर-शून्य स्थिति
यदि फ़ाइल का पता नहीं लगाया जा सका.

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

इस इकाई का उपयोग करने के लिए, $आरपी और $dflt प्रश्न और डिफ़ॉल्ट उत्तर को अवश्य रखना चाहिए, जो
को यथावत पारित कर दिया जाएगा myread स्क्रिप्ट (आगामी देखें)। मायरीड.यू). $एफएन
वेरिएबल ऑपरेशन को नियंत्रित करता है और परिणाम वापस कर दिया जाता है $ans.

किसी फ़ाइल या निर्देशिका का पता लगाने के लिए, 'f' या 'd' डालें च~/. यदि '~' प्रकट होता है, तो ~नाम
प्रतिस्थापन की अनुमति है. यदि '/' प्रकट होता है, तो केवल पूर्ण पथनाम ही स्वीकार किए जाते हैं
~नाम प्रतिस्थापन हमेशा लौटने से पहले विस्तारित किए जाते हैं। यदि '+' निर्दिष्ट है,
अस्तित्व की जांच छोड़ दी गई है। यदि 'एन' भीतर आता है $एफएन, तो उपयोगकर्ता को इसकी अनुमति है
उत्तर 'कोई नहीं'।

आम तौर पर, जब तक आप पोर्टेबिलिटी के लिए नहीं पूछते, ~नाम प्रतिस्थापन तब होता है जब अनुरोध किया जाता है।
हालाँकि, कुछ बार आप पोर्टेबिलिटी को बायपास करना चाहते हैं और इसे बाध्य करना चाहते हैं
प्रतिस्थापन. ऐसा करने के लिए आप 'ई' अक्षर (विस्तार) का उपयोग कर सकते हैं।

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

dflt='~समाचार/lib'
: जब 'एल' का उपयोग किया जाता है तो 'डी' या 'एफ' निर्दिष्ट करने की आवश्यकता नहीं होती है
fn='l~:सक्रिय'
आरपी='सक्रिय फ़ाइल कहाँ है?'
. ।/दस्तावेज लें
सक्रिय='$ans'

इसके अतिरिक्त, बताने के लिए 'पी' (पथ) अक्षर का उपयोग 'एल' के साथ संयोजन में किया जा सकता है
दस्तावेज लें कि बिना '/' वाले उत्तर को यह मानते हुए स्वीकार किया जाना चाहिए कि ऐसा होगा
जिस समय इस मान की आवश्यकता होगी, उस समय यह सभी के PATH में होगा।

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

dflt='/bin/install'
fn='/fe~(इंस्टॉल,./इंस्टॉल)'
आरपी='किस इंस्टॉल प्रोग्राम का उपयोग करें?'
. ।/दस्तावेज लें
इंस्टॉल='$ans'

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

यदि प्रश्न का उत्तर 'कोई नहीं' है, तो अस्तित्व जांच छोड़ दी जाती है और
खाली स्ट्रिंग लौटा दी गई है. ध्यान दें कि तब से दस्तावेज लें कॉल myread आंतरिक रूप से, सभी
के साथ उपलब्ध सुविधाएँ myread यहां आवेदन करें.

यदि पूर्णतः विस्तारित मान की आवश्यकता है (उदाहरण के लिए मेकफ़ाइल में), तो आप इसका उपयोग कर सकते हैं
la $ansexp वैरिएबल जो हमेशा द्वारा ठीक से सेट किया जाता है दस्तावेज लें विस्तारित के रूप में
के संस्करण $ans. निःसंदेह, यह ~नाम का विस्तार नहीं करेगा यदि आपने इसकी अनुमति नहीं दी है
में प्रथम स्थान $एफएन चर।

Inhdr.U
यह इकाई उत्पादन करती है $inhdr शेल वैरिएबल, आंतरिक रूप से उपयोग किया जाता है कॉन्फ़िगर जाँच करने के लिए
हेडर का एक सेट मौजूद है या नहीं। एक सामान्य उपयोग है:

हेडर i_header सेट करें [header2 i_header2 ...]
eval $inhdr

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

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

फ़ंक्शन d_func सेट करें
eval $inlibc

वह एक संदेश प्रिंट करेगा, जिसमें बताया जाएगा कि फ़ंक्शन मिला या नहीं और सेट हो गया
$d_func इसलिए। आंतरिक रूप से, इसका उपयोग किया गया $csym दिनचर्या।

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

dflt=`./loc Sendmail.cf X / Usr / lib /var/lib/sendmail / दायित्व`

सेट होगा $dflt सेवा मेरे X यदि नही सेंडमेल.सीएफ फ़ाइल सूचीबद्ध निर्देशिकाओं के अंतर्गत पाई गई,
या ऐसा कुछ /usr/lib/sendmail.cf कुछ सिस्टम पर. यह सभी देखें गेटफाइल.यू.

मेलऑथर.यू
इस इकाई को बनाने के लिए आपके अपने निजी End.U की ?MAKE: लाइन में शामिल करने की आवश्यकता है
इसे में कॉन्फ़िगर. यह उपयोगकर्ता को वैकल्पिक रूप से स्वयं को लेखक के रूप में पंजीकृत करने की पेशकश करता है
नए पैच आने पर सूचित किया जाना या जारी होने पर उन्हें स्वचालित रूप से प्राप्त करना।
आपको स्थापित करने की आवश्यकता है मेल एजेंट ऐसा करने के लिए (कम से कम संस्करण 3.0)।

मेललिस्ट.यू
इस इकाई को बनाने के लिए आपके अपने निजी End.U की ?MAKE: लाइन में शामिल करने की आवश्यकता है
इसे में कॉन्फ़िगर. यह उपयोगकर्ता को मेलिंग सूची की सदस्यता लेने या सदस्यता समाप्त करने की पेशकश करता है
जहां पैकेज से जुड़ी चर्चा हो रही है. तुम्हें दौड़ने की जरूरत है पैकिनिट
और अपने में उचित चर स्थापित करने के लिए मेलिंग सूची से संबंधित प्रश्नों का उत्तर दें
.पैकेज इससे पहले कि यह इकाई चालू हो जाए।

Myinit.U
इस इकाई को अपने प्राइवेट में कॉपी करें U कुछ में अपने स्वयं के डिफ़ॉल्ट मान जोड़ने के लिए निर्देशिका
आंतरिक चर. इस इकाई में लोड किया गया है कॉन्फ़िगर आख़िरकार डिफ़ॉल्ट
आरंभीकरण किया जा चुका है.

मायरीड.यू
यह इकाई उत्पादन करती है myread ऐसा करने के लिए शेल स्क्रिप्ट का स्रोत होना आवश्यक है
पढ़ना। यह शेल एस्केप, डिफ़ॉल्ट असाइनमेंट और पैरामीटर मूल्यांकन की अनुमति देता है
Instruct.U इकाई में प्रलेखित। यह की गतिशील सेटिंग की भी अनुमति देता है -d विकल्प,
जिसका उपयोग शेष स्क्रिप्ट निष्पादन के लिए किया जाएगा।

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

यहाँ एक विशिष्ट उपयोग है:

dflt='y'
आरपी='प्रश्न?'
. ./मायरीड
मूल्य='$ans'

अधिक जानकारी के लिए इकाई को ही देखें।

Oldconfig.U
यह इकाई आपकी निर्भरता का हिस्सा होनी चाहिए ?MAKE: लाइन जब आपकी कुछ इकाइयाँ प्रयास करती हैं
किसी पुराने प्रतीक मान का पुन: उपयोग करने के लिए। यह इकाई पुराने उत्तर प्राप्त करने के लिए उत्तरदायी है
से config.श या किसी दिए गए प्लेटफ़ॉर्म पर चलते समय उपयोगी संकेत प्रदान करना
पहली बार। देखें कॉन्फ़िगर संकेत संकेतों के बारे में अधिक जानकारी के लिए पैराग्राफ।

उपसर्ग.यू
इस इकाई का उद्देश्य संस्थापन उपसर्ग निर्देशिका में परिवर्तनों का पता लगाना है
पिछले उत्तरों से स्वचालित रूप से उपयुक्त डिफ़ॉल्ट की पुनः गणना करें। यह पर निर्भर करता है
का मूल्य $पुरानाउपसर्ग वेरिएबल जो पिछली उपसर्ग निर्देशिका रखता है जब यह
बदल गया है, और अन्यथा खाली है। उदाहरण के लिए, यदि उपसर्ग से बदला गया था / opt सेवा मेरे
/ Usr / स्थानीय, तो पिछली बाइनरी इंस्टॉलेशन निर्देशिका को बदल दिया जाएगा
/ऑप्ट/बिन सेवा मेरे / Usr / स्थानीय / बिन, या अपरिवर्तित रहेगा यदि ऐसा था, तो कहें, / bin.

आपको कॉल करने की आवश्यकता है सेट जारी करने से पहले विकसित करना on $उपसर्ग, जैसे:

डीएफएलटी संस्करण सेट करें [डीआईआर]
eval $prefixit

जो सेट हो जायेगा $dflt सेवा मेरे $वर or $उपसर्ग/dir इस पर निर्भर करता है कि उपसर्ग बना हुआ है या नहीं
वही या नहीं. अगर दीर स्ट्रिंग है कोई नहीं, में एक एकल स्थान मान $dflt इस प्रकार रखा गया है-
है, तब भी जब उपसर्ग बदलता है। अगर दीर छोड़ा गया है, तो $dflt रिक्त पर सेट है
यदि उपसर्ग बदल गया है, तो स्ट्रिंग $वर अन्यथा।

प्रीफ़िक्सअप.यू
इस इकाई का इरादा Prefixit.U के समान है, अर्थात यह इसे ठीक करने में मदद करता है
उपसर्ग परिवर्तनों को समायोजित करने के लिए डिफ़ॉल्ट स्ट्रिंग। हालाँकि, शेल वैरिएबल $उपसर्ग,
जब मूल्यांकन किया जाता है, तो केवल ~नाम विस्तार को पुनर्स्थापित किया जाएगा, उपसर्ग को ऐसे एस्केप का उपयोग करना चाहिए
तंत्र। इसे इस प्रकार उपयोग करें:

डीएफएलटी सेट करें
eval $prefixup

के माध्यम से संकेत देने से पहले दस्तावेज लें उदाहरण के लिए। यदि उपसर्ग ~नाम का उपयोग नहीं करता है
विस्तार, तो उपरोक्त पर नो-ऑप होगा y परिवर्तनशील, स्वाभाविक रूप से।

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

टाइपडिफ़ val_t डिफ़ॉल्ट सेट करें [शामिल हैं]
eval $typedef

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

यूनिक्स.यू
इस इकाई का उद्देश्य चर के माध्यम से कुछ सबसे सामान्य UNIX-isms को परिभाषित करना है
जिसे कमांड लाइन से या उचित संकेत फ़ाइलों के माध्यम से बदला जा सकता है। विशेष रूप से,
$_exe, $_ओ और $_a तैयार। सभी इकाइयों का संदर्भ लेना चाहिए $_ओ और नहीं .o सीधे.
'.' इन चरों का हिस्सा है.

सेट्वर.यू
यह इकाई वेरिएबल उत्पन्न करती है, जिसका उपयोग आंतरिक रूप से किया जाता है कॉन्फ़िगर सेट करने के लिए a
परिभाषितकिसी दिए गए प्रतीक के लिए /undef मान, अचानक परिवर्तन होने पर चेतावनी जारी करता है
पिछले मान से. उदाहरण के लिए:

वैल='$परिभाषित करें'
d_variable सेट करें
eval $setvar

यदि पिछला $d_variable मान गैर-शून्य था और $ वैल अलग है, एक "वाह"
चेतावनी जारी की जाती है.

वाह.यू
यह इकाई उत्पादन करती है रुको स्क्रिप्ट, जो एक चेतावनी उत्सर्जित करती है जब मूल्य चर में
जिसका नाम है $वर यह अपने पुराने पिछले मूल्य के समान नहीं है $था. ऊपर
वापसी, $td और $टीयू के लिए उचित मान रखें परिभाषित or यूएनडीईएफ परिवर्तनशील. देखना
में उदाहरण इनलिबसी.यू.

अंतर्निहित पूर्व प्रोसेसर
प्रत्येक इकाई को शामिल किया जाना है कॉन्फ़िगर एक अंतर्निर्मित प्री-प्रोसेसर के माध्यम से चलाया जाता है। के पूर्व
प्रोसेसर स्टेटमेंट्स को '@' कैरेक्टर ('#' शेल कमेंट है) द्वारा पेश किया जाता है
चरित्र)। यह केवल C प्री-प्रोसेसर की तरह कार्य करता है लेकिन शेल और पर्ल के लिए अनुमति देता है
भाग जाता है. यहां उपलब्ध फ़ंक्शन हैं:

@अगर अभिव्यक्ति
If अभिव्यक्ति सत्य है, @end, @elsif या @else तक कोड लोड करना जारी रखें।

@elsif अभिव्यक्ति
वैकल्पिक विकल्प. अगर अभिव्यक्ति सत्य है, @end तक कोड लोड करना जारी रखें,
अन्य @elsif या @else.

@else डिफ़ॉल्ट कोड लोड किया जाएगा यदि @if अभिव्यक्ति झूठा था और इनमें से कोई भी नहीं
वैकल्पिक @elsif मिलान हुआ। @अंत तक लोड करें.

@end @if द्वारा खोले गए सशर्त लोडिंग स्टेटमेंट को बंद करें।

@परिभाषित करना प्रतीक
प्री-प्रोसेसर को बताता है कि प्रतीक अभी से परिभाषित किया गया है।

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

एकल कोष्ठक के भीतर संलग्न पाठ एक शेल परीक्षण है, जबकि दोहरे कोष्ठक के बीच का पाठ है
एक पर्ल परीक्षण. अर्थात् भाव:

{ खोल टेक्स्ट }
{{ पर्ल टेक्स्ट }}

में अनुवादित हैं:

if खोल टेक्स्ट >/dev/null 2>&1; फिर बाहर निकलें 0; अन्यथा बाहर निकलें 1; फाई
अगर (पर्ल टेक्स्ट) {निकास 0;} अन्यथा {निकास 1;}

और निकास स्थिति का उपयोग बूलियन मान प्राप्त करने के लिए मानक तरीके से किया जाता है, यानी 0 सत्य है और
बाकी सब झूठ है. ध्यान दें कि पर्ल में केवल साधारण स्थितियों को ही व्यक्त किया जा सकता है
कुछ जटिल कोड को भीतर लोड किया जा सकता है मेटाकॉन्फिग और निष्पादित किया गया.

अंतर्निर्मित प्री-प्रोसेसर का उपयोग कुछ इकाइयों को बारीक रूप से ट्यून करने के लिए किया जा सकता है (देखें)। d_getname.U एक के लिए
जटिल उदाहरण) वास्तव में प्रोग्राम या फ़ाइलों द्वारा उपयोग किए गए प्रतीकों पर निर्भर करता है
वितरण में मौजूद. उदाहरण के लिए, Oldconfig.U जैसे परीक्षण का उपयोग करता है:

@if {test -d ../संकेत}

और कॉन्फ़िगर संकेत-निर्भर कोड तभी शामिल होगा जब कोई हो संकेत में निर्देशिका
पैकेज की शीर्ष स्तरीय निर्देशिका। ध्यान दें कि परीक्षण 'के भीतर से चलाए जाते हैं.एमटी' निर्देशिका,
इसलिए परीक्षण में '../' की आवश्यकता है।

प्री-प्रोसेसर का उपयोग प्रतीक न होने पर बेकार कोड डालने से बचने के लिए भी किया जा सकता है
परिभाषित। एक से अधिक प्रतीकों को परिभाषित करने वाली इकाइयों को इस तरह से संरक्षित किया जा सकता है (क्योंकि इकाई है
@if/@end जोड़ी के भीतर प्रतीक-निर्भर कोड इकट्ठा करके समग्र रूप से लोड किया गया)। के लिए
उदाहरण:

@अगर मैं_समय || I_SYS_TIME || I_SYS_TIME_KERNEL
आवश्यकता_समय_एच='सत्य'
@अन्य
आवश्यकता_समय_एच='झूठा'
@समाप्त

परीक्षण करेगा कि क्या स्रोत कोड नियंत्रण करने वाले तीन प्रतीकों में से किसी एक का उपयोग करता है
la समय or sys/time.h समावेशन और तदनुसार शेल प्रतीक को परिभाषित करें। देता है कि
कॉन्फ़िगर स्रोतों को क्या चाहिए, इस पर प्रतिक्रिया दें और उसे ठीक करने की कमी से बचें
जमी हुई इकाइयाँ।

'?W:' पंक्तियों के माध्यम से, आप इंटरस्टिंग संयोजन प्राप्त कर सकते हैं। उदाहरण के लिए, i_time.U इकाई
यह जानने की जरूरत है कि क्या सी स्रोत इसका कोई उपयोग करते हैं struct समयक्षेत्र प्रकार। इसलिए,
रेखा:

?W::समयक्षेत्र

प्रतीक को परिभाषित करने के दुष्प्रभाव के लिए उपयोग किया जाता है समयक्षेत्र प्री-प्रोसेसर के लिए.
यूनिट कोड तब कह सकता है:

@यदि समयक्षेत्र
'-DS_TIMEZONE' '' में s_timezone के लिए; करना
@अन्य
s_timezone=''
@समाप्त

... s_timezone का उपयोग कर कोड...

@यदि समयक्षेत्र
किया
@समाप्त

और इसके लिए दो क्रमिक मानों का प्रयास करते हुए एक अतिरिक्त लूप रखें s_timezone परिवर्तनशील, लेकिन केवल
यदि ज़रूरत हो तो।

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

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

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

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

तब से, आप कुछ शेल वेरिएबल्स को पूर्व-सेट कर सकते हैं कॉन्फ़िगर ओएस-विशिष्ट में उपयोग करता है
.sh फ़ाइल. इसमें कोड है Oldconfig.U यह अनुमान लगाने का प्रयास करता है कि किन संकेत फ़ाइलों की आवश्यकता है
सिस्टम OS नाम, कर्नेल नाम, रिलीज़ के आधार पर एक मानक नाम की गणना करना
संख्या, आदि... चूँकि यह जानकारी तेजी से बदलने की संभावना है, इसलिए मैं इसका दस्तावेजीकरण नहीं कर रहा हूँ
यहाँ। आपको कोड को रिवर्स इंजीनियर करना होगा Oldconfig.U.

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

उदाहरण के लिए, एसजीआई सिस्टम ख़राब होने के लिए जाने जाते हैं vfork() सिस्टम कॉल, इस प्रकार
लिखना। और संबंधित संकेत फ़ाइल का नाम है sgi.sh. तो आपको बस बनाने की ज़रूरत है
a संकेत/sgi.sh वह फ़ाइल जिसमें आप लिखते हैं:

d_vfork='$define'

जो हमेशा रीमैप करेगा vfork on कांटा (देखें d_vfork.U). जब एसजीआई सिस्टम पर चल रहा हो
पहली बार, कॉन्फ़िगर यह पता लगाएगा कि वहाँ एक है संकेत/sgi.sh फ़ाइल, और हम उस पर हैं
एक IRIX मशीन (कर्नेल नाम अक्सर /irix होता है), इसलिए यह प्रस्तावित करेगा एसजीआई एक के रूप में
संभव संकेत. यदि उपयोगकर्ता इसे स्वीकार करता है, और तब से $d_vfork के माध्यम से मान संशोधित किया जाता है
$सेटवार कॉल करें, ए रुको! यह चेतावनी देने के लिए उत्सर्जित किया जाएगा कि हम मूल्य को ओवरराइड करने वाले हैं
द्वारा गणना की गई कॉन्फ़िगर.

ध्यान दें कि आपको प्रदान नहीं करना है सब द्वारा ज्ञात संकेत Oldconfig.U. यदि कोई संकेत फ़ाइल है
अनुपस्थित, इसे संभावित विकल्प के रूप में प्रस्तावित नहीं किया जाएगा। गणना करने के लिए अनुमानी परीक्षण चलाए गए
संभावित संकेत उम्मीदवार परतदार हैं। यदि आपके पास नए मान या भिन्न परीक्षण हैं, तो कृपया
उन्हें मेरे पास भेजें...

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

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

कॉन्फ़िगर ऑप्शंस
RSI कॉन्फ़िगर स्क्रिप्ट को कमांड लाइन पर निर्दिष्ट कुछ विकल्पों के साथ कॉल किया जा सकता है
इसके व्यवहार को थोड़ा संशोधित करें। यहां अनुमत विकल्प हैं:

-d सभी उत्तरों के लिए डिफ़ॉल्ट का उपयोग करें.

-e के उत्पादन पर सवाल उठाए बिना आगे बढ़ें config.श.

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

-h सहायता संदेश प्रिंट करें और बाहर निकलें।

-r यदि संभव हो तो C प्रतीक मान का पुन: उपयोग करें। इससे महंगा खर्च नहीं होगा nm प्रतीक
निष्कर्षण. यदि पहली बार उपयोग किया गया हो (बिना किसी पिछली कॉन्फ़िगरेशन फ़ाइल के),
कॉन्फ़िगर इसके बारे में जानने के लिए एक छोटे प्रोग्राम को संकलित और लिंक करने का प्रयास करूंगा
किसी प्रतीक की उपस्थिति, या उसकी अनुपस्थिति।

-s शांत अवस्था। केवल फ़ाइल डिस्क्रिप्टर #4 पर मुद्रित स्ट्रिंग्स ही दिखाई देंगी
स्क्रीन (यही महत्वपूर्ण संदेश हैं)। इसे पूरी तरह बंद करना संभव नहीं है
कोई भी आउटपुट, लेकिन आप 'का उपयोग कर सकते हैंकॉन्फ़िगर -डर्स > / Dev / बातिल 2> और 1'पूरा होना
बैच बिना किसी आउटपुट और उपयोगकर्ता इंटरैक्शन की आवश्यकता के चलता है।

-D प्रतीक = मान
पूर्व परिभाषित करता है प्रतीक निर्दिष्ट सहन करना मूल्य. 'का उपयोग करना भी संभव है'-D
प्रतीक' जो 'परिभाषित' के डिफ़ॉल्ट मान का उपयोग करेगा।

-E कॉन्फ़िगरेशन प्रश्न तैयार करने के बाद अंत में रुकें
config.श. यह कोई कार्य नहीं करेगा'बनाना निर्भर'या .SH फ़ाइलें निष्कर्षण।

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

-O a के माध्यम से निर्दिष्ट मानों की अनुमति दें -D or -U किसी भी लोड की गई सेटिंग्स को ओवरराइड करने के लिए
विन्यास फाइल। ओवरराइडिंग वसीयत के बाद से यह डिफ़ॉल्ट व्यवहार नहीं है
जिन्हें आप वर्तमान में बदल रहे हैं, उनसे प्राप्त वेरिएबल्स में प्रसारित न किया जाए।
स्वाभाविक रूप से, बिना -O, सेटिंग केवल तभी की जाती है जब कोई कॉन्फ़िगरेशन फ़ाइल न हो
लोड किया गया, जो सुरक्षित है क्योंकि व्युत्पन्न चर की गणना अभी तक नहीं की गई है...

-S सभी .SH फ़ाइलों पर परिवर्तनीय प्रतिस्थापन करें। आप इसे इसके साथ जोड़ सकते हैं
-f अपनी पसंद के किसी भी कॉन्फ़िगरेशन को प्रचारित करने के लिए स्विच करें।

-U प्रतीक=
पूर्व सेट प्रतीक एक खाली मूल्य सहन करने के लिए. 'का उपयोग करना भी संभव है'-U प्रतीक'
जो सेट हो जायेगा प्रतीक 'अनडिफ़' करने के लिए.

-V का संस्करण क्रमांक प्रिंट करें मेटाकॉन्फिग जिससे यह उत्पन्न हुआ कॉन्फ़िगर लिपि
और बाहर निकलें

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

तुम दौड़ सकते हो कॉन्फ़िगर हालाँकि दूर से, जैसे:

../पैकेज/कॉन्फ़िगर करें

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

भीतर से UU उपनिर्देशिका, आप उपयोग कर सकते हैं $rsrc स्रोत फ़ाइलों (इकाइयों) तक पहुंचने के लिए
स्रोत फ़ाइलों के संदर्भ में लिंक संकेत हमेशा इस तंत्र का उपयोग करेंगे और यह नहीं मानेंगे
फ़ाइल मूल निर्देशिका में मौजूद है)। सभी मेकफाइल्स को $src वेरिएबल का उपयोग करना चाहिए
बिल्ड निर्देशिका के शीर्ष से स्रोतों के सूचक के रूप में (जहां कॉन्फ़िगर चलाया जाता है),
या तो सीधे या VPATH सेटिंग के माध्यम से।

दौड़ते समय कॉन्फ़िगर दूरस्थ रूप से, .SH फ़ाइलें बिल्ड निर्देशिका में निकाली जाती हैं, नहीं
स्रोत वृक्ष में. हालाँकि, इसके लिए किसी प्रकार की आवश्यकता होती है बनाना संकलन करने में सक्षम होने के लिए समर्थन
चीज़ें बिल्ड निर्देशिका में हैं जबकि स्रोत कहीं और हैं।

का प्रयोग जादू पुनर्परिभाषाएँ
का उपयोग करके -M स्विच, कुछ जादुई रीमैपिंग एक के भीतर हो सकती है confmagic.h
फ़ाइल। उस फ़ाइल को बाद में शामिल करने की आवश्यकता है कॉन्फ़िग.एच, निःसंदेह, लेकिन आख़िरकार भी
अन्य आवश्यक फाइलों में शामिल हैं। अर्थात्:

#"config.h" शामिल करें
...
... अन्य inclusions ...
...
#शामिल करें "confmagic.h"

आमतौर पर, confmagic.h पुनः मैप करने का प्रयास करेंगे बीकॉपी() on memcpy() यदि नही बीकॉपी() is
स्थानीय रूप से उपलब्ध है, या रूपान्तरण vfork में कांटा जब आवश्यक हो, इसलिए इसे बेकार बना दिया जाता है
के बारे में चिंता करें HAS_VFORK प्रतीक।

यह कॉन्फ़िगरेशन जादू शब्दावली फ़ाइल में प्रलेखित है।

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

लेखक

लैरी वॉल[ईमेल संरक्षित]> संस्करण 2.0 के लिए।
हरलान स्टेन[ईमेल संरक्षित]> महत्वपूर्ण इकाई एक्सटेंशन के लिए।
राफेल मैनफ्रेडी[ईमेल संरक्षित]>.
के लिए कई अन्य योगदानकर्ता मेटाकॉन्फिग इकाइयाँ। सूची के लिए क्रेडिट फ़ाइल देखें.

onworks.net सेवाओं का उपयोग करके ऑनलाइन मेटाकॉन्फ़िग का उपयोग करें