ദോഷങ്ങൾ - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

ദോഷങ്ങൾ - ഒരു സോഫ്റ്റ്‌വെയർ നിർമ്മാണ സംവിധാനം

വിവരണം

പതിപ്പ് 2.2.0-നുള്ള ഒരു ഗൈഡും റഫറൻസും

പകർപ്പവകാശം (സി) 1996-2000 സൗജന്യ സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷൻ, Inc.

ഈ പ്രോഗ്രാം ഒരു സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ആണ്; നിബന്ധനകൾക്ക് കീഴിൽ നിങ്ങൾക്ക് ഇത് പുനർവിതരണം ചെയ്യാനും കൂടാതെ/അല്ലെങ്കിൽ പരിഷ്ക്കരിക്കാനും കഴിയും
സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷൻ പ്രസിദ്ധീകരിച്ച ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ്; ഒന്നുകിൽ
ലൈസൻസിന്റെ പതിപ്പ് 2, അല്ലെങ്കിൽ (നിങ്ങളുടെ ഓപ്‌ഷനിൽ) പിന്നീടുള്ള ഏതെങ്കിലും പതിപ്പ്.

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

ഈ പ്രോഗ്രാമിനൊപ്പം നിങ്ങൾക്ക് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസിന്റെ ഒരു പകർപ്പ് ലഭിച്ചിരിക്കണം;
പകർത്തുന്ന ഫയൽ കാണുക. ഇല്ലെങ്കിൽ, Free Software Foundation, Inc., 59 Temple-ലേക്ക് എഴുതുക
സ്ഥലം - സ്യൂട്ട് 330, ബോസ്റ്റൺ, എംഎ 02111-1307, യുഎസ്എ.

അവതാരിക

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

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

മേൽപ്പറഞ്ഞവയും അതിലേറെയും വാഗ്ദാനം ചെയ്യുമ്പോൾ, ദോഷങ്ങൾ ലളിതവും ഉപയോഗിക്കാൻ എളുപ്പവുമാണ്. ഇത് ചെയ്യും,
ഈ പ്രമാണത്തിന്റെ ബാക്കി ഭാഗം വായിക്കുമ്പോൾ വ്യക്തമാകുമെന്ന് പ്രതീക്ഷിക്കുന്നു.

എന്തുകൊണ്ട് ദോഷങ്ങൾ? എന്തുകൊണ്ട് അല്ല ഉണ്ടാക്കണോ?

ദോഷം എ ഉണ്ടാക്കുക മാറ്റിസ്ഥാപിക്കൽ. ഇനിപ്പറയുന്ന ഖണ്ഡികകളിൽ, അവയിൽ ചിലത് ഞങ്ങൾ നോക്കുന്നു
മേക്കിന്റെ അനഭിലഷണീയമായ സവിശേഷതകളും നിർമ്മാണത്തെ അടിസ്ഥാനമാക്കിയുള്ള സാധാരണ ബിൽഡ് പരിതസ്ഥിതികളും
കോൺസിന്റെ വികസനത്തിന് പ്രചോദനം നൽകി.

പണിയുക സങ്കീർണ്ണത

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

പണിയുക പുനരുൽപാദനക്ഷമത

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

മാറ്റമുള്ള പണിയുന്നു

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

റിപ്പോസിറ്ററികൾ

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

ഗണന it ലഘുവായ

നിർമ്മാണത്തിലെ ചില ബുദ്ധിമുട്ടുകൾ മുകളിൽ ഉദ്ധരിച്ചിരിക്കുന്നു. ഇതിലും തുടർന്നുള്ളതിലും
വിഭാഗങ്ങളിൽ, ഞങ്ങൾ ദോഷങ്ങൾ അവതരിപ്പിക്കുകയും ഈ പ്രശ്നങ്ങൾ എങ്ങനെ അഭിസംബോധന ചെയ്യപ്പെടുന്നുവെന്ന് കാണിക്കുകയും ചെയ്യും.

പേൾ സ്ക്രിപ്റ്റുകൾ

ദോഷങ്ങൾ പേൾ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. അതായത്, Cons scripts--നിർബന്ധിത ഒപ്പം നിർമ്മിക്കുക ഫയലുകൾ, തത്തുല്യമായത്
ലേക്ക് Makefile or makefile--എല്ലാം പേളിൽ എഴുതിയിരിക്കുന്നു. ഇത് ഉടനടി പ്രയോജനം നൽകുന്നു:
സ്ക്രിപ്റ്റുകൾ എഴുതുന്നതിനുള്ള ഭാഷ പരിചിതമാണ്. നിങ്ങൾ ഒരു പേർളായിരിക്കില്ലെങ്കിലും
പ്രോഗ്രാമർ, പേൾ അടിസ്ഥാനപരമായി ഒരു ലളിതമായ പ്രഖ്യാപന ഭാഷയാണെന്ന് അറിയാൻ ഇത് സഹായിക്കുന്നു,
നന്നായി നിർവചിക്കപ്പെട്ട നിയന്ത്രണ പ്രവാഹവും പരിചിതമായ അർത്ഥശാസ്ത്രവും. ഇതിന് പെരുമാറുന്ന വേരിയബിളുകൾ ഉണ്ട്
അടിസ്ഥാനപരമായി നിങ്ങൾ അവ പ്രതീക്ഷിക്കുന്ന രീതി, സബ്റൂട്ടീനുകൾ, നിയന്ത്രണത്തിന്റെ ഒഴുക്ക് തുടങ്ങിയവ. അവിടെ
ദോഷങ്ങൾക്കായി പ്രത്യേക വാക്യഘടന അവതരിപ്പിച്ചിട്ടില്ല. ഒരു സ്ക്രിപ്റ്റിംഗ് ഭാഷയായി പേൾ ഉപയോഗിക്കുന്നത്
പലപ്പോഴും സങ്കീർണ്ണമായ ഉചിതമായ പരിഹാരം പ്രകടിപ്പിക്കുന്നതിനുള്ള ചുമതല ലളിതമാക്കുന്നു
ഒരു നിർമ്മാണത്തിന്റെ ആവശ്യകതകൾ.

ഹലോ, ലോകം!

ഇനിപ്പറയുന്ന ചർച്ചയെ അടിസ്ഥാനമാക്കുന്നതിന്, നിങ്ങൾക്ക് എങ്ങനെ നിർമ്മിക്കാമെന്ന് ഇവിടെയുണ്ട് ഹലോ, ലോകം! C
ദോഷങ്ങളുള്ള അപേക്ഷ:

$env = പുതിയ ദോഷങ്ങൾ();
പ്രോഗ്രാം $env 'ഹലോ', 'hello.c';

നിങ്ങൾ ഈ സ്‌ക്രിപ്റ്റ് ഒരു ഡയറക്‌ടറിയിൽ ഇൻസ്‌റ്റാൾ ചെയ്‌താൽ, സ്‌ക്രിപ്‌റ്റിന് പേര് നൽകുക നിർമ്മിക്കുക, സൃഷ്ടിക്കുക
hello.c സോഴ്സ് ഫയൽ അതേ ഡയറക്‌ടറിയിൽ, തുടർന്ന് നിങ്ങൾക്ക് നിർമ്മിക്കാൻ `കോൺസ് ഹലോ' എന്ന് ടൈപ്പ് ചെയ്യാം
അപ്ലിക്കേഷൻ:

% cons ഹലോ
cc -c hello.c -o hello.o
cc -o ഹലോ hello.o

നിര്മ്മാണം പരിസ്ഥിതികൾ

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

$env = പുതിയ ദോഷങ്ങൾ(
CC => 'gcc',
LIBS => 'libworld.a'
);

പ്രോഗ്രാം $env 'ഹലോ', 'hello.c';

ഈ സാഹചര്യത്തിൽ, ഡിഫോൾട്ട് നിർമ്മാണ പരിസ്ഥിതി ഉപയോഗിക്കുന്നതിനുപകരം, ഞങ്ങൾക്കുണ്ട്
'CC' യുടെ മൂല്യം അസാധുവാക്കുക, അങ്ങനെ GNU C കംപൈലറിന് തുല്യമായത് ഉപയോഗിക്കുന്നു. മുതലുള്ള
ഈ പതിപ്പ് ഹലോ, ലോകം! ഒരു ലൈബ്രറി ആവശ്യമാണ്, libworld.a, ഞങ്ങൾ ഏതെങ്കിലും എന്ന് വ്യക്തമാക്കിയിട്ടുണ്ട്
ഈ പരിതസ്ഥിതിയിൽ ലിങ്കുചെയ്തിരിക്കുന്ന പ്രോഗ്രാം ആ ലൈബ്രറിയുമായി ബന്ധിപ്പിക്കണം. ലൈബ്രറി ആണെങ്കിൽ
ഇതിനകം നിലവിലുണ്ട്, നല്ലതും നല്ലതാണ്, പക്ഷേ ഇല്ലെങ്കിൽ, ഞങ്ങൾ ഈ പ്രസ്താവനയും ഉൾപ്പെടുത്തേണ്ടതുണ്ട്:

ലൈബ്രറി $env 'libworld', 'world.c';

ഇപ്പോൾ നിങ്ങൾ `കോൺസ് ഹലോ' എന്ന് ടൈപ്പ് ചെയ്താൽ, പ്രോഗ്രാം ലിങ്ക് ചെയ്യുന്നതിനുമുമ്പ് ലൈബ്രറി നിർമ്മിക്കപ്പെടും, കൂടാതെ,
തീർച്ചയായും, രണ്ട് മൊഡ്യൂളുകളും കംപൈൽ ചെയ്യാൻ `gcc' ഉപയോഗിക്കും:

% cons ഹലോ
gcc -c hello.c -o hello.o
gcc -c world.c -o world.o
ar r libworld.a world.o
ar: libworld.a സൃഷ്ടിക്കുന്നു
ranlib libworld.a
gcc -o ഹലോ hello.o libworld.a

ഓട്ടോമാറ്റിക് ഒപ്പം പൂർണ്ണമായ ആശ്രിതത്വം വിശകലനം

ദോഷങ്ങളോടൊപ്പം, ഡിപൻഡൻസികൾ സ്വയമേവ കൈകാര്യം ചെയ്യപ്പെടും. മുമ്പത്തെ ഉദാഹരണം തുടരുക, ശ്രദ്ധിക്കുക
ഞങ്ങൾ പരിഷ്കരിക്കുമ്പോൾ ലോകം.സി, world.o വീണ്ടും സമാഹരിച്ചിരിക്കുന്നു, libworld.a പുനഃസൃഷ്ടിച്ചു, ഒപ്പം ഹലോ
വീണ്ടും ലിങ്ക് ചെയ്തു:

% vi world.c
[തിരുത്തുക]
% cons ഹലോ
gcc -c world.c -o world.o
ar r libworld.a world.o
ar: libworld.a സൃഷ്ടിക്കുന്നു
ranlib libworld.a
gcc -o ഹലോ hello.o libworld.a

ഇത് താരതമ്യേന ലളിതമായ ഒരു ഉദാഹരണമാണ്: ദോഷങ്ങൾ ``അറിയാം'' world.o ആശ്രയിച്ചിരിക്കും ലോകം.സി, കാരണം
ആശ്രിതത്വം വ്യക്തമായി സജ്ജീകരിച്ചിരിക്കുന്നത് `ലൈബ്രറി' രീതിയാണ്. അതും അറിയാം libworld.a
ആശ്രയിച്ചിരിക്കും world.o അത് ആ ഹലോ ആശ്രയിച്ചിരിക്കും libworld.a, എല്ലാം സമാനമായ കാരണങ്ങളാൽ.

ഇപ്പോൾ അത് മാറുന്നു hello.c ഇന്റർഫേസ് ഡെഫനിഷൻ ഫയലും ഉൾപ്പെടുന്നു, world.h:

% emacs world.h
[തിരുത്തുക]
% cons ഹലോ
gcc -c hello.c -o hello.o
gcc -o ഹലോ hello.o libworld.a

അത് കോൺസിന് എങ്ങനെ അറിയാം hello.c ഉൾപ്പെടുന്നു world.h, പിന്നെ ആ hello.o. അതിനാൽ ആയിരിക്കണം
വീണ്ടും സമാഹരിച്ചോ? വേണ്ടയോ എന്ന് ആലോചിക്കുമ്പോൾ തൽക്കാലം പറഞ്ഞാൽ മതി hello.o. ഉയർന്നു-
ഇന്നുവരെ, കോൺസ് അതിന്റെ ആശ്രിതത്വത്തിനായി ഒരു സ്കാനറിനെ വിളിക്കുന്നു, hello.c. ഈ സ്കാനർ കണക്കാക്കുന്നു
ഫയലുകൾ ഉൾപ്പെടുത്തിയത് hello.c അവയ്‌ക്കപ്പുറമുള്ള കൂടുതൽ ആശ്രിതത്വങ്ങളുടെ ഒരു പട്ടിക കൊണ്ടുവരാൻ
Cons സ്ക്രിപ്റ്റ് വഴി വ്യക്തമാക്കിയത്. ഈ പ്രക്രിയ ആവർത്തനപരമാണ്: ഏത് ഫയലുകളും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്
ഉൾപ്പെടുത്തിയ ഫയലുകളും സ്കാൻ ചെയ്യും.

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

ഓട്ടോമാറ്റിക് ഗ്ലോബൽ പണിയുക സീക്വൻസിങ്

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

കെട്ടിടം വലിയ മരങ്ങൾ--ഇപ്പോഴും വെറും as ലഘുവായ

A അധികാരശ്രേണി of പണിയുക സ്ക്രിപ്റ്റുകൾ

ഒരു വലിയ ബിൽഡ്, കോൺസിൽ, ഒരു ശ്രേണി സൃഷ്ടിച്ചുകൊണ്ട് ക്രമീകരിച്ചിരിക്കുന്നു പണിയുക സ്ക്രിപ്റ്റുകൾ. ഏറ്റവും മുകളില്
മരത്തിന്റെ ഒരു സ്ക്രിപ്റ്റ് ആണ് നിർമ്മിക്കുക. കൺവെൻഷൻ പ്രകാരം ബാക്കിയുള്ള സ്ക്രിപ്റ്റുകൾ ഓരോന്നും
വിളിച്ചു നിർബന്ധിത. ഈ സ്ക്രിപ്റ്റുകൾ ഒരുമിച്ച് ബന്ധിപ്പിച്ചിരിക്കുന്നു, വളരെ ലളിതമായി, `ബിൽഡ്',
'കയറ്റുമതി', 'ഇറക്കുമതി' കമാൻഡുകൾ.

ദി പണിയുക കമാൻഡ്

'Build' കമാൻഡ് ഒരു ലിസ്റ്റ് എടുക്കുന്നു നിർബന്ധിത ഫയലുകളുടെ പേരുകൾ, അവ ക്രമപ്പെടുത്തുന്നു
നിർമ്മാണത്തിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഉദാഹരണത്തിന്:

നിർമ്മിക്കുക qw(
ഡ്രൈവറുകൾ/ഡിസ്‌പ്ലേ/കോൺസ്‌ക്രിപ്റ്റ്
ഡ്രൈവറുകൾ/മൗസ്/കൺസ്ക്രിപ്റ്റ്
പാഴ്സർ/കൺസ്ക്രിപ്റ്റ്
യൂട്ടിലിറ്റികൾ/കൺസ്ക്രിപ്റ്റ്
);

ഇത് ബിൽഡ് സ്ക്രിപ്റ്റുകളുടെ ലളിതമായ രണ്ട്-തല ശ്രേണിയാണ്: എല്ലാ സബ്സിഡിയറിയും നിർബന്ധിത ഫയലുകൾ
ഉയർന്ന തലത്തിൽ സൂചിപ്പിച്ചിരിക്കുന്നു നിർമ്മിക്കുക ഫയൽ. ട്രീയിലെ എല്ലാ ഡയറക്ടറികളും ഇല്ല എന്നത് ശ്രദ്ധിക്കുക
അവയുമായി ബന്ധപ്പെട്ട സ്ക്രിപ്റ്റുകൾ നിർമ്മിക്കേണ്ടതുണ്ട്.

ഇത് ഒരു മൾട്ടി ലെവൽ സ്ക്രിപ്റ്റായി എഴുതാം. ഉദാഹരണത്തിന്, ദി നിർമ്മിക്കുക ഫയൽ ആയിരിക്കാം
ഈ കമാൻഡ് അടങ്ങിയിരിക്കുന്നു:

നിർമ്മിക്കുക qw(
പാഴ്സർ/കൺസ്ക്രിപ്റ്റ്
ഡ്രൈവർമാർ/കൺസ്ക്രിപ്റ്റ്
യൂട്ടിലിറ്റികൾ/കൺസ്ക്രിപ്റ്റ്
);

ഒപ്പം നിർബന്ധിത ഫയലിൽ ഫയൽ ചെയ്യുക ഡ്രൈവറുകൾ ഡയറക്ടറിയിൽ ഇത് അടങ്ങിയിരിക്കാം:

നിർമ്മിക്കുക qw(
ഡിസ്പ്ലേ/കൺസ്ക്രിപ്റ്റ്
മൗസ്/കൺസ്ക്രിപ്റ്റ്
);

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

ഡിഫോൾട്ടായി, Cons അതിന്റെ പ്രവർത്തന ഡയറക്‌ടറി a അടങ്ങുന്ന ഡയറക്‌ടറിയിലേക്ക് മാറ്റില്ല
ഉപവിഭാഗം നിർബന്ധിത ഫയൽ അതിൽ ഉൾപ്പെടുന്നു. ഈ സ്വഭാവം ഒരു ബിൽഡിനായി പ്രവർത്തനക്ഷമമാക്കാം
മുകളിൽ-ലെവലിൽ വ്യക്തമാക്കുന്നത് നിർമ്മിക്കുക ഫയൽ:

Conscript_chdir 1;

പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ, Cons സബ്സിഡിയറിയിലേക്ക് മാറും നിർബന്ധിത ഫയലിൽ ഡയറക്‌ടറി അടങ്ങിയിരിക്കുന്നു
ആ ഫയലിൽ വായിക്കുമ്പോൾ, ഫയൽ ഒരിക്കൽ ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറിയിലേക്ക് തിരികെ മാറ്റുക
പ്രോസസ്സ് ചെയ്തിട്ടുണ്ട്.

ഭാവിയിലെ Cons-ന്റെ ചില പതിപ്പുകളിൽ ഈ സ്വഭാവം സ്ഥിരസ്ഥിതിയായി മാറുമെന്ന് പ്രതീക്ഷിക്കുന്നു.
ഈ പരിവർത്തനത്തിന് തയ്യാറെടുക്കുന്നതിന്, ബിൽഡിന്റെ മുകളിൽ തന്നെ ദോഷങ്ങൾ തുടരുമെന്ന് പ്രതീക്ഷിക്കുന്ന ബിൽഡുകൾ
ഒരു സബ്സിഡിയറിയിൽ വായിക്കുമ്പോൾ നിർബന്ധിത ഫയൽ ഈ സവിശേഷത വ്യക്തമായി പ്രവർത്തനരഹിതമാക്കണം
താഴെ:

Conscript_chdir 0;

ബന്ധു, ഉന്നത ബന്ധു, ഒപ്പം കേവലമായ ഫയല് പേരുകൾ

ബിൽഡ് കമാൻഡിൽ വ്യക്തമാക്കിയ ഫയൽ പേരുകൾ ആപേക്ഷികമാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം
സ്ക്രിപ്റ്റിന്റെ സ്ഥാനം അത് അഭ്യർത്ഥിച്ചിരിക്കുന്നു. മറ്റ് ഫയലുകളുടെ പേരിന് ഇത് പൊതുവെ ശരിയാണ്
മറ്റ് കമാൻഡുകളിലേക്കുള്ള ആർഗ്യുമെന്റുകളും, നിങ്ങൾ ആരംഭിക്കുകയാണെങ്കിൽ ഞങ്ങൾ ഇവിടെ പരാമർശിച്ചേക്കാം
ഒരു ഹാഷ് മാർക്കോടുകൂടിയ ഒരു ഫയലിന്റെ പേര്, ``#'', തുടർന്ന് ആ ഫയൽ മുകളിലേക്ക് ആപേക്ഷികമായി വ്യാഖ്യാനിക്കപ്പെടുന്നു-
ലെവൽ ഡയറക്ടറി (എവിടെ നിർമ്മിക്കുക ഫയൽ വസിക്കുന്നു). നിങ്ങൾ അത് ആരംഭിച്ചാൽ അതിശയിക്കാനില്ല
``/'' ഉപയോഗിച്ച്, അത് ഒരു സമ്പൂർണ്ണ പാതനാമമായി കണക്കാക്കപ്പെടുന്നു. സിസ്റ്റങ്ങളിൽ പോലും ഇത് ശരിയാണ്
സമ്പൂർണ്ണ പാതകൾക്ക് പേരിടാൻ ഫോർവേഡ് സ്ലാഷിനു പകരം ബാക്ക് സ്ലാഷ് ഉപയോഗിക്കുന്നു.

ഉപയോഗിക്കുന്നു മൊഡ്യൂളുകൾ in പണിയുക സ്ക്രിപ്റ്റുകൾ

നിങ്ങൾക്ക് ഓരോന്നിലേക്കും മൊഡ്യൂളുകൾ വലിച്ചിടാം നിർബന്ധിത സാധാരണ Perl `ഉപയോഗം' അല്ലെങ്കിൽ `ആവശ്യമാണ്' ഉപയോഗിക്കുന്ന ഫയൽ
പ്രസ്താവനകൾ:

ഇംഗ്ലീഷ് ഉപയോഗിക്കുക;
എന്റെ:: മൊഡ്യൂൾ ആവശ്യമാണ്;

ഓരോ `ഉപയോഗം' അല്ലെങ്കിൽ `ആവശ്യമുള്ളത്' ഒന്നിനെ മാത്രമേ ബാധിക്കുകയുള്ളൂ നിർബന്ധിത അത് ദൃശ്യമാകുന്ന ഫയൽ. ഉപയോഗിക്കുന്നതിന് എ
ഒന്നിലധികം മൊഡ്യൂൾ നിർബന്ധിത ഫയലുകൾ, ഓരോന്നിലും നിങ്ങൾ ഒരു `ഉപയോഗം' അല്ലെങ്കിൽ `ആവശ്യമുണ്ട്' എന്ന പ്രസ്താവന നൽകണം
മൊഡ്യൂൾ ആവശ്യമുള്ള ഒന്ന്.

സ്കോപ്പ് of വേരിയബിളുകൾ

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

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

