metaconfig - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

metaconfig - ഒരു കോൺഫിഗർ സ്ക്രിപ്റ്റ് ജനറേറ്റർ

സിനോപ്സിസ്

metaconfig [-dhkmostvwGMV ] [-L മുതലാളി ]

വിവരണം

Metaconfig കോൺഫിഗർ സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കുന്ന ഒരു പ്രോഗ്രാമാണ്. എന്താണെന്ന് നിങ്ങൾക്കറിയില്ലെങ്കിൽ എ
സ്ക്രിപ്റ്റ് കോൺഫിഗർ ചെയ്യുക എന്നതാണ്, ദയവായി ഇതിലേക്ക് പോകുക TUTORIAL ഈ മാനുവൽ പേജിന്റെ വിഭാഗം. നിങ്ങൾക്ക് വേണമെങ്കിൽ
ഉപയോഗിക്കേണ്ട രീതിയുടെ പൂർണ്ണമായ (ഔപചാരിക) വിവരണം metaconfig അതിന്റെ യൂണിറ്റുകളും, ദയവായി നോക്കുക
REFERENCE വിഭാഗം. അറിവുള്ളവർക്കുള്ള ഒരു ദ്രുത ആമുഖവും അവലംബവുമാണ് ഇനിപ്പറയുന്നത്
ഉപയോക്താക്കൾ.

Metaconfig സെറ്റ് മുതൽ പ്രവർത്തിക്കുന്നു യൂണിറ്റുകൾ മെറ്റാ കോൺഫിഗിന് അറിയാവുന്ന എല്ലാ കാര്യങ്ങളും നിർവ്വചിക്കുന്നു
പോർട്ടബിലിറ്റി. ഓരോ യൂണിറ്റും സ്വയം ഉൾക്കൊള്ളുന്നു, എവിടെയും രജിസ്റ്റർ ചെയ്യേണ്ടതില്ല
പൊതു യു ഡയറക്‌ടറിയിലോ നിങ്ങളുടെ സ്വകാര്യ യു ഡയറക്‌ടറിയിലോ ഉൾപ്പെടുത്തിയല്ലാതെ. എങ്കിൽ
ഡിസ്റ്റ് പാക്കേജ് (ഇതിൽ metaconfig ഒരു ഭാഗമാണ്) LIB-ൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്, തുടർന്ന് പൊതു യു
ഡയറക്ടറി LIB/dist/mcon/U ആണ്. ഈ മെഷീനിൽ, LIB ഡയറക്ടറി /usr/share/dist ആണ്. നിങ്ങളുടെ
പ്രൈവറ്റ് യു ഡയറക്‌ടറി, നിങ്ങളുടേത് ഉണ്ടെങ്കിൽ, നിങ്ങളുടെ പാക്കേജിന്റെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിലാണ്.
നിങ്ങൾക്ക് ഓടാൻ കഴിയും മുമ്പ് metaconfig നിങ്ങൾ നിരവധി കാര്യങ്ങൾ ചെയ്യണം:

· റൺ ചെയ്തുകൊണ്ട് പാക്കേജിന്റെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിൽ ഒരു .package ഫയൽ സൃഷ്‌ടിക്കുക പാക്കിനിറ്റ്.
ഈ പ്രോഗ്രാം നിങ്ങളുടെ പാക്കേജിനെക്കുറിച്ച് നിങ്ങളോട് ചോദിക്കുകയും നിങ്ങൾ എന്താണ് പറയുന്നതെന്ന് ഓർക്കുകയും ചെയ്യും
എല്ലാ ഡിസ്‌റ്റ് പ്രോഗ്രാമുകളും സ്‌മാർട്ടാകും.

· ഗ്ലോസറി പരിശോധിച്ച് (LIB/dist/mcon-ൽ) നിങ്ങളുടെ ഷെൽ സ്ക്രിപ്റ്റുകളും C പ്രോഗ്രാമുകളും എഴുതുക
മെറ്റാ കോൺഫിഗിന് എങ്ങനെ നിർവചിക്കണമെന്ന് അറിയാവുന്ന ചിഹ്നങ്ങളുടെ കാര്യത്തിൽ. നിങ്ങൾ പറയേണ്ടതില്ല
metaconfig നിങ്ങൾ ഉപയോഗിച്ച ചിഹ്നങ്ങൾ, കാരണം metaconfig നിങ്ങൾക്കായി അത് കണ്ടെത്തും.

· Makefiles അല്ലെങ്കിൽ ഷെൽ സ്ക്രിപ്റ്റുകൾ എഴുതാൻ ആവശ്യമായ ഏതെങ്കിലും .SH സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കുക
കോൺഫിഗർ നിർവചിച്ച മൂല്യങ്ങളിൽ. എന്നൊരു പരിപാടിയുണ്ട് ഉണ്ടാക്കുക അത് നിങ്ങളെ സഹായിക്കും
ഒരു പ്ലെയിൻ സ്ക്രിപ്റ്റ് ഒരു script.SH ടെംപ്ലേറ്റ് ആക്കി മാറ്റുക; കുറച്ച് എഡിറ്റിംഗ് ഇനിയും വേണ്ടി വരും
എന്നതിലെ വേരിയബിൾ കോൺഫിഗറേഷൻ ഭാഗം നീക്കുന്നതിന് ഫലമായുണ്ടാകുന്ന .SH ഫയലിൽ നടപ്പിലാക്കുന്നു
സ്ക്രിപ്റ്റിന്റെ മുകൾ ഭാഗം (ഇൻലൈൻ കമന്റുകൾ സൃഷ്ടിച്ചത് കാണുക ഉണ്ടാക്കുക നിങ്ങളുടെ .എസ്.എച്ച്
ഫയൽ).

നിങ്ങളുടെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിൽ എല്ലാ ഫയലുകളും ലിസ്റ്റ് ചെയ്യുന്ന ഒരു MANIFEST.new ഫയൽ സൃഷ്‌ടിക്കുക
നിങ്ങളുടെ പാക്കേജ്. ഈ ഫയൽ സ്വകാര്യമായി തുടരും കൂടാതെ അന്തിമഭാഗത്തിന്റെ ഭാഗവുമല്ല
വിതരണ. (ഒരു സൗകര്യാർത്ഥം, MANIFEST ഫയൽ ഉപയോഗിക്കും metaconfig if
ഇതുവരെ MANIFEST.new ഫയൽ ഒന്നുമില്ല.) ഫയലിന്റെ പേര് ഓരോന്നിന്റെയും ആദ്യ ഫീൽഡ് ആയിരിക്കണം
ലൈൻ. കുറച്ച് വൈറ്റ്‌സ്‌പെയ്‌സിന് ശേഷം നിങ്ങളുടെ ഫയലിനെ വിവരിക്കുന്ന ഒരു ചെറിയ അഭിപ്രായം ചേർക്കാൻ കഴിയും. മാത്രം
സോഴ്സ് ഫയലുകൾ അവിടെ ലിസ്റ്റ് ചെയ്യണം. പ്രത്യേക ഫയൽ patchlevel.h (അതാണ്
പാച്ചിംഗ് ടൂളുകൾ കൈകാര്യം ചെയ്യുകയും പരിപാലിക്കുകയും ചെയ്യുന്നു -- കാണുക pat(1)) ഭാഗമായിരിക്കണം
MANIFEST.new ഫയൽ, എന്നാൽ ചില ഉപകരണങ്ങൾ നിശബ്ദമായി അവഗണിച്ചേക്കാം. ഒരു ചട്ടം പോലെ,
RCS പരിപാലിക്കുന്ന ഫയലുകൾ മാത്രമേ അവിടെ ലിസ്‌റ്റ് ചെയ്യാവൂ patchlevel.h ഫയൽ ആയിരിക്കുന്നു
ഒരു പ്രധാന ഒഴിവാക്കൽ.

· ഓപ്ഷണലായി, നിങ്ങൾ ഒരു MANIFEST ഫയൽ സൃഷ്ടിക്കാൻ ആഗ്രഹിച്ചേക്കാം, അത് കയറ്റുമതി ചെയ്ത പതിപ്പായിരിക്കും
നിങ്ങളുടെ MANIFEST.new. ആ ഫയൽ റിലീസിന്റെ ഭാഗമാക്കണം, അതായത് രണ്ടിലും ലിസ്റ്റ് ചെയ്തിരിക്കണം
നിങ്ങളുടെ MANIFEST.new കൂടാതെ MANIFEST തന്നെ. അതിലൊന്ന് metaconfig യൂണിറ്റുകൾക്ക് ഇതിനെക്കുറിച്ച് അറിയാം
ഫയൽ, എല്ലാ ഫയലുകളും ഉറപ്പാക്കിക്കൊണ്ട് ഒരു റിലീസ് ചെക്ക് നടത്താൻ കോൺഫിഗർ നിർബന്ധിക്കും
വിതരണത്തിന്റെ ഭാഗങ്ങൾ പട്ടികപ്പെടുത്തിയിട്ടുണ്ട്. MANIFEST, MANIFEST.new ഫയലുകൾ വേണം
കണ്ണികളല്ല, വേറിട്ടുനിൽക്കുക.

· നിങ്ങളുടെ സ്വകാര്യ യു ഡയറക്‌ടറിയിലേക്ക് പരിഷ്‌ക്കരിക്കാൻ ആഗ്രഹിക്കുന്ന ഏതെങ്കിലും .U ഫയലുകൾ പകർത്തുക. ഏതെങ്കിലും .U ഫയലുകൾ
നിങ്ങളുടെ സ്വകാര്യ യു ഡയറക്‌ടറിയിൽ പൊതു യു എന്നതിലേക്ക് മുൻഗണന നൽകും
ഡയറക്ടറി. ഉദാഹരണത്തിന്, ഏതെങ്കിലും യൂണിറ്റ് നിർബന്ധമായും ഉൾപ്പെടുത്തുന്നതിനുള്ള ഒരു മാർഗ്ഗം End.U പകർത്തുക എന്നതാണ്
നിങ്ങളുടെ .U ഡയറക്‌ടറിയിലേക്ക് ഫയൽ ചെയ്‌ത് ഒരു ഡിപൻഡൻസിയായി നിങ്ങൾ ആഗ്രഹിക്കുന്ന യൂണിറ്റിന്റെ പേര് ചേർക്കുക
? ഉണ്ടാക്കുക: വരിയുടെ അവസാനം. ചില യൂണിറ്റുകൾ ഈ രീതിയിൽ മാത്രമേ നിർബന്ധിതമാക്കാൻ കഴിയൂ, അതായത്
Warn_*.U, Chk_*.U എന്നീ രൂപത്തിലുള്ളവ. നിങ്ങൾക്ക് ചില ഡിഫോൾട്ട് ഇഷ്‌ടാനുസൃതമാക്കാനും കഴിയും
Myinit.U നിങ്ങളുടെ പാക്കേജിന്റെ സ്വകാര്യ U ഡയറക്ടറിയിലേക്ക് പകർത്തി വേരിയബിളുകൾ കോൺഫിഗർ ചെയ്യുക
ആ യൂണിറ്റിലെ വേരിയബിളുകൾ ക്രമീകരിക്കുന്നു.

ഇപ്പോൾ നിങ്ങൾ ഓടാൻ തയ്യാറാണ് metaconfig. അത് എ സൃഷ്ടിക്കും സജ്ജമാക്കുന്നു ഫയൽ, കൂടാതെ ഓപ്ഷണലായി എ
config_h.SH ഫയൽ (നിങ്ങളുടെ ഉറവിടങ്ങൾ C ചിഹ്നങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ). ജനറേറ്റഡ് ഫയലുകൾ ചെയ്യും
ആവശ്യമെങ്കിൽ നിങ്ങളുടെ MANIFEST.new-ലേക്ക് സ്വയമേവ ചേർക്കും. നിങ്ങളുടെ അപ്ഡേറ്റ് ചെയ്യാൻ മറക്കരുത്
MANIFEST ഫയൽ എങ്കിലും.

പുതിയ യൂണിറ്റുകൾ സൃഷ്ടിക്കുന്നതിന്, ഇനിപ്പറയുന്നവ ചെയ്യുക:

· സമാനമായ ഒരു യൂണിറ്റ് ഒരു പുതിയ .U ഫയലിലേക്ക് പകർത്തുക. നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന പേര് a യുടെ പേരായിരിക്കണം
യൂണിറ്റ് സൃഷ്ടിച്ച വേരിയബിൾ, ഇത് നിങ്ങൾക്ക് ഒരു സൗകര്യം മാത്രമാണെങ്കിലും, a
ആവശ്യം. ഫയലിന്റെ പേര് ചോപ്പുചെയ്യുന്നത് തടയാൻ 12 അല്ലെങ്കിൽ അതിൽ കുറവ് പ്രതീകങ്ങൾ ഉണ്ടായിരിക്കണം.
യഥാർത്ഥത്തിൽ, ഇത് 10 അല്ലെങ്കിൽ അതിൽ കുറവായിരിക്കണം, അതിനാൽ ആർസിഎസ് ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നവർക്ക് കഴിയും
അരിയാതെ അവസാനം a .U,v. എന്നതിന്റെ ആദ്യ അക്ഷരത്തിന്റെ കേസ് Metaconfig ഉപയോഗിക്കുന്നു
ഈ യൂണിറ്റ് യഥാർത്ഥത്തിൽ ഏതെങ്കിലും വേരിയബിൾ നിർമ്മിക്കുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കുക, അതിനാൽ നിങ്ങളുടേത് വലിയക്ഷരമാക്കരുത്
ഒരു ഷെൽ വേരിയബിൾ ഉത്പാദിപ്പിക്കേണ്ടതുണ്ടെങ്കിൽ യൂണിറ്റിന്റെ പേര്.

· നിങ്ങൾ ആഗ്രഹിക്കുന്നത് ചെയ്യാൻ പുതിയ .U ഫയൽ എഡിറ്റ് ചെയ്യുക. ആദ്യത്തെ ?MAKE: ലൈൻ സൂചിപ്പിക്കുന്നത്
ആശ്രിതത്വങ്ങൾ; അന്തിമ ലിസ്റ്റ് കോളണിന് മുമ്പ് ഈ യൂണിറ്റ് നിർവചിക്കുന്ന എല്ലാ വേരിയബിളുകളും, ഒപ്പം
അവസാന കോളണിന് ശേഷം ഈ യൂണിറ്റിനെ ആശ്രയിക്കുന്ന എല്ലാ വേരിയബിളുകളും (അല്ലെങ്കിൽ മറ്റ് യൂണിറ്റുകൾ).
ഈ ലിസ്റ്റുകൾ കൃത്യമായിരിക്കേണ്ടത് വളരെ പ്രധാനമാണ്. ഒരു ആശ്രിതത്വം ഓപ്ഷണൽ ആണെങ്കിൽ കൂടാതെ a
ഡിഫോൾട്ട് മൂല്യം ഉപയോഗിക്കാം, നിങ്ങൾ ഡിപൻഡൻസിയെ ഒരു '+' ചിഹ്നം ഉപയോഗിച്ച് പ്രിഫിക്സ് ചെയ്യണം. ദി
യഥാർത്ഥത്തിൽ ആവശ്യമില്ലെങ്കിൽ, ചിഹ്നം കണക്കാക്കാൻ അനുബന്ധ യൂണിറ്റ് ലോഡ് ചെയ്യില്ല
മറ്റൊരു യൂണിറ്റ് വഴി.

· സാധ്യമായ പരിധിവരെ, നിർവ്വചിച്ചിരിക്കുന്ന ഷെൽ വേരിയബിളിനെ അടിസ്ഥാനമാക്കി നിങ്ങളുടെ യൂണിറ്റ് പാരാമീറ്റർ ചെയ്യുക
?INIT: വരികൾ. ഇത് വേരിയബിൾ നിർവചനങ്ങളെ Init.U യൂണിറ്റിലേക്ക് നീക്കും
Init.U-ന് ശേഷം ഉൾപ്പെടുത്തിയിരിക്കുന്ന Myinit.U-ലെ നിർവചനങ്ങൾ വഴി അവയെ മറികടക്കാൻ കഴിയും.

· ?H: വരികൾ ആയി ആഗ്രഹിക്കുന്ന ഏതെങ്കിലും C ചിഹ്നങ്ങളുടെ നിർവചനം ചേർക്കുക. എന്ന് തുടങ്ങുന്ന ഒരു വരി
?H:?%<: .U ഫയലിലെ config.h ഫയലിൽ ചേർക്കും
ഈ യൂണിറ്റ് ആവശ്യമാണെന്ന് metaconfig തീരുമാനിക്കുന്നു. %< എന്നത് യൂണിറ്റിന്റെ പേരിനെ സൂചിപ്പിക്കുന്നു,
നിങ്ങൾ പിന്തുടരുകയാണെങ്കിൽ ഫയലിന്റെ പേരും (.U ഇല്ലാതെ) ആയിരിക്കും
കൺവെൻഷൻ. എല്ലായ്‌പ്പോഴും ഓരോ ?H: വരിയിലും ഒരു അഭിപ്രായം ഇടുക
വരിയിൽ നേരത്തെയുള്ള സബ്സ്റ്റിറ്റ്യൂഷനുകൾ പൂർത്തിയാക്കാതെ ഒരു കമന്റ് തുടങ്ങുന്നു. ഏതെങ്കിലും ഷെൽ
d_ ൽ ആരംഭിക്കുന്ന വേരിയബിൾ ഇത് ചെയ്തേക്കാം, അതിനാൽ സൂക്ഷിക്കുക. നിങ്ങൾ ?%<: ഒഴിവാക്കുകയാണെങ്കിൽ
metaconfig ഏതെങ്കിലും നിർവചനത്തിന് മുമ്പ് ആവശ്യമുള്ള ചിഹ്നം ഉൾക്കൊള്ളാൻ ശ്രമിക്കും
config.h-ൽ ഉൾപ്പെടുത്തൽ.

· ഗ്ലോസറി നിർവചനങ്ങൾ ?S: ഷെൽ വേരിയബിളുകൾക്കുള്ള വരികൾ, ?C: C-യ്‌ക്കുള്ള വരികൾ എന്നിങ്ങനെ ചേർക്കുക
പ്രീപ്രോസസർ വേരിയബിളുകൾ. ഉദാഹരണങ്ങൾക്കായി നിലവിലെ യൂണിറ്റ് കാണുക. അത് വളരെ പ്രധാനമാണ്
ഓരോ എൻട്രിയും ഇടത് ന്യായമായ ചിഹ്ന നാമത്തിൽ ആരംഭിക്കുക, കൂടാതെ ഓരോ എൻട്രിയും ?C: ഉപയോഗിച്ച് അവസാനിപ്പിക്കുക. അഥവാ
?എസ്:. ലൈൻ. സി പ്രീപ്രൊസസ്സർ ചിഹ്ന എൻട്രികൾ വിവർത്തനം ചെയ്യുന്ന അൽഗോരിതം
config.h-നുള്ള കമന്റുകളിലേക്കുള്ള ഗ്ലോസറി ഇതിനെ ആശ്രയിച്ചിരിക്കുന്നു.

· നിങ്ങളുടെ എല്ലാം ക്രമം ഉറപ്പാക്കുക? വരികൾ ശരിയാണ്. ശരിയായ ക്രമം ഇതാണ്:

?RCS: കൂടാതെ ?X: അടിസ്ഥാനപരമായി അഭിപ്രായങ്ങൾ മാത്രം
?ഉണ്ടാക്കുക: metaconfig ഡിപൻഡൻസികൾ
?Y: യൂണിറ്റ് ലേഔട്ട് നിർദ്ദേശം
?എസ്: ഗ്ലോസറി ഷെൽ നിർവചനങ്ങൾ
?സി: ഗ്ലോസറി സി നിർവചനങ്ങൾ
?H: config.h നിർവചനങ്ങൾ
?എം: confmagic.h നിർവചനങ്ങൾ
?W: ആവശ്യമായ ചിഹ്നങ്ങൾ
?വി: ദൃശ്യമായ ചിഹ്നങ്ങൾ
?F: ഈ യൂണിറ്റ് സൃഷ്ടിച്ച ഫയലുകൾ
?T: താൽക്കാലിക ഷെൽ ചിഹ്നങ്ങൾ ഉപയോഗിച്ചു
?D: ഓപ്ഷണൽ ഡിപൻഡൻസി ഡിഫോൾട്ട് മൂല്യം
?O: കാലഹരണപ്പെട്ട യൂണിറ്റുകൾ അടയാളപ്പെടുത്താൻ ഉപയോഗിക്കുന്നു
?ലിന്റ്: മെറ്റാലിന്റ് സൂചനകൾ
?INIT: ഷെൽ ചിഹ്നങ്ങളുടെ തുടക്കങ്ങൾ

ലൈനുകളുടെ ക്രമവും അനുവദനീയമായ വിവിധ ഫോർമാറ്റുകളും കാണിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

?RCS: $RCS-Id$
?RCS: പകർപ്പവകാശ വിവരങ്ങൾ
?RCS: $RCS-ലോഗ്$
?X:
?X: ഒരു കൃത്രിമ ഉദാഹരണം
?X:
?ഉണ്ടാക്കുക:d_one രണ്ട്: മൂന്ന് +നാല് അഞ്ച്
?ഉണ്ടാക്കുക: -തിരഞ്ഞെടുക്കുക ചേർക്കുക $@ %
?Y:DEFAULT
?S:d_one:
?എസ്: ആദ്യ ഷെൽ ചിഹ്നം, സോപാധികമായി ഒന്ന് നിർവചിക്കുന്നു.
?എസ്:.
?എസ്:രണ്ട്:
?S: രണ്ടാമത്തെ ഷെൽ ചിഹ്നം, TWO എന്നതിനുള്ള മൂല്യം.
?എസ്:.
?കോൺ:
?സി: ആദ്യത്തെ സി ചിഹ്നം.
?സി:.
?C:TWO:
?സി: സെക്കന്റ് സി ചിഹ്നം.
?സി:.
?H:#$d_one ONE /**/
?H:#രണ്ട് "$രണ്ട്" നിർവ്വചിക്കുക
?H:#$d_one ONE_TWO "$two"
?എച്ച്:.
?എം:ഫ്ലിപ്പ്: HAS_FLIP
?എം:#ifndef HAS_FLIP
?എം:#ഫ്ലിപ്പ്(x) ഫ്ലോപ്പ്(x) നിർവ്വചിക്കുക
?എം:#endif
?എം:.
?W:%<:one_two
?V:p_one p_two:p_three
?F:file ./ftest !tmp
?T:tmp var
?D: two='undef'
?ലിന്റ്:മൂന്ന് മാറ്റുക
?INIT:two_init='2'
: യൂണിറ്റ് നടപ്പിലാക്കുന്ന ഷെൽ കോഡ് താഴെ പറയുന്നു
p_one='ഒന്ന്'
p_two='രണ്ട്'
p_three=""

ഒരിക്കൽ കൂടി പറയട്ടെ: മുകളിലെ യൂണിറ്റ് നിർവചനം a വ്യാജ ഒന്ന് കാണിക്കാൻ മാത്രം
വ്യത്യസ്ത സാധ്യതകൾ. അത്തരത്തിലുള്ള ഒരു യൂണിറ്റ് എന്തുതന്നെയായാലും ചെറിയ ഉദ്ദേശ്യങ്ങൾ നിറവേറ്റും... ചിലത്
വിപുലമായ സവിശേഷതകൾ ഇവിടെ വിവരിച്ചിട്ടില്ല. ദയവായി റഫർ ചെയ്യുക REFERENCE കൂടുതൽ കാര്യങ്ങൾക്കായി വിഭാഗം
പൂർണ്ണമായ വിവരങ്ങൾ.

· യുണിറ്റ് പബ്ലിക് അല്ലെങ്കിൽ പ്രൈവറ്റ് യു ഡയറക്‌ടറിയിൽ ഉചിതമായ രീതിയിൽ ഇടുക.

· വീണ്ടും പ്രവർത്തിപ്പിക്കുക metaconfig.

· നിങ്ങളുടെ യൂണിറ്റ് അയയ്‌ക്കുക [ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു] (റാഫേൽ മാൻഫ്രെഡി) മാസ്റ്റർ കോപ്പിയിൽ ഉൾപ്പെടുത്തുന്നതിന്,
ഇത് പൊതു താൽപ്പര്യമാണെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ.

കണ്ടെത്തേണ്ട ഒരു പുതിയ പ്രോഗ്രാം ചേർക്കുന്നതിന്:

· Loc.U എഡിറ്റ് ചെയ്യുക, കൂടാതെ പ്രോഗ്രാമിന്റെ പേര് ?MAKE: എന്ന വരിയിൽ ചേർക്കുക (ഇടയിൽ
രണ്ട് കോളണുകൾ) കൂടാതെ ലോക്കലിസ്റ്റിലേക്കോ ട്രൈലിസ്റ്റിലേക്കോ (പ്രോഗ്രാം ആണോ എന്നതിനെ ആശ്രയിച്ച്
നിർബന്ധമോ അല്ലയോ).

· metaconfig വീണ്ടും പ്രവർത്തിപ്പിക്കുക.

· മാസ്റ്റർ കോപ്പിയിൽ ഉൾപ്പെടുത്തുന്നതിനായി നിങ്ങളുടെ യൂണിറ്റ് എനിക്ക് അയയ്‌ക്കുക, ഇത് പൊതുവായതാണെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ
പലിശ.

.U ഫയലുകൾ എഴുതുന്നതിനുള്ള കുറിപ്പുകൾ:

* സ്ഥിരസ്ഥിതിയായി rm സംവേദനാത്മകമായ സിസ്റ്റങ്ങൾ ഉള്ളതിനാൽ എല്ലായ്പ്പോഴും "rm -f" ഉപയോഗിക്കുക.

* "സെറ്റ് -- ..." ഉപയോഗിക്കരുത് കാരണം '--' എല്ലാ ഷെല്ലിലും പ്രവർത്തിക്കില്ല. "സെറ്റ് x ... ഉപയോഗിക്കുക;
ഷിഫ്റ്റ്".

* സജ്ജീകരിക്കാത്തത് പൂർണ്ണമായി പോർട്ടബിൾ അല്ലാത്തതിനാൽ "അൺസെറ്റ് ENV" ഉപയോഗിക്കരുത്. പകരം "ENV=''" എന്ന് പറയുക.

* യൂനിസ് സിസ്റ്റങ്ങൾ കാരണം എല്ലായ്‌പ്പോഴും എക്കോ "" (സ്‌പെയ്‌സ് ഉള്ളത്) ഉപയോഗിക്കുക.

* മാത്രം ഉപയോഗിക്കുക പരിശോധന പോർട്ടബിൾ സ്വിച്ചുകൾ മാത്രമായതിനാൽ -r, -w, -f അല്ലെങ്കിൽ -d എന്നിവയ്‌ക്കൊപ്പം. ഇൻ
പ്രത്യേകിച്ച്, "ടെസ്റ്റ് -x" ഒഴിവാക്കുക.

* V7 ഉള്ള പ്രോഗ്രാമുകൾ മാത്രം ഉപയോഗിക്കുക, അതുവഴി എല്ലാവർക്കും അവ ഉണ്ടെന്ന് നിങ്ങൾക്കറിയാം.

* എല്ലാ ഗ്രെപ്പുകളും റിട്ടേൺ ചെയ്യാത്തതിനാൽ, സോപാധികമായി ഗ്രെപ്പ് ചെയ്യണമെങ്കിൽ $contains ഉപയോഗിക്കുക
ന്യായമായ നില. '>/dev/null ഉപയോഗിച്ച് ഔട്ട്‌പുട്ട് /dev/null-ലേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നത് ഉറപ്പാക്കുക
2>&1'.

