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

പട്ടിക:

NAME

makepp_rules -- എന്തെങ്കിലും നിർമ്മിക്കാൻ മേക്കപ്പിനോട് എങ്ങനെ പറയും

വിവരണം

?: &,
-,
@, B: :build_cache,
:ബിൽഡ്_ചെക്ക്, D: :അയയ്ക്കുക, E: :env, I: "ignore_error",
:ഉൾപ്പെടുന്നു, L: :അവസാനത്തെ അവസരം, M: മേക്കപ്പർ, N: "നോക്കോ", P: :പാഴ്സർ,
"പേൾ", S: :കയ്യൊപ്പ്

ഒരു ഫയൽ അല്ലെങ്കിൽ ഒരു ക്ലാസ് ഫയലുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് മേക്കപ്പിനോട് പറയുന്നത് ഒരു റൂൾ ആണ്. മേക്കപ്പ് പിന്തുണയ്ക്കുന്നു
മേക്കിന്റെ മറ്റ് നിർവ്വഹണങ്ങളുടെ അതേ റൂൾ വാക്യഘടനയും കൂടാതെ അതിന്റേതായ ചില കൂട്ടിച്ചേർക്കലുകളും.

ഒരു നിയമത്തിന് പൊതുവായ രൂപമുണ്ട്

ടാർഗെറ്റ്_എക്സ്പ്രഷൻ : ഡിപൻഡൻസി_എക്സ്പ്രഷൻ [ : ഓപ്ഷണൽ ആർഗ്യുമെന്റുകൾ]
ഓഹരി

ടാർഗെറ്റുകളുടെ പട്ടികയിൽ യാന്ത്രിക വേരിയബിളുകളൊന്നും അടങ്ങിയിരിക്കണമെന്നില്ല ("$(foreach)" ഒഴികെ). ദി
ഡിപൻഡൻസി ലിസ്റ്റിൽ ടാർഗെറ്റിനെ പരാമർശിക്കുന്ന ഓട്ടോമാറ്റിക് വേരിയബിളുകൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ (അതായത്,
"$(ഔട്ട്പുട്ട്)", "$(ഔട്ട്പുട്ടുകൾ)", അല്ലെങ്കിൽ അവയുടെ പര്യായങ്ങൾ). പ്രവർത്തനത്തിൽ ഏതെങ്കിലും സ്വയമേവ അടങ്ങിയിരിക്കാം
വേരിയബിളുകൾ.

റൂൾ എക്സിക്യൂട്ട് ചെയ്യണമെന്ന് makepp തീരുമാനിക്കുകയാണെങ്കിൽ, റൂളിന്റെ ഓരോ വരിയും എക്സിക്യൂട്ട് ചെയ്യപ്പെടും
ക്രമാനുഗതമായി, ഏതെങ്കിലും പൂജ്യം അല്ലാത്ത അവസ്ഥ തിരികെ നൽകിയാൽ, ബാക്കിയുള്ളവ നടപ്പിലാക്കില്ല (കൂടാതെ
നിങ്ങൾ കമാൻഡ് ലൈനിൽ "-k" ഓപ്ഷൻ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, makepp ഒരു പിശകിനാൽ നിർത്തലാക്കുന്നു.)
ഓരോ പ്രവർത്തനവും ഒരു വരി മാത്രമായിരിക്കണം. ഒരു പ്രവർത്തനം വളരെ ദൈർഘ്യമേറിയതാണെങ്കിൽ a-യിൽ സൗകര്യപ്രദമായി എഴുതാൻ
സിംഗിൾ ലൈൻ, നിങ്ങൾക്ക് അതിനെ പല വരികളായി വിഭജിച്ച് ഒരു ബാക്ക്സ്ലാഷ് ഇടാൻ കഴിയും
നിരവധി വരികൾ ഒന്നായി കൂട്ടിച്ചേർക്കണം.

അടുത്ത നിയമത്തിൽ നിന്ന് പ്രവർത്തനങ്ങളെ വേർതിരിച്ചറിയാൻ, പ്രവർത്തനം കൂടുതൽ ഇൻഡന്റ് ചെയ്യണം
ടാർഗെറ്റുകളും ഡിപൻഡൻസികളും അടങ്ങുന്ന വരിയെക്കാൾ. മറ്റ് നടപ്പാക്കലുകളിൽ നിന്ന് വ്യത്യസ്തമായി
ഉണ്ടാക്കുക, നിങ്ങൾ അത് എത്രമാത്രം ഇൻഡന്റ് ചെയ്യുന്നു എന്നോ ടാബ് പ്രതീകങ്ങൾ ഉപയോഗിക്കുന്നുണ്ടോ എന്നോ മേക്കപ്പ് കാര്യമാക്കുന്നില്ല
പകരം ഇടങ്ങൾ. പരമ്പരാഗത നിർമ്മാണവുമായി പിന്നാക്ക അനുയോജ്യത നിലനിർത്താൻ, നിയമങ്ങൾ
പ്രവർത്തനങ്ങൾ എപ്പോൾ അവസാനിക്കുകയും അടുത്ത നിയമം ആരംഭിക്കുകയും ചെയ്യണമെന്ന് തീരുമാനിക്കാൻ makepp ഉപയോഗിക്കുന്നു:

· ആദ്യ ആക്ഷൻ ലൈൻ ടാർഗെറ്റ് ഉൾക്കൊള്ളുന്ന ലൈനേക്കാൾ കൂടുതൽ ഇൻഡന്റ് ചെയ്യണം.

· ഒരു ടാബ് പ്രതീകമോ 8 സ്‌പെയ്‌സുകളോ അതിലധികമോ ഒരു വരി ഇൻഡന്റ് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, അത് പരിഗണിക്കും
ഒരു ആക്ഷൻ ലൈൻ.

വലത് മാർജിനിൽ "#" എന്ന അക്ഷരമുള്ള ഒരു ശൂന്യമായ വരി അല്ലെങ്കിൽ ഒരു കമന്റ് ലൈൻ അവസാനിക്കുന്നു
നിയമം, അടുത്ത നോൺ-ബ്ലാങ്ക് ലൈൻ 8 സ്‌പെയ്‌സുകളിൽ കൂടുതൽ (അല്ലെങ്കിൽ ഒന്നിൽ കൂടുതൽ) ഇൻഡന്റ് ചെയ്‌തിട്ടില്ലെങ്കിൽ
ടാബ്).

· ഒരു വരി ആദ്യ ആക്ഷൻ ലൈനിനേക്കാൾ കൂടുതലോ അതിലധികമോ ഇൻഡന്റ് ചെയ്തിട്ടുണ്ടെങ്കിൽ, അത്
ഒരു അധിക പ്രവർത്തന രേഖയായി കണക്കാക്കുന്നു.

ചില പ്രത്യേക പ്രവർത്തന ഇനങ്ങൾ ഉണ്ട്:

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

ബിൽറ്റ്-ഇൻ, മേക്ക്ഫയൽ നൽകിയ അല്ലെങ്കിൽ ബാഹ്യ കമാൻഡ് കാര്യക്ഷമമായി വിളിക്കാൻ ഇത് അനുവദിക്കുന്നു.
"&" എന്ന പ്രിഫിക്‌സ് തിരഞ്ഞെടുത്തു, കാരണം ഇത് പേളിലെ ഫംഗ്‌ഷൻ ഇൻവോക്കർ ആയതിനാൽ, കാരണം
തുടക്കത്തിൽ ഇത് ഷെല്ലിൽ നിയമവിരുദ്ധമാണ്.

$(റൂട്ട്)/ഉൾപ്പെടുത്തുക/%.h: %.h
&ln $(ഇൻപുട്ട്) $(ഔട്ട്പുട്ട്)

noecho
@ സാധാരണയായി, ഓരോ ഷെൽ കമാൻഡും എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ പ്രിന്റ് ചെയ്യുന്നു. എന്നിരുന്നാലും, ആദ്യ വാക്ക് എങ്കിൽ
പ്രവർത്തനത്തിന്റെ "noecho" (അല്ലെങ്കിൽ അത് "@" എന്ന അക്ഷരത്തിൽ ആരംഭിക്കുകയാണെങ്കിൽ), തുടർന്ന് കമാൻഡ്
അച്ചടിച്ചിട്ടില്ല. ഉദാഹരണത്തിന്,

%.o: %.cxx
noecho $(LIBTOOL) --mode=compile $(CC) -c $(ഇൻപുട്ട്)

ഇതിനർത്ഥം libtool കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, അത് പ്രിന്റ് ചെയ്യപ്പെടുന്നില്ല എന്നാണ്. (ലിബ്ടൂൾ
അത് എക്സിക്യൂട്ട് ചെയ്യുന്ന പരിഷ്കരിച്ച കമാൻഡ് സാധാരണയായി പ്രിന്റ് ചെയ്യുന്നു, അതിനാൽ ഇത് അനാവശ്യമാണ്
രണ്ടുതവണ പ്രിന്റ് ചെയ്യുക.)