ദി കയറ്റുമതി കമാൻഡ്

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിലെന്നപോലെ `കയറ്റുമതി' കമാൻഡ് ഉപയോഗിക്കുന്നു:

$env = പുതിയ ദോഷങ്ങൾ();
$INCLUDE = "#കയറ്റുമതി/ഉൾപ്പെടുത്തുക";
$LIB = "#കയറ്റുമതി/lib";
കയറ്റുമതി qw ( env LIB ഉൾപ്പെടുത്തുക );
ബിൽഡ് qw( util/Conscript );

`കയറ്റുമതി' ലിസ്റ്റിൽ പരാമർശിച്ചിരിക്കുന്ന ലളിതമായ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ നീക്കം ചെയ്യപ്പെടും
തുടർന്നുള്ള ഏതെങ്കിലും `ബിൽഡ്' കമാൻഡുകൾ വഴി. `എക്‌സ്‌പോർട്ട്' കമാൻഡ് പേൾ മാത്രം എക്‌സ്‌പോർട്ട് ചെയ്യും സ്കെയിലർ
വേരിയബിളുകൾ, അതായത്, `$' എന്നതിൽ തുടങ്ങുന്ന വേരിയബിളുകൾ. മറ്റ് വേരിയബിളുകൾ, വസ്തുക്കൾ മുതലായവ.
റഫറൻസ് വഴി കയറ്റുമതി ചെയ്യാം - എന്നാൽ എല്ലാ സ്ക്രിപ്റ്റുകളും ഒരേ ഒബ്ജക്റ്റിനെ സൂചിപ്പിക്കും, ഇതും
സബ്സിഡിയറി സ്ക്രിപ്റ്റുകളും ഒറിജിനലും വായിക്കാൻ മാത്രം ഒബ്ജക്റ്റ് പരിഗണിക്കണം
സ്ക്രിപ്റ്റ് കയറ്റുമതി ചെയ്യുന്നു. എന്നിരുന്നാലും, കയറ്റുമതി ചെയ്ത സ്കെയിലറിന് ഒരു പുതിയ മൂല്യം നൽകുന്നത് സ്വീകാര്യമാണ്
വേരിയബിൾ - അത് റഫറൻസ് ചെയ്ത അടിസ്ഥാന വേരിയബിളിനെ മാറ്റില്ല. ഈ ക്രമം, വേണ്ടി
ഉദാഹരണത്തിന്, ശരിയാണ്:

$env = പുതിയ ദോഷങ്ങൾ();
കയറ്റുമതി qw ( env LIB ഉൾപ്പെടുത്തുക );
ബിൽഡ് qw( util/Conscript );
$env = പുതിയ ദോഷങ്ങൾ (CFLAGS => '-O');
qw (മറ്റ്/കൺസ്‌ക്രിപ്റ്റ്) നിർമ്മിക്കുക;

`കയറ്റുമതി' കമാൻഡിന് മുമ്പോ ശേഷമോ വേരിയബിൾ സജ്ജീകരിച്ചിട്ടുണ്ടോ എന്നത് പ്രശ്നമല്ല. ദി
'ബിൽഡ്' കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്ന സമയത്തെ വേരിയബിളിന്റെ മൂല്യമാണ് പ്രധാന കാര്യം.
ഇതാണ് ചിതറിപ്പോകുന്നത്. തുടർന്നുള്ള ഏതെങ്കിലും `കയറ്റുമതി' കമാൻഡുകൾ, വഴിയിൽ,
ആദ്യത്തേത് അസാധുവാക്കുക: ഓരോന്നിലും കയറ്റുമതി ചെയ്യാൻ ആഗ്രഹിക്കുന്ന എല്ലാ വേരിയബിളുകളും നിങ്ങൾ സൂചിപ്പിക്കണം
'കയറ്റുമതി' കമാൻഡ്.

ദി ഇറക്കുമതി കമാൻഡ്

'കയറ്റുമതി' കമാൻഡ് വഴി കയറ്റുമതി ചെയ്യുന്ന വേരിയബിളുകൾ സബ്സിഡിയറി സ്ക്രിപ്റ്റുകളിലേക്ക് ഇറക്കുമതി ചെയ്യാൻ കഴിയും
'ഇറക്കുമതി' കമാൻഡ്. സബ്സിഡിയറി സ്ക്രിപ്റ്റ് എപ്പോഴും വേരിയബിളുകൾ നേരിട്ട് ഇറക്കുമതി ചെയ്യുന്നു
മികച്ച സ്ക്രിപ്റ്റ്. ഈ ഉദാഹരണം പരിഗണിക്കുക:

ഇറക്കുമതി qw( env INCLUDE );

പാരന്റ് സ്ക്രിപ്റ്റ് `$env', `$INCLUDE' എന്നിവ കയറ്റുമതി ചെയ്താൽ മാത്രമേ ഇത് നിയമപരമാകൂ. അതും വേണം
ഈ വേരിയബിളുകൾക്ക് ഓരോന്നിനും മൂല്യങ്ങൾ നൽകിയിട്ടുണ്ട്. സബ്സിഡിയറി സ്ക്രിപ്റ്റിന് മാത്രം ഇത് ശരിയാണ്
കയറ്റുമതി ചെയ്ത വേരിയബിളുകളുടെ ഒരു ഉപവിഭാഗം ഇറക്കുമതി ചെയ്യുക (ഈ ഉദാഹരണത്തിൽ, `$LIB', അത് കയറ്റുമതി ചെയ്തത്
മുമ്പത്തെ ഉദാഹരണം, ഇറക്കുമതി ചെയ്തതല്ല).

ഇറക്കുമതി ചെയ്ത എല്ലാ വേരിയബിളുകളും സ്വയമേവ വീണ്ടും കയറ്റുമതി ചെയ്യുന്നു, അതിനാൽ ക്രമം:

qw ഇറക്കുമതി ചെയ്യുക ( env INCLUDE );
ബിൽഡ് qw (beneath-me/Conscript );

സബ്സിഡിയറി ഫയലിലേക്ക് `$env', `$INCLUDE' എന്നിവ നൽകും. `$env' മാത്രമാണെങ്കിൽ
കയറ്റുമതി ചെയ്തു, തുടർന്ന് ഇനിപ്പറയുന്നവ മതിയാകും:

qw ഇറക്കുമതി ചെയ്യുക ( env INCLUDE );
കയറ്റുമതി qw ( env );
ബിൽഡ് qw (beneath-me/Conscript );

'ബിൽഡ്' അഭ്യർത്ഥിക്കുന്നതിന് മുമ്പ് വേരിയബിളുകൾ പ്രാദേശികമായി പരിഷ്‌ക്കരിച്ചേക്കാം എന്ന് പറയേണ്ടതില്ലല്ലോ.
സബ്സിഡിയറി സ്ക്രിപ്റ്റ്.

പണിയുക സ്ക്രിപ്റ്റ് മൂല്യനിർണ്ണയം ഓർഡർ

ബിൽഡ് സ്ക്രിപ്റ്റുകൾ ക്രമപ്പെടുത്തുന്നതിനുള്ള ഒരേയൊരു നിയന്ത്രണം മികച്ച സ്ക്രിപ്റ്റുകൾ ആണ്
അവരുടെ താഴ്ന്ന സ്ക്രിപ്റ്റുകൾക്ക് മുമ്പായി വിലയിരുത്തപ്പെടുന്നു. ഉയർന്ന തലം നിർമ്മിക്കുക ഫയൽ, ഉദാഹരണത്തിന്, ആണ്
ആദ്യം മൂല്യനിർണ്ണയം നടത്തി, പിന്നീട് ഏതെങ്കിലും നിലവാരമില്ലാത്ത സ്ക്രിപ്റ്റുകൾ. നിങ്ങൾ ശരിക്കും അറിയേണ്ടതെല്ലാം ഇതാണ്
മൂല്യനിർണ്ണയ ക്രമത്തെക്കുറിച്ച്, കാരണം ഓർഡർ പൊതുവെ അപ്രസക്തമാണ്. ഇനിപ്പറയുന്നവ പരിഗണിക്കുക
'ബിൽഡ്' കമാൻഡ്:

നിർമ്മിക്കുക qw(
ഡ്രൈവറുകൾ/ഡിസ്‌പ്ലേ/കോൺസ്‌ക്രിപ്റ്റ്
ഡ്രൈവറുകൾ/മൗസ്/കൺസ്ക്രിപ്റ്റ്
പാഴ്സർ/കൺസ്ക്രിപ്റ്റ്
യൂട്ടിലിറ്റികൾ/കൺസ്ക്രിപ്റ്റ്
);

സ്ക്രിപ്റ്റ് നാമങ്ങൾ അക്ഷരമാലാ ക്രമത്തിൽ സ്ഥാപിക്കാൻ ഞങ്ങൾ തിരഞ്ഞെടുത്തു, കാരണം അതാണ് ഏറ്റവും കൂടുതൽ
അറ്റകുറ്റപ്പണികൾക്ക് സൗകര്യപ്രദമാണ്. ക്രമത്തിൽ മാറ്റം വരുത്തുന്നത് ഇതിൽ ഒരു മാറ്റവും ഉണ്ടാക്കില്ല
നിർമ്മിക്കുക.

A മാതൃക വേണ്ടി പങ്കിടുന്നു ഫയലുകൾ

കുറെ ലഘുവായ കൺവെൻഷനുകൾ

ഏതൊരു സങ്കീർണ്ണ സോഫ്‌റ്റ്‌വെയർ സിസ്റ്റത്തിലും, ബിൽഡ് ഉൽപ്പന്നങ്ങൾ പങ്കിടുന്നതിനുള്ള ഒരു രീതി ആവശ്യമാണ്
സ്ഥാപിച്ചു. നടപ്പിലാക്കാൻ നിസ്സാരമായ ഒരു ലളിതമായ കൺവെൻഷനുകൾ ഞങ്ങൾ നിർദ്ദേശിക്കുന്നു
ദോഷങ്ങൾ, എന്നാൽ വളരെ ഫലപ്രദമാണ്.

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

ഈ ഡയറക്‌ടറികൾ ടോപ്പ്-ലെവൽ നിർവചിച്ചിരിക്കുന്നു നിർമ്മിക്കുക ഫയൽ. ഒരു ലളിതമായ നിർമ്മിക്കുക എന്നതിനായുള്ള ഫയൽ
a ഹലോ, ലോകം! ഒന്നിലധികം ഡയറക്‌ടറികൾ ഉപയോഗിച്ച് ഓർഗനൈസുചെയ്‌ത ആപ്ലിക്കേഷൻ ഇതുപോലെയായിരിക്കാം:

# ഹലോ, വേൾഡിനായി ഫയൽ നിർമ്മിക്കുക!

# ഞങ്ങളുടെ പങ്കിട്ട എല്ലാ ഉൽപ്പന്നങ്ങളും എവിടെ സ്ഥാപിക്കണം.
$EXPORT = '#കയറ്റുമതി';

കയറ്റുമതി qw ( CONS LIB BIN ഉൾപ്പെടുന്നു );

# ഉൽപ്പന്നങ്ങൾ പങ്കിടുന്നതിനുള്ള സ്റ്റാൻഡേർഡ് ഡയറക്ടറികൾ.
$INCLUDE = "$ കയറ്റുമതി/ഉൾപ്പെടുത്തുക";
$LIB = "$EXPORT/lib";
$BIN = "$EXPORT/bin";

# ഒരു സാധാരണ നിർമ്മാണ അന്തരീക്ഷം.
$CONS = പുതിയ ദോഷങ്ങൾ (
CPPPATH => $ഉൾപ്പെടുത്തുക, # C കംപൈലേഷനുകൾക്കുള്ള പാത്ത് ഉൾപ്പെടുത്തുക
LIBPATH => $LIB, പ്രോഗ്രാമുകൾ ലിങ്ക് ചെയ്യുന്നതിനുള്ള # ലൈബ്രറി പാത്ത്
LIBS => '-lworld', # സാധാരണ ലൈബ്രറികളുടെ പട്ടിക
);

നിർമ്മിക്കുക qw(
ഹലോ/കൺസ്‌ക്രിപ്റ്റ്
ലോകം / നിർബന്ധിതർ
);

ദി ലോകം ഡയറക്ടറിയുടെ നിർബന്ധിത ഫയൽ ഇതുപോലെ കാണപ്പെടുന്നു:

# ഡയറക്ടറി ലോകത്തിനായുള്ള കോൺ‌സ്‌ക്രിപ്റ്റ് ഫയൽ
ഇറക്കുമതി qw ( CONS LIB ഉൾപ്പെടുന്നു );

# ഈ ഡയറക്ടറിയുടെ ഉൽപ്പന്നങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുക
$CONS $LIB, 'libworld.a' ഇൻസ്റ്റാൾ ചെയ്യുക;
$CONS ഇൻസ്റ്റാൾ ചെയ്യുക $INCLUDE, 'world.h';

# ആന്തരിക ഉൽപ്പന്നങ്ങൾ
ലൈബ്രറി $CONS 'libworld.a', 'world.c';

ഒപ്പം ഹലോ ഡയറക്ടറിയുടെ നിർബന്ധിത ഫയൽ ഇതുപോലെ കാണപ്പെടുന്നു:

# ഡയറക്‌ടറി ഹലോയ്‌ക്കായുള്ള നിർബന്ധിത ഫയൽ
ഇറക്കുമതി qw( CONS BIN );

# കയറ്റുമതി ചെയ്ത ഉൽപ്പന്നങ്ങൾ
$CONS $BIN ഇൻസ്റ്റാൾ ചെയ്യുക, 'ഹലോ';

# ആന്തരിക ഉൽപ്പന്നങ്ങൾ
പ്രോഗ്രാം $CONS 'ഹലോ', 'hello.c';

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

% cons കയറ്റുമതി
export/include/world.h ആയി world/world.h ഇൻസ്റ്റാൾ ചെയ്യുക
cc -Iexport/include -c hello/hello.c -o hello/hello.o
cc -Iexport/include -c world/world.c -o world/world.o
ലോകം/libworld.a world/world.o
ar: ലോകം/libworld.a സൃഷ്ടിക്കുന്നു
ranlib world/libworld.a
export/lib/libworld.a ആയി world/libworld.a ഇൻസ്റ്റാൾ ചെയ്യുക
cc -o hello/hello hello/hello.o -Lexport/lib -lworld
കയറ്റുമതി/ബിൻ/ഹലോ ആയി hello/hello ഇൻസ്റ്റാൾ ചെയ്യുക

ശുദ്ധമായ, മനസ്സിലാക്കാവുന്ന, സ്ഥാനം-സ്വതന്ത്ര സ്ക്രിപ്റ്റുകൾ

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

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

വേർതിരിക്കുന്നു ഉറവിടം ഒപ്പം പണിയുക മരങ്ങൾ

ബിൽഡിൽ നിന്ന് വ്യതിരിക്തമായ ഏതെങ്കിലും ഫയലുകൾ സൂക്ഷിക്കുന്നത് പലപ്പോഴും അഭികാമ്യമാണ്
ഉറവിട ഫയലുകൾ. ഒരു സോഴ്സ് ഫയൽ എന്താണെന്ന് ട്രാക്ക് ചെയ്യുന്നത് ഇത് വളരെ എളുപ്പമാക്കുന്നു, കൂടാതെ
ഇത് കൈകാര്യം ചെയ്യുന്നത് എളുപ്പമാക്കുന്നു വേരിയന്റ് ബിൽഡുകൾ, പ്രത്യേകിച്ച് വേരിയന്റ് ബിൽഡുകൾ വേണമെങ്കിൽ
സഹവർത്തിത്വത്തിന്.

വേർതിരിക്കുന്നു പണിയുക ഒപ്പം ഉറവിടം ഡയറക്ടറികൾ ഉപയോഗിച്ച് The ബന്ധം കമാൻഡ്

ഈ ആവശ്യകതകളെല്ലാം കൈകാര്യം ചെയ്യുന്ന ലളിതമായ ഒരു സംവിധാനം ദോഷങ്ങൾ നൽകുന്നു. 'ലിങ്ക്'
ഈ ഉദാഹരണത്തിലെന്നപോലെ കമാൻഡ് അഭ്യർത്ഥിക്കുന്നു:

ലിങ്ക് 'build' => 'src';

നിർദ്ദിഷ്‌ട ഡയറക്‌ടറികൾ നിർദ്ദിഷ്‌ട ഉറവിട ഡയറക്‌ടറിയിലേക്ക് `ലിങ്ക് ചെയ്‌തിരിക്കുന്നു'. നമുക്ക് ഊഹിക്കാം
നിങ്ങൾ ഒരു ഉറവിട ഡയറക്‌ടറി സജ്ജീകരിക്കുന്നു, ഉറവിട, ഉപ ഡയറക്ടറികൾക്കൊപ്പം ലോകം ഒപ്പം ഹലോ അതിനു താഴെ,
മുമ്പത്തെ ഉദാഹരണത്തിലെന്നപോലെ. നിങ്ങൾക്ക് യഥാർത്ഥ ബിൽഡ് ലൈനുകൾക്ക് പകരം വയ്ക്കാം
താഴെ:

നിർമ്മിക്കുക qw(
ബിൽഡ്/ലോകം/കൺസ്ക്രിപ്റ്റ്
ബിൽഡ്/ഹലോ/കൺസ്ക്രിപ്റ്റ്
);

നിങ്ങൾ ചികിത്സിക്കുന്നത് ശ്രദ്ധിക്കുക നിർബന്ധിത ബിൽഡ് ഡയറക്‌ടറിയിൽ ഉള്ളത് പോലെ ഫയൽ. ഇപ്പോൾ എങ്കിൽ
നിങ്ങൾ മുമ്പത്തെ അതേ കമാൻഡ് ടൈപ്പ് ചെയ്യുക, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഫലങ്ങൾ ലഭിക്കും:

% cons കയറ്റുമതി
export/include/world.h ആയി build/world/world.h ഇൻസ്റ്റാൾ ചെയ്യുക
cc -Iexport/include -c build/hello/hello.c -o build/hello/hello.o
cc -Iexport/include -c build/world/world.c -o build/world/world.o
ar r build/world/libworld.a build/world/world.o
ar: build/world/libworld.a സൃഷ്ടിക്കുന്നു
ranlib build/world/libworld.a
കയറ്റുമതി/lib/libworld.a ആയി build/world/libworld.a ഇൻസ്റ്റാൾ ചെയ്യുക
cc -o build/hello/hello build/hello/hello.o -Lexport/lib -lworld
കയറ്റുമതി/ബിൻ/ഹലോ ആയി ബിൽഡ്/ഹലോ/ഹലോ ഇൻസ്റ്റാൾ ചെയ്യുക

വീണ്ടും, Cons നിങ്ങൾക്കായി വിശദാംശങ്ങൾ ശ്രദ്ധിച്ചു. പ്രത്യേകിച്ചും, നിങ്ങൾ എല്ലാം ശ്രദ്ധിക്കും
ബിൽഡ് ഡയറക്ടറിയിൽ നിന്നുള്ള സോഴ്സ് ഫയലുകളും ഒബ്ജക്റ്റ് ഫയലുകളും ഉപയോഗിച്ചാണ് ബിൽഡുകൾ ചെയ്യുന്നത്. വേണ്ടി
ഉദാഹരണത്തിന്, build/world/world.o എന്നതിൽ നിന്ന് സമാഹരിച്ചതാണ് build/world/world.c, ഒപ്പം
കയറ്റുമതി/ഉൾപ്പെടുത്തുക/world.h മുതൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട് build/world/world.h. ഇത് മിക്കയിടത്തും പൂർത്തീകരിക്കപ്പെടുന്നു
ഓരോ ഉറവിടത്തിൽ നിന്നും ആവശ്യമായ ഫയലുകൾ ബന്ധിപ്പിക്കുന്ന ``ഹാർഡ്'' എന്ന ലളിതമായ ഉപാധി പ്രകാരമുള്ള സിസ്റ്റങ്ങൾ
ഡയറക്ടറി ഉചിതമായ ബിൽഡ് ഡയറക്ടറിയിലേക്ക്.

സോഴ്‌സ് ഡയറക്‌ടറിയിൽ നിങ്ങൾ എന്ത് ചെയ്‌താലും, ലിങ്കുകൾ കോൺസ് ശരിയായി പരിപാലിക്കുന്നു.
നിങ്ങൾ ഒരു സോഴ്‌സ് ഫയൽ പരിഷ്‌ക്കരിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ എഡിറ്റർ ഇത് ``സ്ഥലത്ത്'' ചെയ്യാം അല്ലെങ്കിൽ അത് പുനർനാമകരണം ചെയ്തേക്കാം
ആദ്യം ഒരു പുതിയ ഫയൽ ഉണ്ടാക്കുക. പിന്നീടുള്ള സാഹചര്യത്തിൽ, ഏതെങ്കിലും ഹാർഡ് ലിങ്ക് നഷ്ടപ്പെടും. ദോഷങ്ങൾ ചെയ്യും
അടുത്ത തവണ സോഴ്സ് ഫയൽ ആവശ്യമായി വരുമ്പോൾ ഈ അവസ്ഥ കണ്ടെത്തുകയും അത് വീണ്ടും ലിങ്ക് ചെയ്യുകയും ചെയ്യും
ഉചിതമായി.

വഴിയിൽ, അതും നിങ്ങൾ ശ്രദ്ധിക്കും ഇല്ല അടിസ്ഥാനപരമായി മാറ്റങ്ങൾ ആവശ്യമായിരുന്നു നിർബന്ധിത
ഫയലുകൾ. അടുത്ത വിഭാഗത്തിൽ കാണുന്നത് പോലെ നമുക്ക് കൂടുതൽ മുന്നോട്ട് പോകാം.

മാറ്റമുള്ള പണിയുന്നു

ഹലോ, ലോകം! വേണ്ടി വാഴപ്പഴം ഒപ്പം പീച്ച് OS-കൾ

വേരിയന്റ് ബിൽഡിന് മറ്റൊരു ലളിതമായ വിപുലീകരണം ആവശ്യമാണ്. നമുക്ക് ഒരു ഉദാഹരണമായി എടുക്കാം a
baNaNa, peAcH ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കായി ബിൽഡുകൾ അനുവദിക്കുന്നതിനുള്ള ആവശ്യകത. ഈ സാഹചര്യത്തിൽ,
പ്രത്യേക സിസ്റ്റം ആക്സസ് ചെയ്യാൻ NFS പോലെയുള്ള ഒരു ഡിസ്ട്രിബ്യൂട്ട് ഫയൽ സിസ്റ്റമാണ് ഞങ്ങൾ ഉപയോഗിക്കുന്നത്, കൂടാതെ
ഏതെങ്കിലും ഒരു അഭ്യർത്ഥനയ്ക്കായി ഒന്നോ അതിലധികമോ സിസ്റ്റങ്ങൾ മാത്രമേ കംപൈൽ ചെയ്യാവൂ
`കോൺസ്'. നമുക്ക് സജ്ജീകരിക്കാൻ കഴിയുന്ന ഒരു വഴി ഇതാ നിർമ്മിക്കുക ഞങ്ങൾക്കുള്ള ഫയൽ ഹലോ, ലോകം!
അപ്ലിക്കേഷൻ:

# ഹലോ, വേൾഡിനായി ഫയൽ നിർമ്മിക്കുക!

$OS = $ARG{OS} അല്ലാത്തപക്ഷം ഡൈ qq(OS വ്യക്തമാക്കിയിരിക്കണം);
die qq(OS "പീച്ച്" അല്ലെങ്കിൽ "വാഴപ്പഴം" ആയിരിക്കണം)
$OS ne "പീച്ച്" && $OS ne "വാഴപ്പഴം" എങ്കിൽ;

# ഞങ്ങളുടെ പങ്കിട്ട എല്ലാ ഉൽപ്പന്നങ്ങളും എവിടെ സ്ഥാപിക്കണം.
$EXPORT = "#കയറ്റുമതി/$OS";

കയറ്റുമതി qw ( CONS LIB BIN ഉൾപ്പെടുന്നു );

# ഉൽപ്പന്നങ്ങൾ പങ്കിടുന്നതിനുള്ള സ്റ്റാൻഡേർഡ് ഡയറക്ടറികൾ.
$INCLUDE = "$ കയറ്റുമതി/ഉൾപ്പെടുത്തുക";
$LIB = "$EXPORT/lib";
$BIN = "$EXPORT/bin";

# ഒരു സാധാരണ നിർമ്മാണ അന്തരീക്ഷം.
$CONS = പുതിയ ദോഷങ്ങൾ (
CPPPATH => $ഉൾപ്പെടുത്തുക, # C കംപൈലേഷനുകൾക്കുള്ള പാത്ത് ഉൾപ്പെടുത്തുക
LIBPATH => $LIB, പ്രോഗ്രാമുകൾ ലിങ്ക് ചെയ്യുന്നതിനുള്ള # ലൈബ്രറി പാത്ത്
LIBS => '-lworld', # സാധാരണ ലൈബ്രറികളുടെ പട്ടിക
);

# $BUILD എന്നതിൽ നിന്നാണ് നമ്മൾ എല്ലാം ഉരുത്തിരിയുന്നത്.
$BUILD = "#ബിൽഡ്/$OS";

# $BUILD-ന്റെ ഉറവിട ഫയലുകൾ എവിടെയാണെന്ന് ദോഷഫലങ്ങൾ പറയുക.
ലിങ്ക് $BUILD => 'src';

നിർമ്മിക്കുക (
"$BUILD/hello/Conscript",
"$BUILD/world/Conscript",
);

ഇപ്പോൾ നമ്മൾ ഒരു peAcH സിസ്റ്റത്തിലേക്ക് ലോഗിൻ ചെയ്താൽ, നമുക്ക് അത് നിർമ്മിക്കാൻ കഴിയും ഹലോ, ലോകം! അതിനുള്ള അപേക്ഷ
പ്ലാറ്റ്ഫോം:

% cons കയറ്റുമതി OS=peach
Export/peach/include/world.h ആയി build/peach/world/world.h ഇൻസ്റ്റാൾ ചെയ്യുക
cc -Iexport/peach/include -c build/peach/hello/hello.c -o build/peach/hello/hello.o
cc -Iexport/peach/include -c build/peach/world/world.c -o build/peach/world/world.o
ar r build/peach/world/libworld.a build/peach/world/world.o
ar: build/peach/world/libworld.a സൃഷ്ടിക്കുന്നു
ranlib build/peach/world/libworld.a
കയറ്റുമതി/peach/lib/libworld.a ആയി build/peach/world/libworld.a ഇൻസ്റ്റാൾ ചെയ്യുക
cc -o build/peach/hello/hello build/peach/hello/hello.o -Lexport/peach/lib -lworld
കയറ്റുമതി/പീച്ച്/ബിൻ/ഹലോ ആയി ബിൽഡ്/പീച്ച്/ഹലോ/ഹലോ ഇൻസ്റ്റാൾ ചെയ്യുക

വ്യതിയാനങ്ങൾ on a തീം

ഈ മോഡലിന്റെ മറ്റ് വ്യതിയാനങ്ങൾ സാധ്യമാണ്. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് വേണോ എന്ന് നിങ്ങൾ തീരുമാനിച്ചേക്കാം
നിങ്ങളുടെ ഉൾപ്പെടുത്തിയ ഫയലുകളെ പ്ലാറ്റ്‌ഫോം ആശ്രിതവും പ്ലാറ്റ്‌ഫോം സ്വതന്ത്രവുമായ ഫയലുകളായി വേർതിരിക്കുന്നതിന്.
ഈ സാഹചര്യത്തിൽ, പ്ലാറ്റ്‌ഫോമിനെ ആശ്രയിക്കുന്നതിന് `$INCLUDE' എന്നതിന് ഒരു ബദൽ നിങ്ങൾ നിർവചിക്കേണ്ടതുണ്ട്
ഫയലുകൾ. മിക്കതും നിർബന്ധിത ഫയലുകൾ, പൂർണ്ണമായും പ്ലാറ്റ്‌ഫോം-സ്വതന്ത്രമായി സൃഷ്ടിക്കുന്ന ഫയലുകൾ ഉൾപ്പെടുന്നു
മാറ്റേണ്ടതില്ല.

ഡീബഗ്ഗിംഗ് അല്ലെങ്കിൽ പ്രൊഫൈലിംഗ് ഉപയോഗിച്ച് നിങ്ങളുടെ മുഴുവൻ സിസ്റ്റവും കംപൈൽ ചെയ്യാനും നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം,
ഉദാഹരണത്തിന്, പ്രവർത്തനക്ഷമമാക്കി. ഉചിതമായ കമാൻഡ് ലൈൻ ഓപ്ഷനുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും
`ഡീബഗ്=ഓൺ'. ഇത് പിന്നീട് ഉചിതമായ പ്ലാറ്റ്ഫോം-നിർദ്ദിഷ്ടതയിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടും
ഡീബഗ്ഗിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നതിനുള്ള ആവശ്യകതകൾ (ഇതിൽ ഒപ്റ്റിമൈസേഷൻ ഓഫ് ചെയ്യുന്നത് ഉൾപ്പെട്ടേക്കാം
ഉദാഹരണം). ഈ വ്യത്യസ്‌ത തരം സിസ്റ്റങ്ങൾക്കായി നിങ്ങൾക്ക് ഓപ്‌ഷണലായി നെയിം സ്‌പെയ്‌സ് മാറ്റാം,
പക്ഷേ, അടുത്ത വിഭാഗത്തിൽ നമ്മൾ കാണുന്നത് പോലെ, അങ്ങനെയല്ല അത്യാവശ്യമാണ് ഇത് ചെയ്യാൻ, കാരണം ദോഷങ്ങൾ മനോഹരമാണ്
നിങ്ങൾ ഓപ്‌ഷനുകൾ മാറ്റുമ്പോൾ കാര്യങ്ങൾ പുനർനിർമ്മിക്കുന്നതിൽ മിടുക്കനാണ്.

ഒപ്പുകൾ

MD5 ക്രിപ്റ്റോഗ്രാഫിക് ഒപ്പ്

Cons ഒരു ഡെറിവേഡ് ഫയൽ സൃഷ്ടിക്കുമ്പോഴെല്ലാം, അത് സംഭരിക്കുന്നു a കയ്യൊപ്പ് ആ ഫയലിനായി. ഒപ്പ്
ഓരോ ഡയറക്‌ടറിയിലും ഒരു പ്രത്യേക ഫയലിൽ സംഭരിക്കുന്നു. മുമ്പത്തെ ഉദാഹരണം സമാഹരിച്ച ശേഷം,
The .കൺസൈൻ ഫയലിൽ ഫയൽ ചെയ്യുക പണിയുക/പീച്ച്/ലോകം ഡയറക്ടറി ഇതുപോലെ കാണപ്പെട്ടു:

world.o:834179303 23844c0b102ecdc0b4548d1cd1cbd8c6
libworld.a:834179304 9bf6587fa06ec49d864811a105222c00

ആദ്യത്തെ നമ്പർ ഒരു ടൈംസ്റ്റാമ്പാണ്--ഒരു UNIX സിസ്റ്റങ്ങൾക്ക്, ഇത് സാധാരണയായി ഇവയുടെ സംഖ്യയാണ്
1 ജനുവരി 1970 മുതൽ സെക്കൻഡുകൾ. രണ്ടാമത്തെ മൂല്യം ഒരു MD5 ചെക്ക്സം ആണ്. ദി സന്ദേശം ഡൈജസ്റ്റ്
അൽഗോരിതം ഒരു ഇൻപുട്ട് സ്ട്രിംഗ് നൽകിയാൽ, ശക്തമായ ഒരു ക്രിപ്‌റ്റോഗ്രാഫിക് കണക്കാക്കുന്ന ഒരു അൽഗോരിതം ആണ്
ആ സ്ട്രിംഗിന്റെ ഒപ്പ്. MD5 ചെക്ക്സം സംഭരിച്ചിരിക്കുന്നു .കൺസൈൻ ഫയൽ ഫലത്തിൽ a
നിർദ്ദിഷ്‌ട ഫയലിനായുള്ള എല്ലാ ഡിപൻഡൻസി വിവരങ്ങളും ഡൈജസ്റ്റ് ചെയ്യുക. അതിനാൽ, ഉദാഹരണത്തിന്, വേണ്ടി
world.o ഫയൽ, ഇതിൽ കുറഞ്ഞത് ഉൾപ്പെടുന്നു ലോകം.സി ഫയൽ, കൂടാതെ ദോഷകരമായ ഏതെങ്കിലും ഹെഡർ ഫയലുകൾ
നേരിട്ടോ അല്ലാതെയോ ഉൾപ്പെടുത്തിയിരിക്കുന്നതിനെക്കുറിച്ച് അറിയാം ലോകം.സി. മാത്രമല്ല, ദി
സൃഷ്ടിക്കാൻ ഉപയോഗിച്ച യഥാർത്ഥ കമാൻഡ് ലൈൻ world.o യുടെ കണക്കുകൂട്ടലിലേക്കും നൽകപ്പെടുന്നു
ഒപ്പ്. സമാനമായി, libworld.a എല്ലാം ``ഉൾപ്പെടുന്ന'' ഒരു ഒപ്പ് ലഭിക്കുന്നു
അതിന്റെ ഘടകങ്ങളുടെ ഒപ്പുകൾ (അതിനാൽ, ട്രാൻസിറ്റീവ് ആയി, ഒപ്പുകൾ അവരുടെ
ഘടകങ്ങൾ), അതുപോലെ ഫയൽ സൃഷ്ടിച്ച കമാൻഡ് ലൈനും.

ഒരു നോൺ-ഡെറൈവ്ഡ് ഫയലിന്റെ ഒപ്പ് സ്ഥിരസ്ഥിതിയായി, കറന്റ് എടുത്ത് കണക്കാക്കുന്നു
ഫയലിന്റെ പരിഷ്‌ക്കരണ സമയവും ഫയലിന്റെ എൻട്രി നാമവും (അല്ലെങ്കിൽ a
നിലവിലുള്ളത് .കൺസൈൻ ആ ഫയലിനുള്ള എൻട്രി, ഈ സാഹചര്യത്തിൽ ആ ഒപ്പ് ഉപയോഗിക്കുന്നു).

ഒരു പ്രത്യേക ഫയലിനെ ആശ്രയിക്കേണ്ട ആവശ്യമില്ലെന്ന കാര്യം ശ്രദ്ധിക്കുക നിർമ്മിക്കുക or
നിർബന്ധിത file--ഈ ഫയലുകളിലെ മാറ്റങ്ങൾ സംശയാസ്‌പദമായ ഫയലിനെ ബാധിക്കുകയാണെങ്കിൽ, അങ്ങനെയായിരിക്കും
കമാൻഡ് ലൈനിന്റെ പ്രസക്ത ഭാഗങ്ങൾ ആയതിനാൽ അതിന്റെ ഒപ്പിൽ യാന്ത്രികമായി പ്രതിഫലിക്കുന്നു
ഒപ്പിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ബന്ധമില്ലാത്ത മാറ്റങ്ങൾ ഒരു ഫലവുമുണ്ടാക്കില്ല.

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

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

ഈ ഒപ്പുകളുടെ ഉപയോഗം വളരെ ലളിതവും കാര്യക്ഷമവും ഫലപ്രദവുമായ ഒരു രീതിയാണ്
ഒരു സിസ്റ്റത്തിന്റെ പുനരുൽപാദനക്ഷമത മെച്ചപ്പെടുത്തുന്നു - നാടകീയമായി.

ഒരു ലളിതമായ ഉദാഹരണത്തിലൂടെ ഞങ്ങൾ ഇത് തെളിയിക്കും:

# ലളിതമായ "ഹലോ, വേൾഡ്!" ഫയൽ നിർമ്മിക്കുക
$CFLAGS = $ARG{DEBUG} eq 'on' ആണെങ്കിൽ '-g';
$ CONS = പുതിയ ദോഷങ്ങൾ (CFLAGS => $CFLAGS);
പ്രോഗ്രാം $CONS 'ഹലോ', 'hello.c';

ഉചിതമായ സമയങ്ങളിൽ Cons വീണ്ടും കംപൈൽ ചെയ്യുന്നത് എങ്ങനെയെന്ന് ശ്രദ്ധിക്കുക:

% cons ഹലോ
cc -c hello.c -o hello.o
cc -o ഹലോ hello.o
% cons ഹലോ
ദോഷങ്ങൾ: "ഹലോ" കാലികമാണ്.
% cons DEBUG=ഹലോയിൽ
cc -g -c hello.c -o hello.o
cc -o ഹലോ hello.o
% cons DEBUG=ഹലോയിൽ
ദോഷങ്ങൾ: "ഹലോ" കാലികമാണ്.
% cons ഹലോ
cc -c hello.c -o hello.o
cc -o ഹലോ hello.o

കോഡ് റിപ്പോസിറ്ററികൾ

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

സംഭരണിയാണ്

തിരയുന്ന കോഡ് ശേഖരണങ്ങളുടെ ഒരു ലിസ്റ്റ് വ്യക്തമാക്കുന്നതിനുള്ള ഒരു സംവിധാനം Cons നൽകുന്നു,
പ്രാദേശിക ബിൽഡ് ഡയറക്‌ടറി ട്രീയിൽ കാണാത്ത സോഴ്‌സ് ഫയലുകൾക്കും ഡിറൈവ്ഡ് ഫയലുകൾക്കുമായി ക്രമത്തിൽ.

എയിലെ ഇനിപ്പറയുന്ന വരികൾ നിർമ്മിക്കുക എന്നതിന് താഴെ ആദ്യം നോക്കാൻ ഫയൽ ദോഷങ്ങൾക്ക് നിർദ്ദേശം നൽകും
/usr/experiment/repository ഡയറക്‌ടറിയും അതിനു താഴെയും /usr/product/repository ഡയറക്ടറി:

ശേഖരം qw (
/usr/experiment/repository
/usr/product/repository
);

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

Repositories ഡയറക്ടറികളുടെ ഒരു ആഗോള ലിസ്റ്റ് Cons പരിപാലിക്കുന്നു. ദോഷങ്ങൾ ഇല്ലാതാക്കും
നിലവിലെ ഡയറക്‌ടറിയും നിലവിലില്ലാത്ത ഡയറക്‌ടറികളും ലിസ്റ്റിൽ നിന്ന്.

കണ്ടെത്തുന്നു The നിർമ്മിക്കുക ഫയല് in a സംഭരണിയാണ്

ദോഷങ്ങളെക്കുറിച്ചും അന്വേഷിക്കും നിർമ്മിക്കുക ഒപ്പം നിർബന്ധിത റിപ്പോസിറ്ററി ട്രീയിലോ മരങ്ങളിലോ ഉള്ള ഫയലുകൾ.
ഇത് ഒരു കോഴി-മുട്ട അവസ്ഥയിലേക്ക് നയിക്കുന്നു, എന്നിരുന്നാലും: ഒരു റിപ്പോസിറ്ററി ട്രീയിൽ നിങ്ങൾ എങ്ങനെ കാണപ്പെടുന്നു
ഒരു വേണ്ടി നിർമ്മിക്കുക ഫയൽ എങ്കിൽ നിർമ്മിക്കുക ശേഖരം എവിടെയാണെന്ന് ഫയൽ നിങ്ങളോട് പറയുമോ? ലഭിക്കാൻ
ഇതിന് ചുറ്റും, കമാൻഡ് ലൈനിലെ `-R' ഓപ്ഷനുകൾ വഴി റിപ്പോസിറ്ററികൾ വ്യക്തമാക്കിയേക്കാം:

% cons -R /usr/experiment/repository -R /usr/product/repository .

ൽ വ്യക്തമാക്കിയിട്ടുള്ള ഏതെങ്കിലും റിപ്പോസിറ്ററി ഡയറക്‌ടറികൾ നിർമ്മിക്കുക or നിർബന്ധിത ഫയലുകൾ കൂട്ടിച്ചേർക്കും
കമാൻഡ്-ലൈൻ `-R' ഓപ്ഷനുകൾ വ്യക്തമാക്കിയ റിപ്പോസിറ്ററി ഡയറക്ടറികളിലേക്ക്.

സംഭരണിയാണ് ഉറവിടം ഫയലുകൾ

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

% cons -R /usr/src_only/repository ഹലോ
gcc -c /usr/src_only/repository/hello.c -o hello.o
gcc -c /usr/src_only/repository/world.c -o world.o
ar r libworld.a world.o
ar: libworld.a സൃഷ്ടിക്കുന്നു
ranlib libworld.a
gcc -o ഹലോ hello.o libworld.a

ഒരു ലോക്കൽ സോഴ്സ് ഫയൽ സൃഷ്‌ടിക്കുന്നത് ഉചിതമായ ഡെറിവേഡ് ഫയൽ പുനർനിർമ്മിക്കുന്നതിന് ദോഷങ്ങൾക്ക് കാരണമാകും
ഫയലുകൾ:

% പിക്കോ വേൾഡ്.സി
[തിരുത്തുക]
% cons -R /usr/src_only/repository ഹലോ
gcc -c world.c -o world.o
ar r libworld.a world.o
ar: libworld.a സൃഷ്ടിക്കുന്നു
ranlib libworld.a
gcc -o ഹലോ hello.o libworld.a

കൂടാതെ ലോക്കൽ സോഴ്‌സ് ഫയൽ നീക്കം ചെയ്യുന്നത്, ഡിറൈവ്ഡ് ബിൽഡിംഗിലേക്ക് തിരിച്ചുവരാൻ ദോഷങ്ങൾക്ക് കാരണമാകും
ശേഖരണ ഉറവിടത്തിൽ നിന്നുള്ള ഫയലുകൾ:

% rm world.c
% cons -R /usr/src_only/repository ഹലോ
gcc -c /usr/src_only/repository/world.c -o world.o
ar r libworld.a world.o
ar: libworld.a സൃഷ്ടിക്കുന്നു
ranlib libworld.a
gcc -o ഹലോ hello.o libworld.a

സംഭരണിയാണ് derived ഫയലുകൾ

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

റിപ്പോസിറ്ററിയിൽ (അല്ലെങ്കിൽ,
പകരമായി, ഒരു ബിൽഡ് ഡയറക്‌ടറിയിൽ, തുടർന്ന് ഫലം ശേഖരത്തിലേക്ക് പകർത്തുന്നു):

% cd /usr/all/repository
% cons ഹലോ
gcc -c hello.c -o hello.o
gcc -c world.c -o world.o
ar r libworld.a world.o
ar: libworld.a സൃഷ്ടിക്കുന്നു
ranlib libworld.a
gcc -o ഹലോ hello.o libworld.a

(ഇത് സുരക്ഷിതമാണ് നിർമ്മിക്കുക ഫയൽ പട്ടികപ്പെടുത്തുന്നു /usr/all/repository ഡയറക്‌ടറി a
'റിപ്പോസിറ്ററി' കമാൻഡ് കാരണം കോൻസ് റിപ്പോസിറ്ററിയിൽ നിന്ന് നിലവിലെ ഡയറക്‌ടറി നീക്കം ചെയ്യും
പട്ടിക.)

ഇപ്പോൾ നമുക്ക് സ്വന്തമായി ആപ്ലിക്കേഷന്റെ ഒരു പകർപ്പ് നിർമ്മിക്കണമെങ്കിൽ hello.c ഫയൽ, ഞങ്ങൾക്ക് മാത്രം മതി
ആവശ്യമായ ഒരു സോഴ്‌സ് ഫയൽ സൃഷ്‌ടിക്കുന്നതിന്, '-R' ഓപ്‌ഷൻ ഉപയോഗിച്ച് ദോഷങ്ങൾ മറ്റൊന്ന് ഉപയോഗിക്കുക
ശേഖരത്തിൽ നിന്നുള്ള ഫയലുകൾ:

% mkdir $HOME/build1
% cd $HOME/build1
% ed hello.c
[തിരുത്തുക]
% cons -R /usr/all/repository ഹലോ
gcc -c hello.c -o hello.o
gcc -o ഹലോ hello.o /usr/all/repository/libworld.a

ഒരു ലോക്കൽ പുനഃസൃഷ്‌ടിക്കാൻ കോൺസ്‌ മെനക്കെടുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക libworld.a ലൈബ്രറി (അല്ലെങ്കിൽ വീണ്ടും കംപൈൽ ചെയ്യുക
world.o മൊഡ്യൂൾ), പകരം റിപ്പോസിറ്ററിയിൽ നിന്ന് ഇതിനകം സമാഹരിച്ച പതിപ്പ് ഉപയോഗിക്കുന്നു.

കാരണം കോൺസ് ഇടുന്ന MD5 ഒപ്പുകൾ .കൺസൈൻ ഫയലിൽ ടൈംസ്റ്റാമ്പുകൾ അടങ്ങിയിരിക്കുന്നു
ഉരുത്തിരിഞ്ഞ ഫയലുകൾ, സിഗ്നേച്ചർ ടൈംസ്റ്റാമ്പുകൾ ഒരു സിഗ്നേച്ചറിനുള്ള ഫയൽ ടൈംസ്റ്റാമ്പുകളുമായി പൊരുത്തപ്പെടണം
സാധുതയുള്ളതായി കണക്കാക്കും.

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

Repository_Sig_Times_OK 0;

ഒരു ഒപ്പ് സാധുതയുള്ളതാണോ എന്ന് തീരുമാനിക്കുമ്പോൾ ടൈംസ്റ്റാമ്പുകൾ അവഗണിക്കാൻ ഇത് Cons-നോട് പറയുന്നു. (കുറിപ്പ്
ഈ സാനിറ്റി പരിശോധന ഒഴിവാക്കുക എന്നതിനർത്ഥം ശേഖരത്തിൽ ശരിയായ നിയന്ത്രണം ഉണ്ടായിരിക്കണം എന്നാണ്
ട്രീ അപ്‌ഡേറ്റ് ചെയ്യാതെ ലഭിച്ച ഫയലുകൾ പരിഷ്‌ക്കരിക്കാനാവില്ലെന്ന് ഉറപ്പാക്കാൻ .കൺസൈൻ
കയ്യൊപ്പ്.)

പ്രാദേശിക പകർപ്പുകൾ of ഫയലുകൾ

റിപ്പോസിറ്ററി ട്രീയിൽ ഒരു ബിൽഡിന്റെ പൂർണ്ണമായ ഫലങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ഞങ്ങൾ നിർമ്മിക്കാൻ ശ്രമിക്കുന്നു
ഞങ്ങളുടെ ലോക്കൽ ട്രീയിൽ ഫയലുകളൊന്നും ഇല്ലാത്ത റിപ്പോസിറ്ററി, മിതമായ രീതിയിൽ ആശ്ചര്യപ്പെടുത്തുന്ന ഒന്ന്
സംഭവിക്കുന്നത്:

% mkdir $HOME/build2
% cd $HOME/build2
% cons -R /usr/all/repository ഹലോ
ദോഷങ്ങൾ: "ഹലോ" കാലികമാണ്.

എന്തുകൊണ്ടാണ് Cons എന്ന് പറയുന്നത് ഹലോ ഇല്ലെങ്കിൽ പ്രോഗ്രാം കാലികമാണ് ഹലോ പ്രോഗ്രാം
ലോക്കൽ ബിൽഡ് ഡയറക്ടറി? കാരണം റിപ്പോസിറ്ററിയിൽ (പ്രാദേശിക ഡയറക്ടറി അല്ല) അടങ്ങിയിരിക്കുന്നു
കാലികമാണ് ഹലോ പ്രോഗ്രാം, കൂടാതെ ദോഷങ്ങൾ ഒന്നും ചെയ്യേണ്ടതില്ല എന്ന് കൃത്യമായി നിർണ്ണയിക്കുന്നു
ഫയലിന്റെ ഈ കാലികമായ പകർപ്പ് പുനർനിർമ്മിക്കുക.

എന്നിരുന്നാലും, ഒരു പ്രാദേശിക പകർപ്പ് ഉറപ്പാക്കുന്നത് ഉചിതമാണ്
ഫയൽ എപ്പോഴും നിലവിലുണ്ട്. ഒരു പാക്കേജിംഗ് അല്ലെങ്കിൽ ടെസ്റ്റിംഗ് സ്ക്രിപ്റ്റ്, ഉദാഹരണത്തിന്, അത് ഉറപ്പാണ്
സൃഷ്ടിച്ച ഫയലുകൾ പ്രാദേശികമായി നിലവിലുണ്ട്. ഈ സബ്സിഡിയറി സ്ക്രിപ്റ്റുകളെ കുറിച്ച് ബോധവാന്മാരാക്കുന്നതിന് പകരം
റിപ്പോസിറ്ററി ഡയറക്ടറി, 'ലോക്കൽ' കമാൻഡ് a ലേക്ക് ചേർത്തേക്കാം നിർമ്മിക്കുക or നിർബന്ധിത ലേക്ക് ഫയൽ ചെയ്യുക
ലോക്കൽ ബിൽഡ് ഡയറക്‌ടറിയിൽ ഒരു നിശ്ചിത ഫയലോ ഫയലുകളോ ദൃശ്യമാകണമെന്ന് വ്യക്തമാക്കുക:

പ്രാദേശിക qw(
ഹലോ
);

തുടർന്ന്, നമ്മൾ അതേ കമാൻഡ് വീണ്ടും പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, പ്രോഗ്രാമിന്റെ പ്രാദേശിക പകർപ്പ് കോൺസ് ഉണ്ടാക്കും
റിപ്പോസിറ്ററി കോപ്പി (അത് അങ്ങനെ ചെയ്യുന്നുവെന്ന് നിങ്ങളോട് പറയുന്നു):

% cons -R /usr/all/repository ഹലോ
/usr/all/repository/hello എന്നതിൽ നിന്നുള്ള ഹലോയുടെ പ്രാദേശിക പകർപ്പ്
ദോഷങ്ങൾ: "ഹലോ" കാലികമാണ്.

അത് ശ്രദ്ധിക്കുക, കാരണം പ്രാദേശിക പകർപ്പ് നിർമ്മിക്കുന്നത് "നിർമ്മാണം" ആയി കണക്കാക്കില്ല
ഹലോ ഫയൽ, അത് കാലികമാണെന്ന് കോൺസ് ഇപ്പോഴും റിപ്പോർട്ട് ചെയ്യുന്നു.

പ്രാദേശിക പകർപ്പുകൾ സൃഷ്ടിക്കുന്നത് ഒരു ഫയലിലേക്ക് ഇൻസ്റ്റാൾ ചെയ്യുന്ന ഫയലുകൾക്ക് ഏറ്റവും ഉപയോഗപ്രദമാണ്
'ഇൻസ്റ്റാൾ' കമാൻഡ് വഴി ഇന്റർമീഡിയറ്റ് ഡയറക്ടറി (മറ്റ് ഡയറക്ടറികളുമായി പങ്കിടുന്നതിന്).
ഒരു കമ്പാനിയൻ `ലോക്കൽ' കമാൻഡ് ഉള്ള ഒരു ഫയലിനായി `ഇൻസ്റ്റാൾ' കമാൻഡിനൊപ്പമാണ്
രണ്ടും ചെയ്യുന്നതിനുള്ള സൗകര്യപ്രദമായ മാർഗമായി Cons ഒരു `Install_Local' കമാൻഡ് നൽകുന്നു.

Install_Local $env, '#കയറ്റുമതി', 'ഹലോ';

ഇതിന് കൃത്യമായി തുല്യമാണ്:

$env '#കയറ്റുമതി', 'ഹലോ' ഇൻസ്റ്റാൾ ചെയ്യുക;
പ്രാദേശിക '#കയറ്റുമതി/ഹലോ';

`ലോക്കൽ', `ഇൻസ്റ്റാൾ_ലോക്കൽ' കമാൻഡുകൾ ലോക്കൽ അപ്ഡേറ്റ് ചെയ്യുന്നു .കൺസൈൻ ഫയൽ കൂടെ
ഉചിതമായ ഫയൽ ഒപ്പുകൾ, അതുവഴി ഭാവി ബിൽഡുകൾ ശരിയായി നിർവഹിക്കപ്പെടും.

സംഭരണിയാണ് ആശ്രിതത്വം വിശകലനം

ബിൽറ്റ്-ഇൻ സ്കാനിംഗ് കാരണം, ഉൾപ്പെടുത്തിയിട്ടുള്ള നിർദിഷ്ട റിപ്പോസിറ്ററി ട്രീകളിൽ Cons തിരയും
.h ഫയലുകൾ. കംപൈലറിന് റിപ്പോസിറ്ററി ട്രീകളെക്കുറിച്ച് അറിയില്ലെങ്കിൽ, അത് അങ്ങനെയായിരിക്കും
കണ്ടെത്താൻ കഴിയുന്നില്ല .h ഒരു റിപ്പോസിറ്ററിയിൽ മാത്രം നിലനിൽക്കുന്ന ഫയലുകൾ. എങ്കിൽ, ഉദാഹരണത്തിന്, ദി hello.c
ഫയലിൽ ഉൾപ്പെടുന്നു hello.h ഫയൽ അതിന്റെ നിലവിലെ ഡയറക്ടറിയിൽ:

% cons -R /usr/all/repository ഹലോ
gcc -c /usr/all/repository/hello.c -o hello.o
/usr/all/repository/hello.c:1: hello.h: അത്തരം ഫയലോ ഡയറക്ടറിയോ ഇല്ല

ഈ പ്രശ്നം പരിഹരിക്കുന്നത് നിർമ്മാണ പരിതസ്ഥിതികളുടെ രീതിയിലേക്ക് ചില ആവശ്യകതകളെ പ്രേരിപ്പിക്കുന്നു
നിർവചിക്കുകയും ഫയലുകൾ ഉൾപ്പെടുത്താൻ C `#ഉൾപ്പെടുത്തുക' എന്ന പ്രീപ്രൊസസ്സർ നിർദ്ദേശം ഉപയോഗിക്കുന്ന രീതിയിലേക്ക്.

റിപ്പോസിറ്ററി ട്രീകളെക്കുറിച്ച് കംപൈലറെ അറിയിക്കുന്നതിന്, Cons ഉചിതമായ `-I' ചേർക്കും.
കംപൈലേഷൻ കമാൻഡുകളിലേക്ക് ഫ്ലാഗുകൾ. എന്നതിലെ `CPPPATH' വേരിയബിൾ എന്നാണ് ഇതിനർത്ഥം
കൺസ്ട്രക്റ്റ് എൻവയോൺമെന്റ് തിരയേണ്ട എല്ലാ ഉപഡയറക്‌ടറികളും വ്യക്തമായി വ്യക്തമാക്കണം
നിലവിലെ ഡയറക്‌ടറി ഉൾപ്പെടെ ഉൾപ്പെടുത്തിയ ഫയലുകൾക്കായി. തൽഫലമായി, നമുക്ക് മുകളിൽ പറഞ്ഞവ ശരിയാക്കാം
പരിസ്ഥിതി സൃഷ്ടിയെ മാറ്റുന്നതിലൂടെ ഉദാഹരണം നിർമ്മിക്കുക ഇനിപ്പറയുന്ന രീതിയിൽ ഫയൽ:

$env = പുതിയ ദോഷങ്ങൾ(
CC => 'gcc',
CPPPATH => '.',
LIBS => 'libworld.a',
);

`CPPPATH' വേരിയബിളിന്റെ നിർവചനം കാരണം, നമ്മൾ വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ഇത് ലഭിക്കുന്നു
കമാൻഡ്:

% cons -R /usr/all/repository ഹലോ
gcc -c -I. -I/usr/all/repository /usr/all/repository/hello.c -o hello.o
gcc -o ഹലോ hello.o /usr/all/repository/libworld.a

`-I' ഫ്ലാഗുകളുടെ ക്രമം ആവർത്തിക്കുന്നു, സി പ്രീപ്രൊസസറിനായി, അതേ ശേഖരം-
സ്വന്തം ഡിപൻഡൻസി വിശകലനത്തിനായി കോൻസ് ഉപയോഗിക്കുന്ന ഡയറക്ടറി തിരയൽ പാത. ഉണ്ടെങ്കിൽ
ഒന്നിലധികം റിപ്പോസിറ്ററികളും ഒന്നിലധികം 'CPPPATH' ഡയറക്ടറികളും, Cons റിപ്പോസിറ്ററി കൂട്ടിച്ചേർക്കും
ഓരോ 'CPPPATH' ഡയറക്‌ടറിയുടെയും ആരംഭത്തിലേക്കുള്ള ഡയറക്‌ടറികൾ, സംഖ്യയെ അതിവേഗം ഗുണിക്കുന്നു
`-ഐ' പതാകകളുടെ. ഒരു അങ്ങേയറ്റത്തെ ഉദാഹരണമായി, എ നിർമ്മിക്കുക ഫയൽ അടങ്ങുന്ന:

ശേഖരം qw(
/u1
/u2
);

$env = പുതിയ ദോഷങ്ങൾ(
CPPPATH => 'a:b:c',
);

ഇനിപ്പറയുന്നതിന്റെ ഒരു സമാഹാര കമാൻഡ് നൽകും:

cc -Ia -I/u1/a -I/u2/a -Ib -I/u1/b -I/u2/b -Ic -I/u1/c -I/u2/c -c hello.c -o hello.o

കാരണം, ഏത് ക്രമത്തിൽ ആശയവിനിമയം നടത്താൻ കംപൈലറിന്റെ `-I' ഫ്ലാഗുകളെ കോൺസ് ആശ്രയിക്കുന്നു
റിപ്പോസിറ്ററി ഡയറക്‌ടറികൾ തിരയേണ്ടതുണ്ട്, റിപ്പോസിറ്ററി ഡയറക്‌ടറികൾ കൈകാര്യം ചെയ്യുന്നത് ദോഷകരമാണ്
നിങ്ങളുടെ സിയിലെ `#ഉൾപ്പെടുത്തുക' നിർദ്ദേശങ്ങളിൽ ഇരട്ട ഉദ്ധരണികൾ ഉപയോഗിക്കുന്നതിന് അടിസ്ഥാനപരമായി പൊരുത്തമില്ല
സോഴ്സ് കോഡ്:

#"file.h" ഉൾപ്പെടുത്തുക /* ഇതുപോലുള്ള ഇരട്ട ഉദ്ധരണികൾ ഉപയോഗിക്കരുത് */

കാരണം, മിക്ക സി പ്രീപ്രോസസറുകളും, അത്തരമൊരു നിർദ്ദേശം അഭിമുഖീകരിക്കുമ്പോൾ, എല്ലായ്പ്പോഴും ഒന്നാമതായിരിക്കും
സോഴ്സ് ഫയൽ അടങ്ങുന്ന ഡയറക്ടറി തിരയുക. ഇത് വിപുലമായ `-ഐ'യെ ദുർബലപ്പെടുത്തുന്നു
പ്രീപ്രൊസസർ അതിന്റെ ഇഷ്ടപ്പെട്ട തിരയലുമായി പൊരുത്തപ്പെടുന്ന തരത്തിൽ കോൺസ്‌ട്രക്‌റ്റ് ചെയ്യുന്ന ഓപ്ഷനുകൾ
പാത.

തൽഫലമായി, റിപ്പോസിറ്ററി ട്രീകൾ ഉപയോഗിക്കുമ്പോൾ, എല്ലായിപ്പോഴും ഉൾപ്പെടുത്തുന്നതിന് ആംഗിൾ-ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുക
ഫയലുകൾ:

#ഉൾപ്പെടുന്നു /* പകരം ആംഗിൾ-ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുക */

റിപ്പോസിറ്ററി_ലിസ്റ്റ്

എല്ലാ റിപ്പോസിറ്ററി ഡയറക്‌ടറികളുടെയും ഒരു ലിസ്റ്റ് തിരികെ നൽകുന്നതിന് 'Repository_List' കമാൻഡ് Cons നൽകുന്നു
അവരുടെ നിലവിലെ തിരയൽ ക്രമത്തിൽ. ഇത് ഡീബഗ്ഗിംഗിനോ കൂടുതൽ സങ്കീർണ്ണമായ പേൾ ചെയ്യാനോ ഉപയോഗിക്കാം
സാധനങ്ങൾ:

@ലിസ്റ്റ് = Repository_List;
പ്രിന്റ് ജോയിൻ(' ', @ലിസ്റ്റ്), "\n";

സംഭരണിയാണ് ഇടപെടൽ കൂടെ മറ്റ് ബാക്ക്ട്രെയിസ്കൊണ്ടു് സവിശേഷതകൾ

റിപ്പോസിറ്ററി മരങ്ങൾ കൈകാര്യം ചെയ്യുന്നത് മറ്റ് ദോഷ സവിശേഷതകളുമായി ശരിയായി സംവദിക്കുന്നു - അതായത്
പറയുക, അത് പൊതുവെ നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് ചെയ്യുന്നു.

ഏറ്റവും ശ്രദ്ധേയമായി, റിപ്പോസിറ്ററി മരങ്ങൾ 'ലിങ്ക്' ഉപയോഗിച്ച് ശരിയായി, ശക്തമായി സംവദിക്കുന്നു.
കമാൻഡ്. പതിപ്പ് ബിൽഡുകൾക്കായി ഒരു റിപ്പോസിറ്ററി ട്രീയിൽ ഒന്നോ അതിലധികമോ ഉപഡയറക്‌ടറികൾ അടങ്ങിയിരിക്കാം
ഒരു ഉറവിട ഉപഡയറക്‌ടറിയിലേക്ക് `ലിങ്ക്' വഴി സ്ഥാപിച്ചു. Cons ൽ നിന്ന് ലഭിച്ച ഫയലുകൾക്കായി തിരയും
റിപ്പോസിറ്ററി ട്രീയുടെ കീഴിൽ ഉചിതമായ ബിൽഡ് ഉപഡയറക്‌ടറികൾ.

സ്വതേ ലക്ഷ്യങ്ങൾ

ഇപ്പോൾ വരെ, നിർമ്മിക്കാനുള്ള വ്യക്തമായ ലക്ഷ്യത്തോടെ ഞങ്ങൾ ദോഷങ്ങൾ അഭ്യർത്ഥിക്കുന്നു:

% cons ഹലോ

സാധാരണയായി, ഒരു ടാർഗെറ്റ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, എന്നാൽ '.'
(നിലവിലെ ഡയറക്ടറി) എല്ലാം നിർമ്മിക്കും:

% cons # ഒന്നും നിർമ്മിക്കുന്നില്ല

% ദോഷങ്ങൾ # എല്ലാം ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിക്ക് കീഴിൽ നിർമ്മിക്കുന്നു

ഏതെങ്കിലും ഒന്നിലേക്ക് `ഡിഫോൾട്ട്' രീതി ചേർക്കുന്നു നിർമ്മിക്കുക or നിർബന്ധിത ഫയൽ വ്യക്തമാക്കിയത് ചേർക്കും
ഡിഫോൾട്ട് ടാർഗെറ്റുകളുടെ ഒരു ലിസ്റ്റിലേക്ക് ടാർഗെറ്റുകൾ. ഈ ഡിഫോൾട്ടുകൾ ഇല്ലെങ്കിൽ ദോഷങ്ങൾ നിർമ്മിക്കും
കമാൻഡ് ലൈനിൽ വ്യക്തമാക്കിയ ലക്ഷ്യങ്ങൾ. അതിനാൽ ഇനിപ്പറയുന്ന വരി മുകളിലെ നിലയിലേക്ക് ചേർക്കുന്നു
നിർമ്മിക്കുക എല്ലാം സ്ഥിരസ്ഥിതിയായി നിർമ്മിക്കുന്ന മേക്കിന്റെ സാധാരണ സ്വഭാവത്തെ ഫയൽ അനുകരിക്കും:

സ്ഥിരസ്ഥിതി '.';

ഇനിപ്പറയുന്നവ ചേർക്കും ഹലോ ഒപ്പം വിട കമാൻഡുകൾ (അതേ ഡയറക്ടറിയിൽ
നിർമ്മിക്കുക or നിർബന്ധിത ഫയൽ) സ്ഥിരസ്ഥിതി പട്ടികയിലേക്ക്:

സ്ഥിരസ്ഥിതി qw(
ഹലോ
വിട
);

സ്ഥിരസ്ഥിതി ലിസ്റ്റിലേക്ക് ടാർഗെറ്റുകൾ ചേർക്കുന്നതിന് ഒന്നിലധികം തവണ 'Default' രീതി ഉപയോഗിച്ചേക്കാം.

സെലക്ടീവ് പണിയുന്നു

നൽകിയിരിക്കുന്ന ബിൽഡിന്റെ വലുപ്പം കുറയ്ക്കുന്നതിന് ദോഷങ്ങൾ രണ്ട് രീതികൾ നൽകുന്നു. ആദ്യത്തേത് വ്യക്തമാക്കുന്നതിലൂടെയാണ്
കമാൻഡ് ലൈനിലെ ലക്ഷ്യങ്ങൾ, രണ്ടാമത്തേത് ബിൽഡ് ട്രീ വെട്ടിമാറ്റുന്നതിനുള്ള ഒരു രീതിയാണ്. ഞങ്ങൾ ചെയ്യും
ആദ്യം ടാർഗെറ്റ് സ്പെസിഫിക്കേഷൻ പരിഗണിക്കുക.

സെലക്ടീവ് ടാർഗെറ്റുചെയ്യൽ

make പോലെ, Cons കമാൻഡ് ലൈനിൽ `` ടാർഗെറ്റുകൾ '' സ്പെസിഫിക്കേഷൻ അനുവദിക്കുന്നു. ദോഷ ലക്ഷ്യങ്ങൾ
ഫയലുകളോ ഡയറക്ടറികളോ ആകാം. ഒരു ഡയറക്ടറി വ്യക്തമാക്കുമ്പോൾ, ഇത് ഒരു ഹ്രസ്വ-
എല്ലാ ഡെറിവേബിൾ ഉൽപ്പന്നങ്ങൾക്കുമുള്ള കൈ നൊട്ടേഷൻ - അത് ദോഷങ്ങൾ അറിയുന്നു - വ്യക്തമാക്കിയതിൽ
ഡയറക്ടറിയും താഴെയും. ഉദാഹരണത്തിന്:

% ദോഷങ്ങൾ ബിൽഡ്/hello/hello.o

പണിയുക എന്നർത്ഥം hello.o. അതെല്ലാം hello.o. ആവശ്യമായി വന്നേക്കാം. ഇത് മുമ്പത്തേതിൽ നിന്നുള്ളതാണ്
പതിപ്പ് ഹലോ, ലോകം! ഇതിൽ പ്രോഗ്രാം hello.o. ആശ്രയിച്ചു
കയറ്റുമതി/ഉൾപ്പെടുത്തുക/world.h. ആ ഫയൽ കാലികമല്ലെങ്കിൽ (ആരെങ്കിലും പരിഷ്കരിച്ചതിനാൽ
src/world/world.h), എന്നതിൽ നിന്നുള്ള ഒരു ഡയറക്ടറി റിമോട്ടിലാണെങ്കിലും അത് പുനർനിർമ്മിക്കും
നിർമ്മിക്കുക/ഹലോ.

ഈ ഉദാഹരണത്തിൽ:

% ദോഷങ്ങൾ നിർമ്മിക്കുന്നു

എല്ലാം പണിയുക ആവശ്യമെങ്കിൽ ഡയറക്ടറി നിർമ്മിച്ചിരിക്കുന്നു. വീണ്ടും, ഇത് കൂടുതൽ ഫയലുകൾക്ക് കാരണമായേക്കാം
പണിയണം. പ്രത്യേകിച്ച്, രണ്ടും കയറ്റുമതി/ഉൾപ്പെടുത്തുക/world.h ഒപ്പം കയറ്റുമതി/lib/libworld.a ആകുന്നു
ആവശ്യപ്പെടുന്നത് നിർമ്മിക്കുക/ഹലോ ഡയറക്ടറി, അതിനാൽ അവ കാലഹരണപ്പെട്ടതാണെങ്കിൽ അവ നിർമ്മിക്കപ്പെടും.

ഞങ്ങൾ ചെയ്യുകയാണെങ്കിൽ, പകരം:

% cons കയറ്റുമതി

കയറ്റുമതി ഡയറക്ടറിയിൽ ഇൻസ്റ്റാൾ ചെയ്യേണ്ട ഫയലുകൾ മാത്രമേ പുനർനിർമ്മിക്കുകയുള്ളൂ, എങ്കിൽ
ആവശ്യമായ, തുടർന്ന് അവിടെ ഇൻസ്റ്റാൾ. 'കോൺസ് ബിൽഡ്' 'കോൺസ്' ഫയലുകൾ നിർമ്മിച്ചേക്കാം എന്നത് ശ്രദ്ധിക്കുക
കയറ്റുമതി' നിർമ്മിക്കുന്നില്ല, തിരിച്ചും.

ഇല്ല ``പ്രത്യേകം'' ലക്ഷ്യങ്ങൾ

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

% cons ടെസ്റ്റുകൾ

എല്ലാ ടെസ്റ്റുകളും നിർമ്മിക്കും.

% cons കയറ്റുമതി

സിസ്റ്റത്തിന്റെ പ്രൊഡക്ഷൻ പതിപ്പ് നിർമ്മിക്കും (എന്നാൽ ടെസ്റ്റുകളല്ല), കൂടാതെ:

% ദോഷങ്ങൾ നിർമ്മിക്കുന്നു

ഒരുപക്ഷേ ഒഴിവാക്കണം (അത് അനാവശ്യമായി ടെസ്റ്റുകൾ കംപൈൽ ചെയ്യുമെന്നതിനാൽ).

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

നിങ്ങൾക്ക് മരത്തിൽ എല്ലാം നിർമ്മിക്കണമെങ്കിൽ (നിങ്ങളുടെ ഏത് ഓപ്ഷനും വിധേയമായി
തിരഞ്ഞെടുക്കുക), നിങ്ങൾക്ക് ഉപയോഗിക്കാം:

% ദോഷങ്ങൾ

ഇത് പ്രത്യേകിച്ച് കാര്യക്ഷമമല്ല, കാരണം ഇത് എല്ലാ മരങ്ങളിലും അനാവശ്യമായി നടക്കുന്നു,
ഉറവിട വൃക്ഷം ഉൾപ്പെടെ. ഉറവിട വൃക്ഷത്തിൽ, തീർച്ചയായും, നിർമ്മിക്കാനാകുന്ന വസ്തുക്കൾ ഉണ്ടായിരിക്കാം
അത്--നിങ്ങൾ സാധാരണയായി ഒരു പ്രത്യേക ബിൽഡിൽ നിർമ്മിച്ചാലും ഇത് ചെയ്യുന്നതിൽ നിന്ന് നിങ്ങളെ തടയുന്നില്ല
വൃക്ഷം.

പണിയുക അരിവാൾകൊണ്ടുണ്ടാക്കുന്നു

ടാർഗെറ്റ് സെലക്ഷനുമായി ചേർന്ന്, പണിയുക അരിവാൾകൊണ്ടു യുടെ വ്യാപ്തി കുറയ്ക്കാൻ ഉപയോഗിക്കാം
പണിയുക. മുമ്പത്തെ peAcH, baNaNa ഉദാഹരണത്തിൽ, എങ്ങനെയാണ് സ്ക്രിപ്റ്റ്-ഡ്രൈവൺ എന്ന് നമ്മൾ കണ്ടത്
ബിൽഡ് പ്രൂണിംഗ് ഉപയോഗിച്ച് സാധ്യമായ ബിൽഡിന്റെ പകുതി മാത്രമേ ലഭ്യമായിട്ടുള്ളൂ
'കോൺസ്' എന്നതിന്റെ അഭ്യർത്ഥന. Cons ഒരു സൗകര്യമെന്ന നിലയിൽ, ഒരു കമാൻഡ് ലൈൻ കൺവെൻഷനും നൽകുന്നു
ഏതെന്ന് വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു നിർബന്ധിത ഫയലുകൾ യഥാർത്ഥത്തിൽ ``ബിൽറ്റ്''--അതായത്, ഇൻകോർപ്പറേറ്റ് ചെയ്യപ്പെടും
പണിയുന്ന മരത്തിലേക്ക്. ഉദാഹരണത്തിന്:

% ദോഷങ്ങൾ ബിൽഡ് +ലോകം

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

ഉദാഹരണത്തിൽ, മുകളിൽ, the ഹലോ പ്രോഗ്രാം നിർമ്മിക്കില്ല, കാരണം ദോഷങ്ങൾ ഇല്ല
തിരക്കഥയെക്കുറിച്ചുള്ള അറിവ് ഹലോ/കൺസ്‌ക്രിപ്റ്റ്. ദി libworld.a എന്നിരുന്നാലും, ആർക്കൈവ് നിർമ്മിക്കപ്പെടും
വേണം.

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

താൽക്കാലിക അസാധുവാക്കുന്നു

ഒരു ബിൽഡിന്റെ വശങ്ങളെ മറികടക്കുന്നതിനുള്ള വളരെ ലളിതമായ ഒരു സംവിധാനം ദോഷങ്ങൾ നൽകുന്നു. എന്നാണ് സാരം
ഒന്നോ അതിലധികമോ `ഓവർറൈഡ്' കമാൻഡുകൾ അടങ്ങിയ ഒരു ഓവർറൈഡ് ഫയൽ നിങ്ങൾ എഴുതുന്നു, നിങ്ങൾ
നിങ്ങൾ `കോൺസ്' പ്രവർത്തിപ്പിക്കുമ്പോൾ കമാൻഡ് ലൈനിൽ ഇത് വ്യക്തമാക്കുക:

കയറ്റുമതിയെക്കാൾ % ദോഷങ്ങൾ

നിർമ്മിക്കും കയറ്റുമതി ചെയ്യുക ഡയറക്‌ടറി, എല്ലാ ഡിറൈവ്ഡ് ഫയലുകളും നിലവിലുള്ള ഓവർറൈഡുകൾക്ക് വിധേയമാണ്
ലെ മേൽ ഫയൽ. നിങ്ങൾ `-o' ഓപ്‌ഷൻ ഉപേക്ഷിക്കുകയാണെങ്കിൽ, നീക്കം ചെയ്യേണ്ടതെല്ലാം
എല്ലാ ഓവർറൈഡുകളും പുനർനിർമ്മിക്കപ്പെടും.

അസാധ്യം പരിസ്ഥിതി വേരിയബിളുകൾ

ഓവർറൈഡ് ഫയലിൽ രണ്ട് തരം ഓവർറൈഡുകൾ അടങ്ങിയിരിക്കാം. ആദ്യത്തേത് ഇൻകമിംഗ് പരിസ്ഥിതിയാണ്
വേരിയബിളുകൾ. ഇവയ്ക്ക് സാധാരണയായി ആക്സസ് ചെയ്യാവുന്നതാണ് നിർമ്മിക്കുക `%ENV' ഹാഷിൽ നിന്നുള്ള ഫയൽ
വേരിയബിൾ. സജ്ജീകരിച്ച് ഓവർറൈഡ് ഫയലിൽ ഇവ നിസ്സാരമായി അസാധുവാക്കാം
`%ENV' യുടെ ഉചിതമായ ഘടകങ്ങൾ (ഇവ ഉപയോക്താവിന്റെ പരിതസ്ഥിതിയിലും അസാധുവാക്കാം,
തീർച്ചയായും).