* "if [...]" എന്നതിനുപകരം "if test" ഉപയോഗിക്കുക.

* ഇൻപുട്ടുകൾക്കായി myread സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുക, അതിലൂടെ അവർക്ക് ഷെൽ എസ്കേപ്പുകളും ഡിഫോൾട്ടും ചെയ്യാൻ കഴിയും
മൂല്യനിർണ്ണയം. പൊതുവായ രൂപം

"$grimble" എന്ന കേസ്
'') dflt=452;;
*) dflt="$grimble";;
സി
rp='നിങ്ങൾക്ക് എത്ര മുറുമുറുപ്പ് ഉണ്ട്?'
. ./myread
മുറുമുറുക്കുക="$ans"

* ഓപ്‌ഷണൽ ലഭിക്കാൻ ഒരു ഫയൽ പാത്ത്‌നെയിം ആവശ്യപ്പെടുമ്പോൾ getfile സ്‌ക്രിപ്റ്റ് ഉപയോഗിക്കുക
~പേര് വിപുലീകരണവും സാനിറ്റി പരിശോധനകളും. പൂർണ്ണമായ വിവരണത്തിനായി Getfile.U യൂണിറ്റ് കാണുക.

* എപ്പോഴും ഒരു ഇടുക

$startsh

ലോഞ്ച് ചെയ്യാനോ സ്രോതസ് ചെയ്യാനോ പോകുന്ന എല്ലാ ജനറേറ്റഡ് സ്ക്രിപ്റ്റിന്റെയും മുകളിൽ
സജ്ജമാക്കുന്നു.

* ഒരു ഒബ്‌ജക്റ്റ് ഫയൽ a എന്നതിൽ അവസാനിക്കുന്നത് പോലെയുള്ള പൊതുവായ UNIX-isms ഒരിക്കലും ഊഹിക്കരുത് .o ഒപ്പം
ഒരു ലൈബ്രറിയുടെ പേര് അവസാനിക്കുന്നത് .a. ഉപയോഗിക്കുക $_o ഒപ്പം $_a പകരം വേരിയബിളുകൾ (കാണുക
Unix.U).

* ഒരു കംപൈൽ-ലിങ്ക് എക്സിക്യൂട്ട് ടെസ്റ്റ് നടത്തുമ്പോൾ, എല്ലായ്പ്പോഴും ഇതുപോലെ എഴുതുക:

$cc $ccflags $ldflags try.c -o $libs ശ്രമിക്കുക

കാരണം കംപൈൽ ചെയ്യുന്നതിന് മുമ്പ് ലിങ്കിംഗ് ഫ്ലാഗുകൾ വ്യക്തമാക്കണമെന്ന് ചില സിസ്റ്റങ്ങൾ ആവശ്യപ്പെടുന്നു
ടാർഗെറ്റ് (ലൈബ്രറികൾ ലിങ്കുചെയ്യുന്നത് ഒഴികെ).

* ഔട്ട്‌പുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നതിന് '>&4' ഉപയോഗിച്ച് ഫയൽ ഡിസ്ക്രിപ്റ്റർ #4-ൽ പ്രധാനപ്പെട്ട സന്ദേശങ്ങൾ നൽകുക.
എപ്പോൾ ആ സന്ദേശങ്ങൾ മാത്രമേ ദൃശ്യമാകൂ -s എന്നതിലേക്ക് സ്വിച്ച് നൽകിയിരിക്കുന്നു സജ്ജമാക്കുന്നു ന്
കമാൻഡ് ലൈൻ (സൈലന്റ് മോഡ്).

* ഒരു സവിശേഷത ഏറ്റവും നിർദ്ദിഷ്ട രീതിയിൽ ഉണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ എപ്പോഴും ശ്രമിക്കുക--അരുത്
നിങ്ങൾക്ക് libc ഗ്രെപ്പ് ചെയ്യാൻ കഴിയുമ്പോൾ "if bsd" എന്ന് പറയുക. അവിടെ ധാരാളം ഹൈബ്രിഡ് സംവിധാനങ്ങളുണ്ട്, കൂടാതെ
ഓരോ സവിശേഷതയും തനിയെ നിൽക്കുകയോ വീഴുകയോ വേണം.

* ഒരു സവിശേഷത ഏറ്റവും പൊതുവായ രീതിയിൽ ഉണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ എപ്പോഴും ശ്രമിക്കുക, അങ്ങനെ
മറ്റ് പാക്കേജുകൾക്ക് നിങ്ങളുടെ യൂണിറ്റ് ഉപയോഗിക്കാം.

* സംശയമുണ്ടെങ്കിൽ, സ്ഥിരസ്ഥിതി സജ്ജമാക്കി ചോദിക്കുക. ഒന്നും ഊഹിക്കരുത്.

* ഉപയോക്താവ് തെറ്റാണെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ, അവൻ ശരിയായിരിക്കാം എന്ന വസ്തുത അനുവദിക്കുക. വേണ്ടി
ഉദാഹരണത്തിന്, അവൻ ഉപയോഗിക്കാൻ പോകുന്നതിനേക്കാൾ വ്യത്യസ്തമായ ഒരു സിസ്റ്റത്തിൽ കോൺഫിഗർ പ്രവർത്തിപ്പിക്കുകയായിരിക്കാം
അന്തിമ ഉൽപ്പന്നം.

Metaconfig നിങ്ങളുടെ ഡയറക്‌ടറിയിൽ ഇനിപ്പറയുന്ന പേരുകൾ സംവരണം ചെയ്യുന്നു, നിങ്ങൾ അത്തരമൊരു പേര് ഉപയോഗിക്കുകയാണെങ്കിൽ
ക്ലോബ്ബർ ചെയ്യപ്പെടാം അല്ലെങ്കിൽ മറ്റ് അപ്രതീക്ഷിത ഫലങ്ങൾ ഉണ്ടാകാം:

.എംടി/*
സജ്ജമാക്കുന്നു
ആഗ്രഹിച്ചു
കാലഹരണപ്പെട്ടു
കോൺഫിഗർ
config_h.SH
confmagic.h
യു/*
MANIFEST.new

കൂടാതെ, കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന ഡയറക്‌ടറിയിൽ ഈ പേരുകൾ ക്ലോബ്ബർ ചെയ്‌തേക്കാം:

UU/*
config.sh
config.h

ഓപ്ഷനുകൾ

ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ തിരിച്ചറിയുന്നു metaconfig:

-d ഡീബഗ് മോഡ് ഓണാക്കുക. നിങ്ങൾ ഡീബഗ്ഗിംഗ് ചെയ്യുന്നില്ലെങ്കിൽ ശരിക്കും ഉപയോഗപ്രദമല്ല metaconfig
സ്വയം.

-h സഹായ സന്ദേശം അച്ചടിച്ച് പുറത്തുകടക്കുക.

-k താൽക്കാലിക ഡയറക്‌ടറി സൂക്ഷിക്കുക, അതുവഴി നിങ്ങൾ ഉപയോഗിക്കുന്ന ഫയലുകൾ പരിശോധിക്കാം
metaconfig നിങ്ങളുടെ നിർമ്മിക്കാൻ സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ്. ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ മാത്രം ഉപയോഗപ്രദമാണ്
യൂണിറ്റുകൾ.

-m ധാരാളം മെമ്മറിയും സ്വാപ്പ് സ്പേസും കരുതുക. ഇത് ചിഹ്ന ലുക്ക് അപ്പ് വേഗത്തിലാക്കും
സോഴ്സ് ഫയലുകൾ മെമ്മറിയുടെ ചെലവിൽ ഗണ്യമായ സമയം
ഉപഭോഗം...

-o കാലഹരണപ്പെട്ട ചിഹ്നങ്ങൾ പുതിയവയിൽ മാപ്പ് ചെയ്യുക. നിങ്ങൾക്ക് ഇപ്പോഴും എന്തെങ്കിലും ഉണ്ടെങ്കിൽ ഈ സ്വിച്ച് ഉപയോഗിക്കുക
നിങ്ങളുടെ സോഴ്സ് കോഡിലെ കാലഹരണപ്പെട്ട ചിഹ്നങ്ങൾ നീക്കംചെയ്യാൻ ആഗ്രഹിക്കുന്നില്ല (അല്ലെങ്കിൽ കഴിയില്ല).
ഇപ്പോൾ അവരെ. കാലഹരണപ്പെട്ട ചിഹ്നങ്ങൾ മറ്റുവിധത്തിൽ അവഗണിക്കപ്പെടുന്നു, എന്നിരുന്നാലും
എന്നതിൽ നിന്ന് നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകും metaconfig.

-s നിശബ്ദ മോഡ് ഓണാക്കുക.

-t അവ കണ്ടെത്തിയതുപോലെ അടയാളങ്ങൾ കണ്ടെത്തുക.

-v വെർബോസ് മോഡ് ഓണാക്കുക.

-w ആവശ്യമുള്ള ഫയൽ കാലികമാണെന്ന് കരുതുക. ഇത് സമയവും ഓർമ്മയും ഒഴിവാക്കും
സോഴ്സ് കോഡ് സ്കാനിംഗിന്റെ ഉപഭോഗ ഘട്ടം, അറിയപ്പെടുന്ന ചിഹ്നങ്ങൾക്കായി തിരയുന്നു. ഉപയോഗികുക
എന്നതുമായി ബന്ധപ്പെട്ട് നിങ്ങളുടെ ഉറവിട ഫയൽ മാറിയിട്ടില്ലെന്ന് അറിയുമ്പോൾ മാത്രം
കുളം metaconfig ഉപയോഗിച്ച ചിഹ്നങ്ങൾ.

-G ഒരു ഗ്നു കൂടി നൽകുക കോൺഫിഗർ- ജനറേറ്റുചെയ്തതിന്റെ മുൻഭാഗം പോലെ സജ്ജമാക്കുന്നു
സ്ക്രിപ്റ്റ്, വിതരണത്തിലും ഉൾപ്പെടുത്തണം. ഇതൊരു പൊതിച്ചോറ് മാത്രമാണ്
ചുറ്റും സജ്ജമാക്കുന്നു സ്വാഭാവികമായും സ്ക്രിപ്റ്റ്, പക്ഷേ ഇത് പരിചിതരായ ആളുകളെ അനുവദിക്കുന്നു
ഒരു പുതിയ വിതരണത്തെ അഭിമുഖീകരിക്കുമ്പോൾ GNU ടൂൾ നഷ്ടപ്പെടാതിരിക്കുക.

-L മുതലാളി ഡിഫോൾട്ട് ലൈബ്രറി ലൊക്കേഷൻ അസാധുവാക്കുക. സാധാരണയായി metaconfig-ന് മാത്രം ഉപയോഗപ്രദമാണ്
എന്നതിനുപകരം വികസിപ്പിച്ചുകൊണ്ടിരിക്കുന്ന യൂണിറ്റുകൾ പ്രാദേശികമായി ഉപയോഗിക്കുന്നതിന് പരിപാലിക്കുന്നവർ
പൊതുവായി ലഭ്യമായവ. ദി മുതലാളി യൂണിറ്റുകൾ അടങ്ങുന്ന ഒന്നാണ് വ്യക്തമാക്കിയത്
U ഡയറക്ടറി.

-M എ യുടെ ഉത്പാദനം അനുവദിക്കുക confmagic.h സ്വയമേവ ചിലത് നന്നായി റീമാപ്പ് ചെയ്യാൻ ഫയൽ-
മറ്റ് ചില ബദലുകളിലേക്കുള്ള അറിയപ്പെടുന്ന ചിഹ്നങ്ങൾ bcopy() റീമാപ്പ് ചെയ്യുന്നു
സുതാര്യമായി memcpy() ലഭ്യമല്ലാത്തപ്പോൾ. ഈ ഓപ്ഷൻ ഓണാക്കി
എപ്പോൾ യാന്ത്രികമായി confmagic.h ഫയൽ ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറിയിൽ നിലവിലുണ്ട്.
നിങ്ങൾക്ക് ഈ ഓപ്‌ഷൻ ശാശ്വതമായി പ്രവർത്തനരഹിതമാക്കണമെങ്കിൽ ആ ഫയൽ നീക്കം ചെയ്യുക.

-V പതിപ്പ് നമ്പർ പ്രിന്റ് ചെയ്ത് പുറത്തുകടക്കുക.

TUTORIAL

ഈ (നീണ്ട) ഭാഗം ഒരു ആമുഖമാണ് metaconfig, അതിൽ നമ്മൾ എല്ലാം പഠിക്കും
അടിസ്ഥാനകാര്യങ്ങൾ. എങ്ങനെ ഉപയോഗിക്കണമെന്ന് നിങ്ങൾക്ക് ഇതിനകം അറിയാമെങ്കിൽ metaconfig, നിങ്ങൾക്ക് സുരക്ഷിതമായി അടുത്തതിലേക്ക് പോകാം
വിഭാഗം.

പൊതു അവലോകനം
സാധാരണയായി നിങ്ങളുടെ കൈവശമുള്ള ഒരു പ്ലാറ്റ്‌ഫോമിൽ കംപൈൽ ചെയ്യുന്നതിന് ചില സോഴ്‌സ് പാക്കേജ് ലഭിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ
പ്രധാന Makefile എഡിറ്റുചെയ്യാൻ (ഒന്ന് ഉണ്ടെന്ന് കരുതുക!), ഒരു C കംപൈലർ തിരഞ്ഞെടുക്കുക, നിങ്ങൾ ഉറപ്പാക്കുക
ശരിയായ ലൈബ്രറികൾ ഉണ്ടായിരിക്കുക, തുടർന്ന് വെടിവയ്ക്കുക ഉണ്ടാക്കുക കമാൻഡ്. പാക്കേജ് ന്യായമാണെങ്കിൽ
നന്നായി എഴുതിയിരിക്കുന്നു, അത് കംപൈൽ ചെയ്യും (മുന്നറിയിപ്പ് ഇല്ലാതെ ഒരു ഓപ്ഷൻ :-). അതിൽ തന്നെ അവസാനത്തേത്
ഇന്ന് ലഭ്യമായ വിവിധതരം UNIX പ്ലാറ്റ്‌ഫോമുകൾ കണക്കിലെടുക്കുമ്പോൾ വാക്യം ഒരു യഥാർത്ഥ പ്രകടനമാണ്
രുചികളുടെ വൈവിധ്യവും, അതിനർത്ഥം പാക്കേജിന്റെ രചയിതാവ് ആഴത്തിൽ പോയി എന്നാണ്
ചില സ്റ്റാൻഡേർഡ് ട്രയൽ, ഊഹിക്കൽ, കുഴപ്പങ്ങൾ എന്നിവ നൽകിയിട്ടുള്ള ശരിയായ ചോയിസുകൾ കണ്ടുപിടിക്കാൻ ബുദ്ധിമുട്ട്
സിസ്റ്റവും ഉൾപ്പെടുന്ന തരങ്ങളും.

എന്നിരുന്നാലും, അദ്ദേഹത്തിന്റെ എല്ലാ കഴിവുകളും ഉണ്ടായിരുന്നിട്ടും, ചില സിസ്റ്റങ്ങൾക്ക് ഒരു ഉണ്ടെന്ന് രചയിതാവിന് അറിയാൻ കഴിയില്ല
തകർന്ന സിസ്റ്റം കോൾ, അല്ലെങ്കിൽ ചില സിസ്റ്റം ഘടനയിൽ ഒരു സാധാരണ ഫീൽഡ് ഇല്ല, അല്ലെങ്കിൽ
നൽകിയിരിക്കുന്ന ഉൾപ്പെടുന്ന ഫയൽ നിലവിലുണ്ടോ ഇല്ലയോ എന്നത്. പിന്നെ ഞാൻ പരോക്ഷമായി പരിഗണിക്കുന്നില്ല
അനുമാനങ്ങൾ, നൽകിയ തരം പോലെ malloc () പ്രവർത്തനം അല്ലെങ്കിൽ സാന്നിധ്യം
പേരുമാറ്റുക() കുറച്ച് പേരിടാൻ സിസ്റ്റം കോൾ. എന്നാൽ യാഥാർത്ഥ്യം നേടാൻ ആ അറിവ് ആവശ്യമാണ്
പോർട്ടബിലിറ്റി.

ഇനി നമുക്ക് നമ്മെത്തന്നെ ദുരുപയോഗം ചെയ്യരുത്. ആ വിവരങ്ങൾ ഉപയോഗിക്കുന്നതിന് കൂടുതൽ വൈദഗ്ധ്യം ആവശ്യമാണ്, എന്നിട്ടും അതിന് കഴിയും
കൂടുതൽ പോർട്ടബിൾ പ്രോഗ്രാമുകളിലേക്ക് നയിക്കുന്നു, കാരണം ഇത് ഒരു സിസ്റ്റം-സ്വതന്ത്ര ശൈലിയിൽ എഴുതിയിരിക്കുന്നു
ഒരു പ്രത്യേക സിസ്റ്റത്തിൽ ചില അനുമാനങ്ങൾ ശരിയോ തെറ്റോ ആണെന്ന വസ്തുതയെ മാത്രം ആശ്രയിക്കുന്നു,
ഓരോ അനുമാനവും പരസ്പരം ബന്ധമില്ലാത്തതാണ്. അതായത്, ഞങ്ങൾ പറയുന്നില്ല: ഞങ്ങൾ എയിലാണ്
BSD സിസ്റ്റം അല്ലെങ്കിൽ ഞങ്ങൾ ഒരു USG സിസ്റ്റത്തിലാണ്. ഇന്നത്തെ കാലത്ത് അത് വളരെ അവ്യക്തമാണ്. ഇല്ല, ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
സോഴ്സ് കോഡിനോട് പറയുക: ഈ സിസ്റ്റത്തിന് ഇല്ല പേരുമാറ്റുക() സിസ്റ്റം കോൾ കൂടാതെ malloc ()
തിരികെ നൽകുന്നു a (അസാധു *) മൂല്യം.

Metaconfig ഒരു ടൂളാണ്, അത് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നില്ല, അല്ല എന്നതിന്റെ അധിക നേട്ടം
എല്ലാം ശരിയാണെങ്കിൽ Makefile കൈകൊണ്ട് എഡിറ്റ് ചെയ്യണം. ഓടിക്കൊണ്ട് metaconfig, നിങ്ങൾ ഒരു സൃഷ്ടിക്കുക
ഷെൽ സ്ക്രിപ്റ്റ് എന്ന പേര് സജ്ജമാക്കുന്നു. സ്ക്രിപ്റ്റ് കോൺഫിഗർ ചെയ്യുന്നതിനായി ധാരാളം ശ്രമങ്ങൾ നടത്തിയിട്ടുണ്ട്
നിലവിൽ ലഭ്യമായ ഷെല്ലുകളുടെ 99% ലും ഇത് പ്രവർത്തിക്കുമെന്ന് ഉറപ്പാക്കാൻ ഇന്റേണലുകൾ
എഴുത്തു. കോൺഫിഗർ ചെയ്യുക ടാർഗെറ്റ് സിസ്റ്റം അന്വേഷിക്കും, സംശയം തോന്നുമ്പോൾ ചോദ്യങ്ങൾ ചോദിക്കും
എല്ലാ ഉത്തരങ്ങളും ഒരൊറ്റ ഷെൽ ഫയലിൽ ശേഖരിക്കുക, അത് ഉപയോഗിക്കാം
കോൺഫിഗർ ചെയ്‌ത മേക്ക്‌ഫയലുകളും സി ഉൾപ്പെടുന്ന ഫയലുകളും സ്വയമേവ സൃഷ്‌ടിക്കുന്നു.

നിങ്ങളുടെ ഷെൽ സ്ക്രിപ്റ്റുകൾക്ക് പരിമിതമായ (എന്നാൽ വളരെ വലിയ) ചിഹ്നങ്ങൾ മാത്രമേ ലഭ്യമുള്ളൂ
സി പ്രോഗ്രാമുകളും. അവയെല്ലാം ഗ്ലോസറി ഫയലിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്. പഠിച്ചാൽ മതി
അവയെ കുറിച്ച്, പോർട്ടബിലിറ്റി, കോൺഫിഗറേഷൻ പ്രശ്നങ്ങൾ എന്നിവ പരിഹരിക്കുന്നതിന് അവ ഉപയോഗിക്കാൻ തുടങ്ങുക. പിന്നെ,
ഓടുന്നതിലൂടെ metaconfig, നിങ്ങളുടെ പാക്കേജിനായി അനുയോജ്യമായ ഒരു കോൺഫിഗർ സ്ക്രിപ്റ്റ് ജനറേറ്റ് ചെയ്യും.

കോൺഫിഗർ സ്ക്രിപ്റ്റ് നിരവധി യൂണിറ്റുകൾ (300-ൽ കൂടുതൽ) നിർമ്മിച്ചിരിക്കുന്നു, ഓരോ യൂണിറ്റും
ഒരു ചെറിയ എണ്ണം ഷെൽ കൂടാതെ/അല്ലെങ്കിൽ സി ചിഹ്നങ്ങൾ നിർവചിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം. യൂണിറ്റുകൾ കൂട്ടിച്ചേർക്കുന്നു
അവസാന ഘട്ടത്തിൽ, ഡിപൻഡൻസി ഗ്രാഫ് മാനിക്കുന്നു (ഒരു യൂണിറ്റിന് ഫലം ആവശ്യമായി വന്നേക്കാം
സ്ക്രിപ്റ്റിൽ മുമ്പ് സ്ഥാപിക്കുന്ന മറ്റ് നിരവധി യൂണിറ്റുകളുടെ).

ചിഹ്നങ്ങൾ
അതിൽ ഏറ്റവും പ്രധാനപ്പെട്ടത് ചിഹ്നങ്ങളാണ് metaconfig ലോകം. അവ ഏറ്റവും ചെറുതാണ്
അംഗീകൃത എന്റിറ്റി, സാധാരണയായി ഒരു വാക്ക്, കോൺഫിഗറിന്റെ അവസാനം ഒരു മൂല്യം നൽകാം
വധശിക്ഷ. ഉദാഹരണത്തിന്, സി പ്രീ-പ്രോസസർ ചിഹ്നം HAS_RENAME ഒരു ആണ് metaconfig അതിന്റെ പ്രതീകം
എങ്കിൽ മാത്രമേ നിർവചിക്കാവൂ എന്ന് ഉറപ്പുനൽകുന്നു പേരുമാറ്റുക() സിസ്റ്റം കോൾ നിലവിലുണ്ട്. അതുപോലെ,
The $ranlib ഷെൽ വേരിയബിൾ ':' അല്ലെങ്കിൽ 'ranlib' എന്നതാണോ എന്നതിനെ ആശ്രയിച്ച് സജ്ജീകരിക്കും
എന്നതിലേക്ക് വിളിക്കുക ranlib ഒരു ലൈബ്രറി ഫയൽ ഓർഡർ ചെയ്യാൻ പ്രോഗ്രാം ആവശ്യമാണ്. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതല്ല
ഇപ്പോൾ പ്രധാനമാണ്, ആ ചിഹ്നങ്ങൾ a നൽകിയിട്ടുണ്ടെന്ന് മനസ്സിലാക്കുക എന്നതാണ് പ്രധാനം ജീവന്
(അതായത് ഒരു മൂല്യം). സജ്ജമാക്കുന്നു വധശിക്ഷ.

ചിഹ്നങ്ങൾ ഉപയോഗിക്കുന്നത് താരതമ്യേന ലളിതമാണ്. ഒരു സി സോഴ്സ് ഫയലിൽ, നിങ്ങൾ ചിഹ്നം ഉപയോഗിക്കുക
മൂല്യം, ഒരു പ്രീ-പ്രോസസർ നിർദ്ദേശം പോലെ (ഉദാഹരണത്തിന്: #ifdef HAS_RENAME) അല്ലെങ്കിൽ, ചിഹ്നമാണെങ്കിൽ
മൂല്യം ഒരു സ്ട്രിംഗ് ആണ്, നിങ്ങൾ C-യിലും ഷെൽ ഫയലിലോ a-യിലോ മാക്രോ ഉപയോഗിക്കുന്നത് പോലെ നേരിട്ട്
Makefile, നിങ്ങൾക്ക് ഒരു ഷെൽ ചിഹ്നം നേരിട്ട് പരാമർശിക്കാം.

യഥാർത്ഥത്തിൽ, ഞാൻ കള്ളം പറയുകയാണ്, കാരണം അത് മുമ്പത്തെ ഖണ്ഡിക പോലെ പൂർണ്ണമായും മാന്ത്രികമല്ല
ശബ്ദം കേൾക്കാമായിരുന്നു. ഒരു C ഫയലിൽ, നിങ്ങൾ കോൺഫിഗർ-പ്രൊഡ്യൂസ്ഡ് ഉൾപ്പെടുത്തേണ്ടതുണ്ട് config.h ഫയൽ, ഒപ്പം
നിങ്ങളുടെ ഷെൽ സ്‌ക്രിപ്‌റ്റോ മേക്ക്‌ഫൈലോ ഒരു .SH ഫയലിൽ പൊതിയണം, നിങ്ങൾക്ക് ഷെല്ലിനെ പരാമർശിക്കാം
ആ .SH ഫയലിന്റെ വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ ഭാഗത്ത് മാത്രം ചിഹ്നം. ഇതിനെക്കുറിച്ച് കൂടുതൽ പിന്നീട്.

ഉറവിടം ഫയലുകൾ
പരിമിതമായ ഉറവിട ഫയലുകളിൽ മാത്രമേ ചിഹ്നങ്ങൾ ദൃശ്യമാകൂ, കാരണം metaconfig മാത്രം ചെയ്യും
അറിയപ്പെടുന്ന ചിഹ്നങ്ങൾക്കായി തിരയുമ്പോൾ അവ സ്കാൻ ചെയ്യുക, അതിന് ഏതൊക്കെ യൂണിറ്റുകൾ ആവശ്യമാണെന്ന് കണ്ടുപിടിക്കാൻ ശ്രമിക്കുക.
നിങ്ങൾക്ക് സി സോഴ്‌സ് ഫയലുകളിൽ സി ചിഹ്നങ്ങൾ ഉപയോഗിക്കാം, അതായത് എ ഉള്ള ഫയലുകൾ .c, .h, .y or .l വിപുലീകരണം, കൂടാതെ
ഷെൽ ചിഹ്നങ്ങൾ .SH ഫയലുകളിൽ മാത്രം തിരയുന്നു.

ഒരു ചിഹ്നത്തിന്റെ മൂല്യം ലഭിക്കുന്നതിന്, ഒരു C ഫയലിൽ പ്രത്യേകം ഉൾപ്പെടുത്തേണ്ടതുണ്ട് config.h
ഫയൽ, നിർമ്മിക്കുന്നത് സജ്ജമാക്കുന്നു സി ചിഹ്നങ്ങൾ ഉള്ളപ്പോൾ. കൂടാതെ .SH ഫയലുകൾ റൺ ചെയ്യുന്നു
ഒരു ഷെല്ലിലൂടെ, ഒരു പുതിയ ഫയൽ നിർമ്മിക്കുന്നു. എന്നിരുന്നാലും, .SH ഫയലിന്റെ മുകളിലെ വിഭാഗത്തിൽ, the
പ്രത്യേക config.sh ഫയൽ (ഓട്ടം വഴിയും നിർമ്മിക്കുന്നു സജ്ജമാക്കുന്നു) ഉറവിടവും വേരിയബിളുമാണ്
പകരക്കാർ ബാധകമാണ്. യഥാർത്ഥത്തിൽ, config.h പ്രവർത്തിപ്പിച്ചാണ് നിർമ്മിക്കുന്നത് metaconfig- നിർമ്മിച്ചത്
config_h.SH ഫയൽ, വീണ്ടും വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ ഉപയോഗിച്ച്. അതിനാൽ ഞങ്ങൾ അത് നോക്കാൻ പോകുന്നു a
ഇത് മൊത്തത്തിലുള്ള ഹൃദയമായതിനാൽ കുറച്ചുകൂടി അടുത്ത് കോൺഫിഗറേഷൻ പദ്ധതി...

വേരിയബിൾ ഉപവിഭാഗം
എന്ന് വിളിക്കപ്പെടുന്ന ഷെൽ നിർമ്മാണമുണ്ട് ഇവിടെ പ്രമാണം ഒരു ഇൻപുട്ട് എടുക്കാൻ ഒരു കമാൻഡ് പ്രാപ്തമാക്കുന്നു
സ്ക്രിപ്റ്റിൽ തന്നെ വ്യക്തമാക്കിയിട്ടുണ്ട്. ആ ഇൻപുട്ടിനെ ഷെൽ ഇരട്ടിയായി വ്യാഖ്യാനിക്കുന്നു.
ഇവിടെയുള്ള ഡോക്യുമെന്റിന്റെ രൂപത്തെ ആശ്രയിച്ച് ഉദ്ധരിച്ച സ്ട്രിംഗ് അല്ലെങ്കിൽ ഒരൊറ്റ ഉദ്ധരണി സ്ട്രിംഗ്
സവിശേഷത.

ഇവിടെ ഒരു ഡോക്യുമെന്റ് വ്യക്തമാക്കുന്നതിന്, '<<' ടോക്കൺ ഉപയോഗിക്കുന്നു, തുടർന്ന് ഒരൊറ്റ ഐഡന്റിഫയർ. നിന്ന്
തുടർന്ന്, ഇവിടെ വരെ ശേഷിക്കുന്ന സ്ക്രിപ്റ്റ് ലൈനുകൾ കമാൻഡിനുള്ള ഇൻപുട്ടായി മാറുന്നു
പ്രമാണം ഒരു വരിയിൽ തന്നെ കാണപ്പെടുന്നു. ഷെൽ സബ്സ്റ്റിറ്റ്യൂഷൻ (ഷെൽ വേരിയബിൾ ഉൾപ്പെടെ
ഐഡന്റിഫയർ ഒറ്റ ഉദ്ധരണികളാൽ ചുറ്റപ്പെട്ടിട്ടില്ലെങ്കിൽ സബ്സ്റ്റിറ്റ്യൂഷനുകൾ) ചെയ്യപ്പെടും. ഉദാഹരണത്തിന്:

var='ആദ്യം'
ടാർ='രണ്ടാം'
echo "--> ആദ്യം ഇവിടെ പ്രമാണം:"
പൂച്ച <
var='$var'
ടാർ='$tar'
OEM
പ്രതിധ്വനി "--> ഇവിടെ രണ്ടാമത്തേത് പ്രമാണം:"
പൂച്ച <<'EOM'
പ്രതിധ്വനി $var
പ്രതിധ്വനി $tar
OEM
പ്രതിധ്വനി "--> അവസാനം."

ഒരു ഷെല്ലിലൂടെ ഓടുമ്പോൾ ഉൽപ്പാദിപ്പിക്കും:

--> ആദ്യം ഇവിടെ പ്രമാണം:
var='ആദ്യം'
ടാർ='രണ്ടാം'
--> ഇവിടെ രണ്ടാമത്തേത് പ്രമാണം:
പ്രതിധ്വനി $var
പ്രതിധ്വനി $tar
--> അവസാനം.

ഇവിടെ ആദ്യത്തേത് അതിന്റെ ഉള്ളടക്കത്തെ വ്യാഖ്യാനിക്കുന്നു, രണ്ടാമത്തേത് ഔട്ട്‌പുട്ട് ഇതുപോലെയാണ്.
നമ്മൾ കാണാൻ പോകുന്നതുപോലെ, രണ്ടും .SH സ്ക്രിപ്റ്റിൽ ഉപയോഗപ്രദമാണ്.

ഉപയോഗിക്കുന്നു .എസ്.എച്ച് സ്ക്രിപ്റ്റുകൾ
ഒരു .SH സ്ക്രിപ്റ്റ് സാധാരണയായി പ്രവർത്തിപ്പിച്ചാണ് നിർമ്മിക്കുന്നത് MakeSH സ്ക്രിപ്റ്റ് മറ്റൊന്ന് നിലവിലുള്ള ഫയൽ,
പരിവർത്തനം ചെയ്യുന്നു ഫയല് ഒരു file.SH. ഒരൊറ്റ ഉദാഹരണമെടുക്കാം. ഇതാ ഒരു ചെറിയ തിരക്കഥ
(നമുക്ക് വിളിക്കാം intsize) ഇത് ഒരൊറ്റ സന്ദേശം പ്രിന്റ് ചെയ്യുന്നു, അതിന്റെ വലുപ്പം int സിയിലെ ഡാറ്റാ ടൈപ്പ്
ദൗർഭാഗ്യവശാൽ, അതിന് ശക്തമായ മൂല്യമുണ്ട്, അതിനാൽ:

#!/ bin / sh
intsize='4'
പ്രതിധ്വനി "ഈ മെഷീനിൽ, int തരം $intsize bytes ആണ്"

ഓടാം ഉണ്ടാക്കുക അതിൽ ' എന്ന് ടൈപ്പ് ചെയ്യുകഉണ്ടാക്കുക intsize'. നമുക്ക് ഒരു സിംഗിൾ ലഭിക്കും intsize.SH അത് ഫയൽ ചെയ്യുക
ഇത് പോലെ തോന്നുന്നു:

കേസ് $CONFIG ഇൻ
'')
ടെസ്റ്റ് എങ്കിൽ -f config.sh; അപ്പോൾ TOP=.;
elif ടെസ്റ്റ് -f ../config.sh; അപ്പോൾ TOP=..;
elif ടെസ്റ്റ് -f ../../config.sh; അപ്പോൾ TOP=../..;
elif ടെസ്റ്റ് -f ../../../config.sh; അപ്പോൾ TOP=../../..;
elif ടെസ്റ്റ് -f ../../../../config.sh; അപ്പോൾ TOP=../../../..;
മറ്റാരെങ്കിലും
echo "config.sh കണ്ടെത്താൻ കഴിയുന്നില്ല."; പുറത്തുകടക്കുക 1
fi
. $TOP/config.sh
;;
സി
: SH ഫയലിന്റെ അതേ ഡയറക്ടറിയിൽ ടാർഗെറ്റ് സൃഷ്ടിക്കാൻ ഇത് SH ഫയലുകളെ പ്രേരിപ്പിക്കുന്നു.
: SH ഡെറിവേറ്റീവുകൾ എവിടെയാണ് കണ്ടെത്തേണ്ടതെന്ന് മേക്ക് ഡിപൻഡന്റിന് എപ്പോഴും അറിയാൻ വേണ്ടിയാണിത്.
കേസ് "$ 0" ൽ
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
സി
പ്രതിധ്വനി "ഇൻസൈസ് എക്‌സ്‌ട്രാക്റ്റിംഗ് (വേരിയബിൾ സബ്‌സ്റ്റിറ്റ്യൂഷനുകൾക്കൊപ്പം)"
: ഫയലിന്റെ ഈ വിഭാഗത്തിൽ വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷനുകൾ ഉണ്ടായിരിക്കും.
: !ഇല്ല!SUBS! !ഗ്രോക്ക്!ഇത്!
: നിങ്ങൾ വ്യാഖ്യാനിക്കാൻ ആഗ്രഹിക്കാത്ത ഏതെങ്കിലും ഡോളർ ചിഹ്നങ്ങളും ബാക്ക്ടിക്കുകളും സംരക്ഷിക്കുക
: മുന്നിൽ ഒരു ബാക്ക്സ്ലാഷ് ഇട്ടുകൊണ്ട്. നിങ്ങൾക്ക് ഈ കമന്റുകൾ ഇല്ലാതാക്കാം.
$spitshell >intsize <
$startsh
!ഗ്രോക്ക്!ഇത്!

: ഇനിപ്പറയുന്ന ഡോളറുകളിലും ബാക്ക്ടിക്കുകളിലും അധിക ബാക്ക്സ്ലാഷ് ആവശ്യമില്ല.
$spitshell >>intsize <<'!NO!SUBS!'
intsize='4'
പ്രതിധ്വനി "ഈ മെഷീനിൽ, int തരം $intsize bytes ആണ്"
!ഇല്ല!SUBS!
chmod 755 intsize
$eunicefix intsize

ഈ സ്ക്രിപ്റ്റിന്റെ ആദ്യ ഭാഗം (ഇൽ കേസ് പ്രസ്താവന) കണ്ടെത്താൻ ശ്രമിക്കുന്നു config.sh
ഫയൽ, അത് ഉറവിടമാക്കുന്നതിന്. ദി $CONFIG വേരിയബിൾ സ്ഥിരസ്ഥിതിയായി തെറ്റാണ്, എപ്പോൾ ശരിയാണ്
config.sh ഇതിനകം സ്രോതസ്സുചെയ്‌തു (ഈ ഫയൽ എക്‌സിക്യൂട്ട് ചെയ്‌താൽ അത് സംഭവിക്കും
ഉള്ളിൽ സജ്ജമാക്കുന്നു തന്നെ, പക്ഷേ ഇവിടെ പ്രശ്നം ആശയക്കുഴപ്പത്തിലാക്കരുത്).

ഒരിക്കൽ ഒരു config.sh ഫയൽ ഉറവിടങ്ങളാണ്, എല്ലാ ഷെൽ ചിഹ്നങ്ങളും നിർവചിച്ചിരിക്കുന്നത് സജ്ജമാക്കുന്നു ആകുന്നു
സെറ്റ്. നിലവിലെ ഡയറക്‌ടറി മാറ്റാൻ ഉപയോഗിക്കുന്ന രണ്ടാമത്തെ കേസ് സ്റ്റേറ്റ്‌മെന്റിൽ എത്തുമെന്ന് ഞങ്ങൾക്കറിയാം a
ഈ പ്രോഗ്രാമിൽ എത്തിച്ചേരാൻ പാത ഉപയോഗിക്കുന്നു (ഉദാഹരണത്തിന് ഞങ്ങൾ പറഞ്ഞാൽ 'sh ../scripts/intsize.SH', ഞങ്ങൾ
ആദ്യം ഓടും'cd ../സ്ക്രിപ്റ്റുകൾ' തുടരുന്നതിന് മുമ്പ്). നിങ്ങൾക്ക് ഇത് മനസ്സിലായില്ലെങ്കിൽ, ചെയ്യരുത്
അതിനെക്കുറിച്ച് വിഷമിക്കേണ്ട.

രസകരമായ കാര്യങ്ങൾ ഇതാ വരുന്നു. ഈ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു $സ്പിറ്റ്ഷെൽ വേരിയബിൾ, അത് അല്ല
നമുക്ക് അറിയാവുന്ന ഒന്ന്...ഇപ്പോഴും. നിങ്ങൾ ഗ്ലോസറി ഫയലിലൂടെ നോക്കിയാൽ, അത് നിങ്ങൾ കാണും
ഇത് അറിയപ്പെടുന്ന ഒരു വേരിയബിൾ ആണ് metaconfig. ഈ ഫയൽ നിങ്ങളുടെ വിതരണത്തിന്റെ ഭാഗമാക്കുകയാണെങ്കിൽ
(ഇത് MANIFEST.new ഫയലിൽ ഉൾപ്പെടുത്തിക്കൊണ്ട്, ഞങ്ങൾ പിന്നീട് അതിലേക്ക് മടങ്ങിവരും) തുടർന്ന് പ്രവർത്തിപ്പിക്കുക
metaconfig, പിന്നെ സജ്ജമാക്കുന്നു ഈ വേരിയബിളിന് അനുയോജ്യമായ ഒരു മൂല്യം സ്ക്രിപ്റ്റ് നിർണ്ണയിക്കും
അതു സജ്ജീകരിക്കുകയും ചെയ്യും config.sh. അതുപോലെ തന്നെ $startsh നിഗൂഢവും $eunicefix at
അവസാനം. ന്യായമായ സംവിധാനത്തിൽ, പ്രസക്തമായ ഭാഗം config.sh ഇതുപോലെ കാണപ്പെടും:

സ്പിറ്റ്ഷെൽ='പൂച്ച'
startsh='#!/ bin / sh'
eunicefix=':'

ആഹ്! ഞങ്ങൾ അവിടെ എത്തുകയാണ്. ഇപ്പോൾ അത് പരിചിതമാണെന്ന് തോന്നുന്നു. ഞങ്ങൾ ഒറ്റയാളെ അഭിമുഖീകരിക്കുകയാണ് പൂച്ച ആരുടെ കമാൻഡ്
ഇൻപുട്ട് വരുന്നത് വേരിയബിൾ-ഇന്റർപോളേറ്റഡ് ഹിയർ ഡോക്യുമെന്റിൽ നിന്നാണ്, അതിന്റെ ഔട്ട്പുട്ട് റീഡയറക്‌ട് ചെയ്‌തിരിക്കുന്നു
intsize. എന്നതായിരിക്കും മൂല്യം $startsh, അതായത് '#!/ bin / sh'. ഇതുവരെ നന്നായി.

തുടർന്ന് സ്‌ക്രിപ്റ്റിന്റെ ശേഷിക്കുന്ന ഭാഗം ലഭിക്കുന്നതിന് ഞങ്ങൾ ഇവിടെ രണ്ടാമത്തെ ഡോക്യുമെന്റ് വിപുലീകരണത്തിലേക്ക് എത്തുന്നു. ഈ
സമയം, ഇവിടെയുള്ള പ്രമാണ ചിഹ്നം ഒറ്റ ഉദ്ധരണികളാൽ ചുറ്റപ്പെട്ടിരിക്കുന്നു, അതിനാൽ ഉള്ളടക്കം ആയിരിക്കും
എന്നതിലേക്ക് അക്ഷരാർത്ഥത്തിൽ ചേർത്തു intsize ഫയൽ. അതിനാൽ, ഓടിക്കൊണ്ട് 'sh intsize.SH', നമുക്ക് ലഭിക്കുന്നു
ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട്:

ഇൻസൈസ് എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നു (വേരിയബിൾ സബ്‌സ്റ്റിറ്റ്യൂഷനുകൾക്കൊപ്പം)

നിർമ്മിച്ച intsize ഫയൽ നോക്കുന്നതിലൂടെ, നമ്മൾ കാണുന്നത്:

#!/ bin / sh
intsize='4'
പ്രതിധ്വനി "ഈ മെഷീനിൽ, int തരം $intsize bytes ആണ്"

തുടക്കത്തിൽ ഞങ്ങൾക്ക് ഉണ്ടായിരുന്നത് അതാണ്. ഇതുവരെ, ഇത് ഒരു നോ-ഓപ്പറേഷൻ നടപടിക്രമമാണ് ...
പക്ഷേ, എത്ര അത്ഭുതകരം! അത് അങ്ങനെ സംഭവിക്കുന്നു (ശുദ്ധമായ യാദൃശ്ചികം, എന്നെ വിശ്വസിക്കൂ!), അത് metaconfig അറിയാം
കുറിച്ച് $intsize ഷെൽ ചിഹ്നം. intsize ന്റെ സമാരംഭം വേരിയബിളിലേക്ക് നീക്കുന്നതിലൂടെ-
.SH സ്‌ക്രിപ്‌റ്റിന്റെ ഇന്റർപോളേറ്റഡ് ഏരിയയും അത് ഉപയോഗിച്ച് സമാരംഭിക്കുകയും ചെയ്യുന്നു സജ്ജമാക്കുന്നു- കണക്കാക്കിയ മൂല്യം,
ഒപ്പം ചേർത്ത ഇപ്പോൾ ഉപയോഗശൂന്യമായ കമന്റുകൾ നീക്കം ചെയ്യുന്നു ഉണ്ടാക്കുക, നമുക്ക് ലഭിക്കുന്നത്:

കേസ് $CONFIG ഇൻ
'')
ടെസ്റ്റ് എങ്കിൽ -f config.sh; അപ്പോൾ TOP=.;
elif ടെസ്റ്റ് -f ../config.sh; അപ്പോൾ TOP=..;
elif ടെസ്റ്റ് -f ../../config.sh; അപ്പോൾ TOP=../..;
elif ടെസ്റ്റ് -f ../../../config.sh; അപ്പോൾ TOP=../../..;
elif ടെസ്റ്റ് -f ../../../../config.sh; അപ്പോൾ TOP=../../../..;
മറ്റാരെങ്കിലും
echo "config.sh കണ്ടെത്താൻ കഴിയുന്നില്ല."; പുറത്തുകടക്കുക 1
fi
. $TOP/config.sh
;;
സി
കേസ് "$ 0" ൽ
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
സി
പ്രതിധ്വനി "ഇൻസൈസ് എക്‌സ്‌ട്രാക്റ്റിംഗ് (വേരിയബിൾ സബ്‌സ്റ്റിറ്റ്യൂഷനുകൾക്കൊപ്പം)"
$spitshell >intsize <
$startsh
intsize='$intsize'
!ഗ്രോക്ക്!ഇത്!

$spitshell >>intsize <<'!NO!SUBS!'
പ്രതിധ്വനി "ഈ മെഷീനിൽ, int തരം $intsize bytes ആണ്"
!ഇല്ല!SUBS!
chmod 755 intsize
$eunicefix intsize

തീർച്ചയായും, ഒരു ഷെല്ലിലൂടെ ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നത് അതേ സ്ക്രിപ്റ്റ് വീണ്ടും ഔട്ട്പുട്ട് ചെയ്യും. പക്ഷേ ചിലപ്പോള
ഞങ്ങൾ ഓടുന്നു സജ്ജമാക്കുന്നു ഒരു മെഷീനിൽ എവിടെ ഒരു int 64 ബിറ്റുകളുടെ അളവിൽ സംഭരിച്ചിരിക്കുന്നു, config.sh ഉദ്ദേശിക്കുന്ന
ഗണം intsize 8 വരെ intsize സ്ക്രിപ്റ്റ് ശരിയായ മൂല്യവും പ്രിന്റും വഹിക്കും:

ഈ മെഷീനിൽ, int തരം 8 ബൈറ്റുകൾ ആണ്

ഏതാണ് ശരി. അഭിനന്ദനങ്ങൾ! ഞങ്ങൾ ഒരു ഷെൽ സ്ക്രിപ്റ്റ് കോൺഫിഗർ ചെയ്‌തു!!

നിർമ്മിക്കുന്നു config.h
ഇനി നമുക്ക് വഴി നോക്കാം config.h നിന്ന് ഉത്പാദിപ്പിക്കപ്പെടുന്നു config_h.SH. അത് ഞങ്ങൾക്കറിയാം
പ്രവർത്തിക്കുന്ന സജ്ജമാക്കുന്നു a ഉൽ‌പാദിപ്പിക്കുന്നു config.sh സ്ക്രിപ്റ്റ് (ഇത് എങ്ങനെ കൃത്യമായി ചെയ്യപ്പെടുന്നു എന്നത് കർശനമല്ല
ഇവിടെ പ്രസക്തമാണ്, എന്നാൽ ജിജ്ഞാസുക്കൾക്ക്, ഇവിടെയുള്ള മറ്റൊരു ഡോക്യുമെന്റ് സബ്സ്റ്റിറ്റ്യൂഷനാണിത്
സജ്ജമാക്കുന്നു സ്വയം). ദി config_h.SH സ്വയം നിർമ്മിച്ചതാണ് metaconfig അതേ സമയം തന്നെ
സജ്ജമാക്കുന്നു നിങ്ങളുടെ സ്രോതസ്സുകളിൽ കുറഞ്ഞത് ഒരു സി ചിഹ്നമെങ്കിലും ഉപയോഗിച്ചാൽ.

നമുക്ക് ചില യാദൃശ്ചികത നോക്കാം config_h.SH യഥാർത്ഥത്തിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണാൻ ഫയൽ:

കേസ് $CONFIG ഇൻ
'')
ടെസ്റ്റ് എങ്കിൽ -f config.sh; അപ്പോൾ TOP=.;
elif ടെസ്റ്റ് -f ../config.sh; അപ്പോൾ TOP=..;
elif ടെസ്റ്റ് -f ../../config.sh; അപ്പോൾ TOP=../..;
elif ടെസ്റ്റ് -f ../../../config.sh; അപ്പോൾ TOP=../../..;
elif ടെസ്റ്റ് -f ../../../../config.sh; അപ്പോൾ TOP=../../../..;
മറ്റാരെങ്കിലും
echo "config.sh കണ്ടെത്താൻ കഴിയുന്നില്ല."; പുറത്തുകടക്കുക 1
fi
. $TOP/config.sh
;;
സി
കേസ് "$ 0" ൽ
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
സി
പ്രതിധ്വനി "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_
#define_config_h_

/* bcopy:
* bcopy() ദിനചര്യ ഇല്ലെങ്കിൽ ഈ ചിഹ്നം memcpy-യിലേക്ക് മാപ്പ് ചെയ്‌തിരിക്കുന്നു
* സ്ട്രിംഗുകൾ പകർത്താൻ ലഭ്യമാണ്.
*/
/* HAS_BCOPY:
* bcopy() ദിനചര്യ ലഭ്യമാണെങ്കിൽ ഈ ചിഹ്നം നിർവചിക്കപ്പെടുന്നു
* മെമ്മറി ബ്ലോക്കുകൾ പകർത്തുക. താഴെ ഈ ചിഹ്നം ഉപയോഗിക്കരുത്
* സാധാരണ സാഹചര്യങ്ങളും പകരം നേരിട്ട് bcopy() ഉപയോഗിക്കുക, ഏത്
* bcopy ലഭ്യമല്ലെങ്കിൽ memcpy() ലേക്ക് മാപ്പ് ചെയ്യപ്പെടും.
*/
#$d_bcopy HAS_BCOPY /**/
#ifndef HAS_BCOPY
#ifdef bcopy
#un-def bcopy
#അവസാനം
#define bcopy(s,d,l) memcpy((d),(s),(l)) /* memcpy ലേക്ക് മാപ്പ് ചെയ്‌തു */
#അവസാനം

/* HAS_DUP2:
* ഈ ചിഹ്നം, നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, ഡ്യൂപ്പ്2 ദിനചര്യ എന്ന് സൂചിപ്പിക്കുന്നു
* ഡ്യൂപ്ലിക്കേറ്റ് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾക്ക് ലഭ്യമാണ്.
*/
#$d_dup2 HAS_DUP2 /**/

/* I_STRING:
* ഈ ചിഹ്നം, നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, അത് സി പ്രോഗ്രാമിനെ സൂചിപ്പിക്കുന്നു
* ഉൾപ്പെടുന്നു (USG സിസ്റ്റങ്ങൾ) പകരം (ബിഎസ്ഡി സംവിധാനങ്ങൾ).
*/
#$i_string I_STRING /**/

#അവസാനം
!ഗ്രോക്ക്!ഇത്!

ഫയലിന്റെ മുകളിൽ, ഞങ്ങൾ ഇതിനകം ഉള്ള സ്റ്റാൻഡേർഡ് .SH നിർമ്മാണം ഞങ്ങൾ തിരിച്ചറിയുന്നു
വിശദമായി പഠിച്ചു. അടുത്തതായി ഫയലിന്റെ എക്‌സ്‌ട്രാക്‌ഷൻ വരുന്നു, ഇവിടെയുള്ള ഒരു ഡോക്യുമെന്റ് വഴി
വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷനുകൾ. എന്നിരുന്നാലും, ഇവിടെ ഞങ്ങൾ ഒരു സമതലം ഉപയോഗിക്കുന്നില്ല പൂച്ച എന്നാൽ ഒരു sed പകരം, മുതൽ
ഞങ്ങൾ ഈ ഫ്ലൈയിൽ കുറച്ചുകൂടി എഡിറ്റിംഗ് നടത്തേണ്ടതുണ്ട്. എന്തുകൊണ്ടെന്ന് പിന്നീട് നോക്കാം, അതിനാൽ നമുക്ക് മറക്കാം
അതിനെക്കുറിച്ച് ഇപ്പോൾ.

ഞങ്ങൾ ഇപ്പോൾ മുൻനിര അഭിപ്രായത്തിൽ എത്തി, ഫയൽ കോൺഫിഗറേഷൻ സമയം ഉപയോഗിച്ച് ടാഗ് ചെയ്‌തിരിക്കുന്നു, the
ടാർഗെറ്റ് സിസ്റ്റം, മുതലായവ... (ആ വേരിയബിളുകൾ ഉറവിടത്തിൽ നിന്ന് വരുന്നു config.sh ഫയൽ ചെയ്തിട്ടുണ്ട്
സ്ഥാപിച്ചത് സജ്ജമാക്കുന്നു). ആ കമന്റ് ഹെഡറിന് ശേഷം ഒരു '#ifndef' പരിരക്ഷയുണ്ട്
ഈ ഫയലിന്റെ ഒന്നിലധികം ഉൾപ്പെടുത്തലുകൾക്കെതിരെ. അപ്പോൾ ഫയലിന്റെ ഹൃദയം വരുന്നു ...

അത് അറിയാൻ സഹായിക്കുന്നു $d_* ഒപ്പം $i_* വേരിയബിളുകൾ ഒന്നുകിൽ സജ്ജീകരിച്ചിരിക്കുന്നു 'നിര്വചിക്കുക' അഥവാ 'undef' വഴി
സജ്ജമാക്കുന്നു, ഒരു ഫംഗ്‌ഷനോ ഉൾപ്പെടുത്തിയ ഫയലോ സിസ്റ്റത്തിൽ ഉണ്ടോ അല്ലെങ്കിൽ
അല്ല. അതിനർത്ഥം:

#$d_bcopy HAS_BCOPY /**/

ലൈൻ ഒന്നിലേക്ക് വികസിപ്പിക്കും:

#HAS_BCOPY നിർവ്വചിക്കുക /**/

$d_bcopy വേരിയബിൾ 'നിർവചിക്കുക' അല്ലെങ്കിൽ:

#undef HAS_BCOPY /**/

$d_bcopy 'undef' ആയി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, കാരണം ഫീച്ചർ ഇല്ലായിരുന്നു. എന്നിരുന്നാലും, അങ്ങനെയല്ല
എന്താണ് എഴുതിയിരിക്കുന്നത് config.h ഫയൽ കാരണം sed ഞങ്ങൾ ഇതിനകം കണ്ട ഫിൽട്ടർ,
ഇത് രണ്ടാമത്തെ രൂപത്തെ രൂപാന്തരപ്പെടുത്തും:

/*#HAS_BCOPY നിർവ്വചിക്കുക /**/

പിന്നീടുള്ള എഡിറ്റിംഗിനുള്ള ഒരു സുലഭമായ രൂപമാണിത് config.h കാരണം നിങ്ങൾ നീക്കം ചെയ്യേണ്ടതുണ്ട്
നിങ്ങൾ അസാധുവാക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ '/*' നയിക്കുന്നു സജ്ജമാക്കുന്നുന്റെ തിരഞ്ഞെടുപ്പ്. അതുപോലെ, നിങ്ങൾക്ക് ഒറ്റത്തവണ ചേർക്കാം
ഒരു പ്രത്യേക ചിഹ്നത്തിന്റെ നിർവചനം ഒഴിവാക്കാൻ '#define' വരിയുടെ തുടക്കത്തിൽ '/*'.
അതുകൊണ്ടാണ് ഓരോ ചിഹ്ന നിർവചനവും മുൻനിരയിലുള്ളത് അടയ്‌ക്കുന്നതിന് '/**/' എന്ന ട്രെയിലിംഗ് ഉപയോഗിച്ച് പരിരക്ഷിച്ചിരിക്കുന്നത്
അഭിപ്രായം തുറന്നത് '/*' (അഭിപ്രായങ്ങൾ C-ൽ നെസ്റ്റ് ചെയ്തിട്ടില്ല).