അവഗണിക്കുക_പിശക്
- സാധാരണയായി, ഷെൽ കമാൻഡ് പൂജ്യമല്ലാത്ത ഒരു സ്റ്റാറ്റസ് നൽകുന്നുവെങ്കിൽ, makepp അബോർറ്റ് ചെയ്യുന്നു
കമാൻഡ് പരാജയപ്പെട്ടു. എന്നിരുന്നാലും, ചില പ്രോഗ്രാമുകൾ പുറത്തുകടക്കുമ്പോൾ സ്റ്റാറ്റസ് തെറ്റായി സജ്ജീകരിക്കുന്നു, അല്ലെങ്കിൽ
യഥാർത്ഥത്തിൽ മാരകമല്ലാത്ത ഒരു പിശക് ഉണ്ടായേക്കാം
സമാഹാരം. റിട്ടേൺ സ്റ്റാറ്റസ് വ്യക്തമാക്കുന്നതിലൂടെ നിങ്ങൾക്ക് makepp അവഗണിക്കാൻ കഴിയും
"ignore_error" കമാൻഡ് ലൈനിലെ ആദ്യ പദമായി (അല്ലെങ്കിൽ "-" ആദ്യ പ്രതീകമായി).
ഉദാഹരണത്തിന്,

$(വ്യാജ വിതരണം):
അവഗണിക്കുക_പിശക് rm -r my_program-$(VERSION) # മുമ്പത്തെ ജങ്ക് ഒഴിവാക്കുക.
&mkdir my_program-$(VERSION)
&cp $(FILES) my_program-$(VERSION)
tar cf my_program-$(VERSION).tar my_program-$(VERSION)

ഈ കമാൻഡ് ഒരു ഡയറക്ടറി ഉണ്ടാക്കുന്നു, അതിലേക്ക് ഒരു കൂട്ടം ഫയലുകൾ പകർത്തുന്നു, തുടർന്ന് ഇടുന്നു
വിതരണത്തിനായി എല്ലാം ഒരു ടാർ ഫയലാക്കി. ഇത് വൃത്തിയാക്കുന്നത് നല്ലതാണ്
ഡയറക്‌ടറിയിലെ മുൻ ഉള്ളടക്കങ്ങൾ, മുമ്പ് എന്തെങ്കിലും ഉണ്ടായിരുന്നെങ്കിൽ, അതാണ്
ആദ്യ വരി എന്താണ് ചെയ്യുന്നത്. "rm" പരാജയപ്പെട്ടേക്കാം, എന്നാൽ അതിന്റെ റിട്ടേൺ നില അവഗണിക്കപ്പെടും.

മുത്ത്
makeperl
ഇത് പ്രധാനമായും perl പ്രസ്താവനയ്ക്ക് സമാനമാണ്, എന്നാൽ ഓരോ തവണയും ഇത് നടപ്പിലാക്കുന്നു
റൂൾ പ്രവർത്തിപ്പിക്കുക, മേക്ക്ഫിൽ വായിക്കുമ്പോൾ അല്ല. ആദ്യത്തെ വേരിയന്റ് പ്ലെയിൻ പേൾ ആണ്
കോഡ്, രണ്ടാമത്തെ വേരിയൻറ് ആദ്യം മേക്ക്-സ്റ്റൈൽ വേരിയബിളിലൂടെ സ്റ്റേറ്റ്മെന്റ് കൈമാറുന്നു
വിപുലീകരണം

ശരീരത്തിന്റെ ബ്രേസുകൾ ഇടുന്നതിനുള്ള രണ്ട് സാധ്യതകൾക്കായി, ഇവിടെ വിശദീകരണം കാണുക
makepp_statements-ൽ "perl_perlcode". മൂന്നാമത്തെ വേരിയന്റ് അവിടെ വിശദീകരിച്ചത് ശ്രദ്ധിക്കുക
ഇവിടെ അർത്ഥമില്ല, കാരണം എല്ലാ പ്രവർത്തന ലൈനുകളും ഇൻഡന്റ് ചെയ്തിരിക്കണം. നിങ്ങൾ സിഗ്നൽ ചെയ്യണം
"ഡൈ" എന്ന് വിളിച്ച് പേൾ പ്രസ്താവനകളിലെ പരാജയം.

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

$(ഫോണി പതിപ്പ്):
noecho perl {{ # $(ലക്ഷ്യം) & $(VERSION) പേളിൽ നിന്ന്:
പ്രിന്റ് "ഇത് ".f_target()." $VERSION\n";
}}
echo നിങ്ങൾക്ക് ഇത് ഷെൽ കമാൻഡുകളുമായി മിക്സ് ചെയ്യാം
-makeperl {print "ഇത് $(ലക്ഷ്യം) $(VERSION)\n" }

പല തരത്തിലുള്ള നിയമങ്ങളുണ്ട്, ഓരോന്നിനും വ്യത്യസ്ത ഉദ്ദേശ്യങ്ങളുണ്ട്.

പ്രായപൂർത്തിയായവർക്കുള്ളത് നിയമങ്ങൾ
ലക്ഷ്യം1 ലക്ഷ്യം2: ആശ്രിതത്വം1 ആശ്രിതത്വം2 ...
നടത്തേണ്ട പ്രവർത്തനങ്ങൾ

ഒന്നുകിൽ ഉണ്ടാക്കാൻ വേണ്ടി ഈ വാക്യഘടന വ്യക്തമാക്കുന്നു ലക്ഷ്യം1 or ലക്ഷ്യം2, എല്ലാ ഫയലുകളും
ആശ്രിതത്വം1, ആശ്രിതത്വം2മുതലായവ, ഇതിനകം ഉണ്ടാക്കിയിരിക്കണം. അപ്പോൾ നൽകിയിരിക്കുന്ന പ്രവർത്തനങ്ങൾ
ടാർഗെറ്റുകൾ നിർമ്മിക്കാൻ ഷെൽ ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു.

ഒരു ഫയലിലെ ആദ്യത്തെ വ്യക്തമായ നിയമം ഡിഫോൾട്ട് ടാർഗെറ്റാണ്, നിങ്ങൾ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ അത് നിർമ്മിക്കപ്പെടും
കമാൻഡ് ലൈനിലെ ഏതെങ്കിലും ടാർഗെറ്റുകൾ.

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

y.tab.c y.tab.h : parser.y
$(YACC) -d parser.y

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

· റൂൾ ആക്ഷൻ $@ എന്ന ഓട്ടോമാറ്റിക് വേരിയബിളിനെ പരാമർശിക്കുന്നു. (പര്യായങ്ങൾ "$(ഔട്ട്പുട്ട്)" അല്ലെങ്കിൽ
"$(ലക്ഷ്യം)" ഈ സ്വഭാവം ട്രിഗർ ചെയ്യരുത്.)

· റൂൾ ആക്ഷൻ ഓട്ടോമാറ്റിക് വേരിയബിൾ "$(ഔട്ട്പുട്ടുകൾ)" (അല്ലെങ്കിൽ അതിന്റെ പര്യായപദം) പരാമർശിക്കുന്നില്ല
"$(ലക്ഷ്യങ്ങൾ)").

· ഇതൊരു പാറ്റേൺ നിയമമല്ല, കൂടാതെ ഫോർച്ച് ക്ലോസും ഇല്ല.

ഉദാഹരണത്തിന്,

എല്ലാ ടെസ്റ്റ് ഇൻസ്റ്റാളും:
$(SUBDIRS) എന്നതിലെ സബ്ദിറിനായി; സിഡി ചെയ്യുക $$subdir && $(ഉണ്ടാക്കുക) $@; cd ..; ചെയ്തു

മേക്ക് ഫയലുകളിലെ ഒരു സാധാരണ ഐഡിയം ആണ്, makepp അതിനെ പിന്തുണയ്ക്കുന്നു. (നിങ്ങൾ ഒരിക്കലും ഉപയോഗിക്കരുത് എന്നത് ശ്രദ്ധിക്കുക
നിങ്ങൾ എഴുതുന്ന ഏതൊരു പുതിയ മേക്ക് ഫയലുകളിലും ആവർത്തനരൂപം ഉണ്ടാക്കുക--"load_makefile" പ്രസ്താവന ഉപയോഗിക്കുക, അല്ലെങ്കിൽ
പകരം ഇംപ്ലിസിറ്റ് മേക്ക് ഫയൽ ലോഡിംഗ്.)

ഓരോ ലക്ഷ്യത്തിനും ഒരേ നിയമം ഒരിക്കൽ നിർവ്വഹിക്കണമെങ്കിൽ (ഉദാ, ലക്ഷ്യങ്ങൾ
സമാനമായ കമാൻഡുകൾ ഉണ്ട്), ഒരു പാറ്റേൺ റൂൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത് (ചുവടെ കാണുക) അല്ലെങ്കിൽ a
"ഫോറച്ച്" ക്ലോസ്. ഉദാഹരണത്തിന്, ഒരു പരമ്പരാഗത മേക്ക് പ്രോഗ്രാം ഉണ്ടെങ്കിൽ നിങ്ങൾ എഴുതും:

എ ബി സി ഡി:
നിർമ്മിക്കാൻ_എന്തെങ്കിലും ചെയ്യുക $@ > $@

makepp-ൽ, നിങ്ങൾ ഇത് ഇതുപോലെ എഴുതാൻ ആഗ്രഹിച്ചേക്കാം:

$(foreach) :: foreach abcd
$(ഔട്ട്‌പുട്ട്) > $(ഔട്ട്‌പുട്ട്) നിർമ്മിക്കാൻ_എന്തെങ്കിലും ചെയ്യുക

ഫോണി ലക്ഷ്യങ്ങൾ

A വ്യാജൻ ലക്ഷ്യം ഫയൽ സിസ്റ്റത്തിൽ യഥാർത്ഥത്തിൽ ഒരിക്കലും നിലനിൽക്കാത്ത ഒരു ലക്ഷ്യമാണ്; അത് വെറും ഒരു
ചില ടാർഗെറ്റുകൾ നിർമ്മിക്കുന്നതിനും ചില അധിക കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനും മേക്കപ്പ് നേടുന്നതിനുള്ള മാർഗം.

ഒരു സാധാരണ വ്യാജ ലക്ഷ്യം "എല്ലാം" ആണ്, ഇത് സാധാരണയായി സാധ്യമായ എല്ലാത്തിനും കാരണമാകുന്നു
നിർമ്മിക്കാൻ നിർമ്മിച്ചത്, ഇതുപോലെ:

എല്ലാം: prog1 prog2 subdir/prog3 subdir2/libmine.a
@&echo "എല്ലാം ചെയ്തു!"

നിങ്ങൾ "makepp all" എന്ന് ടൈപ്പ് ചെയ്യുകയാണെങ്കിൽ, അല്ലെങ്കിൽ എല്ലാം നിങ്ങളുടെ മേക്ക് ഫയലിലെ ആദ്യ വ്യക്തമായ ടാർഗെറ്റായി ഇട്ടാൽ
(ഇത് സാധാരണമാണ്) കൂടാതെ "makepp" എന്ന് ടൈപ്പ് ചെയ്യുക, തുടർന്ന് അത് എല്ലാ ഡിപൻഡൻസികളും ആകും
നിർമ്മിച്ചു, അപ്പോൾ അത് "എല്ലാം ചെയ്തു!" എന്ന് പ്രിന്റ് ചെയ്യും. ഈ സമയത്ത്, makepp ഫയലിനായി നോക്കും ./എല്ലാം
അത് നിലവിലില്ലെന്ന് കണ്ടെത്തുകയും ചെയ്യും. ഉറക്കെ പരാതി പറയും.

ഫയൽ പ്രതീക്ഷിക്കുന്നതിൽ നിന്ന് makepp നിലനിർത്താൻ ./എല്ലാം പുറത്തുകടക്കാൻ, അത് ഒരു ആണെന്ന് നിങ്ങൾ പറയേണ്ടതുണ്ട്
വ്യാജ ലക്ഷ്യം. നിങ്ങളുടെ മേക്ക് ഫയലിൽ ഇനിപ്പറയുന്നതുപോലുള്ള ഒരു ലൈൻ ഇടുക (ഇത് ഒരു വ്യത്യാസവുമില്ല
എവിടെ):

.ഫോണി: എല്ലാം

"$(phony )" ഉപയോഗിക്കുന്നതാണ് ചിലപ്പോൾ കൂടുതൽ സൗകര്യപ്രദമായ തത്തുല്യമായ ബദൽ
പ്രവർത്തനം, ഇതുപോലെ:

$(എല്ലാം വ്യാജം): prog1 prog2 subdir/prog3 subdir2/libmine.a

ഒരു മേക്ക് ഫയലിലെ ഫോണി ടാർഗെറ്റുകൾക്ക് മറ്റൊരു മേക്ക് ഫയലിലെ വ്യാജ ടാർഗെറ്റുകളെ സൂചിപ്പിക്കാൻ കഴിയും. ഇതാണ്
പലപ്പോഴും "വൃത്തിയുള്ള" ടാർഗെറ്റിലാണ് ചെയ്യുന്നത്, ഇതുപോലെ:

# ഉയർന്ന തലത്തിലുള്ള മേക്ക് ഫയൽ:
# ധാരാളം നിയമങ്ങളും കാര്യങ്ങളും ഇവിടെയുണ്ട്
# ....
$(phony clean): subdir1/clean subdir2/clean
&rm -fm my_program

ഉപഡയറക്‌ടറികളിൽ, മേക്ക്‌ഫയലുകൾ ഇതുപോലെ വായിക്കാം:

# ഒരു ഉപഡയറക്‌ടറിയിൽ ഫയൽ ഉണ്ടാക്കുക
#...
$(ഫോണി ക്ലീൻ):
&rm -fm $(വൈൽഡ്കാർഡ് *.o *.a)

എന്നാൽ ഇക്കാലത്ത് നിങ്ങൾ ഒരു ക്ലീൻ ടാർഗെറ്റിന് പകരം "makeppclean" കമാൻഡ് ഉപയോഗിക്കും.

വൈൽഡ്കാർഡുകൾ

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

libmine.a: *.o
&rm -f $(ഔട്ട്പുട്ട്)
ar cr $(ഔട്ട്പുട്ട്) $(ഇൻപുട്ടുകൾ)

".o" ഫയലുകളൊന്നും ഇതുവരെ സൃഷ്ടിച്ചിട്ടില്ലെങ്കിലും ഇത് പ്രവർത്തിക്കും, കാരണം makepp ന്റെതാണ്
വൈൽഡ്കാർഡുകൾ ഇതുവരെ നിലവിലില്ലാത്തതും നിർമ്മിക്കാൻ കഴിയുന്നതുമായ ഫയലുകളുമായി പൊരുത്തപ്പെടുന്നു. ഇത് പോലും എടുക്കും
റൂൾ പിന്നീട് കണ്ടെത്തിയ ഫയലുകൾ (അതേ മേക്ക് ഫയലിൽ, അല്ലെങ്കിൽ ഇതുവരെ വായിച്ചിട്ടില്ലാത്ത ഒന്ന്). ഇതിൽ
അവസാന പോയിന്റ് "വൈൽഡ്കാർഡ്" ഫംഗ്ഷനിൽ നിന്ന് വ്യത്യസ്തമാണ്, അത് അറിയപ്പെടുന്ന നിയമങ്ങളിൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു,
കാരണം അത് വികസിക്കുമ്പോൾ അതിന്റെ ഫലം തിരികെ നൽകണം.

Makepp എല്ലാ സാധാരണ ഷെൽ വൈൽഡ്കാർഡുകളെയും ("*", "?", കൂടാതെ "[]") പിന്തുണയ്ക്കുന്നു. ഇതിന് ഒരു ഉണ്ട്
വൈൽഡ്കാർഡ് "**" ഏത് ഇന്റർവെൻസിംഗ് ഡയറക്‌ടറികളുമായി പൊരുത്തപ്പെടുന്നു. (ഈ ആശയം മോഷ്ടിക്കപ്പെട്ടതാണ്
zsh-ൽ നിന്ന്.) ഉദാഹരണത്തിന്, "**/*.c" എല്ലാം പൊരുത്തപ്പെടുന്നു .c മുഴുവൻ സോഴ്സ് ട്രീയിലെയും ഫയലുകൾ.
"objects/**/*.o" എല്ലാം പൊരുത്തപ്പെടുന്നു .o ഉപഡയറക്‌ടറിയിൽ എവിടെയും അടങ്ങിയിരിക്കുന്ന ഫയലുകൾ വസ്തുക്കൾ
അല്ലെങ്കിൽ അതിന്റെ ഏതെങ്കിലും ഉപഡയറക്‌ടറികൾ അല്ലെങ്കിൽ അവയുടെ ഏതെങ്കിലും ഉപഡയറക്‌ടറികൾ. "**" വൈൽഡ്കാർഡ് ചെയ്യില്ല
ഏത് തലത്തിലുള്ള ഡയറക്ടറികളിലേക്കും സോഫ്റ്റ് ലിങ്കുകൾ പിന്തുടരുക. ഇത് ഒരിക്കലും വ്യാജ ലക്ഷ്യങ്ങളെ തിരികെ നൽകില്ല.

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

ഇത് സുരക്ഷിതമാണെന്നാണ് പ്രാഥമിക നിഗമനം. ഇത് പ്രവർത്തിക്കുന്നു എന്ന അർത്ഥത്തിലാണ് ഇത്
ഫയലുകൾ ഇതിനകം നിലവിലുണ്ട്, അല്ലെങ്കിൽ ആദ്യം നിർമ്മിക്കേണ്ടതുണ്ട്. എന്നിരുന്നാലും ഇത് അർത്ഥത്തിൽ സുരക്ഷിതമല്ല
makepp നിർമ്മിച്ച ഫയലുകളുമായി ഇത് ഇപ്പോഴും പൊരുത്തപ്പെടും, എന്നാൽ ഇനി ഒരു നിയമവുമില്ല (ഉദാ
നിങ്ങൾ നീക്കം ചെയ്തു .c ഫയൽ, എന്നാൽ .o ഫയൽ ഇപ്പോഴും അവിടെയുണ്ട്.) ഇത് തടയാൻ, ഉപയോഗിക്കുക
"--rm-stale" ഓപ്ഷൻ.