ദി അസാധുവാക്കുക കമാൻഡ്

രണ്ടാമത്തെ തരം ഓവർറൈഡ് ചെയ്യുന്നത് 'ഓവർറൈഡ്' കമാൻഡ് ഉപയോഗിച്ചാണ്, അത് ഇതുപോലെ കാണപ്പെടുന്നു
ഈ:

അസാധുവാക്കുക , => , => , ...;

പതിവ് ആവിഷ്കാരം regexp ഒരു കാൻഡിഡേറ്റ് ആയ എല്ലാ ഉരുത്തിരിഞ്ഞ ഫയലുമായും പൊരുത്തപ്പെടുന്നു
നിർമ്മാണത്തിനായി. ഉരുത്തിരിഞ്ഞ ഫയൽ പൊരുത്തപ്പെടുന്നുവെങ്കിൽ, വേരിയബിൾ/മൂല്യം ജോഡികൾ ഉപയോഗിക്കും
ഉരുത്തിരിഞ്ഞ ഫയലുമായി ബന്ധപ്പെട്ട നിർമ്മാണ പരിതസ്ഥിതിയിലെ മൂല്യങ്ങൾ അസാധുവാക്കുക.

നമുക്ക് ഇതുപോലുള്ള ഒരു നിർമ്മാണ അന്തരീക്ഷമുണ്ടെന്ന് കരുതുക:

$CONS = പുതിയ ദോഷങ്ങൾ(
COPT => '',
CDBG => '-g',
CFLAGS => '%COPT %CDBG',
);

അപ്പോൾ നമുക്ക് ഒരു ഓവർറൈഡ് ഫയൽ ഉണ്ടെങ്കിൽ മേൽ ഈ കമാൻഡ് അടങ്ങിയിരിക്കുന്നു:

അസാധുവാക്കുക '\.o$', COPT => '-O', CDBG => '';

തുടർന്ന് സൃഷ്ടിക്കുന്ന `-o over' ഉള്ള ഏതെങ്കിലും `കോൺസ്' അഭ്യർത്ഥന .o ഈ പരിതസ്ഥിതി വഴി ഫയലുകൾ ചെയ്യും
അവയെ `-O' കൂടാതെ `-g' എന്നതുപയോഗിച്ച് സമാഹരിക്കുന്നതിന് കാരണമാകുന്നു. അസാധുവാക്കൽ തീർച്ചയായും ആകാം
ഒരു റെഗുലർ എക്‌സ്‌പ്രെഷന്റെ ഉചിതമായ തിരഞ്ഞെടുപ്പ് വഴി ഒരൊറ്റ ഡയറക്‌ടറിയിലേക്ക് പരിമിതപ്പെടുത്തിയിരിക്കുന്നു.