ഇപ്പോൾ '#undef' എന്നത് '/*#define' ആക്കി മാറ്റുന്നത് നല്ലതാണ്, എന്നാൽ നമുക്ക് യഥാർത്ഥത്തിൽ എഴുതണമെങ്കിൽ a
'#undef', ഞങ്ങൾ കുടുങ്ങിയിരിക്കുന്നു... '#un-def' എന്ന് എഴുതിയില്ലെങ്കിൽ അനുവദിക്കുക sed അത് '#undef' എന്നാക്കി മാറ്റുക
ഉൽപ്പാദിപ്പിക്കുമ്പോൾ config.h, യഥാർത്ഥത്തിൽ ഇവിടെ എന്താണ് ചെയ്യുന്നത്.

ഒരേ തരത്തിലുള്ള ന്യായവാദം ആ രണ്ട് വരികൾക്കും ബാധകമാണ്:

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

അനുമാനിക്കുകയും ചെയ്യുന്നു config.sh നിർവചിക്കുന്നു:

d_dup2='define'
i_string='undef'

ഞങ്ങൾ ഉൽപ്പാദിപ്പിക്കും config.h:

#HAS_DUP2 /**/ നിർവ്വചിക്കുക
/*#നിർവ്വചിക്കുക I_STRING /**/

ഒഴുകുന്ന വെള്ളം പോലെ തെളിഞ്ഞതാണോ? നല്ലത്!

ഇപ്പോൾ അത് ഉൾപ്പെടുത്തിക്കൊണ്ട് വ്യക്തമാകണം config.h നിങ്ങളുടെ എല്ലാ സി സോഴ്‌സ് ഫയലുകളിലും, നിങ്ങൾക്ക് ലഭിക്കും
എന്താണെന്ന് അറിയുക സജ്ജമാക്കുന്നു നിങ്ങളുടെ സിസ്റ്റത്തിൽ ഊഹിച്ചു. ഫലത്തിൽ, ആ ചിഹ്നങ്ങൾ ഉപയോഗിക്കുന്നതിലൂടെ, നിങ്ങളാണ്
കോൺഫിഗർ ചെയ്ത C കോഡ് എഴുതുന്നത്, മുതൽ metaconfig നിങ്ങൾക്ക് ആ ചിഹ്നങ്ങളും ഇഷ്ടവും ആവശ്യമാണെന്ന് അറിയും
അനുയോജ്യമായ ഒരു സൃഷ്ടിക്കുക config_h.SH ഫയലും ആവശ്യമായ എല്ലാ കോഡും സജ്ജമാക്കുന്നു ലേക്ക്
അവയ്‌ക്ക് ശരിയായ മൂല്യം കണക്കാക്കുക (അനുബന്ധ ഷെൽ വേരിയബിളുകൾക്ക് മൂല്യങ്ങൾ നൽകിക്കൊണ്ട്).

പ്രവർത്തിക്കുന്ന Metaconfig
എന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാം metaconfig അതിന്റെ യൂണിറ്റുകൾ എങ്ങനെ ഉപയോഗിക്കുന്നു എന്ന് മനസിലാക്കാൻ കുറച്ച് സമയത്തേക്ക് പ്രോഗ്രാം ചെയ്യുക
ആവശ്യമായ എല്ലാ കോൺഫിഗറേഷൻ ഫയലുകളും നിർമ്മിക്കാൻ നിങ്ങളുടെ സോഴ്സ് കോഡ്. നിങ്ങൾ പുതിയതായി എഴുതാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
യൂണിറ്റുകൾ, നിങ്ങൾക്ക് മുഴുവൻ സ്കീമിനെക്കുറിച്ച് നല്ല ധാരണ ഉണ്ടായിരിക്കണം.

MANIFEST.new ഫയൽ ഇല്ലെങ്കിൽ, metaconfig പകരം MANIFEST ഫയൽ ഉപയോഗിക്കാൻ ശ്രമിക്കും,
സൗകര്യത്തിനായി. എല്ലായിടത്തും നമ്മൾ MANIFEST.new എന്ന് പരാമർശിക്കുന്നു, അത് MANIFEST എന്ന് മനസ്സിലാക്കാം
നിങ്ങളുടെ പാക്കേജിന്റെ റൂട്ടിൽ MANIFEST.new ഫയൽ ഇല്ലെങ്കിൽ.

നിങ്ങളുടെ MANIFEST.new ഫയൽ ശരിയായി സജ്ജീകരിച്ചിട്ടുണ്ടെന്നും നിങ്ങൾ ആഗ്രഹിക്കുന്ന എല്ലാ ഉറവിട ഫയലുകളും ലിസ്റ്റുചെയ്യുന്നുവെന്നും കരുതുക
കോൺഫിഗർ ചെയ്യുക, നിങ്ങൾ പ്രവർത്തിപ്പിച്ചത് പാക്കറ്റ് നിങ്ങളുടെ റൂട്ട് സോഴ്സ് ഡയറക്ടറിയിൽ ഒരു സൃഷ്ടിക്കാൻ
.പാക്കേജ് ഫയൽ, നിങ്ങൾക്ക് പ്രവർത്തിപ്പിക്കാം metaconfig നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ലഭിക്കും:

$ metaconfig
യൂണിറ്റുകൾ കണ്ടെത്തുന്നു...
312 യൂണിറ്റുകളിൽ നിന്ന് ഡിപൻഡൻസി ലിസ്‌റ്റുകൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നു...
MANIFEST.new-ൽ നിന്ന് ഫയൽനാമങ്ങൾ (*[chyl], *.SH) എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നു...
ആവശ്യമുള്ള ഫയൽ നിർമ്മിക്കുന്നു...
ചിഹ്നങ്ങൾക്കായി .[chyl] ഫയലുകൾ സ്കാൻ ചെയ്യുന്നു...
ചിഹ്നങ്ങൾക്കായി .SH ഫയലുകൾ സ്കാൻ ചെയ്യുന്നു...
ഒപ്റ്റിമൽ ഡിപൻഡൻസി ഗ്രാഫ് കമ്പ്യൂട്ടിംഗ് ചെയ്യുന്നു...
സ്വകാര്യ ഫയൽ നിർമ്മിക്കുന്നു...
ലോഡ് ചെയ്യാവുന്ന യൂണിറ്റുകൾ നിർണ്ണയിക്കുന്നു...
മെയ്ക്ക് ഫയൽ അപ്ഡേറ്റ് ചെയ്യുന്നു...
യൂണിറ്റുകളുടെ ശരിയായ ക്രമം നിർണ്ണയിക്കുന്നു...
കോൺഫിഗർ സൃഷ്‌ടിക്കുന്നു...
ചെയ്തുകഴിഞ്ഞു.

ആദ്യ ഘട്ടം പബ്ലിക് ഡയറക്‌ടറിയിലെ എല്ലാ യൂണിറ്റ് ഫയലുകൾക്കും (.U യിൽ അവസാനിക്കുന്നു) തിരയുന്നു
ആദ്യം, പിന്നെ നിങ്ങളുടെ സ്വകാര്യത്തിൽ. നിങ്ങളുടെ സ്വകാര്യ യു ഡയറക്‌ടറിയിൽ ഒരു പൊതു ഫയൽ പകർത്തുകയാണെങ്കിൽ
(അതായത്, നിങ്ങളുടെ പാക്കേജിന്റെ മുകളിലെ തലത്തിലുള്ള U എന്ന പേരിലുള്ള ഒരു ഡയറക്ടറി), അത് പൊതുജനങ്ങളെ അസാധുവാക്കും
പതിപ്പ്. ലഭ്യമായ എല്ലാ യൂണിറ്റുകളുടെയും ഒരു ലിസ്റ്റ് അതിന് ലഭിച്ചുകഴിഞ്ഞാൽ, അത് അവയെ പാഴ്‌സ് ചെയ്യുകയും എല്ലാം എക്‌സ്‌ട്രാക്റ്റ് ചെയ്യുകയും ചെയ്യുന്നു
? ഉണ്ടാക്കുക: ഡിപൻഡൻസികളെക്കുറിച്ചും അറിയപ്പെടുന്ന ഷെൽ ചിഹ്നങ്ങളെക്കുറിച്ചും അറിയാനുള്ള വരികൾ. അതും
സി ചിഹ്നങ്ങളെ കുറിച്ചും ഷെൽ ചിഹ്നങ്ങൾ ഏതൊക്കെയായിരിക്കണം എന്നതിനെ കുറിച്ചും അറിയാൻ ?H: ലൈനുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു
ആ സി ചിഹ്നത്തിന് ശരിയായ മൂല്യം ലഭിക്കുന്നതിന് കണക്കാക്കി (അതിനാൽ ഞങ്ങൾക്ക് മറ്റൊരു തലത്തിലുള്ള ആശ്രിതത്വമുണ്ട്
ഇവിടെ).

അടുത്തതായി, MANIFEST.new ഫയലുകളിൽ നിന്ന് ശരിയായ ഫയൽനാമങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു കൂടാതെ a ആഗ്രഹിച്ചു ഫയൽ ആണ്
നിർമ്മിച്ചത്: ആ ഫയൽ ആ പാക്കേജിന് ആവശ്യമായ എല്ലാ സി ചിഹ്നങ്ങളും ഷെൽ ചിഹ്നങ്ങളും ലിസ്റ്റുചെയ്യുന്നു. ഞങ്ങൾ
ആദ്യം സി-ടൈപ്പ് ഫയലുകൾ സി ചിഹ്നങ്ങൾക്കായി സ്കാൻ ചെയ്യുക, തുടർന്ന് ഡിപൻഡൻസികൾ അവയിലേക്ക് പ്രചരിപ്പിക്കുക
അനുബന്ധ ഷെൽ ചിഹ്നങ്ങൾ (?H: വരികളിൽ നിന്ന് ശേഖരിച്ചത്). അടുത്തത് .SH ഫയലുകൾ സ്കാൻ ചെയ്യുകയും അവസാനം
എല്ലാ ഷെൽ ചിഹ്നങ്ങളും അറിയാം.

ഒരു താൽക്കാലിക Makefile നിർമ്മിക്കുകയും metaconfig ശ്രമിക്കുകയും ചെയ്യുന്നു ഉണ്ടാക്കുക കാണാനുള്ള എല്ലാ ഷെൽ ചിഹ്നങ്ങളും
ഏതൊക്കെ കമാൻഡുകൾ (രണ്ടാമത്തേതിൽ ലിസ്റ്റ് ചെയ്തിരിക്കുന്നു ?MAKE: ലൈനുകൾ) എക്സിക്യൂട്ട് ചെയ്യുന്നു, അങ്ങനെ ഏതൊക്കെ യൂണിറ്റുകളാണ്
ശരിക്കും ആവശ്യമാണ്. മറ്റുവിധത്തിൽ ആവശ്യമില്ലാത്ത ഓപ്ഷണൽ യൂണിറ്റുകൾ നീക്കം ചെയ്യുകയും രണ്ടാമത്തെ Makefile ആണ്
സൃഷ്ടിച്ചത്. ഇത്തവണ, എല്ലാ യൂണിറ്റുകളെയും അവയുടെ ഓർഡറുകളെയും കുറിച്ച് ഞങ്ങൾക്കറിയാം, ഓപ്ഷണൽ
യൂണിറ്റുകൾ നീക്കം ചെയ്യുകയും അവയുടെ ഷെൽ ചിഹ്നങ്ങൾക്കായി ഡിഫോൾട്ട് മൂല്യങ്ങൾ കണക്കാക്കുകയും ചെയ്തു. ദി
സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ് പിന്നീട് ജനറേറ്റ് ചെയ്യാവുന്നതാണ് config_h.SH. ഞങ്ങൾ കഴിഞ്ഞു.

കൺവെൻഷനുകൾ
മുഴുവൻ പ്രക്രിയയും ശബ്‌ദമാക്കുന്നതിന് ശരിയായ കൺവെൻഷനുകൾ പാലിക്കേണ്ടതുണ്ട്. ഒരു കേസുണ്ട്
യൂണിറ്റുകൾക്കായുള്ള കൺവെൻഷനും വേരിയബിൾ നാമകരണ കൺവെൻഷനും.

എല്ലാ യൂണിറ്റുകളും പ്രത്യേക യൂണിറ്റുകളല്ലെങ്കിൽ അവയുടെ ആദ്യ അക്ഷരം ലോവർ-കേസ് ആയിരിക്കണം. എഴുതിയത്
പ്രത്യേകം, ഞങ്ങൾ അർത്ഥമാക്കുന്നത് അവ യഥാർത്ഥത്തിൽ ഉപയോഗിക്കാനാകുന്ന പുതിയ ഷെൽ വേരിയബിളുകൾ നിർവ്വചിക്കുന്നില്ല എന്നാണ്
അവന്റെ .SH ഫയലുകളിലെ ഉപയോക്താവ്, പകരം സ്ക്രിപ്റ്റുകൾ അല്ലെങ്കിൽ ഷെൽ വേരിയബിളുകൾ നിർമ്മിക്കുന്ന യൂണിറ്റുകൾ
വഴി ആന്തരികമായി ഉപയോഗിക്കും സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ്. സാധാരണ ഉദാഹരണങ്ങളാണ് Init.U ഫയൽ ആണ്
പ്രധാന വേരിയബിൾ സമാരംഭം, അല്ലെങ്കിൽ മൈറെഡ്.യു ഏത് ഉത്പാദിപ്പിക്കുന്നു myread സ്ക്രിപ്റ്റ് ഏതാണ്ട് ഉപയോഗിച്ചു
എല്ലായിടത്തും സജ്ജമാക്കുന്നു ഉപയോക്താവിനോട് ഒരു ചോദ്യം ചോദിക്കുമ്പോൾ.

നോൺ-സ്പെഷ്യൽ യൂണിറ്റുകൾ പിന്നീട് രണ്ട് വ്യത്യസ്ത ഗ്രൂപ്പുകളായി വിഭജിക്കുന്നു: വേരിയബിളുകളെ നിർവചിക്കുന്ന യൂണിറ്റുകൾ
ഒരു സി ചിഹ്നവും അവയുടെ സ്വന്തം ഷെൽ വേരിയബിളുകൾ നിർവചിക്കുന്ന യൂണിറ്റുകളും. ആദ്യത്തെ ഗ്രൂപ്പ്
ഫയലുകൾ ഉൾപ്പെടുത്തുന്നതുമായി ബന്ധപ്പെട്ട വേരിയബിളുകളായി വിഭജിച്ചിരിക്കുന്നു (അവയുടെ പേര് ആരംഭിക്കുന്നത് i_) ഒപ്പം
മറ്റ് നിർവചനങ്ങളുമായി ബന്ധപ്പെട്ട വേരിയബിളുകൾ (പേര് ആരംഭിക്കുന്നത് d_). രണ്ടാമത്തെ ഗ്രൂപ്പിന് ഉണ്ട്
പേരുകൾ സ്വയം നിലകൊള്ളുന്നു, ഉദാഹരണത്തിന് cc.U നിർവചിക്കുന്നു $cc ഷെൽ വേരിയബിൾ അതിന്റെ മൂല്യം
C കംപൈലർ ഉപയോഗിക്കണം.

പ്രത്യേക യൂണിറ്റുകൾ ചില സമയങ്ങളിൽ മുൻകൂട്ടി നിശ്ചയിച്ചിരിക്കുന്ന ചില വേരിയബിളുകൾ സ്വയം സംവരണം ചെയ്യുകയും "ഫലങ്ങൾ" നൽകുകയും ചെയ്യുന്നു.
മറ്റ് അറിയപ്പെടുന്ന വേരിയബിളുകളിൽ. ഉദാഹരണത്തിന്, ദി myread Myread.U ആണ് തിരക്കഥ നിർമ്മിച്ചിരിക്കുന്നത്
പ്രോംപ്റ്റ് പ്രതീക്ഷിക്കുന്നു $rp, ഡിഫോൾട്ട് ഉത്തരം ഇൻ $dflt കൂടാതെ ഉപയോക്താവിന്റെ ഉത്തരം നൽകുകയും ചെയ്യുന്നു $ans.
ഈ മാനുവൽ പേജിൽ ഇത് രേഖപ്പെടുത്തിയിട്ടില്ല: നിങ്ങൾ പോയി യൂണിറ്റ് തന്നെ നോക്കണം
ഏതൊക്കെ വേരിയബിളുകളാണ് ഉപയോഗിക്കുന്നതെന്നും യൂണിറ്റ് എങ്ങനെ ഉപയോഗിക്കണമെന്നും മനസ്സിലാക്കുക.

ഉപയോഗിക്കുന്നു ദി നിഘണ്ടു
ഗ്ലോസറി ഫയൽ സ്വയമേവ നിർമ്മിക്കുന്നത് മേക്ക്ഗ്ലോസ് സ്ക്രിപ്റ്റ്, അത് വേർതിരിച്ചെടുക്കുന്നു
?S:, ?C:, കൂടാതെ ?MAKE: എന്നിവയിൽ നിന്നുള്ള വിവരങ്ങൾ വരികളായി അവയെ അക്ഷരമാലാക്രമത്തിൽ പുനഃക്രമീകരിക്കുന്നു
ക്രമീകരിച്ച പദാവലി. നിങ്ങളുടേതായ ചിഹ്നങ്ങളെക്കുറിച്ച് അറിയാൻ ഗ്ലോസറി വായിക്കേണ്ടത് പ്രധാനമാണ്
ഉപയോഗിക്കാൻ അനുവദിച്ചിരിക്കുന്നു. എന്നിരുന്നാലും, അവ എങ്ങനെ ഉപയോഗിക്കണമെന്ന് ഗ്ലോസറി നിങ്ങളോട് പറയുന്നില്ല. സാധാരണയായി, അത്
നിങ്ങളെ ആശ്രയിച്ച്.

ഒരു ദിവസം, നിങ്ങൾ ഒരുപക്ഷേ നിങ്ങളുടെ സ്വന്തം യൂണിറ്റുകൾ എഴുതുകയും നിങ്ങൾക്ക് വേണ്ടത്ര അറിയുകയും ചെയ്യും metaconfig
വേഗത്തിലും കാര്യക്ഷമമായും അങ്ങനെ ചെയ്യാൻ. എന്നിരുന്നാലും, നിങ്ങളുടെ ജോലി ശരിയായി രേഖപ്പെടുത്താൻ മറക്കരുത്
?എസ്: കൂടാതെ ?സി: ലൈനുകൾ അല്ലെങ്കിൽ മറ്റ് ആളുകൾക്ക് ഇത് വീണ്ടും ഉപയോഗിക്കാൻ കഴിയില്ല. കുറിച്ച് ഓർക്കുക
ആരംഭിക്കാൻ നിങ്ങൾക്ക് ഗ്ലോസറിയും ഈ മാനുവൽ പേജും മാത്രമുണ്ടായിരുന്ന സമയം.

തീരുമാനം
ഇപ്പോൾ നിങ്ങൾക്കറിയാം metaconfig അടിസ്ഥാനകാര്യങ്ങൾ, നിങ്ങൾ വായിക്കണം വിവരണം വിഭാഗം, പിന്നെ
എന്നതിലേക്ക് പോകുക REFERENCE അനുവദനീയമായത് പോലുള്ള എല്ലാ ഗുരുതരമായ വിശദാംശങ്ങളെക്കുറിച്ചും അറിയാനുള്ള വിഭാഗം
യൂണിറ്റ് കൺട്രോൾ ലൈനുകൾക്കുള്ള വാക്യഘടന ('?' എന്നതിൽ തുടങ്ങുന്ന വരികൾ) അല്ലെങ്കിൽ വ്യത്യസ്തമായ MAKE കമാൻഡുകൾ
നിങ്ങൾക്ക് ഉപയോഗിക്കാൻ അനുവാദമുണ്ട്.

REFERENCE

ഈ വിഭാഗത്തിന്റെ ആന്തരികഭാഗങ്ങൾ രേഖപ്പെടുത്തുന്നു metaconfig, അടിസ്ഥാനപരമായി യൂണിറ്റ് വാക്യഘടന, പ്രത്യേക
നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട യൂണിറ്റുകളും സൂചന ഫയലുകളും.

പൊതുവായ ഘടകം പദവിന്യാസം
ഒരു metaconfig യൂണിറ്റ് രണ്ട് വ്യത്യസ്ത ഭാഗങ്ങളായി തിരിച്ചിരിക്കുന്നു. തലക്കെട്ട് വിഭാഗം (വരികൾ ആരംഭിക്കുന്നു
കൂടെ '?') ഒരു ഷെൽ സെക്ഷനും (ഇതിൽ ഉൾപ്പെടുത്തേണ്ട കോഡ് സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ്). അത്
യൂണിറ്റിനുള്ളിൽ എവിടെയും '?X:' കമന്റുകൾ ചേർക്കാം, എന്നാൽ മറ്റൊന്ന് '?' വരികൾ (കൂടാതെ
വിളിച്ചു നിയന്ത്രണം ലൈനുകൾ) കർശനമായ ഓർഡർ നയം ഉണ്ടായിരിക്കുക.

ഒരു നിയന്ത്രണ രേഖ വളരെ ദൈർഘ്യമേറിയതാണെങ്കിൽ, ഫൈനലിൽ നിന്ന് രക്ഷപ്പെടുന്നതിലൂടെ ഒരു തുടർച്ച ഉപയോഗിക്കാൻ കഴിയും
ഒരു ബാക്ക്‌സ്ലാഷുള്ള പുതിയ-ലൈൻ അടുത്ത വരിയിൽ തുടരുന്നു (അത് പിന്നീട് ഇൻഡന്റ് ചെയ്യണം
സ്‌പെയ്‌സുകൾ അല്ലെങ്കിൽ ടാബുകൾ വഴി).

ഓരോ നിയന്ത്രണ ലൈനുകളുടെയും ഔപചാരിക വിവരണമാണ് ഇനിപ്പറയുന്നത്. പ്രസ്താവിച്ചിട്ടില്ലെങ്കിൽ
അല്ലെങ്കിൽ, ഈ അവതരണത്തിന്റെ ക്രമം യൂണിറ്റിനുള്ളിൽ ഉപയോഗിക്കേണ്ട ക്രമമാണ്.

?RCS: സ്വതന്ത്ര ടെക്സ്റ്റ്
യൂണിറ്റിന്റെ മുകളിൽ, RCS കമന്റുകൾക്കായി ഉപയോഗിക്കുന്നതിന്.

?X: എന്തെങ്കിലും ടെക്സ്റ്റ്
പൊതുവായ ഉദ്ദേശ്യ അഭിപ്രായങ്ങൾ. യൂണിറ്റിൽ എവിടെയും ദൃശ്യമാകാം, പക്ഷേ ന്യായീകരിക്കപ്പെടണം.
RCS അഭിപ്രായങ്ങൾക്ക്, ദയവായി ?RCS: കമന്റ് ഫോം ഉപയോഗിക്കുക.

?ഉണ്ടാക്കുക:ചിഹ്നം പട്ടിക: ആശ്രിതത്വം പട്ടിക [+ഓപ്ഷണൽ]
ഇതാണ് ആദ്യത്തെ ഡിപൻഡൻസി ലൈൻ. ആദ്യത്തേത് ചിഹ്നം പട്ടിക എല്ലാ ചിഹ്നങ്ങളും ലിസ്റ്റ് ചെയ്യണം
ഈ യൂണിറ്റ് നിർമ്മിച്ചത് (അതായത് യൂണിറ്റിന്റെ ഷെൽ സെക്ഷൻ ഉപയോഗിച്ച് അതിന്റെ മൂല്യം കണക്കാക്കുന്നു).
ചിഹ്നങ്ങൾ ഇടം വേർതിരിച്ചിരിക്കണം. നിർവചിക്കപ്പെട്ട ചിഹ്നം ആന്തരിക ഉപയോഗത്തിന് മാത്രമാണെങ്കിൽ ഒപ്പം
സൃഷ്ടിച്ചതിൽ ദൃശ്യമാകരുത് config.sh ഫയൽ, അതിനുശേഷം അതിന് മുമ്പായി a നൽകണം
'+' (ഇനിമുതൽ നിർവചിച്ചിരിക്കുന്ന ഓപ്ഷണൽ ഡിപൻഡൻസികളുമായി തെറ്റിദ്ധരിക്കരുത്). രണ്ടാമത്തെ
ലിസ്റ്റിന്റെ ഒരു ഭാഗം (മധ്യഭാഗത്തിന് ശേഷം ':') യൂണിറ്റ് ആശ്രിതത്വമാണ്. ഇത് എല്ലാം പട്ടികപ്പെടുത്തണം
ആവശ്യമായ പ്രത്യേക യൂണിറ്റുകളും ഷെൽ ഉപയോഗിക്കുന്ന എല്ലാ ചിഹ്നങ്ങളും
നടപ്പിലാക്കൽ. ഒരു ചിഹ്നം ആവശ്യമാണെങ്കിലും അതിന്റെ കോൺഫിഗറേഷൻ മൂല്യം നിർണായകമല്ലെങ്കിൽ, അത്
മുമ്പായി ഒരു '+' നൽകാം, ഈ സാഹചര്യത്തിൽ അതിനെ ഒരു സോപാധിക ആശ്രിതത്വം എന്ന് വിളിക്കുന്നു: അതിന്റെ
ആ ചിഹ്നം യഥാർത്ഥത്തിൽ ആണെങ്കിൽ മാത്രമേ അനുബന്ധ യൂണിറ്റ് ലോഡ് ചെയ്യപ്പെടുകയുള്ളൂ
ആഗ്രഹിച്ചു; അല്ലെങ്കിൽ ഡിഫോൾട്ട് മൂല്യം ഉപയോഗിക്കും.

?ഉണ്ടാക്കുക:ടാബ് കമാൻഡ്
പ്രാരംഭ ഡിപൻഡൻസി ലൈനുകൾക്ക് ശേഷം ഒന്നോ അതിലധികമോ കമാൻഡ് ലൈനുകൾ ഉണ്ടാകാം. ആ
കമാൻഡുകൾ യൂണിറ്റ് ലോഡുചെയ്യാൻ ആഗ്രഹിക്കുമ്പോൾ അവ നടപ്പിലാക്കും സജ്ജമാക്കുന്നു. കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് കമാൻഡുകൾ ഉണ്ടാക്കുന്നതിനെക്കുറിച്ചുള്ള ഖണ്ഡിക. നയിക്കുന്നത് ശ്രദ്ധിക്കുക ടാബ്
എന്നതിന് മുമ്പ് സ്വഭാവം ആവശ്യമാണ് കമാൻഡ്.

?Y:ലേഔട്ട്
ഈ യൂണിറ്റിനായി ഒരു ലേഔട്ട് നിർദ്ദേശം പ്രഖ്യാപിക്കുക. ആ നിർദ്ദേശം സ്ട്രിംഗുകളിൽ ഒന്നായിരിക്കാം
മുകളിൽ, സ്ഥിരസ്ഥിതി or അടിത്തട്ട് (കേസ് പ്രശ്നമല്ല, ശുപാർശ ചെയ്യുന്ന ശൈലി അവ ഉച്ചരിക്കുക എന്നതാണ്
വലിയക്ഷരം). ഒഴിവാക്കിയാൽ, സ്ഥിരസ്ഥിതി അനുമാനിക്കപ്പെടുന്നു.