മാതൃക നിയമങ്ങൾ
ചില വാചക പാറ്റേണിനെ അടിസ്ഥാനമാക്കി പ്രയോഗിക്കുന്ന ഒരു നിയമമാണ് പാറ്റേൺ റൂൾ. ഇത് പതിവാണ്
ഒരു മുഴുവൻ തരം ഫയലുകളിലും ഇതേ നിയമം പ്രയോഗിക്കുക. വാക്യഘടനയും ഗ്നു മേക്കിന്റെ സമാനമാണ്
പാറ്റേൺ നിയമങ്ങൾ:

%.o: %.c
$(CC) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

നിലവിലെ ഡയറക്‌ടറിയിൽ "*.c" എന്നതുമായി പൊരുത്തപ്പെടുന്ന ഏത് ഫയലും പരിവർത്തനം ചെയ്യാമെന്ന് ഇത് പറയുന്നു
നൽകിയിരിക്കുന്ന കമാൻഡ് ഉപയോഗിച്ച് അനുബന്ധ .o ഫയൽ.

നിരവധി പാറ്റേൺ ഡിപൻഡൻസികൾ നൽകിയേക്കാമെന്നത് ശ്രദ്ധിക്കുക. ഉദാഹരണത്തിന്, നിങ്ങളുടേതാണെങ്കിൽ xyz.o ഫയല്
ബന്ധപ്പെട്ടതിനെ ആശ്രയിച്ചിരിക്കുന്നു xyz.cpp ഫയൽ, കൂടാതെ ഒരു ഫയലിലും moc_xyz.cflags ഏത്
കംപൈലർ ഓപ്‌ഷനുകൾ അടങ്ങിയിരിക്കുന്നു, ഇത് ഇനിപ്പറയുന്നവ ഉപയോഗിച്ച് പ്രകടിപ്പിക്കാം:

%.o: %.cpp %.cflags
$(CXX) `പൂച്ച $(സ്റ്റെം).cflags` -c $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്)

നിങ്ങൾക്ക് നിരവധി പാറ്റേൺ ലക്ഷ്യങ്ങളും ഉണ്ടായിരിക്കാം. ഉദാഹരണത്തിന്,

%.tab.h %.tab.c : %.y
yacc -d $(ഇൻപുട്ട്)
&mv y.tab.h $(stem).tab.h
&mv y.tab.c $(stem).tab.c

സാധാരണഗതിയിൽ, പാറ്റേൺ നിയമങ്ങൾ നിലവിലെ ഡയറക്‌ടറികളിലെ ഫയലുകൾക്കായി മാത്രമേ നോക്കൂ. നിങ്ങൾക്ക് നിർബന്ധിക്കാം
നിലവിലെ ഡയറക്‌ടറിയിലും അതിനു താഴെയുള്ള എല്ലാ ഡയറക്‌ടറികളിലും ക്രമീകരണം വഴി തിരയാൻ അവ

makepp_percent_subdirs := 1

നിങ്ങളുടെ മേക്ക്‌ഫൈലിലെ ആദ്യ പാറ്റേൺ റൂളിന് മുമ്പ് അല്ലെങ്കിൽ ഉദാഹരണത്തിന് കമാൻഡ് ലൈനിൽ.

"%" ഉം വൈൽഡ്കാർഡ് "*" ഉം തമ്മിൽ വ്യക്തമായ വ്യത്യാസമുണ്ട്, എന്നിരുന്നാലും ഇവ രണ്ടും തമ്മിൽ പൊരുത്തപ്പെടുന്നു
string: വൈൽഡ്കാർഡ് ആ ഘട്ടത്തിൽ പൂർണ്ണമായും ഉപയോഗിച്ച ഫയലുകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു. അങ്ങനെ
ഇത് എല്ലാവരെയും ആശ്രയിച്ചിരിക്കുന്നു .o ഇവിടെ നിർമ്മിക്കാവുന്ന ഫയലുകൾ:

പ്രോഗ്: *.ഒ
$(LD) $(LDFLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്)

"*" എന്നതിന് പകരം "%" ഉപയോഗിച്ച് ഇത് നേടാനായില്ല, കാരണം രണ്ടാമത്തേത് ഓരോന്നായി
ഇൻപുട്ട് ഔട്ട്പുട്ടുമായി പൊരുത്തപ്പെടുത്തൽ, പൊരുത്തപ്പെടുന്ന ഓരോ തണ്ടിനും ആന്തരികമായി ഒരു നിയമം നിർമ്മിക്കുന്നു.

സ്റ്റാറ്റിക് പാറ്റേൺ നിയമങ്ങൾ
ഒരു സ്റ്റാറ്റിക് പാറ്റേൺ റൂൾ എന്നത് ഒരു പരിമിതമായ ഫയലുകളിൽ മാത്രം പ്രയോഗിക്കുന്ന ഒരു പാറ്റേൺ റൂളാണ്:

$(SPECIAL_MODULES).o : %.o : %.cpp
$(CXX) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

"$(SPECIAL_MODULES).o" എന്നതിലെ ഫയലുകൾക്ക് മാത്രമേ പാറ്റേൺ നിയമം ബാധകമാകൂ എന്ന് ഇത് പറയുന്നു.

ഇത് കൂടുതലും ഗ്നു നിർമ്മാണവുമായി പൊരുത്തപ്പെടുന്നതിനാണ്; foreach നിയമങ്ങൾ (താഴെ കാണുക) കൂടുതൽ
ഒരേ കാര്യം ചെയ്യാനുള്ള ശക്തമായ മാർഗം.

ഫോറെച്ച് നിയമങ്ങൾ
മുകളിലുള്ള പാറ്റേൺ റൂൾ വാക്യഘടന മിക്കവാറും എല്ലാ ബിൽഡുകളെയും പിന്തുണയ്ക്കാൻ പര്യാപ്തമാണ്, പക്ഷേ
ഇടയ്ക്കിടെ കൂടുതൽ സങ്കീർണ്ണമായ എന്തെങ്കിലും ചെയ്യേണ്ടത് ആവശ്യമാണ്. Makepp കൂടുതൽ നൽകുന്നു
ശക്തമായ വാക്യഘടന: റൂളിനുള്ള ":foreach" ക്ലോസ്.

target_expression : ഡിപൻഡൻസി_എക്‌സ്‌പ്രഷൻ: ഫയൽ-ലിസ്റ്റ് ഫോറെച്ച്
ഓഹരി

ഏറ്റവും ലളിതമായ രീതിയിലുള്ള ഫോർച്ച് റൂൾ, ആപ്ലിക്കേഷൻ നിയന്ത്രിച്ചിരിക്കുന്ന ഒരു പാറ്റേൺ റൂൾ മാത്രമാണ്
ഫയലുകളുടെ ഒരു പ്രത്യേക ലിസ്റ്റിലേക്ക്. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് പറയുന്ന ഒരു പാറ്റേൺ റൂൾ ഉണ്ടെന്ന് കരുതുക
എല്ലാം കംപൈൽ ചെയ്യുന്നതെങ്ങനെയെന്ന് makepp .c ഫയലുകൾ. എന്നിരുന്നാലും, നിങ്ങൾക്ക് ഒരു ലിസ്റ്റ് ഉണ്ട് .c നിങ്ങൾക്കുള്ള ഫയലുകൾ
വ്യത്യസ്തമായ എന്തെങ്കിലും ചെയ്യാൻ ആഗ്രഹിക്കുന്നു. നിങ്ങൾക്ക് ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യാൻ കഴിയും:

# എല്ലാത്തിനും ബാധകമായ നിയമം ഇതാ:
%.o : %.c
$(CC) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