ഹലോ, വേൾഡിന്റെ യഥാർത്ഥ പതിപ്പ് ഇതാ! ഈ പരിതസ്ഥിതിയിൽ നിർമ്മിച്ച പ്രോഗ്രാം.
അസാധുവാക്കൽ പ്രയോഗിക്കുമ്പോഴോ നീക്കം ചെയ്യുമ്പോഴോ ദോഷങ്ങൾ ഉചിതമായ ഭാഗങ്ങൾ പുനർനിർമ്മിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക:

% cons ഹലോ
cc -g -c hello.c -o hello.o
cc -o ഹലോ hello.o
% ദോഷങ്ങൾ -ഒ ഓവർ ഹലോ
cc -O -c hello.c -o hello.o
cc -o ഹലോ hello.o
% ദോഷങ്ങൾ -ഒ ഓവർ ഹലോ
ദോഷങ്ങൾ: "ഹലോ" കാലികമാണ്.
% cons ഹലോ
cc -g -c hello.c -o hello.o
cc -o ഹലോ hello.o

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

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

കൂടുതൽ on നിര്മ്മാണം പരിസ്ഥിതികൾ

സ്വതേ നിര്മ്മാണം വേരിയബിളുകൾ

എ എന്ന ആശയം ഞങ്ങൾ പരാമർശിക്കുകയും ഉപയോഗിക്കുകയും ചെയ്തു നിര്മ്മാണം പരിസ്ഥിതി, പല തവണ
മുൻ പേജുകൾ. ഇപ്പോൾ ഇത് കുറച്ചുകൂടി കോൺക്രീറ്റ് ചെയ്യാൻ സമയമായി. ഇനിപ്പറയുന്നവ ഉപയോഗിച്ച്
പ്രസ്താവന:

$env = പുതിയ ദോഷങ്ങൾ();

ഒരു പുതിയ, ഡിഫോൾട്ട് നിർമ്മാണ പരിസ്ഥിതിയെക്കുറിച്ചുള്ള ഒരു റഫറൻസ് സൃഷ്ടിക്കപ്പെടുന്നു. ഇതിൽ ഒരു നമ്പർ അടങ്ങിയിരിക്കുന്നു
നിർമ്മാണ വേരിയബിളുകളും ചില രീതികളും. ഇപ്പോൾ എഴുതുമ്പോൾ, ഡിഫോൾട്ട് ലിസ്റ്റ്
നിർമ്മാണ വേരിയബിളുകൾ ഇനിപ്പറയുന്ന രീതിയിൽ നിർവചിച്ചിരിക്കുന്നു:

CC => 'cc',
CFLAGS => '',
CCCOM => '%CC %CFLAGS %_IFLAGS -c %< -o %>',
INCDIRPREFIX => '-I',
CXX => '%CC',
CXXFLAGS => '%CFLAGS',
CXXCOM => '%CXX %CXXFLAGS %_IFLAGS -c %< -o %>',
ലിങ്ക് => '%CXX',
LINKCOM => '%LINK %LDFLAGS -o %> %< %_LDIRS %LIBS',
LINKMODULECOM => '%LD -r -o %> %<',
LIBDIRPREFIX => '-L',
AR => 'ar',
ARFLAGS => 'r',
ARCOM => "%AR %ARFLAGS %> %<\n%RANLIB %>",
RANLIB => 'ranlib',
AS => 'ആയി',
പതാകകൾ => '',
ASCOM => '%AS %ASFLAGS %< -o %>',
LD => 'ld',
LDFLAGS => '',
PREFLIB => 'lib',
SUFLIB => '.a',
SUFLIBS => '.so:.a',
SUFOBJ => '.o',
ENV => { 'PATH' => '/ ബിൻ:/ usr / bin'},

Win32 സിസ്റ്റങ്ങളിൽ (Windows NT), ഇനിപ്പറയുന്ന നിർമ്മാണ വേരിയബിളുകൾ അസാധുവാക്കുന്നു
സ്ഥിരസ്ഥിതി:

CC => 'cl',
CFLAGS => '/nologo',
CCCOM => '%CC %CFLAGS %_IFLAGS /c %< /Fo%>',
CXXCOM => '%CXX %CXXFLAGS %_IFLAGS /c %< /Fo%>',
INCDIRPREFIX => '/I',
LINK => 'ലിങ്ക്',
LINKCOM => '%LINK %LDFLAGS /out:%> %< %_LDIRS %LIBS',
LINKMODULECOM => '%LD /r /o %> %<',
LIBDIRPREFIX => '/LIBPATH:',
AR => 'lib',
ARFLAGS => '/nologo ',
ARCOM => "%AR %ARFLAGS /out:%> %<",
RANLIB => '',
LD => 'ലിങ്ക്',
LDFLAGS => '/nologo ',
PREFLIB => '',
SUFEXE => '.exe',
SUFLIB => '.lib',
SUFLIBS => '.dll:.lib',
SUFOBJ => '.obj',

ഈ വേരിയബിളുകൾ പരിസ്ഥിതിയുമായി ബന്ധപ്പെട്ട വിവിധ രീതികൾ ഉപയോഗിക്കുന്നു
പ്രത്യേകിച്ച് ഒരു ബാഹ്യ കമാൻഡ് ആത്യന്തികമായി ആവശ്യപ്പെടുന്ന ഏത് രീതിയും ഇവയ്ക്ക് പകരം വയ്ക്കും
വേരിയബിളുകൾ അവസാന കമാൻഡിലേക്ക് ഉചിതമായത്. ഉദാഹരണത്തിന്, `Objects' രീതി എടുക്കുന്നു
നിരവധി സോഴ്സ് ഫയലുകളും ആവശ്യമെങ്കിൽ അനുബന്ധ ഒബ്‌ജക്‌റ്റ് ലഭിക്കാൻ ക്രമീകരിക്കുകയും ചെയ്യുന്നു
ഫയലുകൾ. ഉദാഹരണത്തിന്:

ഒബ്ജക്റ്റുകൾ $env 'foo.c', 'bar.c';

ആവശ്യമെങ്കിൽ ഉൽപ്പാദിപ്പിക്കാൻ ഇത് ക്രമീകരിക്കും. foo.o ഒപ്പം bar.o. അഭ്യർത്ഥിച്ച കമാൻഡ് ലളിതമാണ്
`%CCCOM', അത് ആവശ്യമായ ബാഹ്യ കമാൻഡിലേക്ക് പകരത്തിലൂടെ വികസിക്കുന്നു
ഓരോ വസ്തുവും നിർമ്മിക്കാൻ. 'കമാൻഡിന്' കീഴിൽ ഞങ്ങൾ പകരം വയ്ക്കൽ നിയമങ്ങൾ പര്യവേക്ഷണം ചെയ്യും
രീതി, താഴെ.

നിർമ്മാണ വേരിയബിളുകൾ മറ്റ് ആവശ്യങ്ങൾക്കും ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, `CPPPATH' ആണ്
ഡയറക്‌ടറികൾ ഉൾപ്പെടുത്തുന്നതിന്റെ കോളൻ-വേർതിരിക്കപ്പെട്ട പാത വ്യക്തമാക്കാൻ ഉപയോഗിക്കുന്നു. ഇവയാണ് ഉദ്ദേശിക്കുന്നത്
സി പ്രീപ്രോസസറിലേക്ക് കൈമാറുകയും സി-ഫയൽ സ്കാനിംഗ് മെഷിനറി ഉപയോഗിക്കുകയും ചെയ്യുന്നു
ഒരു സി കമ്പൈലേഷനിൽ ഉൾപ്പെട്ടിരിക്കുന്ന ഡിപൻഡൻസികൾ നിർണ്ണയിക്കുക. എന്ന് തുടങ്ങുന്ന വേരിയബിളുകൾ
അടിവരയിടുക, വിവിധ രീതികളാൽ സൃഷ്ടിക്കപ്പെട്ടവയാണ്, അവ സാധാരണയായി ``ആന്തരികം'' എന്ന് പരിഗണിക്കണം
വേരിയബിളുകൾ. ഉദാഹരണത്തിന്, ഒരു വസ്തുവിനെ സൃഷ്ടിക്കാൻ ആവശ്യപ്പെടുന്ന ഒരു രീതി വിളിക്കുമ്പോൾ
ഒരു സി ഉറവിടത്തിൽ നിന്ന്, `_IFLAGS' വേരിയബിൾ സൃഷ്ടിച്ചു: ഇത് `-I' സ്വിച്ചുകളുമായി യോജിക്കുന്നു
'CPPPATH' വ്യക്തമാക്കിയ ഡയറക്‌ടറികളെ പ്രതിനിധീകരിക്കാൻ C കംപൈലറിന് ആവശ്യമാണ്.

ഏതെങ്കിലും പ്രത്യേക പരിതസ്ഥിതിക്ക്, ഒരു വേരിയബിളിന്റെ മൂല്യം ഒരിക്കൽ സജ്ജീകരിച്ചിരിക്കുന്നു, തുടർന്ന്
ഒരിക്കലും പുനഃസജ്ജമാക്കരുത് (ഒരു വേരിയബിൾ മാറ്റാൻ, നിങ്ങൾ ഒരു പുതിയ പരിസ്ഥിതി സൃഷ്ടിക്കണം. രീതികൾ നൽകിയിരിക്കുന്നു
ഈ ആവശ്യത്തിനായി നിലവിലുള്ള പരിതസ്ഥിതികൾ പകർത്തുന്നതിന്). പോലുള്ള ചില ആന്തരിക വേരിയബിളുകൾ
`_IFLAGS' ആവശ്യാനുസരണം സൃഷ്‌ടിക്കപ്പെട്ടവയാണ്, എന്നാൽ ഒരിക്കൽ സജ്ജീകരിച്ചാൽ, അവ ജീവന്റെ ജീവിതത്തിനായി സ്ഥിരമായി നിലനിൽക്കും
പരിസ്ഥിതി.

`CFLAGS', `LDFLAGS', `ARFLAGS' വേരിയബിളുകൾ എല്ലാം ഓപ്‌ഷനുകൾ കൈമാറുന്നതിനുള്ള ഒരു സ്ഥലം നൽകുന്നു
യഥാക്രമം കമ്പൈലർ, ലോഡർ, ആർക്കൈവർ. കുറച്ച് വ്യക്തമായി, `INCDIRPREFIX'
വേരിയബിൾ, ഉൾപ്പെടുന്ന ഓരോന്നിന്റെയും തുടക്കത്തിൽ കൂട്ടിച്ചേർക്കേണ്ട ഓപ്‌ഷൻ സ്ട്രിംഗ് വ്യക്തമാക്കുന്നു
ഡയറക്‌ടറി അങ്ങനെ കംപൈലറിന് എവിടെ കണ്ടെത്തണമെന്ന് അറിയാം .h ഫയലുകൾ. അതുപോലെ, ദി
`LIBDIRPREFIX' വേരിയബിൾ, ഇതിന്റെ തുടക്കത്തിലേക്ക് ചേർക്കേണ്ട ഓപ്‌ഷൻ സ്ട്രിംഗ് വ്യക്തമാക്കുന്നു.
ലിങ്കർ ലൈബ്രറികൾക്കായി തിരയേണ്ട ഓരോ ഡയറക്ടറിയും.

മറ്റൊരു വേരിയബിൾ, `ENV', എക്സിക്യൂഷൻ സമയത്ത് സിസ്റ്റം എൻവയോൺമെന്റ് നിർണ്ണയിക്കാൻ ഉപയോഗിക്കുന്നു
ഒരു ബാഹ്യ കമാൻഡിന്റെ. സ്ഥിരസ്ഥിതിയായി, സജ്ജീകരിച്ചിരിക്കുന്ന ഏക പരിസ്ഥിതി വേരിയബിൾ `PATH' ആണ്,
ഒരു UNIX കമാൻഡിന്റെ എക്സിക്യൂഷൻ പാതയാണിത്. പരമാവധി പുനരുൽപാദനക്ഷമതയ്ക്കായി, നിങ്ങൾ ചെയ്യണം
നിങ്ങളുടെ ഉയർന്ന തലത്തിൽ നിങ്ങളുടെ സ്വന്തം എക്സിക്യൂഷൻ പാത്ത് സജ്ജീകരിക്കാൻ ശരിക്കും ക്രമീകരിക്കുക നിർമ്മിക്കുക ഫയൽ (അല്ലെങ്കിൽ
ഒരുപക്ഷേ Perl `use' കമാൻഡ് ഉപയോഗിച്ച് ഉചിതമായ ഒരു നിർമ്മാണ പാക്കേജ് ഇറക്കുമതി ചെയ്യുക വഴി). ദി
ഡിഫോൾട്ട് വേരിയബിളുകൾ നിങ്ങളെ ഗ്രൗണ്ടിൽ നിന്ന് പുറത്താക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്.

ഇന്റർപോളിംഗ് നിര്മ്മാണം വേരിയബിളുകൾ

കൺസ്ട്രക്ഷൻ എൻവയോൺമെന്റ് വേരിയബിളുകൾ ഉറവിടത്തിലും ടാർഗെറ്റ് ഫയൽ നാമങ്ങളിലും ഇന്റർപോളേറ്റ് ചെയ്തേക്കാം
നിർമ്മാണ വേരിയബിൾ നാമം `%' ഉപയോഗിച്ച് പ്രിഫിക്സ് ചെയ്തുകൊണ്ട്.

$env = പുതിയ ദോഷങ്ങൾ(
DESTDIR => 'പ്രോഗ്രാമുകൾ',
SRCDIR => 'src',
);
പ്രോഗ്രാം $env '%DESTDIR/hello', '%SRCDIR/hello.c';

നിർമ്മാണ വേരിയബിളുകളുടെ വികാസം ആവർത്തനമാണ് - അതായത് ഫയൽ പേര്(കൾ) വീണ്ടും വരും-
കൂടുതൽ പകരം വയ്ക്കാൻ കഴിയാത്തതു വരെ വിപുലീകരിച്ചു. ഒരു നിർമ്മാണ വേരിയബിൾ ഇല്ലെങ്കിൽ
പരിതസ്ഥിതിയിൽ നിർവചിച്ചാൽ, നൾ സ്ട്രിംഗ് മാറ്റിസ്ഥാപിക്കും.

സ്വതേ നിര്മ്മാണം രീതികൾ

സ്ഥിരസ്ഥിതി നിർമ്മാണ രീതികളുടെ പട്ടികയിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു:

ദി `പുതിയത്' ബിൽഡർ