മുകളിലോ താഴെയോ ഒരു യൂണിറ്റ് നിർബന്ധിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ മാത്രമേ ഈ നിർദ്ദേശം ആവശ്യമുള്ളൂ
സൃഷ്ടിച്ചവയുടെ സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ്, യൂണിറ്റ് ഡിപൻഡൻസികൾ അനുവദിക്കുന്നതുപോലെ. പ്രധാനപ്പെട്ടത്
തുടക്കത്തിൽ തന്നെ ചോദ്യങ്ങൾ നിർബന്ധിതമാകാം. ഒരേ ലേഔട്ട് ക്ലാസിനുള്ളിൽ, യൂണിറ്റുകൾ
നിർബന്ധിതമായി d_*, i_* യൂണിറ്റുകൾക്കായി രണ്ട് പ്രത്യേക കേസുകൾ ഉപയോഗിച്ച് അക്ഷരമാലാക്രമത്തിൽ അടുക്കിയിരിക്കുന്നു
യഥാക്രമം അവരുടെ ക്ലാസുകളുടെ മുകളിലും താഴെയുമായി (എന്നാൽ ഇവയുടേതായിരിക്കണം
ഡിഫോൾട്ട് ക്ലാസ്).

മറ്റെല്ലാ യൂണിറ്റുകളും ആശ്രിതത്വം ആവശ്യപ്പെടുന്ന ഒരു യൂണിറ്റിനെ നിങ്ങൾ മുകളിൽ നിർബന്ധിക്കുന്നു
അതിനുമുമ്പ്, നിങ്ങൾ രസകരമായ ഒന്നും നേടുന്നില്ല. അതിനാൽ, ആ നിർദ്ദേശം ശരിക്കും ആയിരിക്കണം
പലതിനെയും ആശ്രയിക്കാത്ത ചില സംവേദനാത്മക യൂണിറ്റുകളുടെ മുൻഗണന വർദ്ധിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു
പാതയുമായി ബന്ധപ്പെട്ട ചോദ്യങ്ങൾ പോലെയുള്ള മറ്റ് ഉപയോക്തൃ-ദൃശ്യ ചിഹ്നങ്ങൾ.

?എസ്:ചിഹ്നം_പേര് [(കാലഹരണപ്പെട്ടു ചിഹ്നം പട്ടിക)]:
ഒരു ഷെൽ ചിഹ്നം അവതരിപ്പിക്കുന്നു. ഈ ആദ്യ വരി ചിഹ്നത്തിന് പേരുനൽകുന്നു, ഓപ്ഷണലായി എ
പരാന്തീസിസും കാലഹരണപ്പെട്ട തത്തുല്യവും നൽകുന്നതിന് ഇടയിലുള്ള ലിസ്റ്റ്. കാലഹരണപ്പെട്ടവ
ചിഹ്നങ്ങൾ പുതിയതിലേക്ക് റീമാപ്പ് ചെയ്യും ചിഹ്നം_പേര് അങ്ങനെയാണെങ്കിൽ -o എന്ന ഓപ്ഷൻ നൽകിയിരിക്കുന്നു
metaconfig.

?എസ്:എന്തെങ്കിലും ടെക്സ്റ്റ്, വേണ്ടി നിഘണ്ടു
അടിസ്ഥാനപരമായി ഷെൽ ചിഹ്നം വിവരിക്കുന്ന ഒരു അഭിപ്രായം, അത് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യും മേക്ക്ഗ്ലോസ്
ഗ്ലോസറി ഫയലിലേക്ക്.

?എസ്:. ഷെൽ ചിഹ്ന കമന്റ് അടയ്‌ക്കുന്നു.

?സി:ചിഹ്നം_പേര് [~ അപരാഭിധാനം] [(കാലഹരണപ്പെട്ടു ചിഹ്നം പട്ടിക)]:
ഒരു പുതിയ സി ചിഹ്നം അവതരിപ്പിക്കുന്നു. ദി അപരാഭിധാനം പേര് സി ചിഹ്നത്തിന് താഴെയുള്ള പേരാണ്
നിയന്ത്രിക്കണം, അതായത് അപരാഭിധാനം ചിഹ്നം ആവശ്യമാണ്, അപ്പോൾ ആ C ചിഹ്നം എഴുതപ്പെടും
ലെ config_h.SH ഫയൽ. സാധാരണയായി, അപരനാമം '%<' മാത്രമാണ് (യൂണിറ്റിന്റെ പേരിനെ സൂചിപ്പിക്കുന്നു)
കൂടാതെ ഒരു ?W: ലൈൻ മാപ്പിംഗ് സി ചിഹ്നവും ഉണ്ട് അപരാഭിധാനം. അതോടൊപ്പം പ്രസക്ത ഭാഗങ്ങളും
ന്റെ ?H: ലൈനുകൾ ഒരു '?%<' വ്യവസ്ഥയാൽ വ്യക്തമായി സംരക്ഷിക്കപ്പെട്ടിരിക്കുന്നു. ചിഹ്നം കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് ഖണ്ഡികയുടെ അപരനാമം. വരിയുടെ ശേഷിക്കുന്ന ഭാഗം ഓപ്ഷണൽ ആണ്
കാലഹരണപ്പെട്ടു ചിഹ്നം പട്ടിക, ഇത് പുതിയതിന് പഴയ തുല്യതകളെ പട്ടികപ്പെടുത്തുന്നു ചിഹ്നം_പേര്.

?സി:എന്തെങ്കിലും ടെക്സ്റ്റ്, വേണ്ടി നിഘണ്ടു ഒപ്പം config_h.SH
അടിസ്ഥാനപരമായി സി ചിഹ്നം വിവരിക്കുന്ന ഒരു അഭിപ്രായം, അത് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യും മേക്ക്ഗ്ലോസ്
ഗ്ലോസറി ഫയലിലേക്കും വഴിയും metaconfig കടന്നു config_h.SH ചിഹ്നമാണെങ്കിൽ ഫയൽ
ആഗ്രഹിച്ചു (അല്ലെങ്കിൽ ചിഹ്നം അപരനാമം ഉപയോഗിക്കുമ്പോൾ അതിന്റെ അപരനാമം ആവശ്യമാണെങ്കിൽ).

?സി:. സി ചിഹ്ന കമന്റ് അടയ്‌ക്കുന്നു.

?എച്ച്:?ചിഹ്നം:config_h.SH സ്റ്റഫ്
ഇതാണ് പൊതുവായ ഉൾപ്പെടുത്തൽ അഭ്യർത്ഥന config_h.SH. വരുമ്പോൾ മാത്രം എഴുതിയിരിക്കുന്നു
കാവൽക്കാരൻ ചിഹ്നം ശരിക്കും വേണം. സി ചിഹ്നം വരുമ്പോൾ ഈ പൊതുവായ രൂപം ആവശ്യമാണ്
അപരനാമം ഉപയോഗിച്ചു. അല്ലെങ്കിൽ, നിങ്ങൾ മറ്റ് "സ്റ്റാൻഡേർഡ്" ഫോമുകളിൽ ഒന്ന് ഉപയോഗിക്കുകയാണെങ്കിൽ, the
കാവൽ സ്വയമേവ ചെയ്യുന്നു metaconfig സ്വയം.

?എച്ച്:#$d_var VAR ൽ "$var"
സോപാധികമായി നിർവചിക്കുന്നു VAR ൽ സി ചിഹ്നത്തിലേക്ക് $var എപ്പോൾ സജ്ജീകരിച്ചിരിക്കുന്നു 'നിര്വചിക്കുക'. എ സൂചിപ്പിക്കുന്നു
'?VAR ൽ:' കാവൽ അവസ്ഥ, ഒപ്പം metaconfig യാന്ത്രികമായി ലിങ്കുകൾ VAR ൽ അതിന്റെ രണ്ട് ഷെല്ലിലേക്ക്
വേരിയബിൾ ഡിപൻഡൻസികൾ (അതായത് രണ്ടും $d_var ഒപ്പം $var ആയി പതാക ഉയർത്തും ആഗ്രഹിച്ചു if VAR ൽ is
സി ഉറവിടങ്ങളിൽ ഉപയോഗിക്കുന്നു).

?H:#നിർവചിക്കുക VAR ൽ [ഓപ്ഷണൽ ടെക്സ്റ്റ്]
എപ്പോഴും നിർവചിക്കുന്നു VAR ൽ കുറച്ച് മൂല്യത്തിലേക്ക് സി ചിഹ്നം. ഒരു '?VAR ൽ:' കാവൽ അവസ്ഥ.
യൂണിറ്റിന് തന്നെ ഒരു ഓട്ടോമാറ്റിക് ഷെൽ ഡിപൻഡൻസി ഉണ്ടാക്കിയിരിക്കുന്നു.

?H:#നിർവചിക്കുക VAR(x,y,z) $var
എല്ലായ്‌പ്പോഴും മാക്രോ നിർവചിക്കുന്നു VAR ൽ യുടെ മൂല്യമായിരിക്കണം $var വേരിയബിൾ. വരെ ആണ്
ഉറപ്പാക്കാൻ യൂണിറ്റ് $var യുക്തിസഹമായ മൂല്യം വഹിക്കുന്നു. സി തമ്മിലുള്ള ഒരു യാന്ത്രിക ആശ്രിതത്വം
മാക്രോ VAR ൽ കൂടാതെ ഷെൽ വേരിയബിൾ സ്ഥാപിച്ചു, മുഴുവൻ വരിയും ഒരു കാവൽ നിൽക്കുന്നു
പരോക്ഷമായ '?VAR ൽ:'.

?എച്ച്:#$d_var VAR ൽ
സോപാധികമായി നിർവചിക്കുന്നു VAR ൽ if $d_var ' ആയി സജ്ജീകരിച്ചിരിക്കുന്നുനിര്വചിക്കുക'. ഒരു '?VAR ൽ:' കാവൽ
അവസ്ഥ. നേരെ ഒരു ഓട്ടോമാറ്റിക് ഷെൽ ഡിപൻഡൻസി ജനറേറ്റുചെയ്യുന്നു $d_war.

?H:#നിർവചിക്കുക VAR ൽ "$var"
എന്നതിലേക്ക് ഒരു കോൺഫിഗർ ചെയ്ത മൂല്യം നൽകുന്നു VAR ൽ സി ചിഹ്നം. ഒരു '?VAR ൽ: 'ഗുരുഡിംഗ് അവസ്ഥ.
ലിങ്ക് ചെയ്യുന്നതിനായി ഒരു ഓട്ടോമാറ്റിക് ഷെൽ ഡിപൻഡൻസി ജനറേറ്റുചെയ്യുന്നു VAR ൽ ഒപ്പം $var.

?എച്ച്:. അടയ്ക്കുന്നു config_h.SH ഉൾപ്പെടുത്തൽ അഭ്യർത്ഥനകൾ.

?എം:C ചിഹ്നം: C ഡിപൻഡൻസികൾ
സി ചിഹ്നത്തെ സംബന്ധിച്ച മാന്ത്രിക നിർവചനം അവതരിപ്പിക്കുന്നു confmagic.h, എന്നിവ നിർവചിക്കുന്നു
ബാക്കിയുള്ളവയുടെ കാവൽ ചിഹ്നം ?M: നിർവചനങ്ങൾ. ഈ വരി നിശബ്ദമായി സൂചിപ്പിക്കുന്നു
'?W:%<:C ചിഹ്നം', അതായത് C ചിഹ്നം ദൃശ്യമാകുകയാണെങ്കിൽ യൂണിറ്റ് കോൺഫിഗറിലേക്ക് ലോഡ് ചെയ്യും
സി ഉറവിടങ്ങളിൽ, മാജിക് ഉപയോഗിച്ചാലും ഇല്ലെങ്കിലും. സി ഡിപൻഡൻസികൾ സജീവമാക്കി
മാജിക് ഉപയോഗിക്കുമ്പോൾ, അവയുടെ നിർവചനം നിർബന്ധമാക്കുന്നതിന് config_h.SH. എന്നിരുന്നാലും, എങ്കിൽ
മാജിക് ആണ് അല്ല ഉപയോഗിച്ചു എന്നാൽ C ചിഹ്നം ആവശ്യമായ C ഇല്ലാതെ ഉറവിടത്തിൽ ദൃശ്യമാകുന്നു
ഡിപൻഡൻസികൾ, ആവശ്യമുള്ള ഫയൽ നിർമ്മിക്കപ്പെടുമ്പോഴെല്ലാം നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകും, കാരണം അങ്ങനെയായിരിക്കാം
ഒരു പോർട്ടബിലിറ്റി പ്രശ്നം (കൂടാതെ യൂണിറ്റ് നിരുപാധികമായി ലോഡ് ചെയ്തിരിക്കുന്നതിനാലും
എന്നതിൽ നിന്നുള്ള മറ്റ് ?C: വരികൾ പരിഗണിക്കാതെ, C ചിഹ്നം ഉപയോഗിക്കുമ്പോഴെല്ലാം കോൺഫിഗർ ചെയ്യുക
യൂണിറ്റ്).

?എം:സിപിപി defs
ബന്ധപ്പെട്ടവരെല്ലാം confmagic.h-ൽ അവതരിപ്പിക്കേണ്ട മാജിക് cpp മാപ്പിംഗ് നിർവചിക്കുന്നു
ചിഹ്നം ഉപയോഗിക്കുന്നു. അവ്യക്തതയുണ്ടോ?സിം'എവിടെ കാവൽ നിൽക്കുന്നു സിം ചിഹ്ന നാമമാണ്
പ്രമുഖ ?M: ലൈൻ നിർവ്വചിച്ചിരിക്കുന്നു.

?എം:. അടയ്ക്കുന്നു confmagic.h ഉൾപ്പെടുത്തൽ അഭ്യർത്ഥന.

?W:ഷെൽ ചിഹ്നം പട്ടിക:C ചിഹ്നം പട്ടിക
ഷെൽ ചിഹ്നങ്ങളുടെ ഭാഗധേയം സി ചിഹ്നങ്ങളുടേതുമായി ബന്ധിപ്പിക്കുന്നു: ഏതെങ്കിലും സി
ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്ന ചിഹ്നങ്ങൾ ആവശ്യമാണ്, തുടർന്ന് എല്ലാ ഷെൽ ചിഹ്നങ്ങളും ആവശ്യമുള്ളതായി അടയാളപ്പെടുത്തുന്നു. ഉപയോഗപ്രദമാണ്
ഒരു യൂണിറ്റ് നിർബന്ധിതമായി ഉൾപ്പെടുത്തുക (ഷെൽ ചിഹ്ന പട്ടിക '%<' ആയി സജ്ജീകരിച്ചിരിക്കുന്നു) ചില C യുടെ സാന്നിധ്യം ഉണ്ടാകുമ്പോൾ
ചിഹ്നം കണ്ടെത്തി. വശത്ത് നിന്ന് പ്രയോജനം ലഭിക്കുന്നതിന് ഷെൽ ചിഹ്ന ലിസ്റ്റ് ശൂന്യമായി വെച്ചേക്കാം
ബിൽറ്റ്-ഇൻ പ്രീ-പ്രൊസസറിനുള്ളിലെ സി ചിഹ്ന സ്ഥാനത്തിന്റെ പ്രഭാവം (ചിഹ്നം നിർവചിച്ചിരിക്കുന്നത്
ഉറവിടത്തിൽ സ്ഥിതിചെയ്യുന്നുണ്ടെങ്കിൽ ആ പ്രീ-പ്രൊസസറിനായി). ഇടമുള്ള പാറ്റേണുകൾക്കായി തിരയാൻ
അവയിൽ, 'struct' എന്നതുപോലെ ലളിതമായ ഉദ്ധരണികൾക്കുള്ളിൽ നിങ്ങൾ C ചിഹ്നങ്ങൾ ഉദ്ധരിക്കേണ്ടതുണ്ട്
സമയ മേഖല'.

?വി:വായിക്കാൻ മാത്രം ചിഹ്നങ്ങൾ:വായിക്കുക-എഴുതുക ചിഹ്നങ്ങൾ
ഇതൊരു മെറ്റലിന്റ് സൂചനയും ചില ഷെൽ കയറ്റുമതി ചെയ്യുന്ന പ്രത്യേക യൂണിറ്റുകളിൽ മാത്രമേ ഉപയോഗിക്കാവൂ
വേരിയബിളുകൾ. മധ്യഭാഗത്തിന് മുമ്പുള്ള വേരിയബിളുകൾ ':' റീഡ്-ഓൺലി എക്‌സ്‌പോർട്ട് ചെയ്യുന്നു (അവ മാറ്റുന്നു
ഒരു മുന്നറിയിപ്പ് നൽകും), മറ്റ് ചിഹ്നങ്ങൾ സ്വതന്ത്രമായി വായിക്കുകയും മാറ്റുകയും ചെയ്യാം.

?F:ഫയലുകൾ സൃഷ്ടിച്ചു
ഈ വരി രണ്ട് ഉദ്ദേശ്യങ്ങൾ നിറവേറ്റുന്നു: ഇത് എ മെറ്റലിന്റ് സൂചന, കൂടാതെ ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ
ഭാവി jmake ഉപയോഗിക്കുക. ഇത് മൂന്ന് തരത്തിലുള്ള ഫയലുകൾ ലിസ്റ്റ് ചെയ്യണം: താൽക്കാലികമായത്
ഒരു ടെസ്റ്റിനായി സൃഷ്ടിച്ചത്, പിന്നീട് UU ഡയറക്ടറിയിൽ സൃഷ്ടിച്ച സ്വകാര്യ UU
പരിശോധിക്കൽ, പാക്കേജിന്റെ റൂട്ട് ഡയറക്ടറിയിൽ അവശേഷിക്കുന്ന പൊതുവ. താൽക്കാലികം
ഫയലുകൾ മുമ്പത്തെ '!' പ്രതീകം (അർത്ഥം "ഇല്ല! അവ വീണ്ടും ഉപയോഗിക്കുന്നില്ല
പിന്നീട്!"), സ്വകാര്യ UU ഫയലുകൾക്ക് മുമ്പായി './' (അർത്ഥം: അവ ഉപയോഗിക്കാൻ, പറയുക
./ഫയൽ, മാത്രമല്ല ഫയല്), പൊതുവയ്ക്ക് പേരിടണം.

?ടി:ഷെൽ താൽക്കാലികക്കാർ
മറ്റൊരു മെറ്റലിന്റ് സൂചന. താൽക്കാലികമായി ഉപയോഗിക്കുന്ന എല്ലാ ഷെൽ വേരിയബിളുകളും ഈ വരി പട്ടികപ്പെടുത്തുന്നു
ഈ യൂണിറ്റിന്റെ ഷെൽ വിഭാഗത്തിനുള്ളിൽ.

?ഡി:ചിഹ്നം='മൂല്യം'
സോപാധിക ഡിപൻഡൻസികളായി ഉപയോഗിക്കുന്ന ചിഹ്നങ്ങൾക്കുള്ള ഇനീഷ്യലൈസേഷൻ മൂല്യം. ഇല്ലെങ്കിൽ ?D: ലൈൻ ആണ്
കണ്ടെത്തി, പകരം ഒരു ശൂന്യ മൂല്യം ഉപയോഗിക്കുന്നു. ദി മെറ്റലിന്റ് എങ്കിൽ പ്രോഗ്രാം നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകും
ഒരു സോപാധികമായ ആശ്രിതത്വമായി ഒരിക്കലെങ്കിലും ചിഹ്നം ഉപയോഗിക്കുന്നു, അതിന് ശരിയായ ഒരു ആശ്രിതത്വമില്ല
?ഡി: സമാരംഭം. ഒരു അസാധുവായിപ്പോലും ആ വരികൾ ചേർക്കുന്നത് നല്ല രീതിയാണ്
ഒരു ചിഹ്നത്തിന്റെ ഐച്ഛിക സ്വഭാവത്തിന് ഊന്നൽ നൽകുന്നതിനാൽ സമാരംഭം.

?ഒ:എന്തെങ്കിലും സന്ദേശം നിങ്ങളെ ആഗ്രഹിക്കുന്നു
ഈ യൂണിറ്റ് മൊത്തത്തിൽ കാലഹരണപ്പെട്ടതാണെന്ന് ഈ നിർദ്ദേശം സൂചിപ്പിക്കുന്നു. ഏതെങ്കിലും ഉപയോഗിക്കുമ്പോൾ
അതിന്റെ ചിഹ്നങ്ങൾ നിർമ്മിച്ചതാണ് (അല്ലെങ്കിൽ ആശ്രിതത്വം വഴിയുള്ള പരോക്ഷ ഉപയോഗം), സന്ദേശം ഔട്ട്പുട്ട് ഓണാണ്
സ്ക്രീൻ (stderr-ൽ). നിങ്ങൾക്ക് ഒരു അയിര് കൂടുതൽ വരികൾ ഇടാം, ഈ സാഹചര്യത്തിൽ ഓരോ വരിയും
ക്രമത്തിൽ അച്ചടിക്കുക.

?ലിന്റ്:മെറ്റലിന്റ് സൂചനകൾ
കാണുക മെറ്റലിന്റ് സാധ്യമായ വ്യതിരിക്തമായ സൂചനകളുടെ വിശദീകരണത്തിനുള്ള മാനുവൽ പേജ്
ഉപയോഗിച്ചു.

?INIT:സമാരംഭിക്കൽ കോഡ്
ഈ ലൈൻ വ്യക്തമാക്കിയ ഇനീഷ്യലൈസേഷൻ കോഡ് ഇതിന്റെ മുകളിൽ ലോഡ് ചെയ്യും
സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ് നൽകിയാൽ യൂണിറ്റ് ആവശ്യമാണ്.

C ചിഹ്നം അപരനാമം
ചിലപ്പോൾ ആശ്രയിക്കാൻ കഴിയില്ല metaconfigന്റെ സ്വന്തം ഡിഫോൾട്ട് തിരഞ്ഞെടുക്കൽ config_h.SH
അഭിപ്രായങ്ങളും സി ചിഹ്ന നിർവചനവും. അവിടെയാണ് അപരനാമം പ്രസക്തമാകുന്നത്. അത് പകരം ആയതിനാൽ
വിശദീകരിക്കാൻ ബുദ്ധിമുട്ടാണ്, അടിസ്ഥാന മെക്കാനിസം മനസ്സിലാക്കാൻ ഞങ്ങൾ ഒരു ഉദാഹരണം പഠിക്കും.

d_const.U യൂണിറ്റ് നിങ്ങളുടെ C കംപൈലറിന് അറിയാമോ ഇല്ലയോ എന്ന് നിർണ്ണയിക്കാൻ ശ്രമിക്കുന്നു കൺസ്ട്രക്റ്റർ
കീവേഡ്. ഇല്ലെങ്കിൽ, ആ കീവേഡ് ഒരു നൾ സ്ട്രിംഗിലേക്ക് റീമാപ്പ് ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
പ്രോഗ്രാം കംപൈൽ. മാത്രമല്ല, എപ്പോൾ ടെസ്റ്റ് സ്വയമേവ പ്രവർത്തനക്ഷമമാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു കൺസ്ട്രക്റ്റർ വാക്ക്
ഉപയോഗിക്കുന്നു.

d_const.U യൂണിറ്റിന്റെ പ്രസക്ത ഭാഗങ്ങൾ ഇതാ:

?MAKE:d_const: cat cc ccflags Setvar
?ഉണ്ടാക്കുക: -തിരഞ്ഞെടുക്കുക ചേർക്കുക $@ %
?S:d_const:
?എസ്: ഈ വേരിയബിൾ HASCONST ചിഹ്നത്തെ സോപാധികമായി നിർവചിക്കുന്നു, ഏത്
?എസ്: ഈ സി കംപൈലറിന് അറിയാവുന്ന സി പ്രോഗ്രാമിനെ സൂചിപ്പിക്കുന്നു
?എസ്: കോൺസ്റ്റ് തരം.
?എസ്:.
?C:HASCONST ~ %<:
?സി: ഈ ചിഹ്നം, നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, ഈ സി കംപൈലറിന് അറിയാമെന്ന് സൂചിപ്പിക്കുന്നു
?സി: കോൺസ്റ്റ് തരം. യഥാർത്ഥത്തിൽ ആ ചിഹ്നത്തിനായി പരീക്ഷിക്കേണ്ട ആവശ്യമില്ല
?സി: നിങ്ങളുടെ പ്രോഗ്രാമുകൾക്കുള്ളിൽ. "const" എന്ന കീവേഡ് ഉപയോഗിച്ചാൽ മതി
?സി: ആവശ്യമായ പരിശോധനകൾ ട്രിഗർ ചെയ്യുക.
?സി:.
?H:?%<:#$d_const HASCONST /**/
?H:?%<:#ifndef HASCONST
?H:?%<:#define const
?H:?%<:#endif
?എച്ച്:.
?W:%<:const
?LINT:സെറ്റ് d_const
?ലിന്റ്:അറിയപ്പെടുന്ന കോൺസ്റ്റ്
: const കീവേഡ് പരിശോധിക്കുക
പ്രതിധ്വനി ""
echo 'നിങ്ങളുടെ C കംപൈലറിന് "const"-നെ കുറിച്ച് അറിയാമോ എന്ന് പരിശോധിക്കുന്നു...' >&4
/ബിൻ/പൂച്ച >const.c <<'EECP'
പ്രധാന ()
{
കോൺസ്റ്റ് ചാർ *ഫൂ;
}
ഇ.ഒ.സി.പി
എങ്കിൽ $cc -c $ccflags const.c >/dev/null 2>&1 ; പിന്നെ
val="$define"
പ്രതിധ്വനി "അതെ, അത് ചെയ്യുന്നു."
മറ്റാരെങ്കിലും
val="$undef"
പ്രതിധ്വനി "ഇല്ല, അങ്ങനെയല്ല."
fi
d_const സജ്ജമാക്കുക
eval $setvar

ആദ്യം നമ്മൾ ഒരു ?W: വരിയുടെ ഉപയോഗം ശ്രദ്ധിക്കുന്നു, അത് അടിസ്ഥാനപരമായി പറയുന്നു: "ഈ യൂണിറ്റ് ആവശ്യമുള്ളപ്പോൾ
കൺസ്ട്രക്റ്റർ ഒരു C ഫയലിൽ കീവേഡ് ഉപയോഗിക്കുന്നു.". സോപാധികമായി റീമാപ്പ് ചെയ്യുന്നതിന് കൺസ്ട്രക്റ്റർ ഒരു ശൂന്യതയിലേക്ക്
സ്ട്രിംഗ് ഇൻ config.h, ഞാൻ സോപാധികമായി നിർവ്വചിക്കാൻ തിരഞ്ഞെടുത്തു ഹാസ്കോൺസ്റ്റ് വഴി $d_const.

എന്നിരുന്നാലും, ഇത് ഒരു പ്രശ്നം ഉയർത്തുന്നു, കാരണം ഹാസ്കോൺസ്റ്റ് എന്നതിൽ ചിഹ്നം ഉപയോഗിക്കാൻ പോകുന്നില്ല
ഉറവിടങ്ങൾ, മാത്രം കൺസ്ട്രക്റ്റർ ടോക്കൺ ആണ്. കൂടാതെ ?H: ലൈൻ നിർവചിക്കുന്നു ഹാസ്കോൺസ്റ്റ് പരോക്ഷമായി ആണ്
'?HASCONST' സംരക്ഷിച്ചിരിക്കുന്നു. അതിനാൽ, പറയുന്നതിന് നാം വ്യക്തമായ '?%<' പരിമിതി ചേർക്കണം
metaconfig ആ വരികൾ ഉൾപ്പെടുത്തണം എന്ന് config_h.SH എപ്പോഴെങ്കിലും '%<' ചിഹ്നം
ആവശ്യമാണ് (%< എന്നത് യൂണിറ്റിന്റെ പേരിനെ സൂചിപ്പിക്കുന്നു, ഇവിടെ d_const).

