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

പട്ടിക:

NAME

makepp_functions -- makepp-ലെ പ്രവർത്തനങ്ങൾ

വിവരണം

A: absolute_filename,
absolute_filename_nolink,
അസ്പാത്ത്,
ആഡ്പ്രിഫിക്സ്,
അനുബന്ധപ്രത്യയം,
ഒപ്പം, B: അടിസ്ഥാനനാമം, C: വിളി, D: ആണ്,
dir_noslash, E: തെറ്റ്, F: ഫയൽ സബ്സ്റ്റ്,
ഫിൽട്ടർ,
ഫിൽറ്റർ_ഔട്ട്,
ഫിൽട്ടർ_ഔട്ട്_ദിർസ്,
ഫയൽ കണ്ടെത്തുക,
കണ്ടെത്തുക_ആദ്യം_മുകളിലേക്ക്,
ഫൈൻഡ്_പ്രോഗ്രാം,
കണ്ടെത്തൽ,
കണ്ടെത്തുക_മുകളിലേക്ക്,
ആദ്യം_ലഭ്യം,
ആദ്യ വാക്ക്,
മുന്നോട്ട്, I: എങ്കിൽ,
സത്യമാണെങ്കിൽ,
infer_linker,
അനുമാന_വസ്തുക്കൾ,
വിവരം, J: ചേരുക, M: ഉണ്ടാക്കുക,
രൂപരേഖ,
മേക്കപ്പർ,
ഭൂപടം,
"mktemp", N: നോട്ടിർ, O: മാത്രം_ജനറേറ്റഡ്,
മാത്രം_ലക്ഷ്യമില്ലാത്തവ,
മാത്രം_ഫോണി_ലക്ഷ്യങ്ങൾ,
മാത്രം_പഴയ,
മാത്രം_ലക്ഷ്യങ്ങൾ,
അഥവാ,
ഉത്ഭവം, P: patsubst,
perl,
വ്യാജൻ,
മുൻകൂട്ടി നിർമ്മിക്കുക,
അച്ചടിക്കുക, R: യഥാർത്ഥ പാത,
ബന്ധു_ഫയലിന്റെ പേര്,
ബന്ധു S: ഷെൽ,
അടുക്കുക,
സ്ട്രിപ്പ്,
സബ്സ്റ്റ്,
പ്രത്യയം, T: താൽക്കാലിക, W: മുന്നറിയിപ്പ്,
വൈൽഡ്കാർഡ്,
വാക്ക്,
വാക്കുകളുടെ പട്ടിക,
വാക്കുകൾ, X: xargs

"$(name)" ഫോർമാറ്റിന്റെ ഏതെങ്കിലും എക്സ്പ്രഷൻ, ഇവിടെ "പേര്" എന്നത് ഒരു വേരിയബിളിന്റെ പേരല്ല, അല്ലെങ്കിൽ
"$(name arg1 arg2 arg3)" എന്നത് ഒരു ഫംഗ്‌ഷൻ കോളായി വ്യാഖ്യാനിക്കപ്പെടുന്നു. പേരിൽ അക്ഷരങ്ങൾ അടങ്ങിയിരിക്കാം,
അടിവരകൾ, അല്ലെങ്കിൽ ഹൈഫനുകൾ; ആശയക്കുഴപ്പം ഒഴിവാക്കാൻ, നിങ്ങൾക്ക് ഹൈഫനുകളോ അടിവരയോ ഉപയോഗിക്കാം
പരസ്പരം മാറ്റാം, കാരണം ആന്തരികമായി ഹൈഫനുകൾ അണ്ടർസ്കോറുകളായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു. അത്തരത്തിലുള്ള വിലയിരുത്തൽ
ഒരു പദപ്രയോഗം ഒരു പേൾ സബ്റൂട്ടിനെ വിളിക്കുന്നു. "പേര്" എന്നതിന് മുമ്പായി "&" ആണെങ്കിൽ അത് പ്രവർത്തിക്കുന്നു
buildin കമാൻഡ് അല്ലെങ്കിൽ ആ പേരിന്റെ സ്ക്രിപ്റ്റ്, makepp പ്രോസസ്സിനുള്ളിൽ, സ്റ്റാൻഡേർഡ് തിരികെ നൽകുന്നു
ഔട്ട്പുട്ട്. ഇതിന് PerlIO-യ്‌ക്കായി perl നിർമ്മിക്കേണ്ടതുണ്ട്. പേര് ഒരു ഫംഗ്‌ഷന്റെ പേര് നൽകുന്നില്ലെങ്കിൽ
അത് ഒരു വിളിയുടെ ആഹ്വാനമായി രൂപാന്തരപ്പെടുന്നു.