`പുതിയ' രീതി ഒരു പേൾ ഒബ്ജക്റ്റ് കൺസ്ട്രക്റ്ററാണ്. അതായത്, ഇത് ഒരു റഫറൻസ് മുഖേന അഭ്യർത്ഥിച്ചിട്ടില്ല
നിലവിലുള്ള ഒരു നിർമ്മാണ അന്തരീക്ഷത്തിലേക്ക് സൂചന, പക്ഷേ, പകരം സ്ഥിരമായി, പേര് ഉപയോഗിക്കുന്നു
പേളിന്റെ പാക്കേജ് അവിടെ കൺസ്ട്രക്റ്റർ നിർവചിച്ചിരിക്കുന്നു. രീതി ഇനിപ്പറയുന്ന രീതിയിൽ പ്രയോഗിക്കുന്നു:

$env = പുതിയ ദോഷങ്ങൾ( );

നിങ്ങൾക്ക് തിരികെ ലഭിക്കുന്ന പരിസ്ഥിതി പാക്കേജ് `കോൺസ്' ആയി അനുഗ്രഹിക്കപ്പെട്ടിരിക്കുന്നു, അതിനർത്ഥം അത് ചെയ്യും എന്നാണ്
താഴെ വിവരിച്ചിരിക്കുന്ന സ്ഥിരസ്ഥിതി രീതികൾ അതുമായി ബന്ധപ്പെടുത്തിയിരിക്കുന്നു. വ്യക്തിഗത നിർമ്മാണം
ഒരു ഓവർറൈഡ് ലിസ്റ്റിൽ പേര്/മൂല്യം ജോഡികൾ നൽകിക്കൊണ്ട് വേരിയബിളുകൾ അസാധുവാക്കാവുന്നതാണ്. അതല്ല
ഏതെങ്കിലും കമാൻഡ് എൻവയോൺമെന്റ് വേരിയബിളിനെ അസാധുവാക്കാൻ (അതായത് `ENV'-ന് കീഴിലുള്ള എന്തും), നിങ്ങൾ ചെയ്യേണ്ടി വരും
അവയെല്ലാം അസാധുവാക്കുക. ഒരു 'പകർപ്പ്' രീതി ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ ബുദ്ധിമുട്ട് മറികടക്കാൻ കഴിയും
നിലവിലുള്ള നിർമ്മാണ അന്തരീക്ഷം.

ദി 'ക്ലോൺ' രീതി

`ക്ലോൺ' രീതി നിലവിലുള്ള ഒരു നിർമ്മാണ പരിതസ്ഥിതിയുടെ ഒരു ക്ലോൺ സൃഷ്ടിക്കുന്നു, അത് ആകാം
ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ വിളിക്കുന്നത്:

$env2 = $env1->ക്ലോൺ( );

ഇതിൽ നിന്ന് വ്യത്യസ്തമായ അന്തരീക്ഷം സൃഷ്ടിക്കുന്നതിന് നിങ്ങൾക്ക് സാധാരണ രീതിയിൽ ഓവർറൈഡുകൾ നൽകാം
ഒറിജിനൽ. നിങ്ങൾക്ക് ഒരേ പരിതസ്ഥിതിക്ക് ഒരു പുതിയ പേര് വേണമെങ്കിൽ (അത് എപ്പോൾ സഹായകമായേക്കാം
നിലവിലുള്ള ഘടകങ്ങളിലേക്ക് പരിതസ്ഥിതികൾ കയറ്റുമതി ചെയ്യുന്നു), നിങ്ങൾക്ക് ലളിതമായ അസൈൻമെന്റ് ഉപയോഗിക്കാം.

ദി 'പകർപ്പ്' രീതി

ഒരു എന്നതിൽ നിന്ന് ബാഹ്യമായി നിർവചിച്ചിരിക്കുന്ന നിർമ്മാണ വേരിയബിളുകളെ `പകർപ്പ്' രീതി വേർതിരിച്ചെടുക്കുന്നു
പരിതസ്ഥിതി, അവയെ പേര്/മൂല്യ ജോഡികളുടെ പട്ടികയായി തിരികെ നൽകുന്നു. ഓവർറൈഡുകളും ആകാം
നൽകിയിട്ടുണ്ടെങ്കിൽ, അസാധുവാക്കപ്പെട്ട മൂല്യങ്ങൾ ഉചിതമായ രീതിയിൽ തിരികെ നൽകും. ദി
താഴെയുള്ള പ്രോട്ടോടൈപ്പിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, മടങ്ങിയ പട്ടിക ഒരു ഹാഷിലേക്ക് അസൈൻ ചെയ്യാം, പക്ഷേ അതിനും കഴിയും
മറ്റ് വഴികളിൽ കൃത്രിമം നടത്താം:

%env = $env1->പകർപ്പ്( );

ഒരു ഹാഷായ 'ENV' യുടെ മൂല്യവും ഒരു പുതിയ ഹാഷിലേക്ക് പകർത്തുന്നു, അതിനാൽ ഇത്
യഥാർത്ഥ പരിസ്ഥിതിയെ ബാധിക്കുമെന്ന ഭയമില്ലാതെ മാറ്റി. അതിനാൽ, ഉദാഹരണത്തിന്, നിങ്ങൾ ശരിക്കും ആണെങ്കിൽ
സ്ഥിരസ്ഥിതി പരിതസ്ഥിതിയിൽ `PATH' വേരിയബിൾ അസാധുവാക്കാൻ ആഗ്രഹിക്കുന്നു, നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും
താഴെ:

% cons = പുതിയ ദോഷങ്ങൾ()->പകർപ്പ് ();
$cons{ENV}{PATH} = " ";
$cons = പുതിയ ദോഷങ്ങൾ(%cons);

ഇത് ഡിഫോൾട്ട് എക്‌സിക്യൂഷൻ എൻവയോൺമെന്റിലുള്ള മറ്റെന്തെങ്കിലും ശേഷിക്കും
ശല്യപ്പെടുത്താതെ.

ദി 'ഇൻസ്റ്റാൾ ചെയ്യുക' രീതി

'ഇൻസ്റ്റാൾ' രീതി നിർദ്ദിഷ്ട ഫയലുകൾ നിർദ്ദിഷ്ട ഫയലുകളിൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ ക്രമീകരിക്കുന്നു
ഡയറക്ടറി. ഇൻസ്റ്റാളേഷൻ ഒപ്റ്റിമൈസ് ചെയ്‌തിരിക്കുന്നു: ലിങ്ക് ചെയ്യാൻ കഴിയുമെങ്കിൽ ഫയൽ പകർത്തില്ല. എങ്കിൽ
ഇത് ആവശ്യമുള്ള സ്വഭാവമല്ല, ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങൾ മറ്റൊരു രീതി ഉപയോഗിക്കേണ്ടതുണ്ട്
ഫയൽ. ഇതിനെ ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കുന്നു:

$env ഇൻസ്റ്റാൾ ചെയ്യുക , ;

ഇൻസ്‌റ്റാൾ ചെയ്യേണ്ട ഫയലുകൾ ഏകപക്ഷീയമായി പേരിടുമ്പോൾ, അവസാനത്തേത് മാത്രം
ഇൻസ്റ്റാൾ ചെയ്ത ടാർഗെറ്റ് നാമത്തിനായി ഓരോ പേരിന്റെയും ഘടകം ഉപയോഗിക്കുന്നു. അതിനാൽ, ഉദാഹരണത്തിന്, നിങ്ങളാണെങ്കിൽ
ഇൻസ്റ്റാൾ ചെയ്യാൻ ക്രമീകരിക്കുക foo/bar in അടിത്തറ, ഇത് ഒരു സൃഷ്ടിക്കും ബാർ ഫയലിൽ ഫയൽ ചെയ്യുക അടിത്തറ ഡയറക്ടറി (അല്ല
foo/bar).

ദി 'ഇൻസ്റ്റാൾആസ്' രീതി

'InstallAs' രീതി നിർദ്ദിഷ്ട ഉറവിടത്തിനായി ക്രമീകരിക്കുന്നു ഫയല്(കൾ) ആയി ഇൻസ്റ്റാൾ ചെയ്യണം
നിർദ്ദിഷ്ട ലക്ഷ്യം ഫയല്(കൾ). ഒന്നിലധികം ഫയലുകൾ ഒരു ഫയൽ ലിസ്റ്റായി വ്യക്തമാക്കണം. ദി
ഇൻസ്റ്റാളേഷൻ ഒപ്റ്റിമൈസ് ചെയ്‌തിരിക്കുന്നു: ലിങ്ക് ചെയ്യാൻ കഴിയുമെങ്കിൽ ഫയൽ പകർത്തില്ല. ഇതല്ലെങ്കിൽ
ആവശ്യമുള്ള സ്വഭാവം, ഫയൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങൾ മറ്റൊരു രീതി ഉപയോഗിക്കേണ്ടതുണ്ട്. അത്
ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കുന്നു:

'InstallAs' രണ്ട് തരത്തിൽ പ്രവർത്തിക്കുന്നു:

സിംഗിൾ ഫയൽ ഇൻസ്റ്റാളേഷൻ:

InstallAs $env TgtFile, SrcFile;

ഒന്നിലധികം ഫയൽ ഇൻസ്റ്റാളേഷൻ:

ഇൻസ്റ്റാൾആസ് $env ['tgt1', 'tgt2'], ['src1', 'src2'];

അല്ലെങ്കിൽ, ഇങ്ങനെയാണെങ്കിലും:

@srcs = qw(src1 src2 src3);
@tgts = qw(tgt1 tgt2 tgt3);
ഇൻസ്റ്റാൾആസ് $env [@tgts], [@srcs];

ലക്ഷ്യവും ഉറവിട ലിസ്‌റ്റുകളും ഒരേ ദൈർഘ്യമുള്ളതായിരിക്കണം.

ദി 'അമൂല്യമായ' രീതി

മുമ്പ് വ്യക്തമാക്കിയ ഫയലോ ഫയലുകളുടെ ലിസ്‌റ്റോ ഇല്ലാതാക്കരുതെന്ന് 'പ്രെഷ്യസ്' രീതി ദോഷങ്ങളോട് ആവശ്യപ്പെടുന്നു
അവരെ വീണ്ടും പണിയുന്നു. ഇത് ഇപ്രകാരം വിളിക്കപ്പെടുന്നു:

വിലയേറിയ ;

ലൈബ്രറികളിലേക്കോ ഡീബഗ്ഗിലേക്കോ വർദ്ധിച്ചുവരുന്ന അപ്‌ഡേറ്റുകൾ അനുവദിക്കുന്നതിന് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്
ഓരോ തവണയും പുതിയതായി പുനർനിർമ്മിക്കുന്നതിനുപകരം അപ്ഡേറ്റ് ചെയ്യുന്ന വിവര ഫയലുകൾ. ദോഷങ്ങൾ ഇനിയും ഉണ്ടാകും
`-r' ഫ്ലാഗ് വ്യക്തമാക്കുമ്പോൾ ഫയലുകൾ ഇല്ലാതാക്കുക.

ദി 'കമാൻഡ്' രീതി

`കമാൻഡ്' രീതി ഒരു ക്യാച്ചോൾ രീതിയാണ്, അത് ഏതെങ്കിലും ബാഹ്യമായി ക്രമീകരിക്കാൻ ഉപയോഗിക്കാം
ലക്ഷ്യം അപ്ഡേറ്റ് ചെയ്യാൻ വിളിക്കേണ്ട കമാൻഡ്. ഈ കമാൻഡിനായി, ഒരു ടാർഗെറ്റ് ഫയലും ലിസ്റ്റും
ഇൻപുട്ടുകൾ നൽകിയിട്ടുണ്ട്. കൂടാതെ ഒരു നിർമ്മാണ കമാൻഡ് ലൈൻ, അല്ലെങ്കിൽ ലൈനുകൾ, a ആയി നൽകിയിരിക്കുന്നു
string (ഈ സ്ട്രിംഗിൽ ഒന്നിലധികം കമാൻഡുകൾ ഉൾച്ചേർത്തിരിക്കാം, പുതിയത് കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു
ലൈനുകൾ). 'കമാൻഡ്' ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കുന്നു:

കമാൻഡ് $env , , ;

നിർദ്ദിഷ്ട ഇൻപുട്ട് ഫയലുകളുടെ പട്ടികയെ ആശ്രയിച്ചാണ് ടാർഗെറ്റ് നിർമ്മിച്ചിരിക്കുന്നത്, ഇൻപുട്ടുകൾ നിർബന്ധമായും
വിജയകരമായി നിർമ്മിക്കപ്പെടും അല്ലെങ്കിൽ ലക്ഷ്യം നിർമ്മിക്കാൻ ദോഷങ്ങൾ ശ്രമിക്കില്ല.

കൺസ്ട്രക്ഷൻ കമാൻഡിനുള്ളിൽ, കൺസ്ട്രക്ഷൻ എൻവയോൺമെന്റിൽ നിന്നുള്ള ഏത് വേരിയബിളും ആകാം
നിർമ്മാണ വേരിയബിളിന്റെ പേര് `%' ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്തുകൊണ്ട് അവതരിപ്പിച്ചു. ഇത് ആവർത്തനപരമാണ്:
കൂടുതൽ പകരം വയ്ക്കാൻ കഴിയാത്തതു വരെ കമാൻഡ് വിപുലീകരിക്കുന്നു. ഒരു നിർമ്മാണം ആണെങ്കിൽ
പരിതസ്ഥിതിയിൽ വേരിയബിൾ നിർവചിച്ചിട്ടില്ല, അപ്പോൾ നൾ സ്ട്രിംഗ് പകരം വയ്ക്കും. എ
നിർമ്മാണ കമാൻഡിൽ ഇരട്ടിയാക്കിയ `%%' പകരം ഒരൊറ്റ `%' ആയിരിക്കും.

നിരവധി കപട വേരിയബിളുകൾ ഉണ്ട്, അവ വികസിപ്പിക്കുകയും ചെയ്യും:

%> ടാർഗെറ്റ് ഫയലിന്റെ പേര് (ഒരു മൾട്ടി-ടാർഗെറ്റ് കമാൻഡിൽ, ഇത് എല്ലായ്പ്പോഴും ആദ്യ ലക്ഷ്യമാണ്
സൂചിപ്പിച്ചത്).

%0, `%>' എന്നതിന് സമാനമാണ്.

% 1,% 2, ...,% 9
ഇവ യഥാക്രമം ആദ്യത്തെ മുതൽ ഒമ്പതാം വരെയുള്ള ഇൻപുട്ട് ഫയലിനെയാണ് സൂചിപ്പിക്കുന്നത്.

%< ഇൻപുട്ടുകളുടെ മുഴുവൻ സെറ്റ്. ഇവയിലേതെങ്കിലും മറ്റെവിടെയെങ്കിലും ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ
നിലവിലെ കമാൻഡ് ലൈൻ (`% 1', `%2' മുതലായവ വഴി), തുടർന്ന് അവയിൽ നിന്ന് ഇല്ലാതാക്കപ്പെടും
ലിസ്റ്റ് നൽകിയത് `%<'. a യിൽ കാണുന്ന താഴെ പറയുന്ന കമാൻഡ് പരിഗണിക്കുക നിർബന്ധിത ഫയല്
ലെ പരിശോധന ഡയറക്ടറി:

കമാൻഡ് $env 'tgt', qw(foo bar baz), qq(
echo %< -i %1 > %>
echo %< -i %2 >> %>
echo %< -i %3 >> %>
);

If tgt അപ്‌ഡേറ്റ് ചെയ്യേണ്ടത് ആവശ്യമാണ്, തുടർന്ന് ഇത് നടപ്പിലാക്കുന്നതിന് കാരണമാകും
ഇനിപ്പറയുന്ന കമാൻഡുകൾ, ഇതിനായി റീമാപ്പിംഗ് സ്ഥാപിച്ചിട്ടില്ലെന്ന് അനുമാനിക്കുന്നു പരിശോധന
ഡയറക്ടറി:

echo test/bar test/baz -i test/foo> test/tgt
echo test/foo test/baz -i test/bar >> test/tgt
echo test/foo test/bar -i test/baz >> test/tgt

മുകളിലുള്ള ഏതെങ്കിലും വ്യാജ വേരിയബിളുകൾ ഇനിപ്പറയുന്നവയിൽ ഒന്ന് ഉടൻ പിന്തുടരാം
വികസിപ്പിച്ച പാതയുടെ ഒരു ഭാഗം തിരഞ്ഞെടുക്കുന്നതിനുള്ള പ്രത്യയങ്ങൾ:

:എ ഫയലിന്റെ പേരിലേക്കുള്ള സമ്പൂർണ്ണ പാത
:b ഡയറക്‌ടറിയും ഫയലിന്റെ പേരും ഏതെങ്കിലും പ്രത്യയത്തിൽ നിന്ന് നീക്കം ചെയ്‌തു
:ഡി ഡയറക്‌ടറി
:f ഫയലിന്റെ പേര്
:s ഫയലിന്റെ പേര് പ്രത്യയം
:F ഫയലിന്റെ പേര് ഏതെങ്കിലും പ്രത്യയത്തിൽ നിന്ന് നീക്കം ചെയ്തു

മുകളിലെ ഉദാഹരണം തുടരുമ്പോൾ, `%<:f', `foo bar baz' ആയി വികസിക്കും, `%':d>
`ടെസ്റ്റ്' എന്നതിലേക്ക് വികസിപ്പിക്കുക.

കമാൻഡിന്റെ ഒരു ഭാഗം ഉൾപ്പെടുത്തി പ്രോഗ്രാമാമാറ്റിക് റീറൈറ്റുചെയ്യുന്നത് സാധ്യമാണ്
`%[' നും `%]' നും ഇടയിൽ. ഇത് നിർമ്മാണ വേരിയബിളിനെ ആദ്യ വാക്ക് എന്ന് വിളിക്കും
ഒരു പേൾ കോഡ് റഫറൻസായി ബ്രാക്കറ്റുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു; ഈ കോളിന്റെ ഫലങ്ങൾ ഉപയോഗിക്കും
കമാൻഡ് ലൈനിലെ ബ്രാക്കറ്റുകളുടെ ഉള്ളടക്കം മാറ്റിസ്ഥാപിക്കാൻ. ഉദാഹരണത്തിന്, നൽകിയത്
നിലവിലുള്ള ഇൻപുട്ട് ഫയലിന്റെ പേര് tgt.in:

@കീവേഡുകൾ = qw(foo bar baz);
$env = പുതിയ ദോഷങ്ങൾ(X_COMMA => ഉപ {ചേരുക(",", @_)});
കമാൻഡ് $env 'tgt', 'tgt.in', qq(
എക്കോ '# കീവേഡുകൾ: %[X_COMMA @കീവേഡുകൾ %]' > %>
പൂച്ച %< >> %>
);

ഇത് നടപ്പിലാക്കും:

എക്കോ '# കീവേഡുകൾ: foo,bar,baz' > tgt
cat tgt.in >> tgt

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

ഒരു മൾട്ടി-ലൈൻ കമാൻഡ് സ്ട്രിംഗ് നൽകിയിട്ടുണ്ടെങ്കിൽ, കമാൻഡുകൾ തുടർച്ചയായി നടപ്പിലാക്കുന്നു. ഉണ്ടെങ്കിൽ
കമാൻഡുകൾ പരാജയപ്പെടുന്നു, ബാക്കിയുള്ളവയൊന്നും നടപ്പിലാക്കില്ല, ടാർഗെറ്റ് ഇതായി അടയാളപ്പെടുത്തിയിട്ടില്ല
അപ്‌ഡേറ്റ് ചെയ്‌തു, അതായത് ലക്ഷ്യത്തിനായി ഒരു പുതിയ ഒപ്പ് സംഭരിച്ചിട്ടില്ല.

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

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

ഏതെങ്കിലും കമാൻഡ് (മൾട്ടി-ലൈൻ കമാൻഡിനുള്ളിലെ ഒരെണ്ണം പോലും) `[perl]' എന്നതിൽ തുടങ്ങുന്നുവെങ്കിൽ, ബാക്കിയുള്ളത്
ആ കമാൻഡ് ലൈനിന്റെ ഫോർക്ക് ചെയ്യുന്നതിനുപകരം റണ്ണിംഗ് പെർൾ മൂല്യനിർണ്ണയം ചെയ്യും
ഷെൽ. Perl പാഴ്‌സ് ചെയ്യുന്നതിൽ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ അല്ലെങ്കിൽ Perl എക്സ്പ്രഷൻ 0 നൽകുകയാണെങ്കിൽ അല്ലെങ്കിൽ
undef, കമാൻഡ് പരാജയപ്പെട്ടതായി കണക്കാക്കും. ഉദാഹരണത്തിന്, ഇവിടെ ഒരു ലളിതമാണ്
Perl-ൽ നിന്ന് നേരിട്ട് ഒരു ഫയൽ `foo' സൃഷ്ടിക്കുന്ന കമാൻഡ്:

$env = പുതിയ ദോഷങ്ങൾ();
$env 'foo' കമാൻഡ്,
qq([perl] open(FOO,'>foo');print FOO "hi\\n"; close(FOO); 1);

കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, നിങ്ങൾ അതേ പാക്കേജിൽ ആയിരിക്കുമെന്നത് ശ്രദ്ധിക്കുക നിർമ്മിക്കുക
or നിർബന്ധിത ഫയൽ വായിച്ചു, അതിനാൽ നിങ്ങൾ നിർവചിച്ചിരിക്കുന്ന Perl ഫംഗ്‌ഷനുകളെ നിങ്ങൾക്ക് വിളിക്കാം
നിർമ്മിക്കുക or നിർബന്ധിത 'കമാൻഡ്' ദൃശ്യമാകുന്ന ഫയൽ:

$env = പുതിയ ദോഷങ്ങൾ();
sub create_file {
എന്റെ $ ഫയൽ = shift;
തുറക്കുക (FILE, ">$file");
"ഹായ്\n" ഫയൽ പ്രിന്റ് ചെയ്യുക;
അടയ്ക്കുക (ഫയൽ);
തിരികെ വരുക;
}
കമാൻഡ് $env 'foo', "[perl] &create_file('%>')";

ഉരുത്തിരിഞ്ഞ ഫയലിന്റെ ഒപ്പ് സൃഷ്ടിക്കാൻ Perl സ്ട്രിംഗ് ഉപയോഗിക്കും, അങ്ങനെയാണെങ്കിൽ
സ്ട്രിംഗ് മാറ്റുക, ഫയൽ പുനർനിർമ്മിക്കും. നിങ്ങൾ വിളിക്കുന്ന എല്ലാ സബ്റൂട്ടീനുകളുടെയും ഉള്ളടക്കം,
എന്നിരുന്നാലും, സിഗ്നേച്ചറിന്റെ ഭാഗമല്ല, അതിനാൽ നിങ്ങൾ ഒരു സബ്റൂട്ടീൻ പരിഷ്കരിക്കുകയാണെങ്കിൽ
മുകളിൽ `ക്രിയേറ്റ്_ഫയൽ', ടാർഗെറ്റ് ചെയ്യും അല്ല പുനർനിർമ്മിക്കപ്പെടും. മുന്നറിയിപ്പ് ഉപയോക്താവ്.

ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് കോൻസ് സാധാരണയായി പ്രിന്റ് ചെയ്യുന്നു. എങ്കിൽ ഈ സ്വഭാവം അടിച്ചമർത്തപ്പെടും
കമാൻഡിന്റെ ആദ്യ പ്രതീകം `@' ആണ്. ഇതിൽ നിന്ന് നിങ്ങൾ `@' വേർപെടുത്തേണ്ടി വന്നേക്കാം എന്നത് ശ്രദ്ധിക്കുക
'@cmd' എന്നത് Perl ഉദ്ധരണിയിലെ ഒരു അറേ പോലെ കാണപ്പെടാതിരിക്കാൻ കമാൻഡിന്റെ പേര് അല്ലെങ്കിൽ അത് ഒഴിവാക്കുക
ഇന്റർപോളേഷൻ നടത്തുന്ന ഓപ്പറേറ്റർമാർ:

# ആദ്യത്തെ കമാൻഡ് ലൈൻ തെറ്റാണ്,
# കാരണം "@cp" ഒരു അറേ പോലെ കാണപ്പെടുന്നു
# Perl qq// ഫംഗ്‌ഷനിലേക്ക്.
# പകരം രണ്ടാമത്തെ ഫോം ഉപയോഗിക്കുക.
കമാൻഡ് $env 'foo', 'foo.in', qq(
@cp %< ടെംഫിൽ
@ cp ടെംഫിൽ %>
);

വികസിപ്പിച്ച കമാൻഡ് ലൈനിൽ എവിടെയെങ്കിലും ഷെൽ മെറ്റാ പ്രതീകങ്ങൾ ഉണ്ടെങ്കിൽ, `<',
`>', ഉദ്ധരണികൾ, അല്ലെങ്കിൽ അർദ്ധവിരാമം, തുടർന്ന് കമാൻഡ് യഥാർത്ഥത്തിൽ നടപ്പിലാക്കുന്നത് ഒരു
ഷെൽ. ഇതുപോലുള്ള ഒരു കമാൻഡ് എന്നാണ് ഇതിനർത്ഥം:

cd foo

പാതയിൽ 'cd' എന്ന കമാൻഡ് ഇല്ലാത്തതിനാൽ ഒറ്റയ്ക്ക് സാധാരണയായി പരാജയപ്പെടും. എന്നാൽ ആജ്ഞ
സ്ട്രിംഗ്:

cd $<:d; ടാർ cf $>:f $<:f

വികസിപ്പിക്കുമ്പോൾ, ഷെൽ മെറ്റാ ക്യാരക്‌ടർ സെമി-കോളൺ അടങ്ങിയിരിക്കും, ഒരു ഷെൽ ആയിരിക്കും
കമാൻഡ് വ്യാഖ്യാനിക്കാൻ അഭ്യർത്ഥിച്ചു. `cd' എന്നത് ഈ സബ്-ഷെൽ വ്യാഖ്യാനിക്കുന്നതിനാൽ, കമാൻഡ്
പ്രതീക്ഷിച്ച പോലെ നടപ്പിലാക്കും.

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

കമാൻഡ് $env ['foo.h', 'foo.c'], 'foo.template', q(
ജെൻ% 1
);

'gen' കമാൻഡ് രണ്ട് ഫയലുകൾ സൃഷ്ടിക്കുന്ന സന്ദർഭത്തിൽ ഉപയോഗിക്കാം foo.h ഒപ്പം foo.c.

ദി 'വസ്തുക്കൾ' രീതി

'Objects' രീതി നിർദ്ദിഷ്ട ഫയലുകൾക്ക് അനുയോജ്യമായ ഒബ്ജക്റ്റ് ഫയലുകൾ സൃഷ്ടിക്കാൻ ക്രമീകരിക്കുന്നു
ഉറവിട ഫയലുകൾ. താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ ഇത് അഭ്യർത്ഥിച്ചിരിക്കുന്നു:

@files = ഒബ്ജക്റ്റുകൾ $env ;

Unix-ന് കീഴിൽ, സോഴ്സ് ഫയലുകൾ അവസാനിക്കുന്നു .s ഒപ്പം .c നിലവിൽ പിന്തുണയ്ക്കുന്നു, സമാഹരിക്കപ്പെടും
അവസാനിക്കുന്ന അതേ ഫയലിന്റെ പേരിൽ .o. സ്ഥിരസ്ഥിതിയായി, എല്ലാ ഫയലുകളും അഭ്യർത്ഥിച്ചുകൊണ്ടാണ് സൃഷ്ടിക്കുന്നത്
'CCCOM' നിർമ്മാണ വേരിയബിൾ വികസിപ്പിക്കുന്നതിന്റെ ഫലമായുണ്ടാകുന്ന ബാഹ്യ കമാൻഡ്
`%<', `%>' എന്നിവ യഥാക്രമം സോഴ്സ്, ഒബ്ജക്റ്റ് ഫയലുകളിലേക്ക് സജ്ജമാക്കി (`കമാൻഡ്' രീതി കാണുക
വിപുലീകരണ വിശദാംശങ്ങൾക്കായി). ഉറവിട ഫയലുകൾ സ്കാൻ ചെയ്യുമ്പോൾ `CPPPATH' എന്ന വേരിയബിളും ഉപയോഗിക്കുന്നു
ഡിപൻഡൻസികൾക്കായി. ഇത് ഒരു കോളൺ വേർതിരിക്കുന്ന പാതനാമങ്ങളുടെ പട്ടികയാണ്, കൂടാതെ ഇത് സൃഷ്ടിക്കാനും ഉപയോഗിക്കുന്നു
നിർമ്മാണ വേരിയബിൾ `_IFLAGS', അതിൽ -`I' ന്റെ ഉചിതമായ ലിസ്റ്റ് അടങ്ങിയിരിക്കും
സമാഹാരത്തിനുള്ള ഓപ്ഷനുകൾ. `CPPPATH' ലെ ഏതെങ്കിലും ആപേക്ഷിക പാത നാമങ്ങൾ ആപേക്ഷികമായി വ്യാഖ്യാനിക്കപ്പെടുന്നു
അനുബന്ധ നിർമ്മാണ അന്തരീക്ഷം സൃഷ്ടിച്ച ഡയറക്ടറിയിലേക്ക് (സമ്പൂർണ
കൂടാതെ ഉന്നത-ബന്ധു പേരുകളും ഉപയോഗിക്കാം). ഈ വേരിയബിൾ ഉപയോഗിക്കുന്നത് `CCCOM' ആണ്. പെരുമാറ്റം
ഇന്റർപോളേറ്റഡ് ആയ ഏതെങ്കിലും വേരിയബിളുകൾ മാറ്റിക്കൊണ്ട് ഈ കമാൻഡിൽ മാറ്റം വരുത്താവുന്നതാണ്
`CC', `CFLAGS', പരോക്ഷമായി `CPPPATH' എന്നിങ്ങനെയുള്ള `CCCOM'-ലേക്ക്. അതും സാധ്യമാണ്
`CCCOM' മൂല്യം തന്നെ മാറ്റിസ്ഥാപിക്കുക. സൗകര്യാർത്ഥം, ഈ ഫയൽ ലിസ്റ്റ് നൽകുന്നു
ഒബ്ജക്റ്റ് ഫയൽനാമങ്ങൾ.

ദി 'പ്രോഗ്രാം' രീതി

നിർദ്ദിഷ്ട പ്രോഗ്രാമിനെ നിർദ്ദിഷ്ട വസ്തുവുമായി ബന്ധിപ്പിക്കുന്നതിന് `പ്രോഗ്രാം' രീതി ക്രമീകരിക്കുന്നു
ഫയലുകൾ. ഇനിപ്പറയുന്ന രീതിയിൽ ഇത് വിളിക്കപ്പെടുന്നു:

പ്രോഗ്രാം $env , ;

പ്രോഗ്രാമിന്റെ പേരിന് `SUFEXE' നിർമ്മാണ വേരിയബിളിന്റെ മൂല്യം അനുബന്ധമായി ഉണ്ടായിരിക്കും (ബൈ
ഡിഫോൾട്ട്, Win32 സിസ്റ്റങ്ങളിൽ `.exe', Unix സിസ്റ്റങ്ങളിൽ ഒന്നുമില്ല) സഫിക്സ് ഇതിനകം ഇല്ലെങ്കിൽ
വർത്തമാന.

ഒബ്‌ജക്‌റ്റ് ഫയലുകളുടെ സ്ഥാനത്ത് സോഴ്‌സ് ഫയലുകൾ വ്യക്തമാക്കിയേക്കാം--ഒബ്‌ജക്‌റ്റ് രീതി ഇതായിരിക്കും
എല്ലാ ഫയലുകളും ഒബ്‌ജക്റ്റ് ഫയലുകളാക്കി പരിവർത്തനം ചെയ്യാൻ അഭ്യർത്ഥിച്ചു, അതിനാൽ എല്ലാം
മുകളിലുള്ള `ഒബ്ജക്റ്റ്സ്' രീതിയെക്കുറിച്ചുള്ള നിരീക്ഷണങ്ങൾ ഈ രീതിക്കും ബാധകമാണ്.

പ്രോഗ്രാമിന്റെ യഥാർത്ഥ ലിങ്കിംഗ് ഒരു ബാഹ്യ കമാൻഡ് കൈകാര്യം ചെയ്യും, അത് ഫലം ചെയ്യും
ഒബ്ജക്റ്റ് ഫയലുകളിലേക്ക് `%<' സജ്ജീകരിച്ച്, `LINKCOM' നിർമ്മാണ വേരിയബിൾ വികസിപ്പിക്കുന്നതിൽ നിന്ന്
ലിങ്ക് ചെയ്യുക (അവതരിപ്പിച്ച ക്രമത്തിൽ), കൂടാതെ `%>' ലക്ഷ്യത്തിലേക്ക് സജ്ജമാക്കുക (`കമാൻഡ്' രീതി കാണുക
വിപുലീകരണ വിശദാംശങ്ങൾക്കായി). ഉപയോക്താവിന് നിർമ്മാണത്തിൽ അധിക വേരിയബിളുകൾ സജ്ജമാക്കാം
ലിങ്ക് ചെയ്യുന്നതിനായി ഏത് പ്രോഗ്രാം ഉപയോഗിക്കണമെന്ന് നിർവചിക്കുന്നതിന് `ലിങ്ക്' ഉൾപ്പെടെയുള്ള പരിസ്ഥിതി, `LIBPATH', a
ലൈബ്രറി സ്പെസിഫിക്കേഷനുകൾക്കൊപ്പം ഉപയോഗിക്കുന്നതിന്, ലൈബ്രറി തിരയൽ പാതകളുടെ കോളൻ-വേർതിരിക്കപ്പെട്ട ലിസ്റ്റ്
രൂപം -ലിബ്, ഒപ്പം `LIBS', നേരെ ലിങ്ക് ചെയ്യേണ്ട ലൈബ്രറികളുടെ ലിസ്റ്റ് വ്യക്തമാക്കുന്നു (ഏതെങ്കിലും -ലിബ്
രൂപം അല്ലെങ്കിൽ പാതനാമങ്ങൾ പോലെ. `LIBPATH', `LIBS' എന്നിവയിലെ ആപേക്ഷിക പാതനാമങ്ങൾ വ്യാഖ്യാനിക്കപ്പെടുന്നു
അനുബന്ധ നിർമ്മാണ അന്തരീക്ഷം സൃഷ്ടിക്കപ്പെട്ട ഡയറക്ടറിയുമായി ബന്ധപ്പെട്ട്
(കേവലവും ഉന്നത-ബന്ധു പേരുകളും ഉപയോഗിക്കാം). ദോഷങ്ങൾ സ്വയമേവ സജ്ജീകരിക്കുന്നു
`LIBS'-ൽ പരാമർശിച്ചിരിക്കുന്ന ഏതെങ്കിലും ലൈബ്രറികളുടെ ആശ്രിതത്വം: ആ ലൈബ്രറികൾ മുമ്പ് നിർമ്മിക്കപ്പെടും
കമാൻഡ് ബന്ധിപ്പിച്ചിരിക്കുന്നു.

ദി 'ലൈബ്രറി' രീതി

നിർദ്ദിഷ്ട ഒബ്ജക്റ്റിൽ നിന്ന് നിർദ്ദിഷ്ട ലൈബ്രറി സൃഷ്ടിക്കാൻ `ലൈബ്രറി' രീതി ക്രമീകരിക്കുന്നു
ഫയലുകൾ. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