%.o : %.c : foreach $(SPECIAL_MODULES)
$(CC) $(SPECIAL_CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

ഫോർച്ച് നിയമങ്ങളുടെ കൂടുതൽ ശക്തമായ ഉപയോഗം വേരിയബിൾ എന്ന വസ്തുത പ്രയോജനപ്പെടുത്തുന്നു
"$(foreach)" എന്നത് ഫയൽ ലിസ്റ്റും ടാർഗെറ്റുമായി പൊരുത്തപ്പെടുന്ന ഓരോ ഫയലിലേക്കും ക്രമീകരിച്ചിരിക്കുന്നു
ആശ്രിതത്വ പദപ്രയോഗങ്ങൾ വിലയിരുത്തപ്പെടുന്നു. ഫയൽ-ലിസ്റ്റിൽ വൈൽഡ്കാർഡുകളും ഇവയും അടങ്ങിയിരിക്കാം
ഇതുവരെ നിലവിലില്ലാത്തതും എന്നാൽ നിർമ്മിക്കാൻ കഴിയുന്നതുമായ ഫയലുകളുമായി പോലും പൊരുത്തപ്പെടുത്തുക ("വൈൽഡ്കാർഡുകൾ" കാണുക
makepp_rules).

ഇതൊരു അനിയന്ത്രിതമായ വാക്യഘടനയാണ്, പക്ഷേ ഇത് വളരെ വഴക്കമുള്ളതാണ്, കാരണം "$(foreach)" വേരിയബിൾ
എക്സ്പ്രഷനിൽ ഏതെങ്കിലും വിധത്തിൽ പ്രത്യക്ഷപ്പെടാം. ആദ്യം, പാറ്റേൺ നിയമങ്ങൾ യഥാർത്ഥത്തിൽ a ആണെന്ന് ശ്രദ്ധിക്കുക
ഫോർച്ച് നിയമങ്ങളുടെ പ്രത്യേക കേസ്; പാറ്റേൺ നിയമം

%.o : %.c
$(CC) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

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

$(patsubst %.c, %.o, $(foreach)) : $(foreach) : foreach *.c
$(CC) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

(വാസ്തവത്തിൽ, ഇത് ആന്തരികമായി ഏകദേശം പരിവർത്തനം ചെയ്യപ്പെടുന്നു.)

ഒരു പാറ്റേൺ റൂൾ ഇല്ലാത്ത ഒരു ":foreach" ക്ലോസ് നിങ്ങൾ എങ്ങനെ ഉപയോഗിക്കും എന്നതിന്റെ ഒരു ഉദാഹരണമായി
മതി, നിങ്ങൾക്ക് കുറച്ച് ഉണ്ടെന്ന് കരുതുക .c ഏതെങ്കിലും തരത്തിലുള്ള പ്രീപ്രൊസസ്സർ ഉപയോഗിച്ച് നിർമ്മിച്ച ഫയലുകൾ
ഇത് ഒരു ഇൻപുട്ട് ഫയലുകളായി എടുക്കുന്നു .k വിപുലീകരണം. നിങ്ങൾ അവ സമാഹരിക്കാൻ ആഗ്രഹിക്കുന്നു .c എ ഉള്ള ഫയലുകൾ
സാധാരണയിൽ നിന്ന് വ്യത്യസ്തമായ കംപൈലേഷൻ ഓപ്ഷനുകൾ .c സാധാരണ ഉറവിടമായ ഫയലുകൾ
ഫയലുകൾ. നിങ്ങൾക്ക് ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യാൻ കഴിയും:

# സാധാരണ .c ഫയലുകൾക്കുള്ള നിയമം:
%.o : %.c
$(CC) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

# .k ഫയലുകളിൽ നിന്ന് .c ഫയലുകൾ നിർമ്മിക്കുന്നതിനുള്ള നിയമം:
%.c : %.k
$(പ്രിപ്രൊസസ്സർ) $(ഇൻപുട്ട്) > $(ഔട്ട്പുട്ട്)

# .k ഫയലുകളിൽ നിന്ന് നിർമ്മിച്ച .c ഫയലുകൾക്കായുള്ള പ്രത്യേക ബിൽഡ് നിയമങ്ങൾ:
$(foreach:%.k=%.o) : $(foreach:%.c=%.k) : foreach *.k
$(CC) $(SPECIAL_CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

(ഇത് വിളിക്കുന്നതിനേക്കാൾ അൽപ്പം കൂടുതൽ സംക്ഷിപ്തമായ സബ്സ്റ്റിറ്റ്യൂഷൻ റഫറൻസ് വാക്യഘടനയാണ് ഉപയോഗിക്കുന്നത്
"patsubst" വ്യക്തമായി.)

നിങ്ങൾ ചെയ്യേണ്ടത് ഒരു വേരിയബിളിന്റെ ("CFLAGS") മൂല്യം മാറ്റുക എന്നതാണ്.
കേസ്) ടാർഗെറ്റ്-നിർദ്ദിഷ്ട വേരിയബിളുകൾ ഉപയോഗിക്കുന്നത് ചിലപ്പോൾ കൂടുതൽ സൗകര്യപ്രദമാണ്.

ലെഗസി സഫിക്സ് നിയമങ്ങൾ
ബാക്ക്‌വേർഡ് കോംപാറ്റിബിളിറ്റിക്ക്, പഴയ രീതിയിലുള്ള സഫിക്സ് നിയമങ്ങളെ makepp പിന്തുണയ്ക്കുന്നു.

.suffix1.suffix2:
ഓഹരി

എന്നതിന് തുല്യമാണ്

%.suffix2: %.suffix1
ഓഹരി

എന്നാൽ ഓർക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്. (ഏത് പ്രത്യയമാണ് ആദ്യം വരുന്നത്?) സാധാരണ, ഒരു നിയമം ദൃശ്യമാകും
ഇതുപോലുള്ള ഒരു ലെഗസി മേക്ക്ഫയലിൽ:

.co:
$(CC) $(CFLAGS) -c $*.c -o $*.o

കൃത്യമായി തുല്യമാണ്

%.o : %.c
$(CC) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

സംഘട്ടനം നിയമങ്ങൾ
ഒരു ഫയൽ നിർമ്മിക്കാൻ ഒന്നിലധികം മാർഗങ്ങളുണ്ടെങ്കിൽ, makepp ഒരു ലളിതമായ നടപടിക്രമം ഉപയോഗിക്കുന്നു
ഏത് നിയമമാണ് ഉപയോഗിക്കേണ്ടതെന്ന് നിർണ്ണയിക്കുക.

· ഒരു ഫയൽ നിർമ്മിക്കുന്നതിന് പരസ്പരവിരുദ്ധമായ വ്യക്തമായ നിയമങ്ങൾ ഉള്ളത് ഒരു പിശകാണ്.

· പാറ്റേൺ നിയമങ്ങളും വൈൽഡ്കാർഡുകളുള്ള ഫോർച്ച് നിയമങ്ങളും ഒരിക്കലും വ്യക്തമായ നിയമങ്ങളെ മറികടക്കുന്നില്ല. അങ്ങനെ
പാറ്റേൺ നിയമങ്ങൾക്കുള്ള ഒഴിവാക്കലുകൾ വ്യക്തമാക്കുന്നതിന് വ്യക്തമായ നിയമങ്ങൾ ഉപയോഗിക്കാവുന്നതാണ്. (ലളിതമായി ശ്രദ്ധിക്കുക
ഒരു ":foreach" ക്ലോസ് ഉപയോഗിക്കുന്നത് എന്തെങ്കിലും ഒരു പാറ്റേൺ നിയമമാക്കുന്നില്ല. അതിന് ഒരു ഉണ്ടായിരിക്കണം
വൈൽഡ്കാർഡ് ("*" അല്ലെങ്കിൽ "?" പോലെ) ":foreach" ക്ലോസിലെ ഫയൽനാമത്തിന്റെ ഭാഗമായി. അങ്ങനെ എങ്കിൽ
ഫയലുകളുടെ ഒരു വ്യക്തമായ ലിസ്റ്റ്, അവ ഓരോന്നിനും ഒരു വ്യക്തമായ നിയമമായി കണക്കാക്കുന്നു
ഫയലുകൾ.)

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

ഇതിനർത്ഥം നിങ്ങളുടെ എല്ലാ ഫയലുകൾക്കും ബാധകമായ ഒരു പാറ്റേൺ നിയമം നിങ്ങൾക്ക് വ്യക്തമാക്കാം എന്നാണ്
മുഴുവൻ ഡയറക്‌ടറി ട്രീയും ഉയർന്ന തലത്തിലുള്ള മേക്ക്‌ഫയലിൽ മാത്രം, എന്നാൽ നിങ്ങൾക്ക് അത് അസാധുവാക്കാനാകും
ഒരു താഴ്ന്ന നിലയിലുള്ള മേക്ക് ഫയൽ. ഉദാഹരണത്തിന്, നിങ്ങളുടെ ഉയർന്ന തലത്തിലുള്ള മേക്ക് ഫയലിൽ ഇവ ഉൾപ്പെടാം:

%.o : %.c : foreach **/*.c
$(CC) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

ഉപഡയറക്‌ടറികളിലൊന്നിൽ നിങ്ങൾക്ക് ഒരു മേക്ക്‌ഫൈൽ ഉണ്ടായിരിക്കാം:

%.o : %.c
$(CC) $(SPECIAL_CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

· അനുമാനത്തിന്റെ ചെറിയ ശൃംഖലയുള്ള പാറ്റേൺ നിയമങ്ങൾ മറ്റ് പാറ്റേണുകളേക്കാൾ മുൻഗണന നൽകുന്നു
നിയമങ്ങൾ. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന നിയമങ്ങൾ ഉണ്ടെങ്കിൽ (ഇതിൽ നിന്നുള്ള ഒരു ഉദാഹരണത്തെ അടിസ്ഥാനമാക്കി
ലിനക്സ് കേർണൽ):

%.s: %.c
$(CC) -s $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

%.o: %.s
$(AS) $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

%.o: %.c
$(CC) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

നമുക്ക് "xyz.o" നിർമ്മിക്കണമെങ്കിൽ, ഒന്നുകിൽ നമുക്ക് ഇന്റർമീഡിയറ്റ് ".s" ഫയൽ നിർമ്മിക്കാം.
ആദ്യത്തെ രണ്ട് നിയമങ്ങൾ ഉപയോഗിച്ച് അസംബ്ലറിലൂടെ അത് പ്രവർത്തിപ്പിക്കുക, അല്ലെങ്കിൽ നമുക്ക് നേരിട്ട് a എന്നതിലേക്ക് പോകാം
അവസാന നിയമം ഉപയോഗിച്ച് ".o" ഫയൽ. കുറവുള്ളതിനാൽ അവസാന നിയമം മുൻഗണന നൽകുന്നു
അനുമാന ശൃംഖലയിലെ ഘട്ടങ്ങൾ (രണ്ടിന് പകരം ഒന്ന്).

· പിന്നീട് ഒരു മേക്ക്‌ഫൈൽ ഓവർറൈഡ് പാറ്റേൺ നിയമങ്ങളിൽ പാറ്റേൺ നിയമങ്ങൾ നേരത്തെയുള്ളതാണ്. (ഇത്
GNU-ൽ നിന്ന് പിന്നോട്ട്.) ഇതിനർത്ഥം നിങ്ങൾ കൂടുതൽ പൊതുവായ നിയമങ്ങൾ നൽകണം എന്നാണ്
നേരത്തെ, നിങ്ങളുടെ കൂടുതൽ നിർദ്ദിഷ്ട നിയമങ്ങൾ പിന്നീട്. ഉദാഹരണത്തിന്,

%.o: %.c # പൊതു സമാഹാര നിയമം.
നടപടി

special_%.o: special_%.c # a ഉള്ള ഫയലുകൾക്കുള്ള പ്രത്യേക നിയമം
വ്യത്യസ്ത പ്രവർത്തനം # "സ്പെഷ്യൽ_" പ്രിഫിക്സ്.

ചട്ടം ഓപ്ഷനുകൾ
മേക്കപ്പ് എങ്ങനെ എക്സിക്യൂട്ട് ചെയ്യുന്നു എന്ന് പരിഷ്കരിക്കുന്നതിന് ചിലപ്പോൾ അധിക ഓപ്ഷനുകൾ നൽകേണ്ടത് ആവശ്യമാണ്
ഭരണം. ഈ ഓപ്‌ഷനുകൾ അടങ്ങിയിരിക്കുന്ന വരിയിൽ ":optionname value" എന്ന് വ്യക്തമാക്കിയിരിക്കുന്നു
ഡിപൻഡൻസികൾ, അല്ലെങ്കിൽ അടുത്ത വരിയിൽ.

വെവ്വേറെ ലൈനുകളിൽ ഓപ്‌ഷനുകൾ നൽകുന്നത് നിങ്ങൾക്ക് അത് തന്നെ ഉപയോഗിക്കുന്നത് സാധ്യമാക്കിയേക്കാം
മേക്കപ്പും പരമ്പരാഗത നിർമ്മാണവും ഉള്ള makefile. ഉദാഹരണത്തിന്,

ലക്ഷ്യം: ആശ്രിതത്വം
: സിഗ്നേച്ചർ ടാർഗെറ്റ്_ന്യൂവർ
ഓഹരി

ഒരു പരമ്പരാഗത Unix നിർമ്മാണം നന്നായി പ്രവർത്തിക്കും, കാരണം അത് ": സിഗ്നേച്ചർ" ലൈൻ വ്യാഖ്യാനിക്കുന്നു
ഒരു ഷെൽ കമാൻഡ് പോലെ, കോളനിൽ തുടങ്ങുന്ന ഒരു കമാൻഡ് ഒന്നും ചെയ്യുന്നില്ല.

:build_cache /പാത്ത്/ടു/ബിൽഡ്/കാഷെ
ലക്ഷ്യം: ആശ്രിതത്വം
: build_cache /put/cache/files/over/there
ഓഹരി

ഈ നിയമം നിർമ്മിക്കുന്ന ഫയലുകൾക്കായി ഉപയോഗിക്കേണ്ട ഒരു ബിൽഡ് കാഷെയിലേക്കുള്ള പാത വ്യക്തമാക്കുന്നു. ഈ
"build_cache" പ്രസ്താവനയുടെയോ "--build-cache" കമാൻഡിന്റെയോ പ്രഭാവം അസാധുവാക്കുന്നു
ലൈൻ ഓപ്ഷൻ, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ, ഈ നിയമത്തിന്. നിർമ്മാണത്തെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് makepp_build_cache കാണുക
കാഷെകൾ.

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

:ബിൽഡ്_ചെക്ക് ബിൽഡ്_ചെക്ക്_രീതി
ലക്ഷ്യം: ആശ്രിതത്വം
: build_check target_new
ഓഹരി

ടാർഗെറ്റുകൾ പുനർനിർമ്മിക്കേണ്ടതുണ്ടോ എന്ന് തീരുമാനിക്കാൻ എന്ത് അൽഗോരിതം ഉപയോഗിക്കണമെന്ന് ഇത് makepp-നോട് പറയുന്നു.
കൂടുതൽ വിശദാംശങ്ങൾക്ക് makepp_build_check കാണുക. ഇത് ഫലത്തെ മറികടക്കുന്നു
"build_check" പ്രസ്താവന അല്ലെങ്കിൽ "--build-check-method" കമാൻഡ് ലൈൻ ഓപ്ഷൻ, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ,
ഈ നിയമം.

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

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

:അയയ്ക്കുക കമാൻഡ് ...
ഒരു "sh -c '...'"-ൽ ഓരോ ഷെൽ പ്രവർത്തനവും (പക്ഷേ പേൾ പ്രവർത്തനങ്ങളോ പേൾ കമാൻഡുകളോ അല്ല) ഉൾപ്പെടുത്തുക
കമാൻഡ് ഉപയോഗിച്ച് പ്രിഫിക്സ് ചെയ്യുക, പക്ഷേ ലക്ഷ്യം കമാൻഡിനെ ആശ്രയിക്കുന്നില്ലെന്ന് കരുതുക.
ഒരു ജോലി ക്യൂയിംഗ് സിസ്റ്റത്തിലേക്ക് പ്രവർത്തനങ്ങൾ അയയ്‌ക്കണമെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്, പക്ഷേ ഫലം
ക്യൂയിംഗ് പാരാമീറ്ററുകളിൽ നിന്നും ക്യൂയിംഗ് ആണോ എന്നതിൽ നിന്നും സ്വതന്ത്രമാണെന്ന് അനുമാനിക്കപ്പെടുന്നു
സിസ്റ്റം പൂർണ്ണമായും ഉപയോഗിക്കുന്നു.

:ഉൾപ്പെടുന്നു file_or_pattern
കംപൈലറിനെ ആശ്രയിച്ച് നിയമം വ്യത്യാസപ്പെടുന്നു:

%.o : %.c
: %.d ഉൾപ്പെടുന്നു: ഒപ്പ് സി
gcc -MD -c ...

%.o : %.c
: ഉൾപ്പെടുത്തുക %.u : സിഗ്നേച്ചർ C # IBM മറ്റൊരു പ്രത്യയം ഉപയോഗിക്കുന്നു
xlc -M -c...

subdependentify { # മൈക്രോസോഫ്റ്റിന്റെ സംഭാഷണം ഉപയോഗപ്രദമായ ഫോർമാറ്റിലേക്ക് മാറ്റുക
s/\$/\$\$/g;
s/(ശ്രദ്ധിക്കുക: ഫയൽ ഉൾപ്പെടെ: *)?(.+?)\r?\n/$1 ? "'$2' " : "'".f_output()."': "/e;
}
%.o : %.c
: %.d ഉൾപ്പെടുന്നു: ഒപ്പ് സി
cl -showIncludes -c ... >$(stem).d
&sed &dependify -o +<$(stem).d

ചില കംപൈലറുകൾക്ക് (മുകളിലുള്ള gcc പോലെയുള്ള ഇന്റലിന്റെ icc അല്ലെങ്കിൽ IBM-ന്റെ xlc) ഡിപൻഡൻസി ഉണ്ടാക്കാൻ കഴിയും
ഈച്ചയിൽ ഫയലുകൾ. അതായത്, അവർ കംപൈൽ ചെയ്യുമ്പോൾ, makepp-ന് കഴിയുന്ന ഒരു മേക്ക് ഫയൽ എഴുതുന്നു
ഉൾപ്പെടുന്നു. മേക്കപ്പിന്റെ സ്കാനറിനേക്കാൾ പ്രയോജനം അത് 100% ഉറപ്പുനൽകുന്നു എന്നതാണ്
ശരിയാണ്, നമുക്ക് അടുത്ത് മാത്രമേ വരാൻ കഴിയൂ.

ഈ ഐച്ഛികം ഒരു പ്രത്യേക രീതിയിൽ ഉപയോഗിക്കുന്നു: ഫയൽ ഇല്ലെങ്കിൽ, അതായത്
സാധാരണയായി 1st ബിൽഡിൽ, സാധാരണ സ്കാനിംഗ് സംഭവിക്കുന്നു. എന്നാൽ ഫയൽ ഉണ്ടെങ്കിൽ, ഇല്ല
സ്കാനിംഗ് സംഭവിക്കുന്നു (അതുകൊണ്ടാണ് ഞങ്ങൾ മുകളിൽ ഒരു സ്മാർട്ട് സിഗ്നേച്ചർ വ്യക്തമാക്കുന്നത് -- സ്കാനിംഗ് ഫാൾസ് അല്ല
ടൈംസ്റ്റാമ്പിന്റെയും വലുപ്പത്തിന്റെയും ഡം ഡിഫോൾട്ടിലേക്ക് മടങ്ങുക). പകരം അതിൽ മുമ്പുള്ള ഫയൽ ഉൾപ്പെടുന്നു
ഭരണം നടപ്പിലാക്കുന്നു. നിയമം വിജയകരമായി നടപ്പിലാക്കിയ ശേഷം, അത് എന്തും മറക്കുന്നു
ഫയൽ കാലഹരണപ്പെട്ടതാകാമെന്നതിനാൽ, ആദ്യമായി വായിച്ചു. പകരം വായിക്കുന്നു
ഫയൽ വീണ്ടും, അത് മാറിയെങ്കിൽ, കാലികമായ ബിൽഡ് വിവരങ്ങൾക്കായി.

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

നിങ്ങൾ ഒരു "#ഉൾപ്പെടുത്തുക" പ്രസ്താവന നീക്കം ചെയ്യുമ്പോൾ ഒരു ക്യാച്ച് ഉണ്ട് ഒപ്പം അനുബന്ധ ഫയൽ:
ഡിപൻഡൻസി ഫയലിൽ, കഴിഞ്ഞ തവണ ഉണ്ടായിരുന്നത് മുതൽ അത് ഇപ്പോഴും സൂചിപ്പിക്കും
ആവശ്യമുണ്ട്. അത്തരമൊരു സാഹചര്യത്തിൽ ഡിപൻഡൻസി നീക്കം ചെയ്യുന്നതിനായി നിങ്ങൾ ഡിപൻഡൻസി ഫയൽ എഡിറ്റ് ചെയ്യണം
ഇനി നിവൃത്തിയില്ലാത്തത്.

ഒരു ബിൽഡ് കാഷെ ഉപയോഗിച്ച് ഈ സവിശേഷത ഉപയോഗിക്കാൻ കഴിയില്ല, കാരണം അവിടെ നിന്ന് ഒരു ഫയൽ ലഭിക്കുന്നു
ഫയലിനെ കുറിച്ച് എല്ലാം അറിഞ്ഞിരിക്കണം. എന്നാൽ ഒരു ഡിപൻഡൻസി ഫയൽ അവയെ ആശ്രയിച്ചിരിക്കുന്നു
files makepp അത് വായിച്ചാണ് പഠിക്കുന്നത്. അത്തരമൊരു വൃത്താകൃതിയിലുള്ള ആശ്രിതത്വം സാധാരണമല്ല
വിശ്വസനീയമായ ബിൽഡ് സിസ്റ്റത്തിൽ സാധ്യമാണ്. ഇത് ഒരു അപവാദമാണ്, കാരണം പുനർനിർമിച്ചതിന് ശേഷം
ഒരു ഡിപൻഡൻസി ഫയൽ വീണ്ടും വായിക്കുമ്പോൾ എല്ലാം ശരിയാകും.

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

:അവസാനത്തെ അവസരം
പോലുള്ള ഒരു ഓപ്പൺ-എൻഡ് റൂൾ പ്രവർത്തനക്ഷമമാക്കുക

%.foo foo%.bar: :last_chance
&എക്കോ $@ -o $@
&cp $(ഔട്ട്പുട്ടുകൾ)

കാരണം ഇതുപോലുള്ള ഒരു റൂൾ അടിസ്ഥാനപരമായി അനന്തമായ ലക്ഷ്യങ്ങൾ സൃഷ്ടിക്കും,
ഈ നിയമത്തിന്റെ ലക്ഷ്യം $(വൈൽഡ്കാർഡ്) ഫംഗ്ഷനുമായോ പാറ്റേൺ നിയമവുമായോ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ
ടാർഗെറ്റ് പ്രത്യേകമായി പരാമർശിച്ചുകൊണ്ട് മറ്റെന്തെങ്കിലും നിയമം ഇതിനകം സ്ഥാപിച്ചിട്ടുണ്ട്.
കൂടാതെ, "--rm-stale" വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, മുമ്പത്തേതിൽ നിന്ന് ഒരു ടാർഗെറ്റ് അവശേഷിക്കുന്നു
ലാസ്റ്റ്_ചാൻസ് റൂൾ വഴിയാണ് ഇത് നിർമ്മിക്കാനുള്ള ഏക മാർഗം എങ്കിൽ makepp റൺ പഴയതായി കാണപ്പെടും
ടാർഗെറ്റിനായി ഇതുവരെയും ഇത് കണ്ടെത്തിയിട്ടില്ല, കാരണം ഇത് അഭികാമ്യമായ പെരുമാറ്റമാണ്
ഒരു വൈൽഡ്കാർഡിനെ തെറ്റായി ആശ്രയിക്കുമ്പോൾ ബിൽഡ് കൂടുതൽ സ്ഥിരമായി പരാജയപ്പെടും
മുമ്പത്തെ റണ്ണിൽ നിന്നുള്ള മത്സര ലക്ഷ്യങ്ങൾ.

":last_chance" എന്ന ഓപ്‌ഷൻ എന്നതിന്റെ പ്രത്യേക സ്വഭാവത്തിലേക്ക് ശ്രദ്ധ ക്ഷണിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്
വൈൽഡ്കാർഡുകൾ പൊരുത്തപ്പെടുത്തുന്നതുമായി ബന്ധപ്പെട്ട് ഭരണം.

: പാർസർ പാഴ്‌സർ
ഫയലുകൾ കണ്ടെത്തുന്നതിനുള്ള (ഉൾപ്പെടുത്തുക) കമാൻഡ് എങ്ങനെ പാഴ്‌സ് ചെയ്യാമെന്ന് ഇത് makepp-നോട് പറയുന്നു. സാധാരണയായി,
കമാൻഡിലെ വാക്കുകളെ അടിസ്ഥാനമാക്കി ഇത് എങ്ങനെ ചെയ്യാമെന്ന് makepp ഊഹിക്കുന്നു (കാണുക
വിശദാംശങ്ങൾക്കായി makepp_scanning). എന്നിരുന്നാലും, makepp തെറ്റായി ഊഹിച്ചാൽ, നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
പാർസറിനെ വ്യക്തമായി സൂചിപ്പിക്കുക, ഇതുപോലെ:

%.o: %.abc
: പാർസർ c_compilation
ഇവിടെ പ്രവർത്തനം

C/C++ ന് ചെയ്യുന്ന അതേ പാഴ്‌സിംഗും സ്കാനിംഗും മേക്കപ്പും നിർവഹിക്കുന്നതിന് ഇത് കാരണമാകുന്നു
ഒരു C കംപൈലേഷനായി പ്രവർത്തനം തിരിച്ചറിഞ്ഞില്ലെങ്കിലും, കമാൻഡുകൾ നിർമ്മിക്കുക.

ഡിഫോൾട്ട് പാഴ്സർ കമാൻഡിനെ ആശ്രയിച്ചിരിക്കുന്നു. നിങ്ങൾ ഒരു ": പാർസർ" ഓപ്ഷൻ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ,
അപ്പോൾ ഓരോ കമാൻഡിന്റെയും ആദ്യ വാക്ക് പരിശോധിക്കുന്നു. ഉദാഹരണത്തിന് ഒരു കംപൈലിനോ ലിങ്കിനോ വേണ്ടി
കമാൻഡ്, makepp "c_compilation" പാഴ്സർ ഉപയോഗിക്കും; അല്ലെങ്കിൽ കമാൻഡ് പോലെയാണെങ്കിൽ
GNU വേരിയന്റ്, "gcc_compilation". പാർസറൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ അത് "ഒന്നുമില്ല" പാഴ്സർ ഉപയോഗിക്കുന്നു. വേണ്ടി
ഇതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ, അല്ലെങ്കിൽ നിങ്ങൾക്ക് സ്വന്തമായി പാഴ്‌സർ എഴുതാനോ മേക്കപ്പ് മാറ്റാനോ താൽപ്പര്യമുണ്ടെങ്കിൽ
സ്ഥിരസ്ഥിതി പാർസറുകൾ, makepp_scanning കാണുക.

റൂളിലെ എല്ലാ കമാൻഡിനും ഇത് ബാധകമാകുമെന്നത് ശ്രദ്ധിക്കുക, അത് നിങ്ങൾക്ക് വേണ്ടത് ആയിരിക്കില്ല:

%.o: %.c : പാർസർ സി-കംപൈലേഷൻ
@echo 'ബിൽഡിംഗ് $(ഔട്ട്പുട്ട്)'
@funny_cc...

ഇത് "എക്കോ" യെ ഒരു കംപൈലറായി വ്യാഖ്യാനിക്കുകയും അതിന്റെ വാദമായ 'ബിൽഡിംഗ്' കുറയ്ക്കുകയും ചെയ്യും
mymodule.o' ഒരു പരോക്ഷമായ ആശ്രിതത്വമായി. എന്ന പരാതിക്ക് ഇത് വഴിവെക്കും
അത്തരമൊരു ഫയൽ എങ്ങനെ നിർമ്മിക്കണമെന്ന് അറിയില്ല. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ കൂടുതൽ നന്നായിരിക്കും
"register_parser". എങ്ങനെ എന്നതിന്റെ വിശദീകരണം അവിടെ കാണാം പാഴ്‌സർ a ആയി നൽകാം
ക്ലാസ് നാമം അല്ലെങ്കിൽ ഒരു ഫംഗ്‌ഷൻ നാമമായി.

:കയ്യൊപ്പ് ഒപ്പ്_രീതി
ലക്ഷ്യം: ആശ്രിതത്വം
: ഒപ്പ് md5
ഓഹരി

ഡിപൻഡൻസികൾ മാറിയിട്ടുണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ എന്ത് അൽഗോരിതം ഉപയോഗിക്കണമെന്ന് ഇത് makepp-നോട് പറയുന്നു.
കൂടുതൽ വിവരങ്ങൾക്ക് makepp_signatures കാണുക. കൂടെ ഉൾപ്പെടുത്തിയിരിക്കുന്ന സിഗ്നേച്ചർ രീതികൾ
makepp വിതരണം "പ്ലെയിൻ", "md5", "C" അല്ലെങ്കിൽ "c_compilation_md5" എന്നിവയാണ്, കൂടാതെ
"പങ്കിട്ട_വസ്തു". ഇത് "-m" അല്ലെങ്കിൽ ഉപയോഗിച്ച് വ്യക്തമാക്കിയ ഏതെങ്കിലും സിഗ്നേച്ചർ രീതിയെ അസാധുവാക്കുന്നു
"--സിഗ്നേച്ചർ-മെത്തേഡ്" കമാൻഡ് ലൈൻ ഓപ്ഷനുകൾ, അല്ലെങ്കിൽ "സിഗ്നേച്ചർ" സ്റ്റേറ്റ്മെന്റ്.

പ്രത്യേക പ്രതീകങ്ങൾ
വൻകുടൽ അല്ലെങ്കിൽ സ്‌പെയ്‌സ് പോലുള്ള പ്രത്യേക പ്രതീകങ്ങളുള്ള ഫയൽ നാമങ്ങളെ മേക്കപ്പിന് പിന്തുണയ്‌ക്കാൻ കഴിയും.
ഉദാഹരണത്തിന്, "b:thing" എന്ന ഫയലിൽ നിന്ന് "a:thing" എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് കരുതുക.
നിങ്ങൾക്ക് ഈ നിയമം എഴുതാൻ കഴിയില്ല:

a:thing : b:thing # ഇതൊരു വാക്യഘടന പിശകാണ്
&പൂച്ച $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

കാരണം, ആശ്രിതത്വങ്ങളിൽ നിന്ന് ടാർഗെറ്റുകളെ വേർതിരിക്കുന്ന കോളനുകൾ ഏതൊക്കെയാണെന്നും മേക്കപ്പിന് അറിയില്ല
ഫയലുകളുടെ ഒരു ഭാഗം. പകരം, ഇതുപോലുള്ള ഉദ്ധരണികളിൽ പേര് ഉൾപ്പെടുത്തുക:

"a:thing" : "b:thing"
&പൂച്ച $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

ഇപ്പോൾ ഭരണം അവ്യക്തമാണ്.

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

a\:thing : 'b: കാര്യം'
&പൂച്ച $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

ഉദാഹരണത്തിന്, നിങ്ങളുടെ ഫയലിന്റെ പേര് "'"!;\$" ആണെന്ന് കരുതുക. ഇപ്പോൾ എന്തുകൊണ്ടാണ് നിങ്ങൾക്ക് അത്തരമൊരു ഫയൽനാമം വേണ്ടത്
എനിക്കറിയില്ല, പക്ഷേ നിങ്ങൾക്ക് ഇത് makepp-ലേക്ക് (ഷെല്ലും) വ്യക്തമാക്കാൻ കഴിയുന്ന നിരവധി മാർഗങ്ങളുണ്ട്:

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

മേക്കപ്പ് സ്ട്രിപ്പുകൾ എപ്പോൾ ഉദ്ധരണികൾ ചെയ്യുന്നുവെന്നും ഷെൽ എപ്പോൾ ചെയ്യുന്നുവെന്നും ശ്രദ്ധിക്കുക. മേക്കപ്പ് നോക്കുന്നു
ഇനിപ്പറയുന്ന സന്ദർഭങ്ങളിൽ മാത്രം ഉദ്ധരണികൾ:

· ടെസ്റ്റുകളുടെ "ifeq" കുടുംബത്തിൽ

റൂൾ കോളണിന് മുമ്പും ശേഷവും

ഒരു makepp buildin കമാൻഡിൽ

· ഫയലുകളുമായി ബന്ധപ്പെട്ട ഒരു ഫംഗ്ഷനിൽ

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

FILE = 'സ്പെയ്സ് ഉള്ള പേര്'
x := $(print $(FILE)) # ഉദ്ധരണികൾ ഇപ്പോഴും ഉണ്ടോ എന്ന് പരിശോധിക്കാൻ മാത്രം
$(FILE): makepp സ്ട്രിപ്പ് ചെയ്ത ഒരൊറ്റ ഫയലിന് ചുറ്റുമുള്ള # ഉദ്ധരണികൾ
&echo hello -o$(FILE) # ക്വോട്ടുകൾ ഒറ്റ ഫയലിന് ചുറ്റും makepp സ്ട്രിപ്പ് ചെയ്തു
അവിടെ പ്രതിധ്വനിപ്പിക്കുക >>$(FILE) # ഷെൽ നീക്കം ചെയ്ത ഒരൊറ്റ ഫയലിന് ചുറ്റുമുള്ള ഉദ്ധരണികൾ
'സ്പെയ്സ് ഉള്ള പേര്':
&എക്കോ ഹലോ -ഓ'നെയിം സ്‌പെയ്‌സുകൾ'
അവിടെ പ്രതിധ്വനിക്കുക >>'$(ഔട്ട്‌പുട്ട്)' # ഉദ്ധരണികൾ മുകളിൽ നീക്കം ചെയ്‌തു, അവ വീണ്ടും ചേർക്കുക

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

$(എല്ലാം വ്യാജം):
@&echo ഇതൊരു ഡോളർ ചിഹ്നമാണ്: $$
@ for abcd ൽ; പ്രതിധ്വനിപ്പിക്കുക $$val; ചെയ്തു

സാധാരണയായി, ഏതെങ്കിലും പ്രത്യേക കഥാപാത്രത്തെ ഉദ്ധരിച്ച് നിങ്ങൾക്ക് കൈകാര്യം ചെയ്യാൻ കഴിയണം
ഏതെങ്കിലും തരത്തിൽ. ഇതിൽ സ്‌പെയ്‌സുകൾ, നിയന്ത്രണ പ്രതീകങ്ങൾ മുതലായവ ഉൾപ്പെടുന്നു. എന്നിരുന്നാലും, എന്നതിൽ ശ്രദ്ധിക്കുക
നിലവിൽ, makepp-ന്റെ കമന്റ് സ്ട്രിപ്പിംഗ് കുറച്ച് ലളിതമാണ്, കൂടാതെ ഏതെങ്കിലും "#" പ്രതീകങ്ങളും
വൈറ്റ്‌സ്‌പെയ്‌സിന് മുമ്പുള്ളത് അവ എങ്ങനെ ഉദ്ധരിച്ചാലും കമന്റുകളായി വ്യാഖ്യാനിക്കപ്പെടും.

"$(ഔട്ട്പുട്ട്)" പോലെയുള്ള ഒരു ഓട്ടോമാറ്റിക് വേരിയബിളിലേക്ക് ഒരു ടാർഗെറ്റ് അല്ലെങ്കിൽ ഡിപൻഡൻസി നാമം ഇടുമ്പോൾ, തുടർന്ന്
ഉദ്ധരണികളും ഏതെങ്കിലും ബാക്ക്സ്ലാഷുകളും നീക്കംചെയ്തു. ഇതിനർത്ഥം നിങ്ങൾക്ക് റഫറൻസ് ചെയ്യണമെങ്കിൽ
പ്രവർത്തനങ്ങളിൽ ഫയലിന്റെ പേര്, നിങ്ങൾ ഇത് വീണ്ടും ഉദ്ധരിക്കേണ്ടി വരും, ഇതുപോലെ:

"സ്‌പെയ്‌സുകളുള്ള ഒരു ഫയൽ നാമം":
പ്രതിധ്വനി "പ്രത്യേക ഉള്ളടക്കങ്ങൾ" > "$@"

നിങ്ങൾ $@ എന്നതിന് ചുറ്റും ഉദ്ധരണികൾ നൽകിയില്ലെങ്കിൽ, ഷെൽ കമാൻഡ് കാണും

echo "പ്രത്യേക ഉള്ളടക്കങ്ങൾ" > സ്‌പെയ്‌സുകളുള്ള ഒരു ഫയൽ നാമം

അത് വിളിക്കപ്പെടുന്ന ഫയലിലേക്ക് "സ്പെഷ്യൽ ഉള്ളടക്കങ്ങളുടെ ഫയലിന്റെ പേര് സ്പെയ്സുകളുള്ള" എന്ന സ്ട്രിംഗ് എഴുതുന്നു a.
ഇത് ഒരുപക്ഷേ നിങ്ങൾ ആഗ്രഹിക്കുന്നതല്ല.

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