വേരിയബിളുകൾ പോലെ നിങ്ങൾക്ക് "$(name ...)" അല്ലെങ്കിൽ "${name ...}" തിരഞ്ഞെടുക്കാം. നിങ്ങൾക്ക് വേണമെങ്കിൽ
ഒരേ പരാന്തീസിസ് ഉൾപ്പെടുത്തുക, അത് ജോടിയാക്കണം, മറ്റൊന്ന് പ്രശ്നമല്ല: "$(പേര്
...(){..." അല്ലെങ്കിൽ "${name ...{}(...}". (എന്നിരുന്നാലും, മാപ്പിനും പേളിനും ആദ്യ ക്ലോസിംഗ് പാരൻ അവസാനിക്കുന്നു
എക്‌സ്‌പ്രഷൻ.) ഇരട്ടിപ്പിക്കൽ ആർഗ്യുമെന്റുകളെ നിരവധി വരികളിൽ വ്യാപിപ്പിക്കാൻ അനുവദിക്കുന്നു. എന്നിവയാണ് പുതിയ ലൈനുകൾ
പിന്നീട് "നിർവചിക്കുക" എന്നതിൽ ഒഴികെ, സ്‌പെയ്‌സുകളായി കണക്കാക്കുന്നു. "$[name ...]" എന്ന വാക്യഘടനയും ഉണ്ട്.
അല്ലെങ്കിൽ $[[name ...]], ഇത് മേക്ക് ഫയൽ വായിക്കുമ്പോൾ, നിയമങ്ങൾ തട്ടിയെടുക്കുന്നതിന് മുമ്പ് വിലയിരുത്തപ്പെടുന്നു
മറ്റ് നിർമ്മാണങ്ങളും.

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

സോപാധിക പ്രവർത്തനങ്ങൾ
ഒപ്പം വ്യവസ്ഥ1[,condition2[,condition3...]]
ദി ആൻഡ് ഫംഗ്‌ഷൻ ഒരു "ഷോർട്ട് സർക്യൂട്ടിംഗും" പ്രവർത്തനവും നൽകുന്നു. ഓരോ വാദഗതിയും
വിപുലീകരിച്ചു, ക്രമത്തിൽ. ഒരു ആർഗ്യുമെന്റ് ഒരു ശൂന്യമായ സ്ട്രിംഗിലേക്ക് വികസിക്കുകയാണെങ്കിൽ, പ്രോസസ്സിംഗ് നിർത്തുന്നു
വികാസത്തിന്റെ ഫലം ശൂന്യമായ സ്ട്രിംഗാണ്. എല്ലാ വാദങ്ങളും ഒരു നോൺ-ലേക്ക് വികസിക്കുകയാണെങ്കിൽ
ശൂന്യമായ സ്ട്രിംഗ് അപ്പോൾ വികാസത്തിന്റെ ഫലം അവസാന ആർഗ്യുമെന്റിന്റെ വികാസമാണ്.

if സ്ട്രിംഗ്, ഫലം-ഇഫ്-സ്ട്രിംഗ്-ശൂന്യമല്ല[, ഫലം-ഇഫ്-സ്ട്രിംഗ്-ശൂന്യം]
സത്യമാണെങ്കിൽ സ്ട്രിംഗ്, ഫലം-എങ്കിൽ-സ്ട്രിംഗ്-ട്രൂ[, ഫലം-എങ്കിൽ-സ്ട്രിംഗ്-തെറ്റ്]
"ifeq" മുതലായവയ്ക്ക് ഒരു ബദൽ പ്രസ്താവനകൾ. സ്ട്രിംഗ് ശൂന്യമല്ലെങ്കിൽ (അതായത്
വ്യവസ്ഥ ശരിയാണ്), രണ്ടാമത്തെ ആർഗ്യുമെന്റ് ("പിന്നെ" ക്ലോസ്) തിരികെ നൽകുന്നു (ശേഷം
വേരിയബിൾ വികാസം); സ്ട്രിംഗ് ശൂന്യമാണെങ്കിൽ, മൂന്നാമത്തെ വാദം ("മറ്റുള്ള" ക്ലോസ്) ആണ്
മടങ്ങി.

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

CFLAGS := $(എങ്കിൽ $(filter gcc egcc, $(CC)), -g -Wall, -g)

വേരിയബിൾ CC ഒന്നുകിൽ "gcc" അല്ലെങ്കിൽ "egcc", കൂടാതെ "-g" ആണെങ്കിൽ CFLAGS എന്നത് "-g -Wall" ആണെന്ന് നിർവ്വചിക്കുന്നു.
അല്ലാത്തപക്ഷം. (ഇതാണ് ഡിഫോൾട്ട് ബിൽഡ് നിയമങ്ങൾ ചെയ്യുന്നത്.)

"iftrue" എന്നത് "if" എന്നതിന് സമാനമാണ്, അല്ലാതെ സ്ട്രിംഗ് 0 ശൂന്യമായി കണക്കാക്കപ്പെടുന്നു.

or വ്യവസ്ഥ1[,condition2[,condition3...]]
അല്ലെങ്കിൽ ഫംഗ്‌ഷൻ ഒരു "ഷോർട്ട് സർക്യൂട്ട്" അല്ലെങ്കിൽ ഓപ്പറേഷൻ നൽകുന്നു. ഓരോ വാദവും വിപുലീകരിക്കപ്പെടുന്നു,
ക്രമത്തിൽ. ഒരു ആർഗ്യുമെന്റ് ശൂന്യമല്ലാത്ത ഒരു സ്ട്രിംഗിലേക്ക് വികസിക്കുകയാണെങ്കിൽ, പ്രോസസ്സിംഗ് നിർത്തുന്നു
വികാസത്തിന്റെ ഫലം ആ സ്ട്രിംഗ് ആണ്. എല്ലാ വാദങ്ങളും വിപുലീകരിച്ച ശേഷം, എല്ലാം
അവ തെറ്റാണ് (ശൂന്യമാണ്), അപ്പോൾ വികാസത്തിന്റെ ഫലം ശൂന്യമായ സ്ട്രിംഗാണ്.

ഫയല് ഒപ്പം ഫയൽനാമം പ്രവർത്തനങ്ങൾ
absolute_filename ഫയലുകൾ
അസ്പാത്ത് ഫയലുകൾ
ആപേക്ഷിക ഫയൽനാമങ്ങൾ ഇല്ലാതെ കേവലതകളാക്കി മാറ്റുന്നു . or ... ഉദാഹരണത്തിന്,
"$(absolute_filename xyz.c)" "/usr/src/our_project/subdir/xyz.c" തിരികെ നൽകിയേക്കാം.

absolute_filename_nolink ഫയലുകൾ
യഥാർത്ഥ പാത ഫയലുകൾ
absolute_filename പോലെ, എന്നാൽ പ്രതീകാത്മക ലിങ്കുകൾ പരിഹരിച്ചതായി ഉറപ്പാക്കുന്നു.

ബേസ്നെയിം ഫയൽനാമങ്ങൾ
അടിസ്ഥാനനാമം മുഴുവൻ ഫയലിന്റെ പേരുമാണ് (ഡയറക്‌ടറിക്കൊപ്പം), അതിനു ശേഷമുള്ള ടെക്‌സ്‌റ്റ് മൈനസ്
അവസാന കാലഘട്ടം ഉൾപ്പെടെ. ഉദാ, "$(basename myfile/version-1.0-module.c)"
"myfile/version-1.0-module"

മുതലാളി ഫയൽനാമങ്ങൾ
ട്രെയിലിംഗ് ഉൾപ്പെടെ, ഫയൽനാമ ലിസ്റ്റിലെ ഓരോ ഫയലിന്റെയും ഡയറക്ടറി ഭാഗം എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യുന്നു
വെട്ടിമുറിക്കുക. ഫയൽ നാമത്തിൽ ഡയറക്ടറി ഇല്ലെങ്കിൽ "./" നൽകുന്നു.

dir_noslash ഫയലിന്റെ പേര്
"$(dir )" എന്നതിന് സമാനമാണ്, അത് ട്രെയിലിംഗ് സ്ലാഷ് നൽകുന്നില്ല.

filesubst മാതൃക, പകരമായി, വാക്കുകൾ
ഫയൽ നാമങ്ങളിൽ ഒരു പാറ്റേൺ പകരം വയ്ക്കൽ നടത്തുക. ഇതിൽ patsubst ൽ നിന്ന് ഇത് വ്യത്യസ്തമാണ്
ഡയറക്‌ടറികൾക്ക് ഇതര പേരുകൾ നൽകുമ്പോൾ അത് ശരിയായി പ്രവർത്തിക്കും (എത്രത്തോളം
അവ ശതമാനം ചിഹ്നത്തിന് മുമ്പാണ്). ഉദാഹരണത്തിന്,

$(filesubst ./src/%.c, %.o, $(വൈൽഡ്കാർഡ് src/*.c))

filesubst-ൽ പ്രവർത്തിക്കും എന്നാൽ patsubst-ൽ അല്ല.

ഫിൽറ്റർ_ഔട്ട്_ദിർസ് ഫയൽനാമങ്ങൾ
ഡയറക്‌ടറികളെ പരാമർശിക്കാത്ത എല്ലാ ഫയൽനാമങ്ങളും നൽകുന്നു.

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

TCL_INCLUDE := -I$(dir_noslash $(findfile tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/ഉൾപ്പെടുന്നു \
/usr/include/tcl8.4 /usr/include/tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

ഇത് ഫയൽ കണ്ടെത്തുന്നു tcl.h മുകളിലുള്ള എല്ലാ ഡയറക്ടറികളും തിരയുന്നതിലൂടെ. കേവല
ഫയലിലേക്കുള്ള പാത തിരികെ ലഭിച്ചു. തുടർന്ന് "$(dir_noslash )" ആ ഡയറക്ടറിയും അത് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നു
ഉൾപ്പെടുത്തിയ പാതയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു.

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

CC = $(find_program gcc egcc pgcc c89 cc) # കൂടാതെ, മെഷീനിനെ ആശ്രയിച്ച്
F77 = $(find_program f77 g77 fort77)
CXX = $(find_program g++ c++ pg++ cxx CC aCC)

പ്രോഗ്രാമുകളൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ, "$(find_program )" സ്ട്രിംഗ് കണ്ടെത്തിയില്ല, കൂടാതെ
കണ്ടെത്താത്തവ രേഖപ്പെടുത്തുന്നു. ഇത് സാധാരണയായി ഒരു ഫങ്ഷണൽ മേക്ക്ഫയലിന് കാരണമാകില്ല, പക്ഷേ അത്
മികച്ച പിശക് സന്ദേശങ്ങൾ ഉണ്ടാക്കാൻ പ്രവണത കാണിക്കും. ഉദാഹരണത്തിന്, നിങ്ങൾ ഇതുപോലെ എന്തെങ്കിലും ചെയ്താൽ
ഈ:

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

കൂടാതെ makepp-ന് മുകളിലുള്ള ലിസ്റ്റിൽ ഒരു C കംപൈലർ കണ്ടെത്താനായില്ല, അത് കണ്ടെത്തിയില്ല.
അല്ലെങ്കിൽ ഷെൽ സോഴ്സ് ഫയലും തത്ഫലമായുണ്ടാകുന്ന പിശകും എക്സിക്യൂട്ട് ചെയ്യാൻ ശ്രമിക്കും
സന്ദേശം ശരിക്കും വിചിത്രമായിരിക്കാം.

കണ്ടെത്തുക_മുകളിലേക്ക് ഫയലിന്റെ പേര്
ഡയറക്‌ടറിയിൽ നൽകിയിരിക്കുന്ന പേരിന്റെ ഒരു ഫയലിനായി തിരയുന്നു., .., ../..,../../.., തുടങ്ങിയവ.,
ഫയൽ കണ്ടെത്തുന്നതുവരെ അല്ലെങ്കിൽ റൂട്ട് ഡയറക്ടറിയിൽ എത്തുന്നതുവരെ അല്ലെങ്കിൽ ഡയറക്ടറി സ്ഥിതി ചെയ്യുന്നത് വരെ
മറ്റൊരു ഫയൽ സിസ്റ്റത്തിൽ. (ഈ അവസാന ആവശ്യകത പ്രശ്നങ്ങൾ തടയുക എന്നതാണ്
ഓട്ടോമൗണ്ടറുകൾ അല്ലെങ്കിൽ ഹാംഗ് നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റങ്ങൾ.) നിങ്ങൾക്ക് ഉണ്ടെങ്കിൽ a RootMakeppfile, അതും
ഉയർന്ന തിരയലിനെ തടയുന്ന ഒരു തടസ്സം.

ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് പല തലത്തിലുള്ള ഉപഡയറക്‌ടറികളുള്ള ഒരു പ്രോജക്റ്റ് ഉണ്ടെങ്കിൽ, നിങ്ങൾക്ക് കഴിയും
എല്ലാ മേക്ക് ഫയലുകളിലും ഈ പൊതുവായ ശകലം ഉൾപ്പെടുത്തുക (ഉദാ. "ഉൾപ്പെടുത്തുക" ഉപയോഗിച്ച്
പ്രസ്താവന):

TOP_LEVEL_INCLUDE_DIR := $(find_upwards ഉൾപ്പെടുന്നു)
# അടങ്ങുന്ന ഒരു ഡയറക്‌ടറിക്കായി തിരയുന്നു
# ഉപഡയറക്‌ടറി ഉൾപ്പെടുന്നു.

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

"find_upwards" പരിഹരിക്കാൻ സഹായിക്കുന്ന മറ്റൊരു പ്രശ്നം ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറി കണ്ടെത്തുന്നതാണ്
ഒരു ബിൽഡിന്റെ. ഇതുപോലുള്ള ഒരു വേരിയബിൾ നിർവചിക്കുന്നത് പലപ്പോഴും ഉപയോഗപ്രദമാണ്:

മുകളിൽ := ../../..

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

മുകളിൽ := $(dir_noslash $(find_upwards LICENSE))

"$(find_upwards LICENSE)" ലൈസൻസ് ഫയലിന്റെ മുഴുവൻ പാതയും നൽകുന്നു;
"$(dir_noslash ...)" ഫയലിന്റെ പേര് ഒഴിവാക്കി, ഡയറക്ടറി മാത്രം തിരികെ നൽകുന്നു.

("ഉൾപ്പെടുത്തുക" എന്ന പ്രസ്താവന സ്വയമേവ ഫയലുകൾക്കായി മുകളിലേക്ക് തിരയുന്നുവെന്നത് ശ്രദ്ധിക്കുക
ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യേണ്ട ആവശ്യമില്ല:

$(find_upwards top_level_rules.mk) ഉൾപ്പെടുന്നു

പകരം, നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയും

top_level_rules.mk ഉൾപ്പെടുത്തുക

അത് നന്നായി പ്രവർത്തിക്കുകയും ചെയ്യും.)

ഫയൽ കണ്ടെത്തിയില്ലെങ്കിൽ, "find_upwards" ഒരു പിശക് സന്ദേശത്തോടെ ബിൽഡ് നിർത്തലാക്കും.

നിങ്ങൾ ഒന്നിൽ കൂടുതൽ ഫയലുകൾ വ്യക്തമാക്കുകയാണെങ്കിൽ, find_upwards ആദ്യത്തേതിന് തിരയും
രണ്ടാമത്തേത്, തുടങ്ങിയവ. മറ്റൊരു വാക്കിൽ,

$(find_upwards file1 file2)

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

$(find_upwards file1) $(find_upwards file2)

നിങ്ങൾക്ക് ഏതെങ്കിലും ഫയലുകൾക്കായി തിരയണമെങ്കിൽ, പകരം "find_first_upwards" ഉപയോഗിക്കുക.

കണ്ടെത്തുക_ആദ്യം_മുകളിലേക്ക് file1 file2 ...
ഈ ഫംഗ്‌ഷൻ "find_upwards" പോലെ പ്രവർത്തിക്കുന്നു, അത് ഏത് ഫയലിന്റെയും ആദ്യ ഫയൽ നൽകുന്നു എന്നതൊഴിച്ചാൽ
അത് കണ്ടെത്തുന്ന ലിസ്റ്റിലെ ഫയലുകൾ. പ്രത്യേകിച്ചും, ഇത് നിലവിലെ ഡയറക്ടറി പരിശോധിക്കുന്നു
ലിസ്റ്റിലെ ഏതെങ്കിലും ഫയലുകൾ, നിലവിലുള്ളതോ നിർമ്മിക്കാൻ കഴിയുന്നതോ ആയ ആദ്യ ഫയൽ തിരികെ നൽകുന്നു.
ഫയലുകളൊന്നും നിലവിലില്ലെങ്കിലോ ആ ഡയറക്‌ടറിയിൽ നിർമ്മിക്കാനാകുന്നില്ലെങ്കിലോ, അത് പരിശോധിക്കുന്നു ..എന്നിട്ട്
../.., മുതലായവ, അത് റൂട്ട് ഡയറക്‌ടറിയിലോ ഡയറക്‌ടറിയിലോ എത്തുന്നതുവരെ
മറ്റൊരു ഫയൽ സിസ്റ്റത്തിൽ സ്ഥിതിചെയ്യുന്നു.

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

TCL_LIB = $(first_available \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

മേൽപ്പറഞ്ഞ എല്ലാ സ്ഥലങ്ങളിലെയും Tcl ലൈബ്രറിക്കായി ഈ ലൈൻ പരിശോധിക്കും
അത് കണ്ടെത്തുന്ന ആദ്യത്തേത്. ലിങ്ക് കമാൻഡിൽ $(TCL_LIB) ഉൾപ്പെടുന്നു, അതിനാൽ നമുക്ക് ഇത് ലഭിക്കും
ഉചിതമായ Tcl ലൈബ്രറി.

infer_linker file1 file2 ...
ഒബ്‌ജക്റ്റ് ഫയലുകളുടെ ഒരു ലിസ്റ്റ് നൽകിയിരിക്കുന്നു, അവ ഇതുവരെ ഉണ്ടായിട്ടില്ലെങ്കിൽ ആദ്യം അവ നിർമ്മിക്കുക. എന്നിട്ട് കണ്ടെത്തുക
അവ ഫോർട്രാൻ, സി++ അല്ലെങ്കിൽ സി സോഴ്‌സ് എന്നിവയെ ആശ്രയിച്ചാലും അതിനനുസരിച്ചുള്ളവ തിരികെ നൽകിയാലും
കമ്പൈലർ ("ld" എന്നതിനേക്കാൾ എങ്ങനെ ലിങ്ക് ചെയ്യണമെന്ന് നന്നായി അറിയാം).

അനുമാന_വസ്തുക്കൾ file1 file2 ..., പാറ്റേൺ
$(infer_objects object1.o object2.o, *.o)

ഹെഡ്ഡർ ഫയൽ പേരുകൾ സംബന്ധിച്ച് നിങ്ങൾ സ്റ്റാൻഡേർഡ് കൺവെൻഷനുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, makepp-ന് കഴിയും
നിങ്ങളുടെ പ്രോഗ്രാമുമായി ഏത് ".o" അല്ലെങ്കിൽ ".lo" ഫയലുകളാണ് ലിങ്ക് ചെയ്യേണ്ടതെന്ന് ഊഹിക്കുക. ഞാൻ ഇത് ഉപയോഗിക്കുന്നു
വ്യത്യസ്ത രീതികളിൽ ഉപയോഗിക്കുന്ന മൊഡ്യൂളുകൾ അടങ്ങിയ ലൈബ്രറി ഡയറക്ടറിയിൽ നിന്ന് ഫയലുകൾ തിരഞ്ഞെടുക്കുക
പ്രോഗ്രാമുകൾ. ഒരു ലൈബ്രറി ".a" ഫയൽ നിർമ്മിക്കുന്നതിനും ലിങ്കർ തിരഞ്ഞെടുക്കുന്നതിനുപകരം
പ്രസക്തമായ മൊഡ്യൂളുകൾ, makepp നിങ്ങൾക്കായി പ്രസക്തമായ മൊഡ്യൂളുകൾ തിരഞ്ഞെടുക്കാൻ കഴിയും. ഈ വഴി മാത്രം
പ്രസക്തമായ മൊഡ്യൂളുകൾ സമാഹരിക്കുന്നു.

ഒബ്ജക്റ്റ് ഡിപൻഡൻസികൾ അനുമാനിക്കുന്നതിനുള്ള മേക്കപ്പിന്റെ അൽഗോരിതം കൺവെൻഷനെ ആശ്രയിച്ചിരിക്കുന്നു
"xyz.h" എന്ന ഹെഡർ ഫയലിൽ നിർവചിച്ചിരിക്കുന്ന എല്ലാ ക്ലാസുകളുടെയും ഫംഗ്‌ഷനുകളുടെയും നടപ്പിലാക്കൽ
"xyz.o" (അല്ലെങ്കിൽ "xyz.lo") എന്ന് വിളിക്കുന്ന ഒരു ഒബ്‌ജക്റ്റ് ഫയലിലേക്ക് കംപൈൽ ചെയ്‌തു. അതുകൊണ്ട് മേക്കപ്പിന്റെ അൽഗോരിതം
ഒബ്ജക്റ്റ് ഡിപൻഡൻസികൾ അനുമാനിക്കുന്നത് നമുക്ക് അറിയാവുന്ന ഒന്നോ അതിലധികമോ ഒബ്‌ജക്റ്റുകളിൽ നിന്നാണ്
പ്രോഗ്രാമിലേക്ക് ലിങ്ക് ചെയ്തിട്ടുണ്ട്. "#include" എന്നതിൽ ഏതൊക്കെ ഫയലുകളാണ് ഉൾപ്പെടുത്തിയിരിക്കുന്നതെന്ന് ഇത് നോക്കുന്നു
ആ ഉറവിടങ്ങൾ, കൂടാതെ ഉൾപ്പെടുന്ന ഓരോന്നിനും അനുയോജ്യമായ ഒബ്ജക്റ്റ് ഫയലുകൾ കണ്ടെത്താൻ ശ്രമിക്കുന്നു
ഫയലുകൾ.

ഒരു പ്രോഗ്രാമിന്റെ ഡിപൻഡൻസി ലിസ്റ്റിൽ "$(infer_objects )" പരാമർശിക്കേണ്ടതുണ്ട്
ഈ:

myprog: $(infer_objects main.o another_object.o, \
**/*.o /other/library/dirs/**/*.o)
$(CXX) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്) $(LIBS)

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

ഉദാഹരണത്തിന്, "main.o" എന്നത് "my_class.h" ഉൾപ്പെടുന്ന "main.cpp" എന്നതിൽ നിന്നാണ് വരുന്നതെന്ന് കരുതുക.
"$(infer_objects)" "my_class.o" എന്ന പേരിലുള്ള ഫയലുകൾക്കായി തിരയുന്നു. കൃത്യമായി അത്തരത്തിലുള്ള ഒന്നാണെങ്കിൽ
ഫയൽ കണ്ടെത്തി, അത് പട്ടികയിൽ ചേർത്തു. ("my_class.o" എന്ന രണ്ട് ഒബ്‌ജക്റ്റ് ഫയലുകൾ കണ്ടെത്തിയാൽ
വ്യത്യസ്ത ഡയറക്‌ടറികളിൽ, ഒരു മുന്നറിയിപ്പ് സന്ദേശം അച്ചടിച്ചിരിക്കുന്നു.) "infer_objects" എന്നതും
"my_class.cpp" അതിൽ എന്താണ് ഉൾപ്പെട്ടിരിക്കുന്നതെന്നും അധിക ഒബ്ജക്റ്റ് ഫയലുകൾ എന്തൊക്കെയാണെന്നും പരിശോധിക്കുന്നു
സൂചിപ്പിച്ചു.

mktemp
mktemp പ്രിഫിക്‌സ്
mktemp പ്രിഫിക്‌സ്XXX,
mktemp /
പ്രവചനാതീതമായ ഒരു താൽക്കാലിക ഫയൽ നാമം നൽകുന്നു, അത് നിലവിൽ നിലവിലില്ല. പേരില്ല
ഒരേ ഫയലിലേക്ക് ചൂണ്ടിക്കാണിച്ചാൽ, വ്യത്യസ്ത ആപേക്ഷിക പാതകളിൽപ്പോലും, രണ്ടുതവണ തിരികെ നൽകും.
ഒരു മേക്കപ്പ് റണ്ണിനുള്ളിൽ (പരമ്പരാഗത ആവർത്തന നിർമ്മാണം ഒഴികെ, അല്ലെങ്കിൽ പേൾ ആണെങ്കിൽ
ഒരു റൂൾ ആക്ഷൻ കോളുകൾക്കുള്ളിൽ പ്രവർത്തിക്കുന്ന കോഡ് "f_mktemp"). മേക്കപ്പിന്റെ അവസാനം എല്ലാം പ്രവർത്തിപ്പിക്കുക
ഈ ഫംഗ്‌ഷൻ നൽകുന്ന ഫയലുകൾ നിലവിലുണ്ടെങ്കിൽ അവ ഇല്ലാതാക്കപ്പെടും (വീണ്ടും അവ ഒഴികെ
ഒരു റൂളിനുള്ളിൽ പ്രവർത്തിക്കുന്ന പേൾ കോഡിൽ ഈ ഫംഗ്‌ഷൻ വഴി തിരിച്ചുനൽകുന്നു).

ആർഗ്യുമെന്റിന്റെ അവസാനത്തെ വലിയക്ഷരമായ "X" കളുടെ എത്രയോ എണ്ണം മാറ്റി പകരം വയ്ക്കുന്നു
ക്രമരഹിതമായ അക്ഷരങ്ങളും അക്കങ്ങളും. കൂടുതൽ ഉണ്ട്, ഇത് കൂട്ടിയിടിക്കാനുള്ള സാധ്യത കുറവാണ്
മറ്റ് പ്രക്രിയകൾക്കൊപ്പം, അതിനാൽ നിങ്ങൾ ഒരു പ്രിഫിക്സ് നൽകിയാൽ "/tmp/abc.", നിങ്ങൾക്ക് മതിയായിരിക്കണം
"എക്സ്". ഒന്നിൽ കൂടുതൽ X ഉണ്ടെങ്കിൽ, ആദ്യത്തെ പ്രതീകം പ്രോസസ്സ് ഐഡിയിൽ നിന്നാണ് വരുന്നത്. എങ്കിൽ
ഒന്നുമില്ല, അത് പത്ത് ഉണ്ടായിരുന്നതുപോലെയാണ്, അത് മതിയാകും (8.4e17
സാധ്യതകൾ അല്ലെങ്കിൽ വിൻഡോസിൽ 3.7e15). ആർഗ്യുമെന്റ് ഇല്ലെങ്കിൽ, പ്രിഫിക്‌സ് ഡിഫോൾട്ട് ആയി മാറുന്നു
"tmp." നിലവിലെ ഡയറക്ടറിയിൽ.

റൂൾ ടാർഗെറ്റുകളും ഡിപൻഡൻസികളും ആയി അത്തരമൊരു പേര് നൽകാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക. ദി
ഫലം ശരിയായിരിക്കും, എന്നാൽ നിങ്ങൾ makepp പ്രവർത്തിപ്പിക്കുമ്പോഴെല്ലാം അത് പുനഃസൃഷ്ടിക്കും.

കൂടാതെ, ഇത് എല്ലായ്പ്പോഴും വ്യത്യസ്തമായതിനാൽ, നിങ്ങൾ ഇത് ഉപയോഗിക്കുകയാണെങ്കിൽ മാത്രമേ ഇത് ഒരു റൂൾ ആക്ഷനിൽ ഉപയോഗിക്കാവൂ
":build_checkignign_action":

TMPFILE ;= $(mktemp) # 1 കോൾ; "=" എന്നത് 3 കോളുകൾ എന്നാണ് അർത്ഥമാക്കുന്നത്: 3 ഫയലുകൾ
A-count B-count: :build_checkignignor_action
ഉത്പാദിപ്പിക്കുക-ആൻഡ്-ബിഎസ് >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o A-count
&grep -c /B/ $(TMPFILE) -o B-count

അല്ലെങ്കിൽ നിങ്ങൾ അത് കയറ്റുമതി ചെയ്യുകയും ഷെല്ലിനെ വിലയിരുത്താൻ അനുവദിക്കുകയും വേണം:

TMPFILE കയറ്റുമതി ;= $(mktemp)
എ-കൗണ്ട് ബി-കൗണ്ട്:
production-As-and-Bs >$$TMPFILE # makepp var മൂല്യം കാണുന്നില്ല
fgrep -c ഒരു $$TMPFILE >A-count
fgrep -c B $$TMPFILE >B-count

അവസാന ഫോം മുമ്പത്തെ റിട്ടേൺ മൂല്യം ആവർത്തിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് ഇത് ഒരു പാറ്റേൺ റൂളിൽ ഉപയോഗിക്കാം:

%.x: %.y
&grep foo $(ഇൻപുട്ട്) -o $(mktemp)
&sed ബാർ $(mktemp /) -o $(ഔട്ട്പുട്ട്) # &grep ന്റെ ഔട്ട്പുട്ടിൽ പ്രവർത്തിക്കുക

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

മാത്രം_ജനറേറ്റഡ് ഫയൽനാമങ്ങൾ
ലിസ്റ്റിലെ ആ ഫയൽനാമങ്ങൾ മാത്രം നൽകുന്നു, അവ സൃഷ്‌ടിച്ചത് makepp ആണ്
ബിൽഡ് ഇൻഫോ ഫയൽ അനുസരിച്ച് പരിഷ്ക്കരിച്ചു.

ക്ലീൻ ടാർഗെറ്റ് നിയമങ്ങളിൽ ഈ പ്രവർത്തനം ഉപയോഗപ്രദമാണ് (തീർച്ചയായും "makeppclean" ആണ്
തിരഞ്ഞെടുത്ത വേരിയന്റ്):

$(ഫോണി ക്ലീൻ):
&rm -f $(മാത്രം_ജനറേറ്റഡ് **/*)

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

.ഫോണി: വിതരണം

വിതരണ:
&mkdir our_product-$(VERSION)
&cp $(ഫിൽട്ടർ ഔട്ട് %~, $(only_nontargets *)) our_product-$(VERSION)
tar cf - our_product-$(VERSION) | gzip -9c > our_product-$(VERSION).tar.gz

ഈ സാഹചര്യത്തിൽ, "$(only_nontargets *)" നിലവിലെ ഡയറക്‌ടറിയിലെ എല്ലാ ഫയലുകളും നൽകുന്നു
അത് ചില നിയമങ്ങളുടെ ലക്ഷ്യമല്ല. "$(filter_out %~, ...)" എഡിറ്റർ നീക്കം ചെയ്യുന്നു
ബാക്കപ്പുകൾ.

"only_targets" (മുകളിൽ കാണുക) പോലെ, "only_nontargets" എന്നതിന് ടാർഗെറ്റുകളെ കുറിച്ച് മാത്രമേ അറിയൂ
ഇതിനകം നിർവചിക്കപ്പെട്ടിട്ടുണ്ട്. വേരിയബിളുകൾ നിർവചിക്കാൻ നിങ്ങൾ ഇത് ഉപയോഗിക്കുകയാണെങ്കിൽ മാത്രമേ ഇത് ഒരു പ്രശ്‌നമാകൂ
":=" അസൈൻമെന്റ്; നിങ്ങൾ അത് ഡിപൻഡൻസി ലിസ്റ്റിലോ a യുടെ ബോഡിയിലോ ഉപയോഗിക്കുകയാണെങ്കിൽ
ഭരണം, മറ്റെല്ലാ നിയമങ്ങളും ഇതിനകം കണ്ടുകഴിഞ്ഞു.

മാത്രം_പഴയ ഫയൽനാമങ്ങൾ
ലിസ്റ്റിലെ ആ ഫയൽനാമങ്ങൾ മാത്രം നൽകുന്നു, അവ സൃഷ്‌ടിച്ചത് makepp ആണ്
ബിൽഡ് ഇൻഫോ ഫയൽ അനുസരിച്ച് പരിഷ്‌ക്കരിച്ചു, എന്നാൽ ഇനി ഒരു നിയമത്തിന്റെയും ലക്ഷ്യമല്ല.

അത്തരം ഫയലുകളിൽ ഡിപൻഡൻസികൾ ഇല്ലെന്ന് ഉറപ്പാക്കാൻ ഈ ഫംഗ്ഷൻ ഉപയോഗപ്രദമാണ്,
എല്ലാ ലക്ഷ്യങ്ങളുടെയും ശുദ്ധമായ നിർമ്മാണം നിർബന്ധിക്കാതെ:

$(ഫോണി ഫ്ലഷ്):
&rm -f $(only_stale **/*)

യഥാർത്ഥത്തിൽ, സൃഷ്ടിക്കാൻ makepp-നെ വിളിക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് എഴുതുന്നതാണ് നല്ലത്
പഴകിയ ഫയലുകളുടെ ലിസ്റ്റ്, തുടർന്ന് ലിസ്റ്റ് ചെയ്ത എല്ലാ ഫയലുകളും നീക്കം ചെയ്യാൻ ആ സ്ക്രിപ്റ്റ് ആവശ്യപ്പെടുക
നിലവിൽ ഉറവിട നിയന്ത്രണത്തിലല്ല, ജനറേറ്റ് ചെയ്‌ത ഫയൽ ഒരു ഉറവിടമായി മാറിയാൽ മാത്രം
ഫയൽ. Makepp-ന് അത്തരം ഒരു ഫംഗ്‌ഷൻ അന്തർനിർമ്മിതമല്ല, കാരണം makepp (ഒരുപക്ഷേ
നിലനിൽക്കണം) ഉറവിട നിയന്ത്രണത്തെക്കുറിച്ചുള്ള അജ്ഞേയവാദി.

മാത്രം_ലക്ഷ്യങ്ങൾ ഫയൽനാമങ്ങൾ
യഥാർത്ഥത്തിൽ ചില നിയമങ്ങളുടെ ലക്ഷ്യമായ ലിസ്റ്റിലെ ഫയൽനാമങ്ങൾ മാത്രം നൽകുന്നു
(ഒന്നുകിൽ വ്യക്തമായ അല്ലെങ്കിൽ പാറ്റേൺ നിയമങ്ങൾ). നിങ്ങൾക്ക് വൈൽഡ്കാർഡുകൾ വ്യക്തമാക്കാം (മേക്കപ്പിന്റെ ഉൾപ്പെടെ
പ്രത്യേക വൈൽഡ്കാർഡ്, "**") ഫയൽ നാമങ്ങളിൽ. (കൂടുതൽ വിവരങ്ങൾക്ക് "$(വൈൽഡ്കാർഡ് )" ഫംഗ്‌ഷൻ കാണുക
വിശദാംശങ്ങൾ. ഒരു വൃത്തിയുള്ള ലക്ഷ്യത്തിനായി ഇത് ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്:

.ഫോണി: വൃത്തിയാക്കുക

വൃത്തിയാക്കുക:
&rm -f $(only_targets *)

ഇപ്പോൾ നിങ്ങൾ "makepp clean" എന്ന് ടൈപ്പ് ചെയ്താൽ, അത് എങ്ങനെ നിർമ്മിക്കാമെന്ന് അറിയാവുന്നതെല്ലാം ഇല്ലാതാക്കും. പക്ഷേ
ശുദ്ധമായ ഒരു ലക്ഷ്യം സൃഷ്ടിക്കരുത്, പകരം "makeppclean" ഉപയോഗിക്കുക!

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

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

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

mylib.a: $(only_targets *.o)
&rm -f $(ഔട്ട്പുട്ട്)
$(AR) cr $(ഔട്ട്‌പുട്ട്) $(ഇൻപുട്ടുകൾ)

അപ്പോൾ ഈ പ്രശ്നം ഉണ്ടാകില്ല.

ഇത് ടാർഗെറ്റുകളായി അറിയപ്പെടുന്ന ഫയലുകളെ മാത്രമാണ് സൂചിപ്പിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കുക at The കാലം നിങ്ങളെ
അഭ്യർത്ഥിക്കുക "ലക്ഷ്യങ്ങൾ മാത്രം". a-യുടെ ഡിപൻഡൻസികളിലോ പ്രവർത്തനങ്ങളിലോ "only_targets" ദൃശ്യമാകുകയാണെങ്കിൽ
ഭരണം, അപ്പോൾ സാധ്യമായ എല്ലാ ലക്ഷ്യങ്ങളും അറിയപ്പെടും, കാരണം ആശ്രിതത്വങ്ങളും പ്രവർത്തനങ്ങളും അല്ല
നിയമം നടപ്പിലാക്കുന്നത് വരെ വിലയിരുത്തപ്പെടുന്നു. എന്നിരുന്നാലും, നിങ്ങൾ വിലയിരുത്തുകയാണെങ്കിൽ അത് വിലയിരുത്താൻ ശ്രമിക്കുക
നേരത്തെ ഒരു ":=" വേരിയബിൾ ഉള്ള മേക്ക്ഫയലിൽ ഇതുപോലെ:

ALL_TARGETS := $(only_targets *)

ലക്ഷ്യം1: ആശ്രിതത്വം1
ഓഹരി

ലക്ഷ്യം2: ആശ്രിതത്വം2
ഓഹരി

അപ്പോൾ "only_targets" എന്നതിന് തുടർന്നുള്ള നിയമങ്ങളെക്കുറിച്ച് അറിയില്ല.

അതുപോലെ, "only_targets"-ന്, makefiles-ൽ ഉൽപ്പാദിപ്പിക്കുന്ന ലക്ഷ്യങ്ങളെക്കുറിച്ച് അറിയില്ല
റിക്കേഴ്‌സീവ് മേക്കിൽ ലോഡ് ചെയ്‌തിരിക്കുന്നു. (എന്നാൽ നിങ്ങൾ എങ്ങനെയായാലും റിക്കർസീവ് മേക്ക് ഉപയോഗിക്കരുത്; ഉപയോഗിക്കുക
പകരം "load_makefile" സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിക്കുക അല്ലെങ്കിൽ പ്രത്യക്ഷമായ makefile ലോഡിംഗ് ഉപയോഗിക്കുക.)

ബന്ധു_ഫയലിന്റെ പേര് file1 file2 ഫയൽ3[, വെട്ടിമുറിക്കുക]
നിലവിലെ ഡയറക്‌ടറിയുമായി ബന്ധപ്പെട്ട ആ ഫയലുകളുടെ പേര് നൽകുന്നു (ഒന്ന്
makefile ഉണ്ട്). അനാവശ്യമായ "./", മറ്റ് ജങ്കുകൾ എന്നിവ വൃത്തിയാക്കാനും ഇത് ഉപയോഗിക്കാം
പാത:

DIR := .
SUBDIR := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/files
X := $(relative_filename $(FNAME))

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

റൂട്ട് ഡയറക്‌ടറിയിലൂടെയാണ് പാത പോകുന്നതെങ്കിൽ, ഒന്നുകിൽ നിങ്ങളുടെ ഹോം ഡയറക്‌ടറിയുടെ പേരന്റ് അല്ലെങ്കിൽ
നിങ്ങളുടെ ബിൽഡ് സിസ്റ്റത്തിന്റെ "$(ROOT)" അല്ലെങ്കിൽ Windows-ൽ ഒരു ഡ്രൈവിന്റെ റൂട്ട് (അതിനെ ആശ്രയിച്ച്
പരിസ്ഥിതി, ഇതും സംഭവിക്കുന്നു /സിഗ്ഡ്രൈവ്/സി or /c), ഒരു സമ്പൂർണ്ണ പാത ആയിരിക്കും
പകരം മടങ്ങി.

ബന്ധു file1 file2 ഫയൽ3[, ഡയറക്ടറി]
നിർദ്ദിഷ്ട ഡയറക്‌ടറിയുമായി ബന്ധപ്പെട്ട ആ ഫയലുകളുടെ പേര് നൽകുന്നു. ഇതാണ്
ഏത് കാരണത്താലും a-യിൽ നിന്ന് ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യേണ്ടിവരുമ്പോൾ സാധാരണയായി ഉപയോഗപ്രദമാണ്
വ്യത്യസ്ത ഡയറക്‌ടറി (ഡിഫോൾട്ട് കറന്റ് ഡയറക്‌ടറി):

source_backup.tar:
cd .. && ടാർ cf $(relative_to $(output), ..) $(relative_to ., ..)

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

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

$(src/foo.c src-1.0/bar.c ഹാക്കുകൾ എന്ന പ്രത്യയം)

".c .c" എന്ന ഫലം ഉണ്ടാക്കുന്നു.

താൽക്കാലികം വാക്കുകൾ
നിർദ്ദിഷ്‌ട ടാർഗെറ്റുകൾ സൃഷ്‌ടിക്കുന്ന നിയമം വഴി നീക്കം ചെയ്‌തേക്കാമെന്ന് makepp-നെ അറിയിക്കുക
അവരെ. "ഫോണി" എന്നതിന് സമാനമായി, ആ പേരിന്റെ യഥാർത്ഥ ഫയൽ മേക്കപ്പ് പ്രതീക്ഷിക്കുന്നു എന്നതൊഴിച്ചാൽ
ഭരണം ബാധിച്ചേക്കാം. ഒരു നിയമം താൽക്കാലികം മാത്രമാണെങ്കിൽ അത് നടപ്പിലാക്കില്ല
ലക്ഷ്യങ്ങൾ കാലഹരണപ്പെട്ടതാണ്.

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

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

സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾ
ആഡ്പ്രിഫിക്സ് ഉപസർഗ്ഗം, വാക്കുകൾ
ഓരോ പദത്തിനും പ്രിഫിക്‌സ് സ്ട്രിംഗ് മുൻകൂർ ചെയ്യുന്നു. ഇത് കൂടുതലും ഗ്നു നിർമ്മാണത്തിനാണ്
അനുയോജ്യത; ആർസി-സ്റ്റൈൽ എക്സ്പാൻഷൻ ഉപയോഗിച്ച്, ഇത് കൂടുതൽ വായിക്കാവുന്ന രീതിയിൽ ചെയ്യാം
ഇതുപോലെ:

മൊഡ്യൂളുകൾ := abcd
X_OLD_STYLE := $(addprefix $(OBJDIR)/, $(addsuffix .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # വായിക്കാൻ എളുപ്പമല്ലേ?

അനുബന്ധപ്രത്യയം പ്രത്യയം, വാക്കുകൾ
ഓരോ പദത്തിനും സഫിക്സ് സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കുന്നു. ഇത് കൂടുതലും ഗ്നു നിർമ്മാണത്തിനാണ്
അനുയോജ്യത; ആർസി-സ്റ്റൈൽ എക്സ്പാൻഷൻ ഉപയോഗിച്ച്, ഇത് കൂടുതൽ വായിക്കാവുന്ന രീതിയിൽ ചെയ്യാം
ഇതുപോലെ:

X_OLD_STYLE := $(addsuffix .o, $(MODULES))
X_NEW_STYLE := $(MODULES).o

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

മാക്രോയുടെ വികാസ സമയത്ത്, താൽക്കാലിക വേരിയബിളുകൾ $1, $2, "..." കാണുക
അതിന്റെ അഭ്യർത്ഥന സമയത്ത് "വിളിക്കാൻ" നൽകിയ വാദങ്ങൾ. വേരിയബിൾ $0 വരെ വികസിപ്പിക്കും
മാക്രോയുടെ പേര് (ഉദാ വേരിയബിൾ) ആ "കോൾ" നിലവിൽ വികസിക്കുന്നു.

ഒരു മാക്രോയെ എത്ര ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് "വിളിക്കാം" അല്ലെങ്കിൽ എത്രയെണ്ണം എന്നതിന് പരിധിയില്ല
ഒരു മാക്രോ പ്രതീക്ഷിക്കുന്ന പാരാമീറ്ററുകൾ. മാക്രോ ആയി "വിളിക്കുക" എന്നതിലേക്ക് നിങ്ങൾ കൂടുതൽ ആർഗ്യുമെന്റുകൾ നൽകിയാൽ
ആവശ്യം, എല്ലാ കവിഞ്ഞ വാദങ്ങളും തള്ളിക്കളയും. എയേക്കാൾ കുറച്ച് ആർഗ്യുമെന്റുകൾ നിങ്ങൾ പാസാക്കുകയാണെങ്കിൽ
മാക്രോ പ്രതീക്ഷിക്കുന്നു, കവിഞ്ഞ എല്ലാ പാരാമീറ്ററുകളും ശൂന്യമായ സ്ട്രിംഗിലേക്ക് ചുരുങ്ങുന്നു.

ആദ്യം ഒരു ലളിതമായ ഉദാഹരണം:

ബാക്കി = $(വേഡ്‌ലിസ്റ്റ് 2, $(വാക്കുകൾ $(1)),$(1))
ലിസ്റ്റ് = എബിസിഡിഇ
ബട്ട്‌ഫസ്റ്റ് := $(കോൾ റെസ്റ്റ്,$(ലിസ്റ്റ്))

ഇവിടെ, "$(butfirst)" എന്ന വേരിയബിളിൽ "BCDE" ലിസ്റ്റ് അടങ്ങിയിരിക്കും.

ഇപ്പോൾ സാധ്യമായത് കാണിക്കാൻ കൂടുതൽ സങ്കീർണ്ണമായ ഉദാഹരണത്തിനായി:

ബാക്കി = $(വേഡ്‌ലിസ്റ്റ് 2,$(പദങ്ങൾ $(1)),${1})
mymap = $($2 ആണെങ്കിൽ,$($1 എന്ന് വിളിക്കുക,$(ആദ്യ വാക്ക് $2)) $($0,$1,$(കോൾ റെസ്റ്റ്,$2)))
downcase = ${makeperl lc("$1")}

UCWORDS = ഈ വാക്കുകളെല്ലാം അപ്കേസ് ആണ്
DCWORDS := $(കോൾ മൈമാപ്പ്,ഡൗൺകേസ്,$(UCWORDS))

ഇപ്പോൾ "$(DCWORDS)" എന്നതിൽ "ഈ വാക്കുകളെല്ലാം അപ്കേസ് ആണ്". വഴിയിൽ: അത് ഇല്ല
വ്യത്യാസം, ഞങ്ങൾ ആർഗ്യുമെന്റുകൾ വഴി ആക്സസ് ചെയ്യുമോ എന്ന് $1, "${1}" or "$(1)" ഒരു മാക്രോയ്ക്കുള്ളിൽ.

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

ചർച്ച = $0 എന്നത് $1 $2 ആയി മാറി.
നേരിട്ടുള്ള = $(ചർച്ച ഒരു, വാദം)
വിളിച്ചു = $(കോൾ ചർച്ച,ഒരു,വാദം)

"$[കോൾ]" മാക്രോയുടെ "$[]" വിപുലീകരിക്കണമോ എന്നത് ചർച്ചാവിഷയമായി തോന്നിയേക്കാം.
എക്‌സ്‌പ്രഷനുകൾ, അല്ലെങ്കിൽ ഒരു ഫംഗ്‌ഷൻ എല്ലായ്‌പ്പോഴും ഒരേ കാര്യം ചെയ്യണമോ, അത് എങ്ങനെയായാലും
വിളിച്ചു. രണ്ടാമത്തേത് തിരഞ്ഞെടുത്തു, കാരണം ഇത് സാധാരണ വാക്യഘടനയിൽ ആയിരിക്കും
"$[1], $[2]..." ഒരു വേരിയബിളിലേക്ക് കൊണ്ടുവരുന്നത് അസാധ്യമാണ് (അവയ്ക്ക് പകരം മറ്റൊന്നും ലഭിക്കില്ല,
അസൈൻമെന്റ് നടക്കുന്നതിന് മുമ്പ്.) അതിനാൽ, നിർവ്വചിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു മാക്രോ ഉണ്ടെങ്കിൽ a
റൂൾ, റൂൾ പാഴ്‌സ് ചെയ്യുമ്പോൾ "$(ഔട്ട്‌പുട്ട്)" പോലുള്ള പദപ്രയോഗങ്ങൾ കാണണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നു, അതിനാൽ
നിങ്ങൾ അവരെ "വിളിയിൽ" നിന്ന് സംരക്ഷിക്കണം:

myrule നിർവ്വചിക്കുക
$2: $1
mycommand $$(ഇൻപുട്ട്) -o $$(ഔട്ട്പുട്ട്)
endef
$[myrule myinput,myoutput]

ഫിൽറ്റർ ചെയ്യുക പാറ്റേണുകൾ, വാക്കുകൾ
പാറ്റേണുകളുമായി പൊരുത്തപ്പെടുന്ന ലിസ്റ്റിലെ എല്ലാ വാക്കുകളും നൽകുന്നു. പാറ്റേണുകൾ മറ്റുള്ളവയായിരിക്കാം
വാക്കുകൾ, അല്ലെങ്കിൽ ഫയൽനാമം വൈൽഡ്കാർഡുകൾ (അതായത്, "*", "?", "[az]" എന്നിവ അംഗീകരിക്കപ്പെട്ടിരിക്കുന്നു), അല്ലെങ്കിൽ അവ
ഒരു "%" പ്രതീകം ഉണ്ടായിരിക്കും, അതായത് ആ ഘട്ടത്തിൽ ഏത് സ്ട്രിംഗും പൊരുത്തപ്പെടുത്തുക ("*" പോലെ തന്നെ).

ഫിൽറ്റർ_ഔട്ട് പാറ്റേണുകൾ, വാക്കുകൾ
പാറ്റേണുകളുമായി പൊരുത്തപ്പെടാത്ത ലിസ്റ്റിലെ എല്ലാ വാക്കുകളും നൽകുന്നു. പാറ്റേണുകൾ ലളിതമായിരിക്കാം
മറ്റ് വാക്കുകൾ, അല്ലെങ്കിൽ ഫയൽനാമം വൈൽഡ്കാർഡുകൾ (അതായത്, "*", "?", "[az]" എന്നിവ അംഗീകരിക്കപ്പെട്ടിരിക്കുന്നു), അല്ലെങ്കിൽ
അവയ്‌ക്ക് ഒരു "%" പ്രതീകം ഉണ്ടായിരിക്കാം, അതിനർത്ഥം ആ ഘട്ടത്തിൽ ഏതെങ്കിലും സ്‌ട്രിംഗുമായി പൊരുത്തപ്പെടുത്തുക എന്നാണ് (അത് പോലെ
"*").

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

libproduction.a: $(filter_out test_*, $(wildcard *.o))

എല്ലാം ഇടും .o ആരംഭിക്കുന്നവ ഒഴികെ നിലവിലുള്ളതോ നിർമ്മിക്കാൻ കഴിയുന്നതോ ആയ ഫയലുകൾ പരിശോധന_,
കടന്നു ലിബ്പ്രൊഡക്ഷൻ.എ.

ഫൈൻഡ്സ്ട്രിംഗ് കണ്ടെത്തുക, in
മടങ്ങുക കണ്ടെത്തുക, ഇത് ഒരു ഉപസ്ട്രിംഗ് ആണെങ്കിൽ in.

ആദ്യവാക്ക് വാക്കുകൾ
ആദ്യ വാക്ക് തിരികെ നൽകുക.

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

വാക്കുകൾ $_ എന്നതിലാണ്, നിങ്ങൾ $_ എന്നതിനെ ഒഴിവാക്കുന്നില്ലെങ്കിൽ തിരികെ നൽകും. ഇത് ഉദ്ദേശിച്ചുള്ളതാണ്
മാറ്റങ്ങൾ "patsubst" എളുപ്പത്തിൽ കൈകാര്യം ചെയ്യില്ല. ആദ്യത്തെ കോമ മാത്രമാണ് ഒരു സെപ്പറേറ്റർ,
മറ്റുള്ളവയെ അതിന്റെ ഭാഗമായി കണക്കാക്കുന്നു പെർൽകോഡ്.

# വാക്കുകൾ മാറ്റുക. പെർൽകോഡിൽ പാരൻസുകളെ അനുവദിക്കുന്നതിന് ഇരട്ട പാരൻസ്, അല്ലെങ്കിൽ ${} ഉപയോഗിക്കുക:
X = $((മാപ്പ് $(VALUES), s/(.+)-(.+)/$2-$1/))
# നിങ്ങൾക്ക് മേക്ക് എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കാം, എന്നാൽ നിങ്ങൾ പേൾ $-ന് $$ ഉപയോഗിക്കണം:
Y = $(മേക്ക്മാപ്പ് $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ അല്ലെങ്കിൽ $$_ = 'പരാജയപ്പെട്ടു')
# നിങ്ങൾക്ക് സ്ഥാനാർത്ഥികളെ ഒഴിവാക്കാം:
Y = $(മാപ്പ് $(VALUES), undef $_ എങ്കിൽ /no_good/)

ചേരുക വാക്കുകൾ 1, വാക്കുകൾ2
ആദ്യത്തെ വാക്കുകളും രണ്ടാമത്തെ വാക്കുകളും ജോടിയായി കൂട്ടിച്ചേർക്കുക.

patsubst മാതൃക, പകരമായി, വാക്കുകൾ
പദ ലിസ്റ്റിലെ ഓരോ വാക്കിലും ഒരു പകരം വയ്ക്കൽ നടത്തുന്നു. ഏതെങ്കിലും ഒരു "%" പ്രതീകം പൊരുത്തപ്പെടുന്നു
സ്ട്രിംഗ്. ഇത് ഒരു ഉദാഹരണത്തിലൂടെ മികച്ച രീതിയിൽ വ്യക്തമാക്കുന്നു:

OBJS = $(patsubst %.c, object_dir/%.o, $(C_SOURCES))

C_SOURCES-ലെ എല്ലാ ഫയലുകളും എടുക്കുകയും object_dir-ൽ ഒരു ഒബ്‌ജക്റ്റ് ഫയലിന്റെ പേര് നൽകുകയും ചെയ്യുന്നു.
ചിലപ്പോൾ ഒരു സബ്സ്റ്റിറ്റ്യൂഷൻ റഫറൻസ് ഉപയോഗിക്കുന്നത് കൂടുതൽ സംക്ഷിപ്തമാണ്, ഉദാ, മുകളിൽ പറഞ്ഞവ സാധ്യമാണ്
എന്ന് എഴുതിയിട്ടുണ്ട്

OBJS = $(C_SOURCES:%.c=object_dir/%.o)

അടുക്കുക വാക്ക്1 വാക്ക്2 വാക്ക്3 ...
വാക്കുകളെ ലെക്സിക്കൽ ക്രമത്തിൽ അടുക്കുകയും തനിപ്പകർപ്പുകൾ നീക്കം ചെയ്യുകയും ചെയ്യുന്നു.

സ്ട്രിപ്പ് സ്ട്രിംഗ്
സ്‌ട്രിംഗിൽ നിന്ന് ലീഡിംഗ്, ട്രെയിലിംഗ് വൈറ്റ്‌സ്‌പെയ്‌സ് നീക്കം ചെയ്യുകയും ഓരോ ഇന്റേണലും മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യുന്നു
ഒരൊറ്റ സ്‌പെയ്‌സുള്ള ഒന്നോ അതിലധികമോ വൈറ്റ്‌സ്‌പേസ് പ്രതീകങ്ങളുടെ ക്രമം. അങ്ങനെ, "$(സ്ട്രിപ്പ് എബി
c )" ഫലങ്ങൾ "abc" ആയി മാറുന്നു.

സബ്സ്റ്റ് മുതൽ, വരെ, വാചകം
ടെക്‌സ്‌റ്റ് ടെക്‌സ്‌റ്റിൽ ഒരു ടെക്‌സ്‌ച്വൽ റീപ്ലേസ്‌മെന്റ് നടത്തുന്നു: എന്നതിന്റെ ഓരോ സംഭവവും മാറ്റിസ്ഥാപിക്കുന്നു
വഴി. ഫലം ഫംഗ്ഷൻ കോളിന് പകരം വയ്ക്കുന്നു. ഉദാഹരണത്തിന്,

$(സബ്സ്റ്റ് ഇഇ, ഇഇ, പാദങ്ങൾ തെരുവിൽ)

"FEEt on the strEEt" എന്ന സ്ട്രിംഗ് മാറ്റിസ്ഥാപിക്കുന്നു.

വാക്ക് n, ടെക്സ്റ്റ്
തിരികെ നൽകുന്നു nഎന്ന വാക്ക് ടെക്സ്റ്റ്. നിയമാനുസൃതമായ മൂല്യങ്ങൾ n തുടക്കത്തിൽ 1 മുതൽ ആരംഭിക്കുക
അല്ലെങ്കിൽ അവസാനം -1 മുതൽ പിന്നോട്ട്. എങ്കിൽ n പദങ്ങളുടെ എണ്ണത്തേക്കാൾ വലുതാണ് ടെക്സ്റ്റ്,
മൂല്യം ശൂന്യമാണ്.

വാക്കുകളുടെ പട്ടിക സൂചിക പട്ടിക, വാക്കുകൾ
വാക്കുകളുടെ പട്ടിക ആദ്യ സൂചിക, അവസാന സൂചിക, വാക്കുകൾ
ആദ്യ ഫോമിൽ നിങ്ങൾ സൂചികകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു (തുടക്കത്തിൽ 1 മുതൽ എണ്ണുന്നു അല്ലെങ്കിൽ
നിങ്ങൾക്ക് ആവശ്യമുള്ള വാക്കുകൾ തിരഞ്ഞെടുക്കുന്നതിന് അവസാനം -1 ൽ നിന്ന് പിന്നിലേക്ക്. രണ്ടാമത്തെ രൂപത്തിൽ നിങ്ങൾ
നിങ്ങൾക്ക് തിരികെ നൽകേണ്ട പദങ്ങളുടെ ശ്രേണി വ്യക്തമാക്കുക.

വാക്കുകൾ ടെക്സ്റ്റ്
പദങ്ങളുടെ എണ്ണം നൽകുന്നു ടെക്സ്റ്റ്.

കലര്പ്പായ പ്രവർത്തനങ്ങൾ
foreach var, ലിസ്റ്റ്, ടെക്സ്റ്റ്
ആദ്യത്തെ രണ്ട് വാദങ്ങൾ, വേരിയബിൾ ഒപ്പം പട്ടിക, മറ്റെന്തെങ്കിലും ചെയ്യുന്നതിനുമുമ്പ് വിപുലീകരിക്കപ്പെടുന്നു; കുറിപ്പ്
അവസാന വാദം, വാചകം, ഒരേ സമയം വിപുലീകരിക്കപ്പെടുന്നില്ല. പിന്നെ ഓരോ വാക്കിനും
ലിസ്റ്റിന്റെ വിപുലീകരിച്ച മൂല്യം, var ന്റെ വിപുലീകരിച്ച മൂല്യം കൊണ്ട് നാമകരണം ചെയ്ത വേരിയബിൾ ആയി സജ്ജീകരിച്ചിരിക്കുന്നു
ആ വാക്ക്, വാചകം വിപുലീകരിച്ചു. അനുമാനിക്കാവുന്ന ടെക്‌സ്‌റ്റിൽ ആ വേരിയബിളിനെക്കുറിച്ചുള്ള റഫറൻസുകൾ അടങ്ങിയിരിക്കുന്നു,
അതിനാൽ ഓരോ തവണയും അതിന്റെ വികാസം വ്യത്യസ്തമായിരിക്കും.

ഈ ലളിതമായ ഉദാഹരണം വേരിയബിളിനെ സജ്ജമാക്കുന്നു ഫയലുകൾ എന്നതിലെ എല്ലാ ഫയലുകളുടെയും ലിസ്റ്റിലേക്ക്
പട്ടികയിലെ ഡയറക്ടറികൾ dirs:

dirs := abcd
ഫയലുകൾ := $(foreach dir,$(dirs),$(വൈൽഡ്കാർഡ് $(dir)/*))

ഇവിടെ വാചകം "$(വൈൽഡ്കാർഡ് $(dir)/*)" ആണ്. ആദ്യ ആവർത്തനം dir ന് "a" മൂല്യം കണ്ടെത്തുന്നു,
അതിനാൽ ഇത് "$(വൈൽഡ്കാർഡ് a/*)" എന്നതിന് സമാനമായ ഫലം നൽകുന്നു; രണ്ടാമത്തെ ആവർത്തനം ഉത്പാദിപ്പിക്കുന്നു
"$(വൈൽഡ്കാർഡ് ബി/*)" ഫലം; മൂന്നാമത്തേത്, "$(വൈൽഡ്കാർഡ് സി/*)".

ഈ ഉദാഹരണത്തിന് ഇനിപ്പറയുന്ന ഉദാഹരണത്തിന് സമാനമായ ഫലം ("dirs" സജ്ജീകരിക്കുന്നത് ഒഴികെ) ഉണ്ട്:

ഫയലുകൾ := $(വൈൽഡ്കാർഡ് a/* b/* c/* d/*)

ടെക്‌സ്‌റ്റ് സങ്കീർണ്ണമാകുമ്പോൾ, അതിന് ഒരു പേര് നൽകി വായനാക്ഷമത മെച്ചപ്പെടുത്താം
അധിക വേരിയബിൾ:

find_files = $(വൈൽഡ് കാർഡ് $(dir)/*)
dirs := abcd
ഫയലുകൾ := $(foreach dir,$(dirs),$(find_files))

ഇവിടെ നമ്മൾ ഈ രീതിയിൽ find_files എന്ന വേരിയബിൾ ഉപയോഗിക്കുന്നു. a നിർവചിക്കാൻ ഞങ്ങൾ പ്ലെയിൻ "=" ഉപയോഗിക്കുന്നു
ആവർത്തന-വികസിക്കുന്ന വേരിയബിൾ, അതിനാൽ അതിന്റെ മൂല്യത്തിൽ ഒരു യഥാർത്ഥ ഫംഗ്ഷൻ കോൾ അടങ്ങിയിരിക്കുന്നു
ഫോറിന്റെ നിയന്ത്രണത്തിൽ വീണ്ടും വിപുലീകരിക്കും; ലളിതമായി-വികസിപ്പിച്ച വേരിയബിൾ ചെയ്യില്ല,
കാരണം, find_files നിർവചിക്കുന്ന സമയത്ത് ഒരു തവണ മാത്രമേ വൈൽഡ്കാർഡ് വിളിക്കൂ.

ശ്രദ്ധിക്കുക: "$(foreach)" പ്രത്യേക വേരിയബിളുമായി ഇത് ആശയക്കുഴപ്പത്തിലാക്കരുത്.

വിവരം ടെക്സ്റ്റ്
മുന്നറിയിപ്പ് ടെക്സ്റ്റ്
പിശക് ടെക്സ്റ്റ്
ഔട്ട്‌പുട്ട് ടെക്‌സ്‌റ്റ് ഒന്നും തിരികെ നൽകുന്നു. ആദ്യത്തേത് STDOUT-ലേക്ക് പോകുന്നു, രണ്ടാമത്തേത് STDERR-ലേക്ക്,
മൂന്നാമത്തേത് പ്രോസസ്സിംഗ് നിർത്തലാക്കുന്നു.

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

file_list :
പ്രോഗ്രാമിൽ ഉൾപ്പെടുത്തേണ്ട ഫയലുകളുടെ ഒരു ലിസ്റ്റ് കണക്കാക്കുന്നതിനുള്ള # ഷെൽ കമാൻഡുകൾ

my_program : $(&പൂച്ച $(പ്രീബിൽഡ് ഫയൽ_ലിസ്റ്റ്))

നിങ്ങൾക്ക് ഒന്നിലധികം നിയമങ്ങളിൽ ലിസ്റ്റ് ആവശ്യമുണ്ടെങ്കിൽ, ഒരു ഉപയോഗിക്കുന്നത് കൂടുതൽ കാര്യക്ഷമമായിരിക്കും
ഒരു തവണ വേരിയബിൾ വികസിപ്പിക്കുക:

file_list ;= $(&cat $(prebuild file_list))

my_program1 : ao $(file_list)

my_program2 : ബോ $(file_list)

പകരം നിങ്ങൾ "$(&cat file_list)" മാത്രം വ്യക്തമാക്കിയാൽ, makepp നിർബന്ധിക്കില്ല
file_list ഷെൽ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് കാലികമായിരിക്കേണ്ടതാണ്. "$(prebuild )" ഉപയോഗിക്കുന്നു
ഈ പ്രശ്നം പരിഹരിക്കാനുള്ള ഏറ്റവും നല്ല മാർഗമാണ്. മറ്റ് കാര്യങ്ങൾ പരീക്ഷിക്കാൻ നിങ്ങൾ പ്രലോഭിപ്പിച്ചേക്കാം
ഈ:

my_program : file_list $(&cat file_list)

എന്നാൽ ഇത് പ്രവർത്തിക്കില്ല കാരണം "$(&cat file_list)" എന്നത് makepp ശ്രമിക്കുന്നതിന് മുമ്പ് വിലയിരുത്തപ്പെടുന്നു
"file_list" നിർമ്മിക്കുക.

മാത്രം_phony_targets പേരുകൾ
ചില നിയമങ്ങളുടെ വ്യാജ ലക്ഷ്യമായ ലിസ്റ്റിലെ പേരുകൾ മാത്രം നൽകുന്നു (ഒന്നുകിൽ
വ്യക്തമായ അല്ലെങ്കിൽ പാറ്റേൺ നിയമങ്ങൾ). നിങ്ങൾക്ക് വൈൽഡ്കാർഡുകൾ വ്യക്തമാക്കാം (മേക്കപ്പിന്റെ സ്പെഷ്യൽ ഉൾപ്പെടെ
ഫയൽനാമങ്ങളിൽ വൈൽഡ്കാർഡ്, "**"). (കൂടുതൽ വിശദാംശങ്ങൾക്ക് "$(വൈൽഡ്കാർഡ് )" ഫംഗ്ഷൻ കാണുക.
ടാർഗെറ്റുകൾ ഗ്രൂപ്പുചെയ്യുന്നതിന് ഇത് ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്:

$(ഫോണി ടെസ്റ്റുകൾ): $(only_phony_targets */**/tests)

ഉത്ഭവം വേരിയബിൾ
ഒരു വേരിയബിളിന്റെ പേര് നൽകിയാൽ, അതിന്റെ മൂല്യം എവിടെ നിന്നാണ് വരുന്നതെന്ന് നിങ്ങളോട് പറയുന്നു.

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

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

VAR = 1
VAR1 = ${perl ($VAR + 1) * 3}
VAR2 = $(perl do {$VAR *= 3; $VAR ആണെങ്കിൽ $VAR + 1 } തിരികെ നൽകുക)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # ഒന്ന് Make var, ഒരു Perl var
VAR = $((perl if(... ) {... }))

വ്യാജൻ വാക്കുകൾ
വാക്കുകളുടെ ലിസ്റ്റ് യഥാർത്ഥത്തിൽ വ്യാജ ലക്ഷ്യങ്ങളാണെന്ന് സൂചിപ്പിക്കുന്നു, കൂടാതെ ലിസ്റ്റ് തിരികെ നൽകുന്നു
ലക്ഷ്യങ്ങൾ. ഇത് ഇതുപോലെ ഉപയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്:

$(ഫോണി എല്ലാം): my_program

$(ഫോണി ക്ലീൻ):
&rm -f *.o my_program

നിങ്ങൾക്ക് എവിടെയും ഇതുപോലെ ഒരു ലൈൻ ഉപയോഗിച്ച് ഒന്നോ അതിലധികമോ ടാർഗെറ്റുകൾ വ്യാജമായി പ്രഖ്യാപിക്കാനും കഴിയും
നിങ്ങളുടെ മെയ്ക്ക് ഫയൽ:

.ഫോണി: എല്ലാം വൃത്തിയായി

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

XYZ := $(പ്രിന്റ് $(patsubst %.c, %o, $(SOURCE_FILES)))

"patsubst" കോളിന്റെ ഫലം പ്രിന്റ് ചെയ്യും.

XYZ := $(patsubst %.c, %o, $(print $(SOURCE_FILES)))

"patsubst" കോളിലേക്കുള്ള അവസാന ആർഗ്യുമെന്റ് പ്രിന്റ് ഔട്ട് ചെയ്യും.

ഷെൽ ഷെൽ-കമാൻഡ്
നൽകിയിരിക്കുന്ന ഷെൽ കമാൻഡിൽ നിന്നുള്ള ഔട്ട്‌പുട്ട് നൽകുന്നു, പുതിയ ലൈനുകൾ സ്‌പെയ്‌സുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.

ശ്രദ്ധിക്കുക, എല്ലാ ഫംഗ്‌ഷനുകളിലെയും പോലെ, ഉപയോഗിച്ച ഫംഗ്‌ഷൻ ഡിലിമിറ്റർ ഉള്ളിൽ ദൃശ്യമാകണമെന്നില്ല
ഒറ്റ അല്ലെങ്കിൽ ഇരട്ട ഉദ്ധരണി സ്ട്രിംഗുകൾക്ക് പുറത്തുള്ള ഷെൽ-കമാൻഡ്. എന്നാൽ നിങ്ങൾക്ക് ഇത് ഇരട്ടിയാക്കാം
രണ്ടാമത്തെ ഉദാഹരണത്തിലെന്നപോലെ:

തീയതി = $(ഷെൽ തീയതി) # മികച്ചത്: $(പെർൽ സ്കെലാർ പ്രാദേശിക സമയം)
VAR = ${{shell f() {echo hello; }; f}}

xargs കമാൻഡ്, ആർഗ്യുമെന്റുകൾ[,സഫിക്സ്[,നീളം]]
ഓരോന്നും നിർദ്ദിഷ്‌ടമായി ആരംഭിക്കുന്ന കമാൻഡുകളുടെ പുതിയ ലൈൻ-വേർതിരിക്കപ്പെട്ട ലിസ്റ്റ് നൽകുന്നു
കമാൻഡ് ചെയ്യുക, കൂടാതെ ലിസ്റ്റിന്റെ പരമാവധി ഘടകങ്ങൾ ഉപയോഗിച്ച് അവസാനിപ്പിക്കുക
നീളം (ഡിഫോൾട്ട് 1000) പ്രതീകങ്ങൾ.

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

$(ഫോണി ക്ലീൻ):
$(xargs $(RM), $(only_targets **/*))

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

$(ഫോണി ക്ലീൻ):
&rm -f $(മാത്രം_ലക്ഷ്യങ്ങൾ **/*)

മൂന്നാമത്തെ ആർഗ്യുമെന്റ് വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ഓരോ കമാൻഡും പോസ്റ്റ്ഫിക്സ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കുന്നു. ഇതാണ്
റീഡയറക്‌ടറുകൾ വ്യക്തമാക്കുന്നതിന് ഉപയോഗപ്രദമാണ്, ഉദാ (ഇവിടെ വീണ്ടും &എക്കോ സഹായിക്കും):

പ്രകടമായത്:
&rm -f $@
&സ്പർശിക്കുക $@
$(xargs echo, $(only_nontargets **/*), >> $@)

ഈ ഡോക്യുമെന്റേഷനിൽ ചിലത് ഗ്നു മേക്ക് ഡോക്യുമെന്റേഷനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.

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

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