ലൈബ്രറി $env , ;

ലൈബ്രറിയുടെ പേരിന് `SUFLIB' കൺസ്ട്രക്ഷൻ വേരിയബിളിന്റെ മൂല്യം അനുബന്ധമായി ഉണ്ടായിരിക്കും
ഡിഫോൾട്ട്, Win32 സിസ്റ്റങ്ങളിൽ `.lib', Unix സിസ്റ്റങ്ങളിൽ `.a') സഫിക്സ് ഇതിനകം ഇല്ലെങ്കിൽ
വർത്തമാന.

ഒബ്‌ജക്‌റ്റ് ഫയലുകളുടെ സ്ഥാനത്ത് സോഴ്‌സ് ഫയലുകൾ വ്യക്തമാക്കിയേക്കാം--ഒബ്‌ജക്‌റ്റ് രീതി ഇതായിരിക്കും
എല്ലാ ഫയലുകളും ഒബ്‌ജക്റ്റ് ഫയലുകളാക്കി പരിവർത്തനം ചെയ്യാൻ അഭ്യർത്ഥിച്ചു, അതിനാൽ എല്ലാം
മുകളിലുള്ള `ഒബ്ജക്റ്റ്സ്' രീതിയെക്കുറിച്ചുള്ള നിരീക്ഷണങ്ങൾ ഈ രീതിക്കും ബാധകമാണ്.

ലൈബ്രറിയുടെ യഥാർത്ഥ സൃഷ്ടി ഒരു ബാഹ്യ കമാൻഡ് കൈകാര്യം ചെയ്യും
`%<' സജ്ജീകരിച്ച് ലൈബ്രറി അംഗങ്ങൾക്ക് (ഇൻ
അവതരിപ്പിച്ച ഓർഡർ), കൂടാതെ സൃഷ്ടിക്കേണ്ട ലൈബ്രറിയിലേക്കുള്ള `%>' (ഇതിനായുള്ള `കമാൻഡ്' രീതി കാണുക
വിപുലീകരണ വിശദാംശങ്ങൾ). നിർമ്മാണ പരിതസ്ഥിതിയിൽ ഉപയോക്താവിന് വേരിയബിളുകൾ സജ്ജമാക്കാം
കമാൻഡിന്റെ പ്രവർത്തനത്തെ ബാധിക്കും. ഇവയിൽ ഉപയോഗിക്കാനുള്ള ആർക്കൈവ് പ്രോഗ്രാമായ `AR' ഉൾപ്പെടുന്നു,
`AR' വ്യക്തമാക്കിയ പ്രോഗ്രാമിന് നൽകിയിരിക്കുന്ന ഫ്ലാഗുകൾ പരിഷ്കരിക്കാൻ ഉപയോഗിക്കാവുന്ന `ARFLAGS',
ആവശ്യമെങ്കിൽ ഒരു ആർക്കൈവ് ഇൻഡക്സ് ജനറേഷൻ പ്രോഗ്രാമിന്റെ പേര് `RANLIB' (പ്രത്യേകിച്ചാൽ
ആവശ്യത്തിന് പിന്നീടുള്ള പ്രവർത്തനക്ഷമത ആവശ്യമില്ല, തുടർന്ന് `ആർകോം' അല്ല എന്ന് പുനർ നിർവചിക്കേണ്ടതുണ്ട്
റഫറൻസ് `RANLIB').

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

ദി 'മൊഡ്യൂൾ' രീതി

'പ്രോഗ്രാം', 'കമാൻഡ്' രീതികളുടെ സംയോജനമാണ് 'മൊഡ്യൂൾ' രീതി. അതിലും കൂടുതൽ
ഒരു എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം നേരിട്ട് സൃഷ്ടിക്കുമ്പോൾ, നിങ്ങളുടേത് വ്യക്തമാക്കാൻ ഈ കമാൻഡ് നിങ്ങളെ അനുവദിക്കുന്നു
യഥാർത്ഥത്തിൽ ഒരു മൊഡ്യൂൾ സൃഷ്ടിക്കുന്നതിനുള്ള കമാൻഡ്. രീതി ഇനിപ്പറയുന്ന രീതിയിൽ പ്രയോഗിക്കുന്നു:

മൊഡ്യൂൾ $env , , ;

നിങ്ങൾ സൃഷ്ടിക്കാൻ ആഗ്രഹിക്കുന്ന സന്ദർഭങ്ങളിൽ ഈ കമാൻഡ് ഉപയോഗപ്രദമാണ്, ഉദാഹരണത്തിന്, ചലനാത്മകമായി
ലോഡുചെയ്ത മൊഡ്യൂളുകൾ, അല്ലെങ്കിൽ സ്ഥിരമായി ലിങ്ക് ചെയ്ത കോഡ് ലൈബ്രറികൾ.

ദി 'ആശ്രയിക്കുന്നു' രീതി

ഒരു ലക്ഷ്യത്തിനായുള്ള അധിക ഡിപൻഡൻസികൾ വ്യക്തമാക്കാൻ `ഡിപെൻഡ്സ്' രീതി നിങ്ങളെ അനുവദിക്കുന്നു. അത്
ഇനിപ്പറയുന്ന രീതിയിൽ അഭ്യർത്ഥിച്ചു:

$env-നെ ആശ്രയിച്ചിരിക്കുന്നു , ;

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

ഒന്നിലധികം ടാർഗെറ്റുകൾക്ക് സമാനമായ ഡിപൻഡൻസികളുടെ ഒരു കൂട്ടം ഒരു റഫറൻസ് ഉപയോഗിച്ച് വ്യക്തമാക്കിയേക്കാം
ലക്ഷ്യങ്ങളുടെ ഒരു ലിസ്റ്റ്. പേളിൽ, ചതുരത്തിൽ ഒരു ലിസ്റ്റ് ഉൾപ്പെടുത്തി ഒരു ലിസ്റ്റ് റഫറൻസ് ഉണ്ടാക്കാം
ആവരണചിഹ്നം. അതിനാൽ ഇനിപ്പറയുന്ന കമാൻഡ്:

$env ['foo', 'bar'], 'input_file_1', 'input_file_2' എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു;

രണ്ടും എന്ന് വ്യക്തമാക്കുന്നു ഫൂ ഒപ്പം ബാർ ഫയലുകൾ ലിസ്റ്റുചെയ്ത ഇൻപുട്ട് ഫയലുകളെ ആശ്രയിച്ചിരിക്കുന്നു.

ദി 'അവഗണിക്കുക' രീതി

'ഇഗ്നോർ' രീതി നിങ്ങളെ ദോഷകരമായി അനുമാനിക്കുന്ന പ്രത്യക്ഷമായ ആശ്രിതത്വങ്ങളെ അവഗണിക്കാൻ അനുവദിക്കുന്നു
സ്വന്തം. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

അവഗണിക്കുക ;

സിസ്റ്റം ഹെഡർ ഫയലുകളിലോ അല്ലെങ്കിൽ മാറ്റങ്ങൾ മൂലമോ വീണ്ടും കമ്പൈലേഷനുകൾ ഒഴിവാക്കാൻ ഇത് ഉപയോഗിക്കാം
ജനറേറ്റുചെയ്ത ലക്ഷ്യങ്ങളെ ബാധിക്കില്ലെന്ന് അറിയപ്പെടുന്ന യൂട്ടിലിറ്റികൾ.

ഉദാഹരണത്തിന്, ഒന്നിലധികം സിസ്റ്റങ്ങളിൽ NFS-മൌണ്ട് ചെയ്ത ഡയറക്ടറിയിൽ ഒരു പ്രോഗ്രാം നിർമ്മിച്ചിട്ടുണ്ടെങ്കിൽ
യുടെ വ്യത്യസ്ത പകർപ്പുകൾ ഉണ്ട് stdio.h, വ്യത്യാസങ്ങൾ എല്ലാവരുടെയും ഒപ്പുകളെ ബാധിക്കും
'#ഉൾപ്പെടുന്ന ഉറവിട ഫയലുകളിൽ നിന്ന് നിർമ്മിച്ച ലക്ഷ്യങ്ങൾ '. ഇത് എല്ലാത്തിനും കാരണമാകും
സിസ്റ്റങ്ങൾ മാറ്റുമ്പോൾ ആ ലക്ഷ്യങ്ങൾ പുനർനിർമ്മിക്കേണ്ടതാണ്. ഇത് അഭിലഷണീയമായ പെരുമാറ്റമല്ലെങ്കിൽ,
തുടർന്ന് ഇനിപ്പറയുന്ന ലൈൻ ഡിപൻഡൻസികൾ നീക്കം ചെയ്യും stdio.h ഫയൽ:

'^/usr/include/stdio\.h$' അവഗണിക്കുക;

`ഇഗ്നോർ' രീതിയിലേക്കുള്ള ആർഗ്യുമെന്റുകൾ പതിവ് എക്സ്പ്രഷനുകളാണെന്നത് ശ്രദ്ധിക്കുക
പ്രതീകങ്ങൾ ഒഴിവാക്കപ്പെടണം, നിങ്ങൾ അതിന്റെ തുടക്കമോ അവസാനമോ നങ്കൂരമിടാൻ ആഗ്രഹിച്ചേക്കാം
`^' അല്ലെങ്കിൽ `$' പ്രതീകങ്ങളുള്ള പദപ്രയോഗം.

ദി 'ഉപ്പ്' രീതി

`സാൾട്ട്' രീതി ഓരോ ഉരുത്തിരിഞ്ഞതിനും ഒപ്പ് കണക്കുകൂട്ടലിലേക്ക് സ്ഥിരമായ മൂല്യം ചേർക്കുന്നു
ഫയൽ. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

ഉപ്പ് $ സ്ട്രിംഗ്;

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

ഉപ്പ് `uname -s`;

ഓപറേറ്റിംഗ് സിസ്റ്റം ഓണായിരിക്കുമ്പോഴെല്ലാം ലഭിച്ച എല്ലാ ഫയലുകളുടെയും പൂർണ്ണമായ പുനർനിർമ്മാണം നിർബന്ധിതമാക്കും
ഏത് ബിൽഡ് നിർവ്വഹിക്കുന്നു (`uname -s' റിപ്പോർട്ട് ചെയ്തതുപോലെ) മാറ്റങ്ങൾ.

ദി 'UseCache' രീതി

"UseCache" രീതി, പങ്കുവയ്ക്കാൻ ലഭിച്ച ഫയലുകളുടെ ഒരു കാഷെ നിലനിർത്താൻ ദോഷങ്ങൾക്ക് നിർദ്ദേശം നൽകുന്നു
ഒരേ പ്രോജക്റ്റിന്റെ പ്രത്യേക നിർമ്മാണ മരങ്ങൾക്കിടയിൽ.

കാഷെ ഉപയോഗിക്കുക("കാഷെ/ ") ⎪⎪ മുന്നറിയിപ്പ് ("കാഷെ ഡയറക്ടറി കണ്ടെത്തിയില്ല");

ദി 'ഉറവിട പാത' രീതി

'SourcePath' മാത്തോഡ് ഒരു ഫയലിന്റെ യഥാർത്ഥ സോഴ്സ് പാത്ത് നാമം നൽകുന്നു, വിപരീതമായി
ഒരു ബിൽഡ് ഡയറക്ടറിയിൽ പാതയുടെ പേര്. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

$പാത്ത് = ഉറവിട പാത ;

ദി 'കോൺസ്പാത്ത്' രീതി

വിതരണം ചെയ്‌ത പാത്ത് ഒരു ഡെറിവേബിൾ ഫയൽ ആണെങ്കിൽ, 'ConsPath' രീതി ശരിയാണെന്ന് തിരികെ നൽകുന്നു, കൂടാതെ തിരികെ നൽകുന്നു
undef (തെറ്റ്) അല്ലാത്തപക്ഷം. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

$ഫലം = ConsPath ;

ദി `സ്പ്ലിറ്റ്പാത്ത്' രീതി

'SplitPath' രീതി ഡിഫോൾട്ടായി വേർതിരിക്കുന്ന ഒരു സ്ട്രിംഗിൽ ഒന്നിലധികം പാത നാമങ്ങൾ കാണുന്നു
ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിനായുള്ള പാത്ത് സെപ്പറേറ്റർ (':' UNIX സിസ്റ്റങ്ങളിൽ, ';' Windows NT-ൽ), കൂടാതെ
പൂർണ്ണ യോഗ്യതയുള്ള പേരുകൾ നൽകുന്നു. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

@paths = SplitPath ;

'SplitPath' രീതി '#' പ്രിഫിക്‌സ് ചെയ്ത പേരുകളെ ഉചിതമായ ടോപ്പ് ലെവൽ ബിൽഡിലേക്ക് പരിവർത്തനം ചെയ്യും
പേര് ('#' ഇല്ലാതെ) കൂടാതെ ആപേക്ഷിക പേരുകളെ ഉയർന്ന തലത്തിലുള്ള പേരുകളാക്കി മാറ്റും.

ദി 'ദിർപത്ത്' രീതി

`DirPath' രീതി ബിൽഡ് പാത്ത് തിരികെ നൽകുന്നു പേര്(കൾ) ഒരു ഡയറക്ടറിയുടെ അല്ലെങ്കിൽ ഡയറക്ടറികളുടെ പട്ടിക.
ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

$cwd = ദിർപാത്ത് ;

`ദിർപാത്ത്' രീതിയുടെ ഏറ്റവും സാധാരണമായ ഉപയോഗം ഇതാണ്:

$cwd = DirPath '.';

ഒരു സബ്സിഡിയറിയുടെ നിലവിലെ ഡയറക്‌ടറിയിലേക്കുള്ള പാത ലഭ്യമാക്കാൻ നിർബന്ധിത ഫയൽ.

ദി 'ഫയൽപാത്ത്' രീതി

`ഫയൽപാത്ത്' രീതി ബിൽഡ് പാത്ത് നൽകുന്നു പേര്(കൾ) ഒരു ഫയലിന്റെ അല്ലെങ്കിൽ ഫയലുകളുടെ പട്ടിക. അത്
ഇനിപ്പറയുന്ന രീതിയിൽ അഭ്യർത്ഥിച്ചു:

$file = ഫയൽപാത്ത് ;

ദി 'സഹായം' രീതി

'സഹായം' രീതി ഉപയോക്താവ് `കോൺസ് അഭ്യർത്ഥിക്കുമ്പോൾ പ്രദർശിപ്പിക്കുന്ന സഹായ വാചകം വ്യക്തമാക്കുന്നു
-h'. നിർദ്ദിഷ്ട ലക്ഷ്യങ്ങൾ, മൂല്യങ്ങൾ, നിർമ്മാണം എന്നിവയുടെ ഡോക്യുമെന്റേഷൻ നൽകാൻ ഇത് ഉപയോഗിക്കാം
ബിൽഡ് ട്രീയുടെ ഓപ്ഷനുകൾ മുതലായവ. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കപ്പെടുന്നു:

സഹായിക്കൂ ;

`സഹായം' രീതി ഒരു തവണ മാത്രമേ വിളിക്കാവൂ, സാധാരണയായി മുകളിൽ വ്യക്തമാക്കിയിരിക്കണം-
ലെവൽ നിർമ്മിക്കുക ഫയൽ.

വിപുലീകരിക്കുന്നു ബാക്ക്ട്രെയിസ്കൊണ്ടു്

അസാധ്യം നിര്മ്മാണം വേരിയബിളുകൾ

കോൻസ് വിപുലീകരിക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട്, അത് ബുദ്ധിമുട്ടിന്റെ അളവിൽ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. ഏറ്റവും ലളിതമായത്
സ്ഥിരസ്ഥിതി പരിസ്ഥിതിയെ അടിസ്ഥാനമാക്കി, നിങ്ങളുടെ സ്വന്തം നിർമ്മാണ അന്തരീക്ഷം നിർവചിക്കുക എന്നതാണ് രീതി,
എന്നാൽ നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾ പ്രതിഫലിപ്പിക്കുന്നതിന് പരിഷ്ക്കരിച്ചു. സി-അടിസ്ഥാനത്തിന് ഇത് പലപ്പോഴും മതിയാകും
അപേക്ഷകൾ. നിങ്ങൾക്ക് 'പുതിയ' കൺസ്‌ട്രക്‌ടറും 'ക്ലോൺ', 'പകർത്തുക' രീതികളും ഉപയോഗിക്കാം
ഹൈബ്രിഡ് പരിതസ്ഥിതികൾ സൃഷ്ടിക്കുക. ഈ മാറ്റങ്ങൾ അടിസ്ഥാനപരമായി പൂർണ്ണമായും സുതാര്യമായിരിക്കും
നിർബന്ധിത ഫയലുകൾ.

ചേർക്കുന്നു പുതിയ രീതികൾ

അൽപ്പം കൂടുതൽ ആവശ്യപ്പെടുന്ന മാറ്റങ്ങൾക്കായി, 'കോൺസ്' എന്നതിലേക്ക് പുതിയ രീതികൾ ചേർക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം.
പാക്കേജ്. വളരെ ലളിതമായ ഒരു വിപുലീകരണത്തിന്റെ ഒരു ഉദാഹരണം ഇതാ, `ഇൻസ്റ്റാൾസ്ക്രിപ്റ്റ്', അത് എ ഇൻസ്റ്റാൾ ചെയ്യുന്നു
അഭ്യർത്ഥിച്ച സ്ഥലത്ത് tcl സ്ക്രിപ്റ്റ്, എന്നാൽ ഒരു പ്ലാറ്റ്ഫോം പ്രതിഫലിപ്പിക്കുന്നതിന് ആദ്യം സ്ക്രിപ്റ്റ് എഡിറ്റ് ചെയ്യുന്നു-
സ്ക്രിപ്റ്റിൽ ഇൻസ്റ്റാൾ ചെയ്യേണ്ട ആശ്രിത പാത:

# cons::InstallScript - ഒരു ഷെല്ലിന്റെ പ്ലാറ്റ്‌ഫോം ആശ്രിത പതിപ്പ് സൃഷ്‌ടിക്കുക
``#!your-path-here'' എന്ന സ്‌ട്രിംഗിന് പകരം പ്ലാറ്റ്‌ഫോം സ്‌പെസിഫിക് ഉപയോഗിച്ച് # സ്‌ക്രിപ്റ്റ്
# പാത $BIN_DIR.

ഉപ ദോഷങ്ങൾ::InstallScript {
എന്റെ ($env, $dst, $src) = @_;
കമാൻഡ് $env $dst, $src, qq(
sed s+your-path-here+$BIN_DIR+ %< > %>
chmod oug+x %>
);
}

ഈ രീതി `കോൺസ്' പാക്കേജിൽ നേരിട്ട് നിർവചിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക (പേര് പ്രിഫിക്സ് ചെയ്തുകൊണ്ട്
കൂടെ `കോൺസ്::'). ഈ രീതിയിൽ വരുത്തിയ മാറ്റം ആഗോളതലത്തിൽ എല്ലാ പരിതസ്ഥിതികൾക്കും ദൃശ്യമാകും,
ഇനിപ്പറയുന്ന ഉദാഹരണത്തിലെന്നപോലെ വിളിക്കാം:

InstallScript $env "$BIN/foo", "foo.tcl";

സാമാന്യതയിൽ ഒരു ചെറിയ പുരോഗതിക്കായി, `BINDIR' വേരിയബിൾ ഒരു ആയി നൽകാം
വാദം അല്ലെങ്കിൽ നിർമ്മാണ പരിതസ്ഥിതിയിൽ നിന്ന് എടുത്തത് - `%BINDIR' ആയി.

അസാധ്യം രീതികൾ

`കോൺസ്' നെയിം സ്പേസിലേക്ക് മെത്തേഡ് ചേർക്കുന്നതിനുപകരം, നിങ്ങൾക്ക് ഒരു പുതിയ പാക്കേജ് നിർവചിക്കാം
'കോൺസ്' പാക്കേജിൽ നിന്ന് നിലവിലുള്ള രീതികൾ അവകാശമാക്കുകയും മറ്റുള്ളവരെ അസാധുവാക്കുകയോ ചേർക്കുകയോ ചെയ്യുന്നു. ഈ
പേളിന്റെ അനന്തരാവകാശ സംവിധാനങ്ങൾ ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയും.