അത് ഏതാണ്ട് തികഞ്ഞതാണ്, കാരണം ?W: ലൈൻ ആവശ്യപ്പെടും d_const എപ്പോൾ കൺസ്ട്രക്റ്റർ അപ്പോൾ ഉപയോഗിക്കുന്നു
?H: വരികൾ ഇതിൽ ഉൾപ്പെടുത്തും config_h.SH ഫയൽ. എന്നിരുന്നാലും, മുൻനിര അഭിപ്രായം (?C:
വരികൾ) ഘടിപ്പിച്ചിരിക്കുന്നു ഹാസ്കോൺസ്റ്റ് വഴിയും സംരക്ഷിക്കപ്പെടുന്നു ഹാസ്കോൺസ്റ്റ്, അതായത് അതിന് ഒരു അവ്യക്തതയുണ്ട്
'?HASCONST' നിയന്ത്രണം. അതിനാൽ ആവശ്യമുണ്ട് അപരനാമം The ഹാസ്കോൺസ്റ്റ് '%<' എന്നതിലേക്കുള്ള ചിഹ്നം.

യൂണിറ്റിന്റെ ശേഷിക്കുന്ന ഭാഗം (ഷെൽ ഭാഗം) ശരിക്കും നേരായതാണ്. അത് ലളിതമായി
ഉപയോഗിച്ച് ഒരു സാമ്പിൾ സി പ്രോഗ്രാം കംപൈൽ ചെയ്യാൻ ശ്രമിക്കുന്നു കൺസ്ട്രക്റ്റർ കീവേഡ്. കഴിയുമെങ്കിൽ, അത് ചെയ്യും
നിര്വചിക്കുക $d_const വഴി $setvar പ്രവർത്തനം (നിർവചിച്ചിരിക്കുന്നത് സേത്വർ.യു യൂണിറ്റ്). ഖണ്ഡിക കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് പ്രത്യേക യൂണിറ്റുകളെ കുറിച്ച്.

ഉണ്ടാക്കുക കമാൻഡുകൾ
?MAKE: കമാൻഡ് ലൈനിൽ, ഒരു ഷെൽ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനായി എഴുതാം.
പ്രത്യേക - തിരഞ്ഞെടുക്കുക വഴി കുടുങ്ങിയ കമാൻഡ് metaconfig എന്തായിരിക്കണം എന്നറിയാൻ പാഴ്‌സ് ചെയ്യുകയും ചെയ്തു
ചെയ്തു. മുൻനിരയിലുള്ള '-' തടയാൻ മാത്രമേയുള്ളൂ ഉണ്ടാക്കുക കമാൻഡ് തിരികെ വരുമ്പോൾ പരാജയപ്പെടുന്നതിൽ നിന്ന്
പൂജ്യമല്ലാത്ത ഒരു സ്റ്റാറ്റസ് -- നമ്മൾ ഉപയോഗിക്കുന്നതിനാൽ ഇത് ശരിക്കും ആവശ്യമില്ലഉണ്ടാക്കുക -n' പരിഹരിക്കാൻ
ഡിപൻഡൻസികൾ, എന്നാൽ ഭാവി പതിപ്പുകളിൽ ഇത് നിർബന്ധമാണെങ്കിൽ അത് സൂക്ഷിക്കാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു.
എന്ന വാക്യഘടന തിരഞ്ഞെടുക്കൽ കമാൻഡ് ഇതാണ്:

- തിരഞ്ഞെടുക്കുക cmd $@ target_file

എവിടെ $@ നിലവിലെ ടാർഗെറ്റിനെ പ്രതിനിധീകരിക്കുന്ന Makefiles-ലെ സ്റ്റാൻഡേർഡ് മാക്രോ ആണ് (പേര്
നിർമ്മിക്കുന്ന യൂണിറ്റിന്റെ, അന്തിമ .U വിപുലീകരണം നീക്കം ചെയ്തു). ദി cmd ഭാഗം ആണ്
യഥാർത്ഥ metaconfig പ്രവർത്തിപ്പിക്കാനുള്ള കമാൻഡ്, ഒപ്പം target_file മറ്റൊരു പരാമീറ്റർ ആണ്, ആരുടെ
വ്യാഖ്യാനം ആശ്രയിച്ചിരിക്കുന്നു cmd തന്നെ. ഇതിന് അതിന്റെ അവസാന .U വിപുലീകരണവും ഉണ്ട്
സാധാരണയായി ഒരു യൂണിറ്റ് ഫയലിനെയാണ് സൂചിപ്പിക്കുന്നത്, അത് './' എന്നതിൽ ആരംഭിക്കുന്നില്ലെങ്കിൽ അത് ഒന്നിനെ പരാമർശിക്കുന്നു
എന്ന metaconfig ' എന്നതിലെ ഫയലുകൾ നിയന്ത്രിക്കുക.എം.ടി ഡയറക്ടറി.

ലഭ്യമായ കമാൻഡുകൾ ഇവയാണ്:

ചേർക്കുക ചേർക്കുക target_file ലേക്ക് സജ്ജമാക്കുന്നു.

add.Config_sh
ആ ഭാഗത്ത് നിറയുന്നു സജ്ജമാക്കുന്നു ഉൽ‌പാദിപ്പിക്കുന്നു config.sh ഫയൽ. ഉപയോഗിച്ചു മാത്രം
വേരിയബിളുകൾ ചേർത്തിരിക്കുന്നു, സോപാധികമായവ (സോപാധിക ആശ്രിതത്വങ്ങളിൽ നിന്ന്) ആകുന്നു
ഒഴിവാക്കി.

add.Null ഒരു ശൂന്യമായ സ്ട്രിംഗിലേക്ക് ഉപയോഗിക്കുന്ന എല്ലാ ഷെൽ വേരിയബിളുകളും ആരംഭിക്കുന്ന വിഭാഗം ചേർക്കുന്നു.

c_h_weed ഉത്പാദിപ്പിക്കുന്നു config_h.SH ഫയൽ. ആവശ്യമായ വരികൾ മാത്രം അച്ചടിക്കുന്നു.

cm_h_weed ഉത്പാദിപ്പിക്കുന്നു confmagic.h ഫയൽ. ആവശ്യമായ വരികൾ മാത്രം അച്ചടിക്കുന്നു. ഈ
എപ്പോൾ മാത്രമേ കമാൻഡ് പ്രവർത്തനക്ഷമമാകൂ -M സ്വിച്ച് നൽകിയിരിക്കുന്നു, അല്ലെങ്കിൽ എപ്പോൾ confmagic.h ഫയല്
ഇതിനകം നിലവിലുണ്ട്.

അടയ്ക്കുക.Config_sh
ഇവിടെയുള്ള പ്രമാണം അവസാനിപ്പിക്കാൻ ഒരു വരിയിൽ തന്നെ അവസാന 'EOT' ചിഹ്നം ചേർക്കുന്നു
നിർമ്മിക്കുന്ന നിർമ്മാണം config.sh ഫയൽ.

prepend ലക്ഷ്യത്തിന്റെ ഉള്ളടക്കത്തെ മുൻനിറുത്തുന്നു target_file ആ ഫയൽ ശൂന്യമല്ലെങ്കിൽ.

കള ഇതിലേക്ക് യൂണിറ്റ് ചേർക്കുന്നു സജ്ജമാക്കുന്നു അത് പോലെ ചേർക്കുക കമാൻഡ് ചെയ്യുക, എന്നാൽ ചില അധിക പരിശോധനകൾ നടത്തുക
' നീക്കം ചെയ്യണോ?ചിഹ്നം' ഒപ്പം '%ചിഹ്നം' എന്നതിൽ നിന്നുള്ള വരികൾ target_file ചിഹ്നമാണെങ്കിൽ
ആവശ്യമോ വ്യവസ്ഥാപിതമോ അല്ല. '%' ഫോം ആന്തരികമായി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ
metaconfig സ്വന്തം .യു ഫയലുകൾ നിർമ്മിക്കുമ്പോൾ '.എം.ടി' ഡയറക്ടറി.

അതേ പോലെ തുടയ്ക്കുക ചേർക്കുക ശരിക്കും, പക്ഷേ ഒരു അധിക മാക്രോ സബ്സ്റ്റിറ്റ്യൂഷൻ നടത്തുന്നു. ദി
ലഭ്യമായ മാക്രോകൾ എന്നതിൽ വിവരിച്ചിരിക്കുന്നു ഹാർഡ്വെയർ മാക്രോകൾ ഖണ്ഡിക.

ഒരു സൈഡ് നോട്ട് ആയി, metaconfig a സൃഷ്ടിക്കുന്നു -കോണ്ട് സോപാധികമായി ഇടപെടാൻ ആന്തരികമായി കമാൻഡ് ചെയ്യുക
ആശ്രിതത്വങ്ങൾ. നിങ്ങൾ ഇത് സ്വയം ഉപയോഗിക്കരുത്, എന്നാൽ സ്കാൻ ചെയ്താൽ നിങ്ങൾ അത് കാണും
സൃഷ്ടിച്ചു Makefile ലെ .എം.ടി ഡയറക്ടറി.

ഹാർഡ്വെയർ മാക്രോകൾ
ഇനിപ്പറയുന്ന മാക്രോകൾ തിരിച്ചറിയുന്നു തുടച്ചുമാറ്റുക ഉൾപ്പെടുത്തുന്നതിന് മുമ്പ് കമാൻഡും മാറ്റിസ്ഥാപിച്ചു
സജ്ജമാക്കുന്നു:

പാക്കേജിന്റെ അടിസ്ഥാന പുനരവലോകന നമ്പർ, നിന്ന് ഉരുത്തിരിഞ്ഞത് .പാക്കേജ്.

നിലവിലെ തീയതി.


ഈ പാക്കേജ് പരിപാലിക്കുന്നയാളുടെ ഇമെയിൽ വിലാസം, നിങ്ങളുടേതിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതാണ്
.പാക്കേജ്.


പാക്കേജിന്റെ പേര്, നിങ്ങളിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതാണ് .പാക്കേജ് ഫയൽ.


എന്ന പാച്ച് ലെവൽ metaconfig പ്രോഗ്രാം (അനുകൂലമായി ഒഴിവാക്കി ).


യുടെ SVN റിവിഷൻ ലെവൽ metaconfig പ്രോഗ്രാം.

പതിപ്പ് നമ്പർ metaconfig പ്രോഗ്രാം.

ഇവയെ തിരിച്ചറിയാനാണ് ആ മാക്രോകൾ പ്രധാനമായും ഉപയോഗിക്കുന്നത് metaconfig എ സൃഷ്ടിച്ച പതിപ്പ്
പ്രത്യേക സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ്, ഏത് പാക്കേജിനാണ് ഇത് ചെയ്തത്. യുടെ ഇ-മെയിൽ വിലാസം
മുൻനിര നിർദ്ദേശങ്ങളിൽ മെയിന്റനർ ഹാർഡ്‌വൈഡ് ആണ് സജ്ജമാക്കുന്നു ആരംഭിക്കുമ്പോൾ പ്രിന്റുകൾ.

സമീപകാലത്തെ metaconfig ഫോമിന്റെ കൂടുതൽ പൊതുവായ വാക്യഘടന പതിപ്പുകൾ മനസ്സിലാക്കുന്നു:

<$വേരിയബിൾ>

കോൺഫിഗർ-ജനറേഷൻ സമയത്ത് അതിന്റെ മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു വേരിയബിൾ നിങ്ങളിൽ നിന്ന് എടുത്തത്
.പാക്കേജ് ഫയൽ. ഒടുവിൽ, പഴയ ഹാർഡ്‌വയർഡ് മാക്രോ ഫോർമാറ്റ് അപ്രത്യക്ഷമാകും, കൂടാതെ <$baserev>
മാറ്റിസ്ഥാപിക്കും വിതരണം ചെയ്ത എല്ലാ യൂണിറ്റുകളിലും.

പ്രത്യേക യൂണിറ്റുകൾ
കോഡ് ഫാക്‌ടറൈസ് ചെയ്യാനും ഉയർന്ന ലെവൽ നൽകാനും ഇനിപ്പറയുന്ന പ്രത്യേക യൂണിറ്റുകൾ ഉപയോഗിക്കുന്നു
പ്രവർത്തനങ്ങൾ. അവ ഒന്നുകിൽ ഉറവിടമാക്കാവുന്ന ഒരു ഷെൽ സ്ക്രിപ്റ്റ് അല്ലെങ്കിൽ ഒരു ഷെൽ നിർമ്മിക്കുന്നു
വേരിയബിൾ ആകാം പരിണാമം'ed. നന്നായി അറിയാവുന്ന വേരിയബിളുകൾ വഴിയാണ് പാരാമീറ്റർ പാസിംഗ് ചെയ്യുന്നത്
$1, $2, എന്നിങ്ങനെ പേരുള്ളതോ അജ്ഞാതമായതോ... (ഷെൽ വഴി എളുപ്പത്തിൽ സജ്ജീകരിക്കാനാകും ഗണം
ഓപ്പറേറ്റർ). എപ്പോൾ സജ്ജമാക്കുന്നു എക്സിക്യൂട്ട് ചെയ്യുന്നു, അത് സൃഷ്ടിക്കുകയും അതിലേക്ക് പോകുകയും ചെയ്യുന്നു UU ഡയറക്ടറി, അങ്ങനെ ഓരോന്നും
നിർമ്മിച്ച സ്ക്രിപ്റ്റ് അവിടെയുണ്ട്, നിങ്ങളുടെ പാക്കേജിൽ നിന്നുള്ള ഫയലുകളിൽ ഇടപെടുന്നില്ല.

നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട പ്രത്യേക യൂണിറ്റുകളും അവ ഉപയോഗിക്കേണ്ട രീതിയും ഇവിടെയുണ്ട്.

Cppsym.U
ഈ യൂണിറ്റ് ഒരു ഷെൽ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നു Cppsym, ഇത് നിർണ്ണയിക്കാൻ ഉപയോഗിക്കാം
നിങ്ങളുടെ പക്കലുള്ള സി പ്രീപ്രോസസർ അല്ലെങ്കിൽ സി കംപൈലർ ലിസ്റ്റിലെ ഏതെങ്കിലും ചിഹ്നം നിർവചിച്ചിട്ടുണ്ടോ എന്ന്
വ്യക്തമാക്കിയ. ചിഹ്നങ്ങളാണെങ്കിലും ഏത് ചിഹ്നത്തിന്റെയും നില നിർണ്ണയിക്കാൻ ഇതിന് കഴിയും
(ആട്രിബ്യൂട്ട് ലിസ്റ്റ്) കൂടുതൽ എളുപ്പത്തിൽ നിർണ്ണയിക്കപ്പെടുന്നു.

Csym.U
ഇത് ആന്തരികമായി ഉപയോഗിക്കുന്ന $csym ഷെൽ വേരിയബിളിനെ സജ്ജമാക്കുന്നു സജ്ജമാക്കുന്നു എന്ന് പരിശോധിക്കാൻ എ
നൽകിയിരിക്കുന്ന സി ചിഹ്നം നിർവചിച്ചിട്ടുണ്ടോ ഇല്ലയോ. ഒരു സാധാരണ ഉപയോഗം ഇതാണ്:

ചിഹ്ന ഫലം സജ്ജമാക്കുക [-fva] [മുമ്പത്തെ]
eval $csym

അത് സജ്ജമാക്കും ഫലം ഫംഗ്‌ഷൻ [-f] ആണെങ്കിൽ വേരിയബിൾ 'ട്രൂ', വേരിയബിൾ [-v] അല്ലെങ്കിൽ
അറേ [-a] നിർവചിച്ചിരിക്കുന്നു, അല്ലാത്തപക്ഷം 'തെറ്റ്'. മുമ്പത്തെ മൂല്യം നൽകിയിട്ടുണ്ടെങ്കിൽ, ഒപ്പം -r
എന്നതിലേക്ക് സ്വിച്ച് നൽകി സജ്ജമാക്കുന്നു (കാണാൻ സജ്ജമാക്കുന്നു ഓപ്ഷനുകൾ ഖണ്ഡിക), പിന്നെ അത്
ചോദ്യം ചെയ്യാതെ മൂല്യം വീണ്ടും ഉപയോഗിക്കുന്നു.

ഈ കണക്കുകൂട്ടൽ നടത്തുന്ന രീതി ഉപയോക്താവ് ചോദ്യത്തിന് നൽകുന്ന ഉത്തരത്തെ ആശ്രയിച്ചിരിക്കുന്നു
സജ്ജമാക്കുന്നു ഒരു നടത്തണമോ എന്ന് ചോദിക്കും nm വേർതിരിച്ചെടുക്കൽ അല്ലെങ്കിൽ ഇല്ല. എങ്കിൽ
വേർതിരിച്ചെടുക്കൽ നടത്തി, യൂണിറ്റ് ചിഹ്ന പട്ടികയിലൂടെ നോക്കുന്നു, അല്ലാത്തപക്ഷം
ഇത് ഒരു കംപൈൽ-ലിങ്ക് ടെസ്റ്റ് നടത്തുന്നു -r മുമ്പ് കണക്കാക്കിയവ വീണ്ടും ഉപയോഗിക്കുന്നതിന് നൽകി
മൂല്യം, സ്വാഭാവികമായും...

എൻഡ്.യു
ഈ യൂണിറ്റ് നിങ്ങളുടെ സ്വകാര്യതയിലേക്ക് പകർത്തുന്നതിലൂടെ U ഡയറക്ടറിയും അനുബന്ധ ഡിപൻഡൻസികളും
?ഉണ്ടാക്കുക: ലൈൻ, തന്നിരിക്കുന്ന യൂണിറ്റിലേക്ക് ലോഡ് ചെയ്യാൻ നിങ്ങൾക്ക് നിർബന്ധിക്കാം സജ്ജമാക്കുന്നു ഇല്ലെങ്കിലും
അല്ലാത്തപക്ഷം വേണം. ചില യൂണിറ്റുകൾ നിർബന്ധിതമായി മാത്രമേ ഉപയോഗിക്കാവൂ സജ്ജമാക്കുന്നു ആ വഴി.

Filexp.U
ഈ യൂണിറ്റ് ഒരു ഷെൽ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നു filexp എന്ന് തുടങ്ങുന്ന ഫയൽനാമങ്ങൾ വികസിപ്പിക്കും
ടിൽഡുകൾ. ഒരു സാധാരണ ഉപയോഗം ഇതാണ്:

exp_name=`./filexp $name`

വിപുലീകരിച്ച ഫയലിന്റെ പേര് നൽകുന്നതിന് exp_name.

Findhdr.U
ഈ യൂണിറ്റ് എ ഉത്പാദിപ്പിക്കുന്നു findhdr ഹെഡ്ഡർ ഫയലുകൾ കണ്ടെത്താൻ ഉപയോഗിക്കുന്ന സ്ക്രിപ്റ്റ്
$usrinc അല്ലെങ്കിൽ cpp കഴിവുകൾ ഉപയോഗിക്കുന്ന മറ്റ് അപരിചിത സ്ഥലങ്ങൾ. തിരക്കഥ ഒരു നൽകിയിട്ടുണ്ട്
'stdio.h' അല്ലെങ്കിൽ 'sys/file.h' പോലുള്ള ഫയലിന്റെ അടിസ്ഥാന നാമം ഉൾപ്പെടുത്തുക, ഇത് പൂർണ്ണമായ പാത നൽകുന്നു
inlcude ഫയലും കണ്ടെത്തിയാൽ പൂജ്യം നിലയും അല്ലെങ്കിൽ ഒരു ശൂന്യമായ സ്ട്രിംഗും പൂജ്യമല്ലാത്ത നിലയും
ഫയൽ കണ്ടെത്താൻ കഴിയുന്നില്ലെങ്കിൽ.

Getfile.U
ഈ യൂണിറ്റ് ഒരു ഫയൽ ലഭിക്കുന്നതിന് സോഴ്സ് ചെയ്യേണ്ട ഷെൽ കോഡിന്റെ ഒരു ബിറ്റ് നിർമ്മിക്കുന്നു
പേര് നൽകുകയും ചില സാനിറ്റി പരിശോധനകൾ നടത്തുകയും ചെയ്യുക. ഓപ്ഷണലായി, ഒരു ~പേര് വിപുലീകരണം നടത്തുന്നു.

ഈ യൂണിറ്റ് ഉപയോഗിക്കുന്നതിന്, $rp ഒപ്പം $dflt ചോദ്യവും സ്ഥിരസ്ഥിതി ഉത്തരവും കൈവശം വയ്ക്കണം
എന്ന നിലയിലേക്ക് പാസാക്കും myread സ്ക്രിപ്റ്റ് (വരാനിരിക്കുന്നവ കാണുക മൈറെഡ്.യു). എസ് $fn
വേരിയബിൾ പ്രവർത്തനത്തെ നിയന്ത്രിക്കുകയും ഫലം തിരികെ നൽകുകയും ചെയ്യുന്നു $ans.

ഒരു ഫയലോ ഡയറക്ടറിയോ കണ്ടെത്തുന്നതിന്, 'f' അല്ലെങ്കിൽ 'd' ഇടുക f~/. ഒരു '~' പ്രത്യക്ഷപ്പെടുകയാണെങ്കിൽ, ~പേര്
പകരം വയ്ക്കൽ അനുവദനീയമാണ്. ഒരു '/' ദൃശ്യമാകുകയാണെങ്കിൽ, കേവലമായ പാതനാമങ്ങൾ മാത്രമേ സ്വീകരിക്കുകയുള്ളൂ
~പേര് മാറ്റിസ്ഥാപിക്കലുകൾ എപ്പോഴും മടങ്ങുന്നതിന് മുമ്പ് വിപുലീകരിക്കും. '+' വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ,
അസ്തിത്വ പരിശോധനകൾ ഒഴിവാക്കിയിരിക്കുന്നു. ഉള്ളിൽ 'n' പ്രത്യക്ഷപ്പെടുകയാണെങ്കിൽ $fn, തുടർന്ന് ഉപയോക്താവിന് അനുമതിയുണ്ട്
'ഒന്നുമില്ല' എന്ന് ഉത്തരം നൽകുക.

സാധാരണയായി, നിങ്ങൾ പോർട്ടബിലിറ്റി ആവശ്യപ്പെട്ടില്ലെങ്കിൽ, അഭ്യർത്ഥിക്കുമ്പോൾ ~പേര് പകരം വയ്ക്കൽ സംഭവിക്കുന്നു.
എന്നിരുന്നാലും, പോർട്ടബിലിറ്റി ഒഴിവാക്കാനും നിർബന്ധിതമാക്കാനും നിങ്ങൾ ആഗ്രഹിക്കുന്ന ചില സമയങ്ങളുണ്ട്
പകരംവയ്ക്കൽ. അത് ചെയ്യാൻ നിങ്ങൾക്ക് 'ഇ' അക്ഷരം (വികസിപ്പിക്കുക) ഉപയോഗിക്കാം.

പ്രത്യേക 'l' (ലൊക്കേറ്റ്) തരം ഉപയോഗിച്ചാൽ, പിന്നെ $fn വേരിയബിൾ ഒരു ':' എന്നതിൽ അവസാനിക്കണം,
ഒരു ഫയൽ അടിസ്ഥാനനാമം പിന്തുടരുന്നു. ഉത്തരം ഒരു ഡയറക്ടറി ആണെങ്കിൽ, ഫയലിന്റെ അടിസ്ഥാനനാമം ആയിരിക്കും
ഫയൽ നിലനിൽപ്പിനായി പരിശോധിക്കുന്നതിന് മുമ്പ് ചേർത്തു. ലൊക്കേറ്റ് ശൈലിയിലുള്ള ചോദ്യങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാണ്
ഇതുപോലെ:

dflt='~news/lib'
: 'l' ഉപയോഗിക്കുമ്പോൾ 'd' അല്ലെങ്കിൽ 'f' വ്യക്തമാക്കേണ്ടതില്ല
fn='l~:active'
rp='സജീവമായ ഫയൽ എവിടെയാണ്?'
. ./getfile
സജീവം="$ans"

കൂടാതെ, പറയാൻ 'l' എന്നതിനൊപ്പം 'p' (പാത്ത്) അക്ഷരം ഉപയോഗിക്കാം
getfile അതിൽ '/' ഇല്ലാത്ത ഉത്തരം സ്വീകരിക്കണം എന്ന് കരുതി അത് സ്വീകരിക്കണം
ഈ മൂല്യം ആവശ്യമുള്ള സമയത്ത് എല്ലാവരുടെയും പാതയിൽ ആയിരിക്കുക.

സ്വീകരിക്കേണ്ട ഉത്തരങ്ങളുടെ ഒരു ലിസ്റ്റ് വ്യക്തമാക്കാനുള്ള സാധ്യതയും ഉപയോഗപ്രദമാണ്
പദാനുപദം, എല്ലാ പരിശോധനകളും മറികടന്ന്. ഈ ലിസ്റ്റ് പരാൻതീസിസിലും ഇനങ്ങളിലും ആയിരിക്കണം
ഇന്റർലീവിംഗ് സ്‌പെയ്‌സുകളില്ലാതെ കോമ വേർതിരിക്കേണ്ടതാണ്. ഉദ്ധരിക്കാൻ മറക്കരുത്
പരാന്തീസിസ് ഷെല്ലിന് അർത്ഥവത്തായതിനാൽ ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ്. ഉദാഹരണത്തിന്:

dflt='/bin/install'
fn='/fe~(install,./install)'
rp='ഏത് ഇൻസ്റ്റോൾ പ്രോഗ്രാം ഉപയോഗിക്കണം?'
. ./getfile
ഇൻസ്റ്റാൾ="$ans"

നിലവിലുള്ള ഫയലുകളെ പരാമർശിക്കുന്ന പൂർണ്ണ യോഗ്യതയുള്ള പാതകൾ മാത്രം വ്യക്തമാക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കും,
എന്നിട്ടും പ്രത്യേക "ഇൻസ്റ്റാൾ", "./ഇൻസ്റ്റാൾ" എന്നീ ഉത്തരങ്ങൾ അതേപടി അനുവദിക്കുക (അത് അനുമാനിക്കുക
തീർച്ചയായും എന്തെങ്കിലും അവർ ചെയ്യുന്നതിനാൽ പിന്നീട് ശൃംഖലയിൽ പ്രത്യേകമായി അവരുമായി ഇടപെടും
പൊതുവായ പ്രതീക്ഷിത ഫ്രെയിമുമായി പൊരുത്തപ്പെടുന്നില്ല).

ചോദ്യത്തിനുള്ള ഉത്തരം 'ഒന്നുമില്ല' എന്നാണെങ്കിൽ, അസ്തിത്വ പരിശോധനകൾ ഒഴിവാക്കുകയും ചെയ്യും
ശൂന്യമായ സ്ട്രിംഗ് തിരികെ ലഭിച്ചു. അത് മുതൽ ശ്രദ്ധിക്കുക getfile കോളുകൾ myread ആന്തരികമായി, എല്ലാം
ലഭ്യമായ സവിശേഷതകൾ myread ഇവിടെ പ്രയോഗിക്കുക.