സ്റ്റാൻഡേർഡിനെ അസാധുവാക്കുന്ന ഒരു പുതിയ പാക്കേജ് 'cons::switch' ഇനിപ്പറയുന്ന ഉദാഹരണം നിർവചിക്കുന്നു
`ലൈബ്രറി' രീതി. അസാധുവായ രീതി ലൈബ്രറിയേക്കാൾ ലിങ്ക്ഡ് ലൈബ്രറി മൊഡ്യൂളുകൾ നിർമ്മിക്കുന്നു
ആർക്കൈവുകൾ. ഒരു പുതിയ കൺസ്ട്രക്റ്റർ നൽകിയിട്ടുണ്ട്. ഈ കൺസ്‌ട്രക്‌റ്റർ ഉപയോഗിച്ച് സൃഷ്‌ടിച്ച ചുറ്റുപാടുകൾ
പുതിയ ലൈബ്രറി രീതി; മറ്റുള്ളവർ ചെയ്യില്ല.

പാക്കേജ് ദോഷങ്ങൾ :: സ്വിച്ച്;
ആരംഭിക്കുക {@ISA = 'cons'}

ഉപ പുതിയ {
ഷിഫ്റ്റ്;
പുതിയ ദോഷങ്ങളെ അനുഗ്രഹിക്കൂ(@_);
}

ഉപ ലൈബ്രറി {
my($env) = shift;
my($lib) = shift;
my(@objs) = ഒബ്ജക്റ്റുകൾ $env @_;
കമാൻഡ് $env $lib, @objs, q(
%LD -r %LDFLAGS %< -o %>
);
}

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിലെന്നപോലെ ഈ പ്രവർത്തനം അഭ്യർത്ഥിക്കാം:

$env = പുതിയ ദോഷങ്ങൾ :: സ്വിച്ച് (@ ഓവർറൈഡുകൾ);
...
ലൈബ്രറി $env 'lib.o', 'foo.c', 'bar.c';

അഭ്യർത്ഥിക്കുന്നു ബാക്ക്ട്രെയിസ്കൊണ്ടു്

'കോൺസ്' കമാൻഡ് സാധാരണയായി ബിൽഡ് ട്രീയുടെ വേരിൽ നിന്നാണ് വിളിക്കുന്നത്. എ നിർമ്മിക്കുക ഫയല്
ആ ഡയറക്ടറിയിൽ ഉണ്ടായിരിക്കണം. `-f' ആർഗ്യുമെന്റ് ഉപയോഗിച്ചാൽ, ഒരു ബദൽ നിർമ്മിക്കുക
ഫയൽ ഉപയോഗിക്കാം (കൂടാതെ, ഒരുപക്ഷേ, ഒരു ഇതര റൂട്ട്, കാരണം `കോൺസ്' cd to നിർമ്മിക്കുക
ഡയറക്‌ടറി അടങ്ങുന്ന ഫയലിൽ).

ബിൽഡ് ട്രീയുടെ വേരിന്റെ ഒരു കുട്ടിയിൽ നിന്ന് `-t' ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് `കോൺസ്' വിളിച്ചാൽ, അത്
a തിരയുന്ന ഡയറക്ടറി ശ്രേണിയിലേക്ക് നടക്കും നിർമ്മിക്കുക ഫയൽ. (ഒരു ഇതര പേര് വരാം
ഇപ്പോഴും `-f' ഉപയോഗിച്ച് വ്യക്തമാക്കും.) കമാൻഡ് ലൈനിൽ നൽകിയിരിക്കുന്ന ടാർഗെറ്റുകൾ പരിഷ്കരിക്കപ്പെടും
കണ്ടുപിടിച്ചവയുമായി ആപേക്ഷികമാകണം നിർമ്മിക്കുക ഫയൽ. ഉദാഹരണത്തിന്, അടങ്ങുന്ന ഒരു ഡയറക്ടറിയിൽ നിന്ന്
ഒരു ഉയർന്ന തലം നിർമ്മിക്കുക ഫയൽ, ഇനിപ്പറയുന്ന അഭ്യർത്ഥന:

% cd libfoo/subdir
% cons -t ലക്ഷ്യം

ഇതിന് കൃത്യമായി തുല്യമാണ്:

% cons libfoo/subdir/target

ഡയറക്‌ടറി ശ്രേണിയിൽ വ്യക്തമാക്കിയിട്ടുള്ള ഏതെങ്കിലും `ഡിഫോൾട്ട്' ടാർഗെറ്റുകൾ ഉണ്ടെങ്കിൽ നിർമ്മിക്കുക or
നിർബന്ധിത ഫയലുകൾ, 'cons -t' എന്ന ഡയറക്‌ടറിയിലോ അതിനു താഴെയോ ഉള്ള ഡിഫോൾട്ട് ടാർഗെറ്റുകൾ മാത്രം
നിർമ്മിക്കപ്പെടും എന്ന് ആവാഹിച്ചു.

കമാൻഡ് ഇനിപ്പറയുന്ന രീതിയിൽ പ്രയോഗിക്കുന്നു:

ദോഷങ്ങൾ --

എവിടെ വാദങ്ങൾ ഇനിപ്പറയുന്നവയിൽ ഏതെങ്കിലും, ഏത് ക്രമത്തിലും ആകാം:

ലക്ഷ്യം നിർദ്ദിഷ്ട ലക്ഷ്യം നിർമ്മിക്കുക. എങ്കിൽ ലക്ഷ്യം ഒരു ഡയറക്‌ടറിയാണ്, തുടർന്ന് ആവർത്തനപരമായി നിർമ്മിക്കുക
ആ ഡയറക്ടറിയിലെ എല്ലാം.

+പാറ്റേൺ പരിമിതപ്പെടുത്തുക നിർബന്ധിത ഫയലുകൾ പൊരുത്തപ്പെടുന്നവയിലേക്ക് മാത്രം പരിഗണിക്കുന്നു പാറ്റേൺ, അത്
ഒരു പേൾ റെഗുലർ എക്സ്പ്രഷൻ. ഒന്നിലധികം `+' ആർഗ്യുമെന്റുകൾ അംഗീകരിച്ചു.

പേര്=
സജ്ജമാക്കുന്നു പേര് വിലമതിക്കാൻ Val 'ARG' ഹാഷിൽ ഉയർന്ന തലത്തിലേക്ക് കടന്നു നിർമ്മിക്കുക ഫയൽ.

കാഷെയിൽ നിന്ന് വീണ്ടെടുക്കുമ്പോൾ, എക്സിക്യൂട്ട് ചെയ്യപ്പെടുമായിരുന്ന `-cc' കമാൻഡ് കാണിക്കുക. ഇല്ല
ഫയൽ വീണ്ടെടുത്തതായി സൂചന; ഇത് ഉപയോഗപ്രദമാണ്
യഥാർത്ഥ ബിൽഡ് ലോഗുകളുമായി താരതമ്യപ്പെടുത്താവുന്ന ബിൽഡ് ലോഗുകൾ സൃഷ്ടിക്കുന്നു.

`-cd' എല്ലാ കാഷിംഗും പ്രവർത്തനരഹിതമാക്കുക. കാഷെയിൽ നിന്ന് വീണ്ടെടുക്കുകയോ കാഷെയിലേക്ക് ഫ്ലഷ് ചെയ്യുകയോ ചെയ്യരുത്.

`-cr' ക്രമരഹിതമായ ക്രമത്തിൽ ഡിപൻഡൻസികൾ നിർമ്മിക്കുക. ഒന്നിലധികം നിർമ്മിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്
കാഷിംഗ് പ്രവർത്തനക്ഷമമാക്കിയ സമാന മരങ്ങൾ.

`-cs' കാഷെ ഉപയോഗിച്ച് കാലികമാണെന്ന് കണ്ടെത്തിയ നിലവിലുള്ള ബിൽഡ് ടാർഗെറ്റുകൾ സമന്വയിപ്പിക്കുക.
-cc ഉപയോഗിച്ച് കാഷെ ചെയ്യൽ അപ്രാപ്‌തമാക്കിയാലോ അല്ലെങ്കിൽ അടുത്തിടെ പ്രവർത്തനക്ഷമമാക്കിയാലോ ഇത് ഉപയോഗപ്രദമാണ്
UseCache ഉപയോഗിച്ച്.

`-d' ഡിപൻഡൻസി ഡീബഗ്ഗിംഗ് പ്രവർത്തനക്ഷമമാക്കുക.

`-f'
പകരം നിർദ്ദിഷ്ട ഫയൽ ഉപയോഗിക്കുക നിർമ്മിക്കുക (എന്നാൽ ആദ്യം അടങ്ങിയിരിക്കുന്നതിലേക്ക് മാറ്റുക
എന്ന ഡയറക്ടറി ഫയല്).

`-h' അത്തരത്തിലുള്ള ഒന്ന് നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, നിലവിലെ ബിൽഡിന് പ്രാദേശികമായി ഒരു സഹായ സന്ദേശം കാണിച്ച് പുറത്തുകടക്കുക.

`-k' പിശകുകൾക്ക് ശേഷം കഴിയുന്നിടത്തോളം തുടരുക.

`-o'
അസാധുവാക്കൽ ഫയൽ വായിക്കുക ഫയല്.

`-p' നിർദ്ദിഷ്ട മരങ്ങളിൽ നിർമ്മാണ ഉൽപ്പന്നങ്ങൾ കാണിക്കുക. നിർമ്മാണത്തിന് ശ്രമിച്ചിട്ടില്ല.

`-pa' നിർമ്മാണ ഉൽപ്പന്നങ്ങളും അനുബന്ധ പ്രവർത്തനങ്ങളും കാണിക്കുക. നിർമ്മാണത്തിന് ശ്രമിച്ചിട്ടില്ല.

`-pw' ഉൽപ്പന്നങ്ങളും അവ നിർവചിച്ചിരിക്കുന്നതും കാണിക്കുക. നിർമ്മാണത്തിന് ശ്രമിച്ചിട്ടില്ല.

`-q' ടാർഗെറ്റുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനെക്കുറിച്ചും നീക്കംചെയ്യുന്നതിനെക്കുറിച്ചും വാചാലനാകരുത്.

`-r' ഇതുമായി ബന്ധപ്പെട്ട നിർമ്മാണ ഉൽപ്പന്നങ്ങൾ നീക്കം ചെയ്യുക . പണിയാൻ ശ്രമിച്ചിട്ടില്ല.

`-ആർ'
ഫയലുകൾക്കായി തിരയുക ബാക്കി. ഒന്നിലധികം -R ബാക്കി എന്നതിൽ ഡയറക്ടറികൾ തിരയുന്നു
ക്രമം വ്യക്തമാക്കിയിട്ടുണ്ട്.

`-t' ഒരു തിരയുന്ന ഡയറക്‌ടറി ശ്രേണിയുടെ മുകളിലേക്ക് സഞ്ചരിക്കുക നിർമ്മിക്കുക ഫയൽ, നിലവിലില്ലെങ്കിൽ
നിലവിലെ ഡയറക്ടറിയിൽ. ലക്ഷ്യങ്ങൾ ആപേക്ഷികമായി പരിഷ്കരിക്കും
നിർമ്മിക്കുക ഫയൽ.

`-v' `കോൺസ്' പതിപ്പ് കാണിച്ച് പ്രോസസ്സിംഗ് തുടരുക.

`-വി' `കോൺസ്' പതിപ്പ് കാണിച്ച് പുറത്തുകടക്കുക.

`-wf'
പരിഗണിക്കുന്ന എല്ലാ ഫയൽനാമങ്ങളും എഴുതുക ഫയല്.

`-x' ഇതുപോലുള്ള ഒരു സഹായ സന്ദേശം കാണിച്ച് പുറത്തുകടക്കുക.

ഒപ്പം നിർമ്മാണം-ആർഗ്സ് നിങ്ങൾ പ്രോസസ്സ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഏതെങ്കിലും വാദങ്ങൾ ആകാം നിർമ്മിക്കുക ഫയൽ.
ഒരു ഉണ്ടായിരിക്കണം എന്നത് ശ്രദ്ധിക്കുക -- വാദങ്ങളെ ദോഷങ്ങളിലേക്കും നിങ്ങളുടേതായ വാദങ്ങളിലേക്കും വേർതിരിക്കുന്നു
ൽ പ്രോസസ്സ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നു നിർമ്മിക്കുക ഫയൽ.

യുടെ പ്രോസസ്സിംഗ് നിർമ്മാണം-ആർഗ്സ് പോലുള്ള ഏത് സ്റ്റാൻഡേർഡ് പാക്കേജ് വഴിയും ചെയ്യാം ഗെറ്റോപ്റ്റ് അല്ലെങ്കിൽ അതിന്റെ
വേരിയന്റുകൾ, അല്ലെങ്കിൽ ഏതെങ്കിലും ഉപയോക്തൃ നിർവചിച്ച പാക്കേജ്. കോണ് ൽ കടന്നുപോകും നിർമ്മാണം-ആർഗ്സ് as @ARGV ഒപ്പം
ശേഷം ഒന്നും വ്യാഖ്യാനിക്കാൻ ശ്രമിക്കില്ല --.

% cons -R /usr/local/repository -d os=solaris +driver -- -c test -f DEBUG

ഇനിപ്പറയുന്നവ ദോഷങ്ങളിലേയ്ക്ക് കൈമാറും

-R /usr/local/repository -d os=solaris +driver

താഴെപ്പറയുന്നവയും ഉയർന്ന തലത്തിലേക്ക് നിർമ്മിക്കുക ഫയൽ ആയി @ARGV

-സി ടെസ്റ്റ് -എഫ് ഡീബഗ്

ശ്രദ്ധിക്കുക, `കോൺസ് -ആർ .' ഒരു പൂർണ്ണ ആവർത്തനമായ `മേക്ക് ക്ലീൻ' എന്നതിന് തുല്യമാണ്, എന്നാൽ ആവശ്യമില്ല
ൽ പിന്തുണ നിർമ്മിക്കുക ഫയൽ അല്ലെങ്കിൽ മറ്റേതെങ്കിലും നിർബന്ധിത ഫയലുകൾ. നിങ്ങളാണെങ്കിൽ ഇത് ഏറ്റവും ഉപയോഗപ്രദമാണ്
സോഴ്സ് ഡയറക്ടറികളിലേക്ക് ഫയലുകൾ കംപൈൽ ചെയ്യുന്നു (നിങ്ങൾ വേർതിരിക്കുകയാണെങ്കിൽ പണിയുക ഒപ്പം കയറ്റുമതി ചെയ്യുക ഡയറക്ടറികൾ,
അപ്പോൾ നിങ്ങൾക്ക് ഡയറക്ടറികൾ നീക്കം ചെയ്യാം).

വായനയിൽ ഒരു സഹായമായി ഉപയോഗിക്കുന്നതിന് `-p', `-pa', `-pw' എന്നീ ഓപ്ഷനുകൾ വളരെ ഉപയോഗപ്രദമാണ്.
സ്ക്രിപ്റ്റുകൾ അല്ലെങ്കിൽ ഡീബഗ്ഗിംഗ്. എന്താണ് സ്ക്രിപ്റ്റ് ഇൻസ്റ്റാൾ ചെയ്യുന്നതെന്ന് അറിയണമെങ്കിൽ കയറ്റുമതി/ഉൾപ്പെടുത്തുക/foo.h,
ഉദാഹരണത്തിന്, ടൈപ്പ് ചെയ്യുക:

% cons -pw export/include/foo.h

ഉപയോഗിക്കുന്നു ഒപ്പം എഴുത്തു ആശ്രിതത്വം സ്കാനറുകൾ

ഉറവിട ഫയലുകൾക്കായി ലളിതമായ ടാർഗെറ്റ്-ഇൻഡിപെൻഡന്റ് സ്കാനറുകൾ സജ്ജീകരിക്കാൻ QuickScan അനുവദിക്കുന്നു. മാത്രം
ഒരു QuickScan സ്കാനർ നൽകിയിരിക്കുന്ന ഏതെങ്കിലും സോഴ്സ് ഫയലുമായും പരിസ്ഥിതിയുമായും ബന്ധപ്പെട്ടിരിക്കാം.

QuickScan ഇനിപ്പറയുന്ന രീതിയിൽ അഭ്യർത്ഥിക്കുന്നു:

QuickScan CONSENV CODEREF, FILENAME [, PATH]

CODEREF പരാമർശിച്ച സബ്റൂട്ടീൻ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഫയൽനാമങ്ങളുടെ ഒരു ലിസ്റ്റ് തിരികെ നൽകുമെന്ന് പ്രതീക്ഷിക്കുന്നു
നേരിട്ട് FILE വഴി. ഈ ഫയൽനാമങ്ങൾ സ്കാൻ ചെയ്യപ്പെടും. ഓപ്ഷണൽ PATH ആർഗ്യുമെന്റ്
FILENAME കൂടാതെ/അല്ലെങ്കിൽ ഉപയോക്താവ് നൽകിയ ഫയലുകൾ കണ്ടെത്തുന്നതിന് ഒരു ലുക്ക്അപ്പ് പാത്ത് നൽകുന്നു
സബ്റൂട്ടീൻ. PATH എന്നത് ലുക്ക്അപ്പ് ഡയറക്‌ടറി പേരുകളുടെ ഒരു നിരയിലേക്കുള്ള ഒരു റഫറൻസായിരിക്കാം, അല്ലെങ്കിൽ a
സിസ്റ്റത്തിന്റെ സെപ്പറേറ്റർ പ്രതീകം കൊണ്ട് വേർതിരിച്ച പേരുകളുടെ സ്ട്രിംഗ് (':' UNIX സിസ്റ്റങ്ങളിൽ, ';' ഓൺ
വിൻഡോസ് എൻടി).

നിലവിലെ ലൈനിലേക്ക് $_ സജ്ജീകരിച്ച് ഫയലിലെ ഓരോ വരിയിലും സബ്റൂട്ടീൻ ഒരിക്കൽ വിളിക്കുന്നു.
സബ്റൂട്ടീന് അധിക ലൈനുകൾ നോക്കേണ്ടതുണ്ടെങ്കിൽ, അല്ലെങ്കിൽ, മുഴുവൻ ഫയലും,
അപ്പോൾ അത് ഫയൽ ഹാൻഡിൽ SCAN-ൽ നിന്ന് അവ സ്വയം വായിച്ചേക്കാം. എങ്കിൽ, ഇത് ലൂപ്പിനെ അവസാനിപ്പിച്ചേക്കാം
ഫയൽ ഹാൻഡിൽ അടയ്ക്കുന്നതിലൂടെ കൂടുതൽ ഉൾപ്പെടുത്തുന്ന വിവരങ്ങളൊന്നും ലഭ്യമല്ലെന്ന് അതിന് അറിയാം.

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

എയിൽ നിന്ന് എടുത്ത ഒരു യഥാർത്ഥ ഉദാഹരണം ഇതാ നിർമ്മിക്കുക ഫയൽ ഇവിടെ:

ഉപ ദോഷങ്ങൾ::SMFgen {
my($env, @tables) = @_;
ഫോറെച്ച് $t (@tables) {
$env->QuickScan(sub { /\b\S*?\.smf\b/g }, "$t.smf",
$env->{SMF_INCLUDE_PATH});
$env->കമാൻഡ്(
["$t.smdb.cc","$t.smdb.h","$t.snmp.cc","$t.ami.cc", "$t.http.cc"],
"$t.smf",
q(
smfgen %( %SMF_INCLUDE_OPT %) %
)
);
}
}

[`$env->QuickScan ...', `$env->കമാൻഡ് ...' എന്നീ ഫോം പാടില്ല എന്നത് ശ്രദ്ധിക്കുക.
ആവശ്യമാണ്, പക്ഷേ, ചില കാരണങ്ങളാൽ, ഈ പ്രത്യേക അഭ്യർത്ഥനയ്ക്ക് ആവശ്യമാണ്. ഇത് ദൃശ്യമാകുന്നു
പേളിലെ ഒരു ബഗ് അല്ലെങ്കിൽ എന്റെ ഭാഗത്ത് ഒരു തെറ്റിദ്ധാരണ; ഈ അഭ്യർത്ഥന ശൈലി ഇല്ല
എല്ലായ്പ്പോഴും ആവശ്യമാണെന്ന് തോന്നുന്നു.]

ഇത് ഫോമിന്റെ എല്ലാ പേരുകളും കണ്ടെത്തുന്നു ഫയലിൽ .smf. എങ്കിൽപ്പോലും അത് പേരുകൾ തിരികെ നൽകും
അവ അഭിപ്രായങ്ങളിൽ കാണപ്പെടുന്നു, പക്ഷേ അത് ശരിയാണ് (അധിക ഫയലുകൾ ക്ഷമിക്കുന്ന സംവിധാനം;
നഷ്ടപ്പെട്ട ഫയൽ എപ്പോൾ ശ്രദ്ധിക്കപ്പെടുമെന്ന അനുമാനത്തിൽ അവ അവഗണിക്കപ്പെടുന്നു
പ്രോഗ്രാം, ഈ ഉദാഹരണത്തിൽ, smfgen, യഥാർത്ഥത്തിൽ അഭ്യർത്ഥിച്ചിരിക്കുന്നു).

ഒരു സ്‌കാനർ നൽകിയിട്ടുള്ള സോഴ്‌സ് ഫയലിന് വേണ്ടിയുള്ള ചില ടാർഗെറ്റ് ആവശ്യമാണെങ്കിൽ മാത്രമേ അത് ആവശ്യപ്പെടുകയുള്ളൂ
വൃക്ഷം. തന്നിരിക്കുന്ന ഒരു സോഴ്സ് ഫയലിനായി ഇത് ഒരിക്കൽ മാത്രമേ അഭ്യർത്ഥിക്കുകയുള്ളൂ.

അതേ സ്കാനർ നിർമ്മിക്കാനുള്ള മറ്റൊരു വഴി ഇതാ. ഇത് ഒരു വ്യക്തമായ കോഡ് റഫറൻസ് ഉപയോഗിക്കുന്നു,
കൂടാതെ (അനാവശ്യമായി, ഈ സാഹചര്യത്തിൽ) മുഴുവൻ ഫയലും വായിക്കുന്നു:

സബ് മൈസ്കാൻ {
എന്റെ (@ഉൾപ്പെടുന്നു);
ചെയ്യുക {
പുഷ് (@ഉൾപ്പെടുന്നു, /\b\S*?\.smf\b/g);
} സമയത്ത് ;
@ഉൾപ്പെടുന്നു
}

ലൂപ്പിന്റെ ക്രമം വിപരീതമാണ്, അവസാനം ലൂപ്പ് ടെസ്റ്റ് ഉള്ളത് ശ്രദ്ധിക്കുക. ഇതാണ്
കാരണം ആദ്യ വരി നിങ്ങൾക്കായി വായിച്ചുകഴിഞ്ഞു. ഈ സ്കാനർ ഒരു ഉറവിടത്തിൽ ഘടിപ്പിക്കാം
ഫയൽ ചെയ്തത്:

QuickScan $env \myscan, "$_.smf";

പിന്തുണ ഒപ്പം നിർദ്ദേശങ്ങൾ

ഉപയോക്തൃ കമ്മ്യൂണിറ്റിയാണ് ദോഷങ്ങൾ പരിപാലിക്കുന്നത്. സബ്‌സ്‌ക്രൈബ് ചെയ്യാൻ, മെയിൽ അയയ്‌ക്കുക ദോഷങ്ങൾ-ചർച്ച-
[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു] ശരീരം കൊണ്ട് സബ്സ്ക്രൈബുചെയ്യുന്നതിനും.

എന്നതിലൂടെ എന്തെങ്കിലും നിർദ്ദേശങ്ങൾ അറിയിക്കുക [ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു] അയക്കേണ്ട പട്ടിക.

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