പൂർണ്ണമായി വിപുലീകരിച്ച മൂല്യം ആവശ്യമാണെങ്കിൽ (ഉദാഹരണത്തിന് ഒരു Makefile ൽ), നിങ്ങൾക്ക് ഉപയോഗിക്കാം
The $ansexp എല്ലായ്പ്പോഴും ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്ന വേരിയബിൾ getfile വികസിപ്പിച്ചതുപോലെ
പതിപ്പ് $ans. തീർച്ചയായും, നിങ്ങൾ അത് അനുവദിച്ചില്ലെങ്കിൽ ~പേര് വികസിപ്പിക്കില്ല
ൽ ഒന്നാം സ്ഥാനം $fn വേരിയബിൾ.

Inhdr.U
ഈ യൂണിറ്റ് ഉത്പാദിപ്പിക്കുന്നു $inhdr ഷെൽ വേരിയബിൾ, ആന്തരികമായി ഉപയോഗിക്കുന്നത് സജ്ജമാക്കുന്നു പരിശോധിക്കാൻ
ഒരു കൂട്ടം തലക്കെട്ടുകൾ നിലവിലുണ്ടോ ഇല്ലയോ എന്ന്. ഒരു സാധാരണ ഉപയോഗം ഇതാണ്:

തലക്കെട്ട് i_header സജ്ജീകരിക്കുക [ header2 i_header2 ... ]
eval $inhdr

അത് ഹെഡ്ഡർ കണ്ടെത്തിയോ ഇല്ലയോ എന്ന് പറഞ്ഞ് ഒരു സന്ദേശം പ്രിന്റ് ചെയ്യുകയും സജ്ജീകരിക്കുകയും ചെയ്യും
i_header അതിനനുസരിച്ച് വേരിയബിൾ. ഒന്നിലധികം തലക്കെട്ടുകൾ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ ആദ്യത്തേത്
തലക്കെട്ട് കണ്ടെത്തിയില്ല, ലിസ്റ്റ് ശൂന്യമാകുന്നതുവരെ അല്ലെങ്കിൽ ഒന്ന് കണ്ടെത്തുന്നത് വരെ ഞങ്ങൾ അടുത്തത് പരീക്ഷിക്കുന്നു.

Inlibc.U
ഈ യൂണിറ്റ് ഉത്പാദിപ്പിക്കുന്നു $inlibc ഷെൽ വേരിയബിൾ, ആന്തരികമായി ഉപയോഗിക്കുന്നത് സജ്ജമാക്കുന്നു പരിശോധിക്കാൻ
തന്നിരിക്കുന്ന C ഫംഗ്‌ഷൻ നിർവചിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്ന്. ഒരു സാധാരണ ഉപയോഗം ഇതാണ്:

ഫംഗ്ഷൻ d_func സജ്ജമാക്കുക
eval $inlibc

ഫംഗ്‌ഷൻ കണ്ടെത്തിയോ ഇല്ലയോ എന്ന് പറഞ്ഞുകൊണ്ട് അത് ഒരു സന്ദേശം പ്രിന്റ് ചെയ്യും
$d_func അതനുസരിച്ച്. ആന്തരികമായി, അത് ഉപയോഗിച്ചു $csym ദിനചര്യ.

ലോക്ക്.യു
ഈ പ്രധാന യൂണിറ്റ് ഒരു ഷെൽ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നു സ്ഥലം എവിടെയാണെന്ന് കണ്ടെത്താൻ ഇത് ഉപയോഗിക്കാം
ഡയറക്‌ടറികളുടെ ഒരു പട്ടികയിൽ തന്നിരിക്കുന്ന ഫയൽ കിടക്കുന്നു. ആദ്യ ആർഗ്യുമെന്റ് ഫയലിനെ വ്യക്തമാക്കുന്നു
കണ്ടെത്തുക, രണ്ടാമത്തെ വാദം തിരച്ചിൽ പരാജയപ്പെട്ടാൽ എന്താണ് തിരികെ ലഭിക്കുക എന്നതാണ്
ഫയൽ തിരയേണ്ട ഡയറക്‌ടറികളുടെ ഒരു ലിസ്റ്റാണ് റീമൈനിംഗ് ആർഗ്യുമെന്റുകൾ. വേണ്ടി
ഉദാഹരണം:

dflt=`./loc sendmail.cf X / Usr / lib /var/lib/sendmail / ലിബ്`

സജ്ജമാക്കും $dflt ലേക്ക് X അല്ലെങ്കിൽ sendmail.cf ലിസ്റ്റുചെയ്ത ഡയറക്‌ടറികൾക്ക് കീഴിൽ ഫയൽ കണ്ടെത്തി,
അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും /usr/lib/sendmail.cf ചില സിസ്റ്റങ്ങളിൽ. ഇതും കാണുക Getfile.U.

MailAuthor.U
ഈ യൂണിറ്റ് നിർമ്മിക്കാൻ നിങ്ങളുടെ സ്വന്തം സ്വകാര്യ End.U ന്റെ ?MAKE: ലൈനിൽ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്
അതിലേക്ക് സജ്ജമാക്കുന്നു. ഓപ്ഷണലായി രചയിതാവിന് സ്വയം രജിസ്റ്റർ ചെയ്യാൻ ഇത് ഉപയോക്താവിനെ വാഗ്ദാനം ചെയ്യുന്നു
പുതിയ പാച്ചുകൾ വരുമ്പോൾ അറിയിക്കുന്നു അല്ലെങ്കിൽ നൽകുമ്പോൾ അവ സ്വയമേവ സ്വീകരിക്കുന്നു.
നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട് തപാൽക്കാരൻ ഇത് ചെയ്യുന്നതിന് (കുറഞ്ഞത് പതിപ്പ് 3.0).

MailList.U
ഈ യൂണിറ്റ് നിർമ്മിക്കാൻ നിങ്ങളുടെ സ്വന്തം സ്വകാര്യ End.U ന്റെ ?MAKE: ലൈനിൽ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്
അതിലേക്ക് സജ്ജമാക്കുന്നു. മെയിലിംഗ് ലിസ്റ്റിലേക്ക് സബ്‌സ്‌ക്രൈബുചെയ്യാനോ അൺസബ്‌സ്‌ക്രൈബ് ചെയ്യാനോ ഇത് ഉപയോക്താവിനെ വാഗ്ദാനം ചെയ്യുന്നു
പാക്കേജുമായി ബന്ധപ്പെട്ട ചർച്ചകൾ നടക്കുന്നത്. നിങ്ങൾ ഓടണം പാക്കിനിറ്റ്
നിങ്ങളുടെ ശരിയായ വേരിയബിളുകൾ സജ്ജീകരിക്കുന്നതിന് മെയിലിംഗ് ലിസ്റ്റുമായി ബന്ധപ്പെട്ട ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുക
.പാക്കേജ് ഈ യൂണിറ്റ് പ്രവർത്തനക്ഷമമാകുന്നതിന് മുമ്പ്.

മൈനിറ്റ്.യു
ഈ യൂണിറ്റ് നിങ്ങളുടെ സ്വകാര്യതയിലേക്ക് പകർത്തുക U നിങ്ങളുടെ സ്വന്തം ഡിഫോൾട്ട് മൂല്യങ്ങൾ ചിലതിലേക്ക് ചേർക്കുന്നതിനുള്ള ഡയറക്ടറി
ആന്തരിക വേരിയബിളുകൾ. ഈ യൂണിറ്റ് ലോഡുചെയ്‌തു സജ്ജമാക്കുന്നു എല്ലാ സ്ഥിരസ്ഥിതിക്കും ശേഷം
പ്രാരംഭ പ്രവർത്തനങ്ങൾ നടത്തി.

മൈറെഡ്.യു
ഈ യൂണിറ്റ് ഉത്പാദിപ്പിക്കുന്നു myread ഷെൽ സ്ക്രിപ്റ്റ്, അത് സോഴ്സ് ചെയ്യണം
വായിച്ചു. ഇത് ഷെൽ എസ്കേപ്പുകളും ഡിഫോൾട്ട് അസൈൻമെന്റും പാരാമീറ്റർ മൂല്യനിർണ്ണയവും അനുവദിക്കുന്നു
Instruct.U യൂണിറ്റിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്. ഇത് ഡൈനാമിക് സജ്ജീകരണവും അനുവദിക്കുന്നു -d ഓപ്ഷൻ,
സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂഷന്റെ ശേഷിക്കുന്ന ഭാഗത്തിന് ഇത് ഉപയോഗിക്കും.

ഈ യൂണിറ്റ് ഉപയോഗിക്കുന്നതിന്, $rp ചോദ്യം ഹോൾഡ് ചെയ്യണം $dflt സ്ഥിരസ്ഥിതി അടങ്ങിയിരിക്കണം
ഉത്തരം. ചോദ്യം സ്ക്രിപ്റ്റ് തന്നെ പ്രിന്റ് ചെയ്യും, ഫലം തിരികെ നൽകും
ലെ $ans വേരിയബിൾ.

ഒരു സാധാരണ ഉപയോഗം ഇതാ:

dflt='y'
rp='ചോദ്യം?'
. ./myread
മൂല്യം="$ans"

കൂടുതൽ വിവരങ്ങൾക്ക് യൂണിറ്റ് തന്നെ കാണുക.

Oldconfig.U
ഈ യൂണിറ്റ് നിങ്ങളുടെ ആശ്രിതത്വത്തിന്റെ ഭാഗമായിരിക്കണം ?ഉണ്ടാക്കുക: നിങ്ങളുടെ ചില യൂണിറ്റുകൾ ശ്രമിക്കുമ്പോൾ ലൈൻ
ഒരു പഴയ ചിഹ്ന മൂല്യം വീണ്ടും ഉപയോഗിക്കുന്നതിന്. പഴയ ഉത്തരങ്ങൾ ലഭിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം ഈ യൂണിറ്റിനാണ്
നിന്ന് config.sh അല്ലെങ്കിൽ ഒരു നിശ്ചിത പ്ലാറ്റ്‌ഫോമിൽ പ്രവർത്തിക്കുമ്പോൾ ഉപയോഗപ്രദമായ സൂചനകൾ നൽകുന്നു
ആദ്യതവണ. കാണുക സജ്ജമാക്കുന്നു സൂചനകൾ സൂചനകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് ഖണ്ഡിക.

പ്രിഫിക്‌സിറ്റ്.യു
ഈ യൂണിറ്റിന്റെ ഉദ്ദേശ്യം ഇൻസ്റ്റലേഷൻ പ്രിഫിക്‌സ് ഡയറക്‌ടറിയിലെ മാറ്റങ്ങൾ കണ്ടെത്തുക എന്നതാണ്
മുമ്പത്തെ ഉത്തരങ്ങളിൽ നിന്ന് സ്വയമേവ അനുയോജ്യമായ ഡിഫോൾട്ടുകൾ വീണ്ടും കണക്കാക്കുക. ഇത് ആശ്രയിക്കുന്നു
മൂല്യം $oldprefix മുമ്പത്തെ പ്രിഫിക്‌സ് ഡയറക്‌ടറി കൈവശമുള്ള വേരിയബിൾ
മാറ്റി, അല്ലെങ്കിൽ ശൂന്യമാണ്. ഉദാഹരണത്തിന്, പ്രിഫിക്‌സ് മാറ്റിയിട്ടുണ്ടെങ്കിൽ / ഓപ്റ്റ് ലേക്ക്
/ usr / local, അപ്പോൾ മുമ്പത്തെ ബൈനറി ഇൻസ്റ്റലേഷൻ ഡയറക്‌ടറിയിൽ നിന്നും മാറ്റപ്പെടും
/opt/bin ലേക്ക് / usr / local / bin, അല്ലെങ്കിൽ അങ്ങനെയാണെങ്കിൽ മാറ്റമില്ലാതെ തുടരും, പറയുക, / ബിൻ.

നിങ്ങൾ വിളിക്കേണ്ടതുണ്ട് ഗണം ഒരു പുറപ്പെടുവിക്കുന്നതിന് മുമ്പ് പരിണാമം on $പ്രിഫിക്‌സിറ്റ്, അതുപോലെ:

dflt var [dir] സജ്ജമാക്കുക
eval $ prefixit

ഏത് സജ്ജമാക്കും $dflt ലേക്ക് $var or $പ്രിഫിക്സ്/ദിയർ പ്രിഫിക്സ് നിലനിന്നിരുന്നോ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു
ഒരേ അല്ലെങ്കിൽ അല്ല. എങ്കിൽ മുതലാളി ചരടാണ് ആരും, ഒരൊറ്റ സ്പേസ് മൂല്യം $dflt ആയി സൂക്ഷിച്ചിരിക്കുന്നു-
പ്രിഫിക്‌സ് മാറുമ്പോൾ പോലും. എങ്കിൽ മുതലാളി അപ്പോൾ ഒഴിവാക്കിയിരിക്കുന്നു $dflt ശൂന്യമായി സജ്ജീകരിച്ചിരിക്കുന്നു
പ്രിഫിക്സ് മാറിയെങ്കിൽ സ്ട്രിംഗ്, to $var അല്ലെങ്കിൽ.

പ്രിഫിക്സപ്പ്.യു
തിറ്റ് യൂണിറ്റിന്റെ ഉദ്ദേശം Prefixit.U യുടെ ഉദ്ദേശ്യത്തിന് സമാനമാണ്, അതായത് ഇത് പരിഹരിക്കാൻ സഹായിക്കുന്നു
പ്രിഫിക്സ് മാറ്റങ്ങൾ ഉൾക്കൊള്ളാൻ ഡിഫോൾട്ട് സ്ട്രിംഗ്. എന്നിരുന്നാലും, ഷെൽ വേരിയബിൾ $പ്രിഫിക്സപ്പ്,
മൂല്യനിർണ്ണയം ചെയ്യുമ്പോൾ, ~പേര് വിപുലീകരണങ്ങൾ മാത്രമേ പുനഃസ്ഥാപിക്കുകയുള്ളൂ, പ്രിഫിക്‌സ് അത്തരം ഒരു രക്ഷപ്പെടൽ ഉപയോഗിക്കണം
മെക്കാനിസം. ഇത് ഇതായി ഉപയോഗിക്കുക:

dflt സജ്ജമാക്കുക
eval $ prefixup

വഴി ആവശ്യപ്പെടുന്നതിന് മുമ്പ് getfile ഉദാഹരണത്തിന്. പ്രിഫിക്‌സ് ~പേര് ഉപയോഗിക്കുന്നില്ലെങ്കിൽ
വിപുലീകരണം, അപ്പോൾ മുകളിൽ പറഞ്ഞവ ഒരു നോ-ഓപ് ആയിരിക്കും y വേരിയബിൾ, സ്വാഭാവികമായും.

ടൈപ്പ്ഡെഫ്.യു
ഈ യൂണിറ്റ് ഉത്പാദിപ്പിക്കുന്നു $typedef ഷെൽ വേരിയബിൾ, ആന്തരികമായി ഉപയോഗിക്കുന്നത് സജ്ജമാക്കുന്നു പരിശോധിക്കാൻ
ഒരു ടൈപ്പ്ഡെഫ് നിലവിലുണ്ടോ ഇല്ലയോ എന്ന്. ഒരു സാധാരണ ഉപയോഗം ഇതാണ്:

ടൈപ്പ്ഡെഫ് val_t ഡിഫോൾട്ട് സജ്ജമാക്കുക [ഉൾപ്പെടുന്നു]
eval $typedef

ഇത് വേരിയബിൾ സജ്ജമാക്കും val_t മൂല്യത്തിലേക്ക് സ്ഥിരസ്ഥിതി ടൈപ്പ്ഡെഫ് കണ്ടെത്തിയില്ലെങ്കിൽ
ലിസ്റ്റുചെയ്തവയിൽ ഫയലുകൾ ഉൾപ്പെടുന്നു, അല്ലെങ്കിൽ ടൈപ്പ്ഡ് കണ്ടെത്തിയാൽ. ഉൾപ്പെടുത്തിയ ഫയലുകൾ ഇല്ലെങ്കിൽ
വ്യക്തമാക്കിയിരിക്കുന്നു, യൂണിറ്റ് നോക്കുന്നു മാത്രം. ചിലത് ഉൾപ്പെടുന്നുവെന്ന് നിങ്ങൾ വ്യക്തമാക്കുകയാണെങ്കിൽ, മാത്രം
അവ നോക്കുന്നു.

Unix.U
ഈ യൂണിറ്റിന്റെ ഉദ്ദേശ്യം ഏറ്റവും സാധാരണമായ ചില UNIX-isms വേരിയബിളുകൾ വഴി നിർവചിക്കുക എന്നതാണ്
കമാൻഡ് ലൈനിൽ നിന്നോ ശരിയായ സൂചന ഫയലുകൾ വഴിയോ മാറ്റം വരുത്താൻ കഴിയും. പ്രത്യേകിച്ച്,
$_exe, $_o ഒപ്പം $_a സജ്ജീകരിച്ചിരിക്കുന്നു. എല്ലാ യൂണിറ്റുകളും റഫർ ചെയ്യണം $_o അല്ല .o നേരിട്ട്.
'.' ഈ വേരിയബിളുകളുടെ ഭാഗമാണ്.

സേത്വർ.യു
ഈ യൂണിറ്റ് വേരിയബിൾ നിർമ്മിക്കുന്നു, ഇത് ആന്തരികമായി ഉപയോഗിക്കുന്നു സജ്ജമാക്കുന്നു ഒരു സജ്ജീകരിക്കുന്നതിന്
നിര്വചിക്കുകനൽകിയിരിക്കുന്ന ചിഹ്നത്തിന് /undef മൂല്യം, അത് പെട്ടെന്ന് മാറുമ്പോൾ ഒരു മുന്നറിയിപ്പ് പുറപ്പെടുവിക്കുന്നു
മുമ്പത്തെ മൂല്യത്തിൽ നിന്ന്. ഉദാഹരണത്തിന്:

val="$define"
d_variable സജ്ജമാക്കുക
eval $setvar

മുമ്പത്തേതാണെങ്കിൽ $d_variable മൂല്യം അസാധുവായിരുന്നു $val വ്യത്യസ്തമാണ്, "ആരാ"
മുന്നറിയിപ്പ് നൽകിയിട്ടുണ്ട്.

ഹൂ.യു
ഈ യൂണിറ്റ് ഉത്പാദിപ്പിക്കുന്നു ആരാ സ്ക്രിപ്റ്റ്, എപ്പോൾ ഒരു മുന്നറിയിപ്പ് പുറപ്പെടുവിക്കുന്നു മൂല്യം വേരിയബിളിൽ
ആരുടെ പേരാണ് $var അതിന്റെ പഴയ മുൻ മൂല്യത്തിന് തുല്യമല്ല $ ആയിരുന്നു. മേൽ
മടങ്ങുക, $td ഒപ്പം $tu ശരിയായ മൂല്യം നിലനിർത്തുക നിര്വചിക്കുക or undef വേരിയബിൾ. കാണുക
ഉദാഹരണങ്ങളിൽ Inlibc.U.

ബിൽറ്റിൻ പ്രീ-പ്രോസസർ
ഓരോ യൂണിറ്റും ഉൾപ്പെടുത്തണം സജ്ജമാക്കുന്നു ഒരു ബിൽറ്റ്-ഇൻ പ്രീ-പ്രൊസസ്സറിലൂടെ പ്രവർത്തിക്കുന്നു. പ്രീ-
പ്രോസസ്സർ പ്രസ്താവനകൾ അവതരിപ്പിക്കുന്നത് '@' പ്രതീകമാണ് ('#' എന്നത് ഷെൽ കമന്റാണ്
സ്വഭാവം). സി പ്രീ-പ്രോസസർ ചെയ്യുന്നതുപോലെ ഇത് പ്രവർത്തിക്കുന്നു, പക്ഷേ ഷെല്ലിനും പേളിനും അനുവദിക്കുന്നു
രക്ഷപ്പെടുന്നു. ലഭ്യമായ പ്രവർത്തനങ്ങൾ ഇതാ:

@എങ്കിൽ പദപ്രയോഗം
If പദപ്രയോഗം ശരിയാണ്, @end, @elsif അല്ലെങ്കിൽ @else വരെ കോഡ് ലോഡ് ചെയ്യുന്നത് തുടരുക.

@elsif പദപ്രയോഗം
ഇതര തിരഞ്ഞെടുപ്പ്. എങ്കിൽ പദപ്രയോഗം ശരിയാണ്, @end വരെ കോഡ് ലോഡ് ചെയ്യുന്നത് തുടരുക,
മറ്റൊരു @elsif അല്ലെങ്കിൽ @else.

@ if ആണെങ്കിൽ @else ഡിഫോൾട്ട് കോഡ് ലോഡ് ചെയ്യണം പദപ്രയോഗം തെറ്റായിരുന്നു, അതിലൊന്നും ഇല്ല
ഓപ്ഷണൽ @elsif പൊരുത്തപ്പെട്ടു. @end വരെ ലോഡ് ചെയ്യുക.

@end @if തുറന്ന സോപാധിക ലോഡിംഗ് സ്റ്റേറ്റ്മെന്റ് അടയ്ക്കുക.

@നിർവചിക്കുക ചിഹ്നം
പ്രീ-പ്രോസസറോട് അത് പറയുന്നു ചിഹ്നം ഇപ്പോൾ മുതൽ നിർവ്വചിച്ചിരിക്കുന്നു.

സോപാധിക പദപ്രയോഗം ചിഹ്ന നാമങ്ങൾ ഉൾപ്പെടുത്താം (ചിഹ്നം വേണമെങ്കിൽ മൂല്യം ശരിയാണ് അല്ലെങ്കിൽ
വഴി നിർവചിച്ചിരിക്കുന്നത് @നിർവചിക്കുക അല്ലെങ്കിൽ ഷെൽ/പേൾ രക്ഷപ്പെടുന്നു. ഉപയോഗിച്ച് ആ ആറ്റങ്ങളെ സംയോജിപ്പിക്കാം
പരമ്പരാഗത ബൂളിയൻ ഓപ്പറേറ്റർമാർ '!' നിഷേധത്തിന്, '&&' ലോജിക്കൽ, കൂടാതെ '||' ലോജിക്കൽ വേണ്ടി
അഥവാ.

ഒറ്റ ബ്രാക്കറ്റിനുള്ളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന വാചകം ഒരു ഷെൽ ടെസ്റ്റാണ്, അതേസമയം ഇരട്ട ബ്രാക്കറ്റുകൾക്കിടയിലുള്ള വാചകം
ഒരു പേൾ ടെസ്റ്റ്. അതായത് പദപ്രയോഗങ്ങൾ:

{ ഷെൽ ടെക്സ്റ്റ് }
{{ മുത്ത് ടെക്സ്റ്റ് }}

ഇതിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടുന്നു:

if ഷെൽ ടെക്സ്റ്റ് >/dev/null 2>&1; തുടർന്ന് 0-ൽ നിന്ന് പുറത്തുകടക്കുക; വേറെ എക്സിറ്റ് 1; fi
if (മുത്ത് ടെക്സ്റ്റ്) {എക്‌സിറ്റ് 0;} അല്ലെങ്കിൽ {എക്‌സിറ്റ് 1;}

കൂടാതെ എക്സിറ്റ് സ്റ്റാറ്റസ് ഒരു ബൂളിയൻ മൂല്യം ലഭിക്കുന്നതിന് സ്റ്റാൻഡേർഡ് രീതിയിൽ ഉപയോഗിക്കുന്നു, അതായത് 0 ശരിയാണ്
മറ്റെല്ലാം വ്യാജമാണ്. വരെ, ലളിതമായ വ്യവസ്ഥകൾ മാത്രമേ perl-ൽ പ്രകടിപ്പിക്കാൻ കഴിയൂ എന്നത് ശ്രദ്ധിക്കുക
ചില സങ്കീർണ്ണമായ കോഡുകൾ ഉള്ളിൽ ലോഡ് ചെയ്യാൻ കഴിയും metaconfig നിർവ്വഹിക്കുകയും ചെയ്തു.

ബിൽറ്റ്-ഇൻ പ്രീ-പ്രൊസസർ ചില യൂണിറ്റുകൾ നന്നായി ട്യൂൺ ചെയ്യാൻ ഉപയോഗിക്കാം (കാണുക d_gethname.U ഒരു വേണ്ടി
സങ്കീർണ്ണമായ ഉദാഹരണം) പ്രോഗ്രാമോ ഫയലുകളോ യഥാർത്ഥത്തിൽ ഉപയോഗിക്കുന്ന ചിഹ്നങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു
വിതരണത്തിൽ ഉണ്ട്. ഉദാഹരണത്തിന്, ദി Oldconfig.U ഇതുപോലുള്ള ഒരു ടെസ്റ്റ് ഉപയോഗിക്കുന്നു:

@if {test -d ../hints}

ഒപ്പം സജ്ജമാക്കുന്നു ഒരു ഉണ്ടെങ്കിൽ മാത്രം സൂചന-ആശ്രിത കോഡ് അടങ്ങിയിരിക്കും സൂചനകൾ എന്ന ഡയറക്ടറി
പാക്കേജിന്റെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറി. ' എന്നതിനുള്ളിൽ നിന്നാണ് പരിശോധനകൾ നടത്തുന്നത് എന്നത് ശ്രദ്ധിക്കുക..എം.ടിഡയറക്ടറി,
അതിനാൽ ടെസ്റ്റിൽ ആവശ്യമായ '../'.

ഒരു ചിഹ്നം ഇല്ലാത്തപ്പോൾ ഉപയോഗശൂന്യമായ കോഡ് ഇടുന്നത് ഒഴിവാക്കാനും പ്രീ-പ്രൊസസർ ഉപയോഗിക്കാം
നിർവചിച്ചിരിക്കുന്നത്. ഒന്നിലധികം ചിഹ്നങ്ങൾ നിർവചിക്കുന്ന യൂണിറ്റുകൾ അങ്ങനെ സംരക്ഷിക്കപ്പെടാം (യൂണിറ്റ് ആയതിനാൽ
മൊത്തത്തിൽ ലോഡ് ചെയ്‌തത്) @if/@end ജോഡിക്കുള്ളിൽ ചിഹ്ന-ആശ്രിത കോഡ് ശേഖരിക്കുന്നതിലൂടെ. വേണ്ടി
ഉദാഹരണം:

@എങ്കിൽ I_TIME || I_SYS_TIME || I_SYS_TIME_KERNEL
need_time_h='ശരി'
@മറ്റും
need_time_h='false'
@അവസാനിക്കുന്നു

നിയന്ത്രിക്കുന്ന മൂന്ന് ചിഹ്നങ്ങളിൽ ഒന്ന് സോഴ്സ് കോഡ് ഉപയോഗിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കും
The സമയം. എച്ച് or sys/time.h ഉൾപ്പെടുത്തുകയും അതിനനുസരിച്ച് ഷെൽ ചിഹ്നം നിർവ്വചിക്കുകയും ചെയ്യുക. അത് നൽകുന്നു
സജ്ജമാക്കുന്നു സ്രോതസ്സുകൾക്ക് എന്താണ് വേണ്ടതെന്നതിനെക്കുറിച്ചുള്ള ഒരു ഫീഡ്ബാക്ക്, പരിഹരിച്ചതിന്റെ പോരായ്മ ഒഴിവാക്കുക
ശീതീകരിച്ച യൂണിറ്റുകൾ.

'?W:' ലൈനുകൾ വഴി, നിങ്ങൾക്ക് ഇന്റർസ്റ്റിംഗ് കോമ്പിനേഷനുകൾ ലഭിക്കും. ഉദാഹരണത്തിന്, ദി i_time.U യൂണിറ്റ്
സി ഉറവിടങ്ങൾ എന്തെങ്കിലും പ്രയോജനപ്പെടുത്തുന്നുണ്ടോ എന്ന് അറിയേണ്ടതുണ്ട് സ്ട്രക്റ്റ് സമയ മേഖല തരം. അതുകൊണ്ടു,
വര:

?W::സമയമേഖല

ചിഹ്നം നിർവചിക്കുന്നതിനുള്ള അതിന്റെ പാർശ്വഫലത്തിനായി ഉപയോഗിക്കുന്നു സമയ മേഖല പ്രീ-പ്രോസസറിനായി. ദി
യൂണിറ്റ് കോഡിന് ശേഷം ഇങ്ങനെ പറയാൻ കഴിയും:

@എങ്കിൽ സമയമേഖല
'-DS_TIMEZONE' എന്നതിലെ s_timezone-നായി ''; ചെയ്യുക
@മറ്റും
s_timezone=''
@അവസാനിക്കുന്നു

... s_timezone ഉപയോഗിച്ചുള്ള കോഡ് ...

@എങ്കിൽ സമയമേഖല
ചെയ്തു
@അവസാനിക്കുന്നു

കൂടാതെ രണ്ട് തുടർച്ചയായ മൂല്യങ്ങൾ പരീക്ഷിക്കുന്ന ഒരു അധിക ലൂപ്പ് ഉണ്ടായിരിക്കുക സമയമേഖല വേരിയബിൾ, പക്ഷേ മാത്രം
ആവശ്യമെങ്കിൽ.

കാലഹരണപ്പെട്ടു ചിഹ്നങ്ങൾ
കാലഹരണപ്പെട്ട ചിഹ്നങ്ങൾ പഴയതുമായി മാറുന്നത് എളുപ്പമാക്കാൻ സംരക്ഷിക്കപ്പെടുന്നു metaconfig യൂണിറ്റുകൾ. അല്ലാതെ
The -o സ്വിച്ച് കൈമാറുന്നു metaconfig അവ അവഗണിക്കപ്പെടും. എന്നിരുന്നാലും, ഒരു കാലഹരണപ്പെട്ടു ഫയൽ ചെയ്യും
കാലഹരണപ്പെട്ട ആ ചിഹ്നങ്ങൾ ഏതൊക്കെ ഫയലുകളാണ് ഉപയോഗിക്കുന്നതെന്നും എന്തൊക്കെയാണെന്നും നിങ്ങളോട് പറഞ്ഞുകൊണ്ട് ജനറേറ്റ് ചെയ്യപ്പെടും
ഉപയോഗിക്കേണ്ട പുതിയ ചിഹ്നങ്ങളാണ്.

കാലഹരണപ്പെട്ട ചിഹ്നങ്ങളുടെ ആയുസ്സ് ഒരു പൂർണ്ണമായ പുനരവലോകനമാണ്, അതായത് അവ നീക്കം ചെയ്യപ്പെടുമ്പോൾ
അടുത്ത അടിസ്ഥാന പുനരവലോകനം ഇഷ്യു ചെയ്തു (പാച്ച് അപ്‌ഗ്രേഡുകൾ തീർച്ചയായും കണക്കാക്കില്ല). അതുകൊണ്ട്, അത്
നിങ്ങളുടെ ഉറവിടങ്ങൾ വിവർത്തനം ചെയ്യുകയും പുതിയ ചിഹ്നങ്ങൾ എത്രയും വേഗം ഉപയോഗിക്കാൻ തുടങ്ങുകയും ചെയ്യുന്നതാണ് ബുദ്ധി.

സജ്ജമാക്കുന്നു സൂചനകൾ
ആന്തരിക കോൺഫിഗറേഷൻ ലോജിക് തെറ്റായ തിരഞ്ഞെടുപ്പുകൾ നടത്തുന്നത് സംഭവിക്കാം. വേണ്ടി
ഉദാഹരണത്തിന്, ചില പ്ലാറ്റ്ഫോമിൽ, ദി vfork() സിസ്റ്റം കോൾ നിലവിലുണ്ടെങ്കിലും തകർന്നിരിക്കുന്നു, അതിനാൽ അത് ചെയ്യണം
ഉപയോഗിക്കാൻ പാടില്ല. ആ അറിവ് യൂണിറ്റുകളിൽ തന്നെ ഉൾപ്പെടുത്താൻ സാധ്യമല്ല, കാരണം
അത് വെണ്ടർ ഒടുവിൽ പരിഹരിക്കുന്ന ഒരു താൽക്കാലിക പ്രശ്‌നമായിരിക്കാം, അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും
ഒരു പുതിയ OS അപ്‌ഗ്രേഡാണ് അവതരിപ്പിച്ചത്.

എന്തായാലും, സിസ്റ്റം-നിർദ്ദിഷ്‌ടമായ ചെറിയ ചെറിയ പ്രശ്‌നങ്ങൾക്കെല്ലാം, metaconfig
സൂചന ഫയലുകളുടെ പിന്തുണ നൽകുന്നു. ഇത് ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ ഒരു സൃഷ്ടിക്കേണ്ടതുണ്ട് സൂചനകൾ എന്ന ഡയറക്ടറി
പാക്കേജിന്റെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറി, നിങ്ങൾ പ്രവർത്തിപ്പിക്കുമ്പോൾ അത് ഉണ്ടായിരിക്കുക metaconfig. അത് ലോഡ് ചെയ്യും
എന്നതിൽ നിന്നുള്ള സൂചനയുമായി ബന്ധപ്പെട്ട ഭാഗം Oldconfig.U.

അതിനുശേഷം, നിങ്ങൾക്ക് ചില ഷെൽ വേരിയബിളുകൾ മുൻകൂട്ടി സജ്ജമാക്കാം സജ്ജമാക്കുന്നു ഒരു പ്രത്യേക OS-ൽ ഉപയോഗിക്കുന്നു
.sh ഫയൽ. അതിൽ കോഡ് ഉണ്ട് Oldconfig.U ഏത് സൂചന ഫയലുകളാണ് ആവശ്യമുള്ളതെന്ന് ഊഹിക്കാൻ ശ്രമിക്കുന്നു
സിസ്റ്റം OS നാമം, കേർണൽ നാമം, റിലീസ് എന്നിവയെ അടിസ്ഥാനമാക്കി ഒരു സാധാരണ നാമം കണക്കാക്കുന്നു
നമ്പർ മുതലായവ... ഈ വിവരങ്ങൾ പെട്ടെന്ന് മാറാൻ സാധ്യതയുള്ളതിനാൽ, ഞാൻ അത് ഡോക്യുമെന്റ് ചെയ്യുന്നില്ല
ഇവിടെ. നിങ്ങൾ കോഡ് റിവേഴ്സ് എഞ്ചിനീയർ ചെയ്യണം Oldconfig.U.

നിങ്ങൾ ആദ്യം നിങ്ങളുടെ പാക്കേജ് റിലീസ് ചെയ്യുമ്പോൾ, നിങ്ങളുടെ സൂചനകൾ ഫയൽ ഡയറക്ടറി ശൂന്യമായിരിക്കണം. എങ്കിൽ
നിങ്ങളുടെ പാക്കേജിന്റെ ഉപയോക്താക്കൾ തങ്ങൾക്ക് പ്രശ്നമുണ്ടെന്ന് പരാതിപ്പെടുന്നു സജ്ജമാക്കുന്നു a-യിലെ സ്ഥിരസ്ഥിതികൾ
പ്രത്യേക സിസ്റ്റം, ഇതൊരു പ്ലാറ്റ്ഫോം-നിർദ്ദിഷ്ട പ്രശ്നമാണോ അതോ എ
പൊതുവായ ഒന്ന്. മുമ്പത്തെ സാഹചര്യത്തിൽ, ഒരു പുതിയ സൂചന ഫയൽ അവതരിപ്പിക്കാൻ സമയമായി
പിന്നീട്, അനുബന്ധ യൂണിറ്റ് പരിഷ്കരിക്കണം.

ഉദാഹരണത്തിന്, SGI സിസ്റ്റങ്ങൾ തകർന്നതായി അറിയപ്പെടുന്നു vfork() സിസ്റ്റം കോൾ, ഇത് പോലെ
എഴുത്തു. അനുബന്ധ സൂചന ഫയലിന്റെ പേര് sgi.sh. അതിനാൽ നിങ്ങൾ ചെയ്യേണ്ടത് സൃഷ്ടിക്കുക എന്നതാണ്
a സൂചനകൾ/sgi.sh നിങ്ങൾ എഴുതുന്ന ഫയൽ:

d_vfork="$define"

അത് എപ്പോഴും റീമാപ്പ് ചെയ്യും vfork on ഫോർക്ക് (കാണുക d_vfork.U). എസ്ജിഐ സിസ്റ്റങ്ങളിൽ പ്രവർത്തിക്കുമ്പോൾ
ആദ്യതവണ, സജ്ജമാക്കുന്നു ഉണ്ടെന്ന് കണ്ടെത്തും സൂചനകൾ/sgi.sh ഫയൽ, ഞങ്ങൾ ഓണാണ്
ഒരു IRIX മെഷീൻ (കേർണലിന്റെ പേര് പലപ്പോഴും /irix ആണ്), അതിനാൽ അത് നിർദ്ദേശിക്കും എസ്ജിഐ പോലെ
സാധ്യമായ സൂചന. ഉപയോക്താവ് അത് അംഗീകരിക്കുകയാണെങ്കിൽ, കൂടാതെ $d_vfork വഴി മൂല്യം പരിഷ്കരിക്കുന്നു
$setvar വിളിക്കുക, എ അയ്യോ! ഞങ്ങൾ മൂല്യത്തെ മറികടക്കാൻ പോകുകയാണെന്ന് മുന്നറിയിപ്പ് നൽകാൻ പുറപ്പെടുവിക്കും
കണക്കാക്കിയത് സജ്ജമാക്കുന്നു.

നിങ്ങൾ നൽകേണ്ടതില്ല എന്നത് ശ്രദ്ധിക്കുക എല്ലാം വഴി അറിയാവുന്ന സൂചനകൾ Oldconfig.U. ഒരു സൂചന ഫയൽ ആണെങ്കിൽ
കാണുന്നില്ല, സാധ്യമായ ഒരു തിരഞ്ഞെടുപ്പായി ഇത് നിർദ്ദേശിക്കപ്പെടില്ല. ഹ്യൂറിസ്റ്റിക് പരിശോധനകൾ കണക്കുകൂട്ടാൻ ഓടി
സാധ്യമായ സൂചന സ്ഥാനാർത്ഥികൾ അടരുകളായി. നിങ്ങൾക്ക് പുതിയ മൂല്യങ്ങളോ വ്യത്യസ്ത പരിശോധനകളോ ഉണ്ടെങ്കിൽ, ദയവായി
അവ എനിക്ക് അയച്ചുതരിക...

അസാധ്യം തിരഞ്ഞെടുപ്പുകൾ
നിങ്ങൾ ഒരു സൃഷ്ടിക്കുകയാണെങ്കിൽ config.over ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിലെ ഫയൽ, സജ്ജമാക്കുന്നു നിങ്ങളോട് ചോദിക്കും
സ്ഥിര മൂല്യങ്ങൾ അസാധുവാക്കാൻ ഇത് ലോഡുചെയ്യാൻ ആഗ്രഹിക്കുന്നു. ഇത് സൃഷ്ടിക്കുന്നതിന് മുമ്പ് ചെയ്തതാണ്
config.sh ഫയൽ, അതിനാൽ അവിടെ സംഭരിച്ചിരിക്കുന്ന മൂല്യങ്ങൾ പാച്ച് ചെയ്യാൻ ഇത് നിങ്ങൾക്ക് അവസരം നൽകുന്നു.

ഇത് ഒരു പ്രാദേശിക ഫയലാണ്, അത് ഉപയോക്താവാണ് എന്ന സൂചനയുടെ സമീപനത്തിൽ നിന്ന് ഇത് വ്യത്യസ്തമാണ്
സ്വന്തം ഉപയോഗത്തിനായി സൃഷ്ടിക്കാൻ സ്വാതന്ത്ര്യമുണ്ട്. അത്തരമൊരു ഫയൽ നിങ്ങൾ സ്വയം നൽകരുത്, പക്ഷേ അനുവദിക്കുക
ഈ സാധ്യതയെക്കുറിച്ച് ഉപയോക്താവിന് അറിയാം.

സജ്ജമാക്കുന്നു ഓപ്ഷനുകൾ
ദി സജ്ജമാക്കുന്നു കമാൻഡ് ലൈനിൽ വ്യക്തമാക്കിയിട്ടുള്ള ചില ഓപ്ഷനുകൾ ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ് വിളിക്കാം, to
അതിന്റെ സ്വഭാവം ചെറുതായി പരിഷ്കരിക്കുക. അനുവദനീയമായ ഓപ്ഷനുകൾ ഇതാ:

-d എല്ലാ ഉത്തരങ്ങൾക്കും ഡിഫോൾട്ടുകൾ ഉപയോഗിക്കുക.

-e എന്ന ഉൽപ്പാദനത്തെ ചോദ്യം ചെയ്യാതെ മുന്നോട്ട് പോകുക config.sh.

-f ഫയല് ഒരു ഡിഫോൾട്ട് കോൺഫിഗറേഷനായി നിർദ്ദിഷ്ട ഫയൽ ഉപയോഗിക്കുക. ഈ സ്വിച്ച് ഉപയോഗിക്കുന്നില്ലെങ്കിൽ,
കോൺഫിഗറേഷൻ എടുത്തത് config.sh, ഹാജരാകുമ്പോൾ.

-h സഹായ സന്ദേശം അച്ചടിച്ച് പുറത്തുകടക്കുക.

-r സാധ്യമെങ്കിൽ C ചിഹ്നങ്ങളുടെ മൂല്യം വീണ്ടും ഉപയോഗിക്കുക. ഇത് ചെലവ് ഒഴിവാക്കും nm ചിഹ്നം
വേർതിരിച്ചെടുക്കൽ. ആദ്യമായി ഉപയോഗിക്കുകയാണെങ്കിൽ (മുമ്പത്തെ കോൺഫിഗറേഷൻ ഫയലില്ലാതെ),
സജ്ജമാക്കുന്നു എന്നതിനെക്കുറിച്ച് അറിയുന്നതിനായി ഒരു ചെറിയ പ്രോഗ്രാം സമാഹരിച്ച് ലിങ്ക് ചെയ്യാൻ ശ്രമിക്കും
ഒരു ചിഹ്നത്തിന്റെ സാന്നിധ്യം, അല്ലെങ്കിൽ അതിന്റെ അഭാവം.

-s നിശ്ശബ്ദമായ മോഡ്. ഫയൽ ഡിസ്ക്രിപ്റ്റർ #4-ൽ പ്രിന്റ് ചെയ്‌തിരിക്കുന്ന സ്ട്രിംഗുകൾ മാത്രമേ ഇതിൽ കാണാനാകൂ
സ്ക്രീൻ (അതാണ് പ്രധാനപ്പെട്ട സന്ദേശങ്ങൾ). പൂർണ്ണമായും ഓഫ് ചെയ്യാൻ സാധ്യമല്ല
ഏതെങ്കിലും ഔട്ട്പുട്ട്, എന്നാൽ നിങ്ങൾക്ക് ഉപയോഗിക്കാം 'സജ്ജമാക്കുന്നു -ders > / dev / null 2> & 1' ഒരു ഫുൾ കിട്ടാൻ
ഔട്ട്പുട്ടും ഉപയോക്തൃ ഇടപെടൽ ആവശ്യമില്ലാത്തതുമായ ബാച്ച് റൺ.

-D ചിഹ്നം=മൂല്യം
മുൻകൂട്ടി നിർവചിക്കുന്നു ചിഹ്നം വ്യക്തമാക്കിയത് വഹിക്കാൻ മൂല്യം. 'ഉപയോഗിക്കാനും സാധിക്കും.-D
ചിഹ്നം' ഇത് 'define' എന്നതിന്റെ സ്ഥിര മൂല്യം ഉപയോഗിക്കും.

-E എ നിർമ്മിച്ചതിന് ശേഷം കോൺഫിഗറേഷൻ ചോദ്യങ്ങളുടെ അവസാനം നിർത്തുക
config.sh. ഇതൊന്നും നിർവഹിക്കില്ല 'ഉണ്ടാക്കുക ആശ്രയിക്കുന്നു' അല്ലെങ്കിൽ .SH ഫയലുകൾ വേർതിരിച്ചെടുക്കൽ.

-K അറിവുള്ള ഉപയോക്താവ്. നിങ്ങൾ ഈ ഓപ്‌ഷൻ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾ എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്കറിയാം
അതുകൊണ്ട് config.sh ഫയൽ എപ്പോഴും ഉദ്ദേശിച്ചതുപോലെ കൈകാര്യം ചെയ്യും
ഒരു അന്യഗ്രഹ സിസ്റ്റത്തിൽ ജനറേറ്റ് ചെയ്‌തിരിക്കാമെങ്കിലും വീണ്ടും ഉപയോഗിച്ചു. അതും
എപ്പോൾ ഗർഭഛിദ്രം തടയുന്നു സജ്ജമാക്കുന്നു ഉപയോഗശൂന്യമായ ഒരു C കംപൈലർ അല്ലെങ്കിൽ തെറ്റായ സെറ്റ് കണ്ടെത്തുന്നു
സി പതാകകളുടെ. ഈ ഓപ്‌ഷനിലും കൂടുതൽ കുറുക്കുവഴികൾ ഓണാക്കിയേക്കാം
ഭാവി. ഈ ഓപ്‌ഷൻ ഇതിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട് സജ്ജമാക്കുന്നു ഉപയോഗ സന്ദേശം, ഞങ്ങളെ ഓർമ്മിപ്പിക്കാൻ
അതിന്റെ നിലനിൽപ്പിനെക്കുറിച്ച്, എന്നാൽ നൽകിയിരിക്കുന്ന വിവരണം വേണ്ടത്ര നിഗൂഢമായിരിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു.
:-)

-O a വഴി വ്യക്തമാക്കിയ മൂല്യങ്ങൾ അനുവദിക്കുക -D or -U ലോഡുചെയ്‌തതിൽ നിന്ന് ക്രമീകരണങ്ങൾ അസാധുവാക്കാൻ
കോൺഫിഗറേഷൻ ഫയൽ. അസാധുവാക്കൽ ഇഷ്ടം മുതൽ ഇത് സ്ഥിര സ്വഭാവമല്ല
നിങ്ങൾ നിലവിൽ മാറ്റുന്നവയിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ വേരിയബിളുകളിലേക്ക് പ്രചരിപ്പിക്കരുത്.
സ്വാഭാവികമായും, ഇല്ലാതെ -O, ഒരു കോൺഫിഗറേഷൻ ഫയലും ഇല്ലാത്തപ്പോൾ മാത്രമാണ് ക്രമീകരണം ചെയ്യുന്നത്
ലോഡുചെയ്‌തു, ഡെറിവേറ്റീവ് വേരിയബിളുകൾ ഇതുവരെ കണക്കാക്കിയിട്ടില്ലാത്തതിനാൽ ഇത് സുരക്ഷിതമാണ്...

-S എല്ലാ .SH ഫയലുകളിലും വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ നടത്തുക. നിങ്ങൾക്ക് ഇത് സംയോജിപ്പിക്കാം
-f നിങ്ങൾ ഇഷ്ടപ്പെടുന്ന ഏതെങ്കിലും കോൺഫിഗറേഷൻ പ്രചരിപ്പിക്കാൻ മാറുക.

-U ചിഹ്നം=
പ്രീ-സെറ്റുകൾ ചിഹ്നം ഒരു ശൂന്യമായ മൂല്യം വഹിക്കാൻ. 'ഉപയോഗിക്കാനും സാധിക്കും.-U ചിഹ്നം'
ഏത് സജ്ജമാക്കും ചിഹ്നം 'undef' ലേക്ക്.

-V പതിപ്പ് നമ്പർ പ്രിന്റ് ചെയ്യുക metaconfig ഇത് സൃഷ്ടിച്ചത് സജ്ജമാക്കുന്നു സ്ക്രിപ്റ്റ്
പുറത്തുകടക്കുക.

പ്രവർത്തിക്കുന്ന പരിസ്ഥിതി
ആരംഭിക്കുമ്പോൾ, സജ്ജമാക്കുന്നു ഒരു പ്രാദേശിക സൃഷ്ടിക്കുന്നു UU ഡയറക്ടറി അവിടെ നിന്ന് പ്രവർത്തിക്കുന്നു. ഡയറക്ടറി
കോൺഫിഗർ അവസാനിക്കുമ്പോൾ നീക്കം ചെയ്യപ്പെടും, എന്നാൽ ഇതിനർത്ഥം നിങ്ങൾ ഒരു സ്ഥലത്ത് നിന്ന് സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കണമെന്നാണ്
നിങ്ങൾക്ക് എഴുതാം, അതായത് ഒരു റീഡ്-ഒൺലി ഫയൽ സിസ്റ്റത്തിൽ നിന്നല്ല.

നിങ്ങൾക്ക് പ്രവർത്തിപ്പിക്കാൻ കഴിയും സജ്ജമാക്കുന്നു വിദൂരമായി എങ്കിലും, ഇതുപോലെ:

../പാക്കേജ്/കോൺഫിഗർ ചെയ്യുക

പ്രാദേശികമായി ലഭ്യമല്ലാത്ത ഉറവിടങ്ങൾ ക്രമീകരിക്കുന്നതിന്. ജനറേറ്റ് ചെയ്ത എല്ലാ ഫയലുകളും ഉൾപ്പെടുത്തും
നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്ന ഡയറക്ടറി. ഈ മാജിക് ചെയ്തത് src.U
യൂണിറ്റ്, ഏത് സജ്ജമാക്കുന്നു $src ഒപ്പം $rsrc പാക്കേജ് ഉറവിടങ്ങളിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ വേരിയബിളുകൾ. അത്
എന്നതിനെ ആശ്രയിച്ച് പാത പൂർണ്ണമോ ആപേക്ഷികമോ ആണ് സജ്ജമാക്കുന്നു ഒരു പൂർണ്ണമായ അല്ലെങ്കിൽ വഴി അഭ്യർത്ഥിച്ചു
ആപേക്ഷിക പാത.

ഉള്ളിൽ നിന്ന് UU ഉപഡയറക്‌ടറി, നിങ്ങൾക്ക് ഉപയോഗിക്കാം $rsrc ഉറവിട ഫയലുകൾ ആക്സസ് ചെയ്യാൻ (യൂണിറ്റുകൾ
ഉറവിട ഫയലുകളെ പരാമർശിക്കുന്ന ലിങ്ക് സൂചനകൾ എല്ലായ്പ്പോഴും ഈ സംവിധാനം ഉപയോഗിക്കും, അത് അനുമാനിക്കരുത്
ഫയൽ പാരന്റ് ഡയറക്ടറിയിൽ ഉണ്ട്). എല്ലാ മേക്ക് ഫയലുകളും $src വേരിയബിൾ ഉപയോഗിക്കണം
ബിൽഡ് ഡയറക്‌ടറിയുടെ മുകളിൽ നിന്നുള്ള ഉറവിടങ്ങളിലേക്കുള്ള ഒരു പോയിന്ററായി (എവിടെ സജ്ജമാക്കുന്നു ഓടുന്നു),
നേരിട്ടോ VPATH ക്രമീകരണം വഴിയോ.

പ്രവർത്തിക്കുമ്പോൾ സജ്ജമാക്കുന്നു വിദൂരമായി, .SH ഫയലുകൾ ബിൽഡ് ഡയറക്‌ടറിയിൽ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നു, അല്ല
ഉറവിട വൃക്ഷത്തിൽ. എന്നിരുന്നാലും, ഇതിന് ചിലതരം എ ആവശ്യമാണ് ഉണ്ടാക്കുക കംപൈൽ ചെയ്യാൻ കഴിയുന്ന പിന്തുണ
ഒരു ബിൽഡ് ഡയറക്‌ടറിയിലെ കാര്യങ്ങൾ, ഉറവിടങ്ങൾ മറ്റെവിടെയെങ്കിലും കിടക്കും.

ഉപയോഗിക്കുന്നു ജാലവിദ്യ പുനർ നിർവ്വചനങ്ങൾ
ഉപയോഗിക്കുന്നതിലൂടെ -M മാറുക, ചില മാജിക് റീമാപ്പിംഗുകൾ a ഉള്ളിൽ നടന്നേക്കാം confmagic.h
ഫയൽ. അതിനുശേഷം ആ ഫയൽ ഉൾപ്പെടുത്തേണ്ടതുണ്ട് config.h, തീർച്ചയായും, മാത്രമല്ല എല്ലാത്തിനുമുപരി
മറ്റ് ആവശ്യമായ ഫയലുകൾ ഉൾപ്പെടുന്നു. അതായത്:

#"config.h" ഉൾപ്പെടുത്തുക
...
... മറ്റ് ഉൾപ്പെടുത്തലുകൾ ...
...
#"confmagic.h" ഉൾപ്പെടുത്തുക

താരതമ്യേനെ, confmagic.h റീമാപ്പ് ചെയ്യാൻ ശ്രമിക്കും bcopy() on memcpy() അല്ലെങ്കിൽ bcopy() is
പ്രാദേശികമായി ലഭ്യമാണ്, അല്ലെങ്കിൽ രൂപാന്തരം vfork കടന്നു ഫോർക്ക് ആവശ്യമുള്ളപ്പോൾ, അതിനാൽ അത് ഉപയോഗശൂന്യമാക്കുന്നു
എന്നതിനെക്കുറിച്ച് വിഷമിക്കുക HAS_VFORK ചിഹ്നം.

ഈ കോൺഫിഗറേഷൻ മാജിക് ഗ്ലോസറി ഫയലിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്.

ഘടകം ഫലകങ്ങൾ
എന്നതിൽ ഒരു കൂട്ടം യൂണിറ്റ് ടെംപ്ലേറ്റുകൾ ഉണ്ട് metaconfig ഉദ്ദേശിച്ചിട്ടുള്ള ഉറവിട ഡയറക്ടറി
വിവിധ തരത്തിലുള്ള പുതിയ യൂണിറ്റുകൾ വേഗത്തിൽ നിർമ്മിക്കുന്നതിന് (ഇതുവരെ എഴുതിയിട്ടില്ല) പ്രോഗ്രാം ഉപയോഗിക്കുന്നു
സാഹചര്യങ്ങൾ. ഈ പൂർത്തിയാകാത്ത പ്രോജക്റ്റിനായി ഡോക്യുമെന്റേഷൻ ഒന്നുമില്ല, പക്ഷേ ഞാൻ അത് പരാമർശിക്കുമെന്ന് ഞാൻ കരുതി
നിങ്ങൾ അത് സ്വയം ചെയ്യുകയും പിന്നീട് സംഭാവന നൽകുകയും ചെയ്യണമെങ്കിൽ മാനുവൽ പേജിൽ...

AUTHORS

ലാറി വാൾ[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]> പതിപ്പ് 2.0-ന്.
ഹാർലൻ സ്റ്റെൻ[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]> പ്രധാനപ്പെട്ട യൂണിറ്റ് വിപുലീകരണങ്ങൾക്കായി.
റാഫേൽ മാൻഫ്രെഡി[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>.
ഇതിനായി മറ്റ് നിരവധി സംഭാവനകൾ metaconfig യൂണിറ്റുകൾ. ഒരു ലിസ്റ്റിനായി ക്രെഡിറ്റ് ഫയൽ കാണുക.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് metaconfig ഓൺലൈനിൽ ഉപയോഗിക്കുക