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

പട്ടിക:

NAME

makepp_cookbook -- വിവിധ സാഹചര്യങ്ങൾക്കായി മേക്ക് ഫയലുകൾ സജ്ജീകരിക്കുന്നതിനുള്ള മികച്ച മാർഗം

വിവരണം

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

കെട്ടിടം ലൈബ്രറികൾ
Do നിങ്ങളെ ശരിക്കും ആവശ്യം a പുസ്തകശാല?

ഓരോന്നിനും ധാരാളം മൊഡ്യൂളുകൾ അടങ്ങുന്ന നിരവധി വലിയ പ്രോഗ്രാമുകൾ ഞാൻ കണ്ടിട്ടുണ്ട്
സ്വന്തം ഡയറക്ടറിയിൽ ജീവിക്കുന്നത്. സാധാരണയായി, ഓരോ ഡയറക്‌ടറിയും അതിന്റെ സ്വന്തം ലൈബ്രറിയിൽ ഇടുന്നു,
തുടർന്ന് അവസാന പ്രോഗ്രാം എല്ലാ ലൈബ്രറികളുമായും ബന്ധിപ്പിക്കുന്നു.

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

1. നിങ്ങൾക്ക് ഒരു കൂട്ടം സബ്റൂട്ടീനുകൾ ഉള്ളപ്പോൾ, അവ പല വ്യത്യസ്‌തങ്ങളുമായി ലിങ്ക് ചെയ്യേണ്ടതുണ്ട്
പ്രോഗ്രാമുകൾ, കൂടാതെ ഒരു പ്രോഗ്രാമും യഥാർത്ഥത്തിൽ 100% സബ്റൂട്ടീനുകൾ ഉപയോഗിക്കുന്നില്ല--ഓരോ പ്രോഗ്രാമും ഉപയോഗിക്കുന്നു a
വ്യത്യസ്ത ഉപവിഭാഗം. ഈ സാഹചര്യത്തിൽ, ഒരു സ്റ്റാറ്റിക് ലൈബ്രറി ഉപയോഗിക്കുന്നത് നല്ലതായിരിക്കും (എ
.a ഫയൽ, അല്ലെങ്കിൽ ഒരു ആർക്കൈവ് ഫയൽ).

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

3. നിങ്ങളുടെ ലിങ്ക് സമയം വളരെ ദൈർഘ്യമേറിയതാണെങ്കിൽ, വലിയ ഭാഗങ്ങൾക്കായി പങ്കിട്ട ലൈബ്രറികൾ ഉപയോഗിക്കുന്നു
പ്രോഗ്രാമിന് ലിങ്ക് ഗണ്യമായി വേഗത്തിലാക്കാൻ കഴിയും.

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

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

മറ്റേതെങ്കിലും പ്രോഗ്രാമിൽ നിങ്ങളുടെ മൊഡ്യൂൾ ഒരിക്കലും ഉപയോഗിക്കപ്പെടുന്നില്ലെങ്കിൽ, ഉപയോഗിക്കുന്നതിന് ചെറിയ കാരണങ്ങളൊന്നുമില്ല
ഒരു ലൈബ്രറി: ലൈബ്രറികൾ ഉപയോഗിക്കുന്നതിന്റെ എല്ലാ പോരായ്മകളും നിങ്ങൾക്ക് ലഭിക്കും, ഗുണങ്ങളൊന്നുമില്ല.
ഞാൻ തിരഞ്ഞെടുക്കുന്ന സാങ്കേതികത, അത് ലഭ്യമാകുന്നിടത്ത് ഇൻക്രിമെന്റൽ ലിങ്കിംഗ് ഉപയോഗിക്കുന്നതാണ്.

Linux-ൽ നിങ്ങൾക്ക് ഇത് എങ്ങനെ ചെയ്യാമെന്നത് ഇതാ:

my_module.o : $(filter_out my_module.o, $(wildcard *.o))
ld -r -o $(ഔട്ട്പുട്ട്) $(ഇൻപുട്ടുകൾ)

ഇത് ചെയ്യുന്നത് മറ്റൊന്ന് സൃഷ്ടിക്കുക എന്നതാണ് .o എന്ന ഫയൽ my_module.o, അടങ്ങുന്നതാണ്
എല്ലാം .o ഈ ഉപഡയറക്‌ടറിയിലെ ഫയലുകൾ. ലിങ്കർ പലതും പരിഹരിക്കും
അവലംബം കഴിയുന്നത്രയും, ബാക്കിയുള്ള അവലംബങ്ങൾ a-ൽ പരിഹരിക്കാൻ വിടുകയും ചെയ്യും
ലിങ്കിംഗിന്റെ തുടർന്നുള്ള ഘട്ടം. ഉയർന്ന തലത്തിൽ, ഒടുവിൽ നിങ്ങളുടെ പ്രോഗ്രാം നിർമ്മിക്കുമ്പോൾ,
ലിങ്ക് ചെയ്യുന്നതിനുപകരം libmy_module.a or libmy_module.so, നിങ്ങൾ ലളിതമായി ലിങ്ക് ചെയ്യും
my_module.o. നിങ്ങൾ ലിങ്ക് ചെയ്യുമ്പോൾ .o ഫയലുകൾ, ഓർഡർ-ആശ്രിതത്വത്തിൽ നിങ്ങൾക്ക് പ്രശ്നങ്ങളില്ല
ലിങ്കർ കമാൻഡ് ലൈൻ.

അനുവദിക്കുന്നു makepp ചിത്രം പുറത്ത് ഏത് ലൈബ്രറി മൊഡ്യൂളുകൾ ആകുന്നു ആവശ്യമുണ്ട്

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

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

ഞാൻ അത് ഉപയോഗിക്കുന്ന രീതിയുടെ ഒരു ഉദാഹരണം ഇതാ:

my_program: $(infer_objects *.o, $(LIB1)/*.o $(LIB2)/*.o)
$(CXX) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്) $(SYSTEM_LIBRARIES)

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

കെട്ടിടം a സ്റ്റാറ്റിക്ക് ലൈബ്രറി

നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ ഒരു ലൈബ്രറി ആവശ്യമാണെന്ന് ഉറപ്പുണ്ടെങ്കിൽ, ഇൻക്രിമെന്റൽ ലിങ്കിംഗ് ലഭ്യമല്ല അല്ലെങ്കിൽ
നിങ്ങൾ എന്താണ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നത്, അത് ചെയ്യാൻ രണ്ട് വഴികളുണ്ട്. ആദ്യം, ഇതാ ഒരു ഉദാഹരണം
എല്ലാ ഫയലുകളും വ്യക്തമായി പട്ടികപ്പെടുത്തിയിരിക്കുന്നിടത്ത്:

LIBRARY_FILES = abcde

libmine.a: $(LIBRARY_FILES).o
&rm -f $(ഔട്ട്പുട്ട്)
$(AR) cr $(ഔട്ട്‌പുട്ട്) $(ഇൻപുട്ടുകൾ)
ranlib $(ഔട്ട്‌പുട്ട്) # നിങ്ങളുടെ OS അനുസരിച്ച് ആവശ്യമില്ലായിരിക്കാം.

&rm എന്നത് makepp-ന്റെ ബിൽറ്റ്-ഇൻ "rm" കമാൻഡ് ആണ്. നിങ്ങൾ മേക്ക് ഫയലുകൾ എഴുതുന്നത് പതിവാണെങ്കിൽ, നിങ്ങളായിരിക്കാം
ഈ കൽപ്പനയിൽ അൽപ്പം ആശ്ചര്യപ്പെട്ടു; ഇതുപോലുള്ള കൂടുതൽ കാര്യങ്ങൾ നിങ്ങൾ ഉപയോഗിച്ചേക്കാം:

libmine.a: $(LIBRARY_FILES).o
$(AR) ru $@ $? # ശുപാശ ചെയ്യപ്പെടുന്നില്ല!!!!!!!
ranlib $(ഔട്ട്പുട്ട്)

എവിടെ $? ("$(changed_inputs)" എന്നും അറിയപ്പെടുന്നു) ഏതെങ്കിലും ഫയലുകളെ അർത്ഥമാക്കുന്ന ഒരു ഓട്ടോമാറ്റിക് വേരിയബിളാണ്
ലൈബ്രറി നിർമ്മിച്ച അവസാന സമയം മുതൽ ഇത് മാറിയിട്ടുണ്ട്, കൂടാതെ $@ ഏകദേശം സമാനമാണ്
"$(ഔട്ട്പുട്ട്)" ആയി.

പല കാരണങ്ങളാൽ ഈ സമീപനം ശുപാർശ ചെയ്യുന്നില്ല:

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

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

അതുകൊണ്ടാണ് ഞങ്ങൾ ആദ്യം ലൈബ്രറി ഫയൽ നീക്കം ചെയ്യുകയും ആദ്യം മുതൽ സൃഷ്ടിക്കുകയും ചെയ്യുന്നത്. ഇത് ചെയ്യും
ഒരു ലൈബ്രറിയിൽ മൊഡ്യൂളുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനേക്കാൾ അൽപ്പം സമയമെടുക്കും, പക്ഷേ കൂടുതൽ സമയമെടുക്കില്ല; ഓൺ
ഒരു ആധുനിക കമ്പ്യൂട്ടർ, ഉപയോഗിക്കുന്ന സമയം ar പ്രോഗ്രാം താരതമ്യപ്പെടുത്തുമ്പോൾ വളരെ കുറവാണ്
ഒരു സാധാരണ ബിൽഡിൽ സി കംപൈലർ ഏറ്റെടുക്കുന്ന കാര്യങ്ങളിൽ ആശങ്കപ്പെടേണ്ടതില്ല
ഏകദേശം.

ശരിയായ ബിൽഡുകൾക്ക് ഗ്യാരന്റി നൽകാൻ makepp ശ്രമിക്കുന്ന ഒരു മാർഗ്ഗം അത് ചെയ്യും എന്നതാണ്
തന്നിരിക്കുന്ന ടാർഗെറ്റ് നിർമ്മിക്കുന്നതിനുള്ള കമാൻഡ് ലൈൻ മാറിയിട്ടുണ്ടെങ്കിൽ യാന്ത്രികമായി പുനർനിർമ്മിക്കുക. പക്ഷേ
$ ഉപയോഗിക്കുന്നത്? വേരിയബിൾ പ്രശ്നങ്ങൾ ഉണ്ടാക്കാം, കാരണം ഓരോ തവണയും ലൈബ്രറി അപ്ഡേറ്റ് ചെയ്യപ്പെടുന്നു,
ബിൽഡ് കമാൻഡ് വ്യത്യസ്തമാണ്. (ഇത് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അടിച്ചമർത്താൻ കഴിയും
": ബിൽഡ്_ചെക്ക് ഇഗ്നോർ_ആക്ഷൻ"; വിശദാംശങ്ങൾക്ക് makepp_build_check കാണുക.)

· ആർക്കൈവ് പുനർനിർമ്മിക്കുന്നതിന് പകരം അത് അപ്ഡേറ്റ് ചെയ്യുന്നത്, makepp-ന് അത് അസാധ്യമാക്കും
ഫയൽ ശരിയായി ഒരു ബിൽഡ് കാഷെയിൽ ഇടുക (വിശദാംശങ്ങൾക്ക് makepp_build_cache കാണുക).

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

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

ഇത് എല്ലാം ഇടുന്നു .o ലൈബ്രറിയിലേക്കുള്ള നിലവിലെ ഡയറക്ടറിയിലെ ഫയലുകൾ. വൈൽഡ്കാർഡ്
ഏതെങ്കിലും പൊരുത്തപ്പെടുന്നു .o നിലവിലുള്ളതോ നിർമ്മിക്കാൻ കഴിയുന്നതോ ആയ ഫയൽ, അതിനാൽ ഫയലുകൾ ഇല്ലെങ്കിലും ഇത് പ്രവർത്തിക്കും
ഇതുവരെ നിലവിലുണ്ട്.

ഒഴിവാക്കുന്നതിന് "only_targets" ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു .o പൊരുത്തപ്പെടാത്ത ഫയലുകൾ
സോഴ്സ് ഫയലുകൾ. നിങ്ങൾക്ക് ഒരു ഫയൽ ഉണ്ടെന്ന് കരുതുക xyz.c നിങ്ങൾ നിങ്ങളുടെ ഇടയിൽ വെച്ചിരുന്നത്
പുസ്തകശാല. ഇതിനർത്ഥം ഒരു ഉണ്ട് എന്നാണ് xyz.o ഫയൽ ചുറ്റും കിടക്കുന്നു. ഇപ്പോൾ നിങ്ങൾ ഇല്ലാതാക്കുക xyz.c
കാരണം അത് കാലഹരണപ്പെട്ടതാണ്, പക്ഷേ നിങ്ങൾ ഇല്ലാതാക്കാൻ മറക്കുന്നു xyz.o. "only_targets" ഇല്ലാതെ
പ്രവർത്തനം, xyz.o എന്ന പട്ടികയിൽ ഇനിയും ഉൾപ്പെടും .o ലൈബ്രറിയിൽ ഉൾപ്പെടുത്തിയിട്ടുള്ള ഫയലുകൾ.

കെട്ടിടം a ചലനാത്മകം ലൈബ്രറി

ഡൈനാമിക് ലൈബ്രറികൾ നിർമ്മിക്കുന്ന പ്രക്രിയ പൂർണ്ണമായും സിസ്റ്റത്തെ ആശ്രയിച്ചിരിക്കുന്നു. ഞാൻ അത്യധികം ആഗ്രഹിക്കുന്നു
ഒരു ഡൈനാമിക് ലൈബ്രറി നിർമ്മിക്കാൻ ലിബ്ടൂൾ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു (കാണുക
<http://www.gnu.org/software/libtool/>), അതിനാൽ ഇത് എങ്ങനെ ചെയ്യണമെന്ന് നിങ്ങൾ കണ്ടെത്തേണ്ടതില്ല
നിങ്ങളുടെ പ്ലാറ്റ്‌ഫോം, അതിനാൽ നിങ്ങൾ a-യിലേക്ക് മാറുമ്പോഴും നിങ്ങളുടെ മേക്ക്‌ഫൈൽ പ്രവർത്തിക്കുന്നത് തുടരും
വ്യത്യസ്ത OS. വിശദാംശങ്ങൾക്ക് ലിബ്ടൂൾ ഡോക്യുമെന്റേഷൻ കാണുക. ഒരു സാമ്പിൾ Makefile ഇതാ:

LIBTOOL := libtool

libflick.la : $(only_targets *.lo)
$(LIBTOOL) --mode=ലിങ്ക് $(CC) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്)

%.lo: %.c
$(LIBTOOL) --mode=compile $(CC) $(CFLAGS) $(ഉൾപ്പെടെ) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

കെട്ടിടം on പലതും വ്യത്യസ്ത യന്ത്രങ്ങൾ or നെറ്റ്വർക്കുകൾ
മേക്ക്‌ഫൈലുകളുടെ ഏറ്റവും ശല്യപ്പെടുത്തുന്ന പ്രശ്‌നങ്ങളിലൊന്ന്, നിങ്ങളായിരിക്കുമ്പോൾ അവ ഒരിക്കലും പ്രവർത്തിക്കില്ല എന്നതാണ്
മറ്റൊരു മെഷീനിലേക്കോ മറ്റൊരു നെറ്റ്‌വർക്കിലേക്കോ മാറുക. നിങ്ങളുടെ മേക്ക് ഫയലുകൾ പ്രവർത്തിക്കേണ്ടതുണ്ടെങ്കിൽ
ഗ്രഹത്തിലെ സാധ്യമായ എല്ലാ യന്ത്രങ്ങളും, അപ്പോൾ നിങ്ങൾക്ക് ഏതെങ്കിലും തരത്തിലുള്ള കോൺഫിഗർ ആവശ്യമായി വരും
സ്ക്രിപ്റ്റ്. എന്നാൽ നിങ്ങൾക്ക് കുറച്ച് വ്യത്യസ്ത മെഷീനുകളിൽ മാത്രം പ്രവർത്തിക്കണമെങ്കിൽ, നിരവധി മാർഗങ്ങളുണ്ട്
നിങ്ങൾക്ക് ഈ പ്രശ്നം സമീപിക്കാൻ കഴിയും:

ഉപയോഗം a വ്യത്യസ്ത ഉൾപ്പെടുന്നു ഫയല് in എല്ലാം The പരിസ്ഥിതികൾ

ഓരോ മേക്ക് ഫയലിന്റെയും തുടക്കത്തിൽ, നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു ലൈൻ ഉൾപ്പെടുത്താം:

system_defs.mk ഉൾപ്പെടുന്നു

ഫയൽ system_defs.mk സാധാരണയായി ഓരോന്നിനും വ്യത്യസ്‌തമായ സ്ഥലത്താണ് സ്ഥിതി ചെയ്യുന്നത്
പരിസ്ഥിതി. നിങ്ങളുടെ ബിൽഡ് ഡയറക്‌ടറികൾ എല്ലാ മെഷീനുകളിലും ഒരുപോലെ ആയിരിക്കണമെങ്കിൽ, ഇടുക
system_defs.mk ബിൽഡ് ഡയറക്‌ടറികൾക്ക് മുകളിലുള്ള ഒരു ഡയറക്‌ടറിയിൽ, അല്ലെങ്കിൽ ഒരു ഉൾപ്പെടുന്ന പാത നൽകുക
"-I" കമാൻഡ് ലൈൻ ഓപ്ഷൻ ഉപയോഗിച്ച് makepp-ലേക്ക്.

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

ഉപയോഗം if പ്രസ്താവനകൾ

ഇത് ചെയ്യാനുള്ള ഏറ്റവും വൃത്തികെട്ട മാർഗമാണ്, പക്ഷേ ഇത് സാധാരണയായി പ്രവർത്തിക്കും.

ifsys i386
CC := gcc
അല്ലെങ്കിൽ ifsys sun4u
CC := cc
അല്ലെങ്കിൽ ifsys hpux11
CC = c89
endif

നിങ്ങൾ ചെയ്യേണ്ടത് കുറച്ച് പ്രോഗ്രാമുകളോ ലൈബ്രറികളോ കണ്ടെത്തുകയോ വ്യത്യസ്ത ഫയലുകൾ ഉൾപ്പെടുത്തുകയോ ചെയ്യുക എന്നതാണ്
സ്ഥലങ്ങളിൽ, മെച്ചപ്പെട്ട വഴികൾ ഉണ്ടാകാം (ചുവടെ കാണുക).

ഫൈൻഡ്_പ്രോഗ്രാം, ആദ്യം_ലഭ്യം, ഫൈൻഡ് ഫയൽ

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

CXX ;= $(find_program g++ c++ pg++ cxx CC aCC)
# PATH-ൽ ലഭ്യമായ ആദ്യത്തെ C++ കംപൈലർ തിരഞ്ഞെടുക്കുക.
# (ആകസ്മികമായി, നിങ്ങൾ CXX നിർവചിക്കുന്നില്ലെങ്കിൽ, ഇത്
# അത് നിർവചിച്ചിരിക്കുന്ന രീതിയാണ്.)
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))
# $(findfile ) സൂചിപ്പിച്ചിരിക്കുന്ന ഓരോന്നിലും tcl.h തിരയുന്നു
# ഡയറക്‌ടറികളും പൂർണ്ണ പാതയും നൽകുന്നു. അപ്പോൾ ഇതാണ്
# സ്ട്രിപ്പ് ചെയ്തുകൊണ്ട് ഒരു കംപൈലേഷൻ ഓപ്ഷനായി പരിവർത്തനം ചെയ്തു
# ഫയലിന്റെ പേര് (ഡയറക്‌ടറി വിടുന്നു) കൂടാതെ -I ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്യുന്നു.
%.o : %.cpp
$(CXX) $(CXXFLAGS) $(TCL_INCLUDE) $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

TCL_LIB ;= $((ആദ്യ_ലഭ്യം
/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 ലൈബ്രറി എവിടെയാണെന്ന് കണ്ടെത്തുക. ഇത് അപ്പോൾ വ്യക്തമാണ്
# ലിങ്ക് കമാൻഡിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്നു:
my_program : *.o
$(CXX) $(CXXFLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്പുട്ട്) $(TCL_LIB)

എടുക്കുക പ്രയോജനം of പേളിന്റേത് config വിവരം

നിങ്ങൾക്ക് കൂടുതൽ വിവരങ്ങൾ ആവശ്യമുണ്ടെങ്കിൽ മുകളിലുള്ള സാങ്കേതിക വിദ്യകൾ മതിയാകില്ല
നിങ്ങളുടെ സിസ്റ്റം, ഒരു നീണ്ട ഇരട്ട നിലവിലുണ്ടോ, അല്ലെങ്കിൽ ബൈറ്റ് ക്രമം എന്താണെന്നത് പോലെ. എന്നിരുന്നാലും,
perl ഇതിനകം തന്നെ ഈ കാര്യങ്ങൾ കണക്കാക്കിയിട്ടുണ്ട്, അതിനാൽ നിങ്ങൾക്ക് അതിന്റെ ഉത്തരങ്ങൾ ഉപയോഗിക്കാം.

പേളിന്റെ ഓട്ടോകോൺഫിഗർ സ്ക്രിപ്റ്റ് അതിന്റെ എല്ലാ കോൺഫിഗറേഷൻ വിവരങ്ങളും ലഭ്യമാക്കുന്നു
% കോൺഫിഗറേഷൻ ഹാഷ്. makepp-ൽ നേരിട്ട് ഒരു Perl ഹാഷ് ആക്‌സസ് ചെയ്യാൻ വാക്യഘടനയില്ല, പക്ഷേ നിങ്ങൾക്ക് കഴിയും
Makepp-ൽ നിന്ന് നേരിട്ട് ആക്സസ് ചെയ്യാവുന്ന Perl-ലേക്ക് ഡ്രോപ്പ് ചെയ്ത് സ്കെയിലർ വേരിയബിളുകൾ സജ്ജമാക്കുക:

perl_begin
# കോൺഫിഗറേഷൻ ഹാഷിൽ നിന്ന് മൂല്യങ്ങൾ ലഭ്യമാക്കുക.
കോൺഫിഗറേഷൻ ഉപയോഗിക്കുക;
$CC = $Config{'cc'}; പേൾ ഉപയോഗിച്ച # സി കംപൈലർ;
$byteorder_flags = "-DBYTEORDER=$Config{'byteorder'}";
$longdouble_defined = $Config{'d_longdbl'} eq 'define';
$CFLAGS_for_shared_libs = $Config{'cccdlflags'};
$LDFLAGS_for_shared_libs = $Config{'ccdlflags'};
perl_end

കൂടാതെ, നിങ്ങൾ 'ഉപയോഗ കോൺഫിഗറേഷൻ' ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് "$(perl )" എന്ന പ്രസ്താവന ഉപയോഗിക്കാം.
ഈ:

SHARED_LIB_EXTENSION := $(perl $Config{'dlext'})

%Config ഹാഷ് മുഖേന ലഭ്യമായ വിവരങ്ങൾ കാണുന്നതിന് "perldoc Config" എന്ന് ടൈപ്പ് ചെയ്യുക.

പൂർണ്ണസംഖ്യാ തരങ്ങൾ, ബൈറ്റ് എന്നിവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കുന്നതിനുള്ള നല്ലൊരു ഇടമാണ് Perl's config
ക്രമവും മറ്റ് കാര്യങ്ങളും കണ്ടെത്തുന്നതിന് സാധാരണയായി ഒരു പ്രത്യേക കോൺഫിഗറേഷൻ സ്ക്രിപ്റ്റ് ആവശ്യമാണ്. ചിലത്
ഫയൽ സിസ്റ്റത്തിലെ വസ്തുക്കളുടെ സാന്നിധ്യവുമായി ബന്ധപ്പെട്ട വിവരങ്ങൾ ആയിരിക്കില്ല
സാധുവായ. ഉദാഹരണത്തിന്, $Config{'cc'} എന്നത് perl നിർമ്മിച്ച C കംപൈലറിനെ സൂചിപ്പിക്കുന്നു,
നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന അതേ C കംപൈലർ ആയിരിക്കില്ല ഇത്. വാസ്തവത്തിൽ, അത് നിലവിലില്ലായിരിക്കാം
നിങ്ങളുടെ സിസ്റ്റത്തിൽ, നിങ്ങൾ ഒരുപക്ഷേ ഒരു ബൈനറി പാക്കേജ് വഴി Perl ഇൻസ്റ്റാൾ ചെയ്തിരിക്കാം.

നുറുങ്ങുകൾ വേണ്ടി ഉപയോഗിച്ച് വൈൽഡ്കാർഡുകൾ
പൊരുത്തപ്പെടുന്നു എല്ലാം ഫയലുകൾ ഒഴികെ a ചിലത് ഉപഗണം

മേക്കപ്പിന്റെ വൈൽഡ്കാർഡുകൾക്ക് നിലവിൽ എല്ലാ ഫയലുകളും പൊരുത്തപ്പെടുത്താനുള്ള മാർഗമില്ല ഒഴികെ ഒരു നിശ്ചിത
സജ്ജമാക്കുക, എന്നാൽ ഫംഗ്‌ഷനുകളുടെ സംയോജനത്തിലൂടെ നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും.

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

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

"$(filter )", "$(filter_out )" ഫംഗ്‌ഷനുകൾ ചെയ്യാൻ വളരെ ശക്തമായ ഒരു കൂട്ടം ഫിൽട്ടറുകളാണ്
എല്ലാത്തരം സെറ്റ് കവലകളും വ്യത്യാസ പ്രവർത്തനങ്ങളും. ഉദാഹരണത്തിന്,

SUBDIRS ;= $(filter_out *test* *$(ARCH)*, $(shell find . -type d -print))
# ഇല്ലാത്ത എല്ലാ ഉപഡയറക്‌ടറികളും നൽകുന്നു
അവയിൽ # "ടെസ്റ്റ്" അല്ലെങ്കിൽ $(ARCH).

$(ഫിൽട്ടർ $(patsubst test_dir/test_%.o, %.o, $(wildcard test_dir/*.o)), \
$(വൈൽഡ്കാർഡ് *.o))
# നിലവിലുള്ള .o ഫയലുകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു
ഒരു അനുബന്ധമായ # ഡയറക്ടറി
test_dir ഉപഡയറക്‌ടറിയിലെ # test_*.o ഫയൽ.
$(filter_out $(patsubst man/man3/%.3, %.o, $(wildcard man/man3/*.3)), \
$(വൈൽഡ്കാർഡ് *.o))
# നിലവിലുള്ള .o ഫയലുകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു
ഒരു മാനുവൽ പേജ് ഇല്ലാത്ത # ഡയറക്ടറി
# man/man3 ഉപഡയറക്‌ടറിയിലെ അതേ ഫയൽ നാമത്തിൽ.

ഉപയോഗിക്കുന്നു The "$(മാത്രം_ലക്ഷ്യങ്ങൾ )" ഫംഗ്ഷൻ ലേക്ക് ഇല്ലാതെയാക്കുവാൻ പഴകിയ .o ഫയലുകൾ

ഇതുപോലുള്ള ഒരു ബിൽഡ് കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾ ഒരു പ്രോഗ്രാമോ ലൈബ്രറിയോ നിർമ്മിക്കുകയാണെന്ന് കരുതുക:

പ്രോഗ്രാം: *.o
$(CC) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്പുട്ട്)

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

പ്രോഗ്രാം: $(only_targets *.o)
$(CC) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്പുട്ടുകൾ)

പഴകിയവ പണിയാൻ മേക്കപ്പിന് അറിയില്ല .o അതിന്റെ ഉറവിട ഫയൽ ആയതിനാൽ ഇനിമുതൽ ഫയൽ ചെയ്യുക
പോയി, അതിനാൽ "$(only_targets )" ഫംഗ്‌ഷൻ അതിനെ ഡിപൻഡൻസി ലിസ്റ്റിൽ നിന്ന് ഒഴിവാക്കും.

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

എന്ത് ലേക്ക് do in സ്ഥലം of ആവർത്തന ഉണ്ടാക്കുക

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

എന്തുകൊണ്ടാണ് നിങ്ങൾ ആഗ്രഹിക്കാത്തത് എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് makepp-ലെ "ശ്രേണീകൃത ബിൽഡുകൾക്കുള്ള മികച്ച സിസ്റ്റം" കാണുക
റിക്കേഴ്‌സീവ് മേക്ക് ഉപയോഗിക്കുക, അല്ലെങ്കിൽ "ആവർത്തന രൂപീകരണം ഹാനികരമാണെന്ന് കരുതുക" എന്ന് വെബിൽ തിരയുക.

എല്ലാ മേക്ക്‌ഫൈലിലും "എല്ലാം" ടാർഗെറ്റുചെയ്യാൻ ഒരു ആവർത്തന നിർമ്മാണം നടത്തുന്നതിനുപകരം, അതാണ്
ഏത് ലക്ഷ്യങ്ങളാണ് യഥാർത്ഥത്തിൽ നിർമ്മിക്കേണ്ടതെന്ന് മനസിലാക്കാൻ മേക്കപ്പിനെ അനുവദിക്കുന്നത് സാധാരണയായി എളുപ്പമാണ്.
കൂടാതെ, നിങ്ങളുടെ എല്ലാം ഇട്ടാൽ .o അതേ ഡയറക്ടറിയിൽ ലൈബ്രറി ഫയലുകളും
makefiles, അപ്പോൾ makepp സ്വയമേവ ഏതൊക്കെ മേക്ക് ഫയലുകൾ ആവശ്യമാണെന്ന് കണ്ടുപിടിക്കും--the
ആവശ്യമുള്ള ഫയലുകൾ നിങ്ങളുടെ ഉയർന്ന തലത്തിൽ ലിസ്റ്റ് ചെയ്യുക എന്നതാണ് ആവശ്യമുള്ളത്
അവസാന ലിങ്കിംഗ് ഘട്ടത്തിനായി. ചുവടെയുള്ള ഉദാഹരണങ്ങൾ കാണുക.

ഒന്ന് makefile വേണ്ടി ഓരോന്നും ഡയറക്ടറി: കൂടെ അബോധാവസ്ഥ ലോഡിങ്

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

ഇംപ്ലിസിറ്റ് ലോഡിംഗ് ഉപയോഗിക്കുന്ന ഒരു ഡയറക്‌ടറി ശ്രേണിയ്‌ക്കായുള്ള ഒരു സാമ്പിൾ ടോപ്പ്-ലെവൽ മേക്ക്‌ഫൈൽ ഇതാ
നിരവധി പങ്കിട്ട ലൈബ്രറികൾ അടങ്ങുന്ന ഒരു പ്രോഗ്രാം നിർമ്മിക്കുന്നതിന് (എന്നാൽ "നിങ്ങൾക്ക് ശരിക്കും ആവശ്യമുണ്ടോ എന്ന് കാണുക
ലൈബ്രറി?" makepp_cookbook-ൽ, കാരണം ഒരു കൂട്ടം പങ്കിട്ട ലൈബ്രറികളിൽ നിന്ന് ഒരു പ്രോഗ്രാം നിർമ്മിക്കുന്നു
ഒരു നല്ല ആശയം ആയിരിക്കണമെന്നില്ല):

# ഉയർന്ന തലത്തിലുള്ള മേക്ക് ഫയൽ:
program : main.o **/*.la # എല്ലാ ഉപഡയറക്‌ടറികളിൽ നിന്നുമുള്ള പങ്കിട്ട ലൈബ്രറികളിലേക്കുള്ള ലിങ്ക്.
$(LIBTOOL) --mode=ലിങ്ക് $(CC) $(CFLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്) $(LIBS)

ഉയർന്ന തലത്തിലുള്ള മേക്ക്‌ഫയലിൽ നിങ്ങൾക്ക് വേണ്ടത് അത്രമാത്രം. ഓരോ ഉപഡയറക്‌ടറിയിലും, നിങ്ങൾ
ഒരുപക്ഷേ ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യും:

# ഓരോ ഉപഡയറക്‌ടറിയിലും ഫയൽ സൃഷ്‌ടിക്കുക:
Standard_defs.mk ഉൾപ്പെടുത്തുക # തിരയലുകൾ ., .., ../.., മുതലായവ വരെ
# സൂചിപ്പിച്ച ഉൾപ്പെടുത്തിയ ഫയൽ കണ്ടെത്തുന്നു.
# ഇവിടെ ചില വേരിയബിൾ നിർവചനങ്ങൾ അസാധുവാക്കുക
SPECIAL_FLAGS := -do_something_different

ടാർഗെറ്റുകൾ നിർമ്മിക്കാനുള്ള കമാൻഡുകൾ ആണെങ്കിൽ, ഓരോ മേക്ക് ഫയലും ഏതാണ്ട് സമാനമായിരിക്കാം
തികച്ചും സമാനമാണ്.

അവസാനമായി, നിങ്ങൾ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുത്തും standard_defs.mk ഫയൽ (ഒരുപക്ഷേ
ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറിയിൽ സ്ഥിതിചെയ്യുക):

# എല്ലാ ഡയറക്‌ടറികൾക്കും പൊതുവായ വേരിയബിൾ ക്രമീകരണങ്ങളും ബിൽഡ് നിയമങ്ങളും.
CFLAGS := -g -O2
INCLUDE_DIR := $(find_upwards ഉൾപ്പെടുന്നു)
# തിരയലുകൾ ., .., ../.., മുതലായവ ഒരു ഫയലിനായി അല്ലെങ്കിൽ
വിളിക്കുന്ന # ഡയറക്ടറി ഉൾപ്പെടുന്നു, അതിനാൽ നിങ്ങൾ ഇട്ടാൽ
# നിങ്ങളുടെ എല്ലാ ഫയലുകളും അതിൽ ഉൾപ്പെടുത്തും, ഇത് ചെയ്യും
# അവരെ കണ്ട് പിടിക്കു.
ഉൾപ്പെടുന്നു := -I$(INCLUDE_DIR)

%.lo: %.c
$(LIBTOOL) --mode=compile $(CC) $(CFLAGS) $(ഉൾപ്പെടെ) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

lib$(relative_to ., ..).la: $(only_targets *.lo)
$(LIBTOOL) --mode=ലിങ്ക് $(CC) $(CFLAGS) -o $(ഔട്ട്‌പുട്ട്) $(ഇൻപുട്ടുകൾ)
# $(relative_to ., ..) കറന്റിന്റെ പേര് നൽകുന്നു
മുകളിലെ നിലയുമായി ബന്ധപ്പെട്ട # ഉപഡയറക്‌ടറി
# ഉപഡയറക്‌ടറി. അതിനാൽ ഈ makefile xyz/Makefile ആണെങ്കിൽ,
# ഈ നിയമം xyz/libxyz.la നിർമ്മിക്കും.

# പബ്ലിക് ഉൾപ്പെടുത്തുക ഫയലുകൾ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിൽ ഉൾപ്പെടുത്തുക:
$(INCLUDE_DIR)/public_%.h : public_%.h
:build_check symlnk
&ln -fr $(ഇൻപുട്ട്) $(ഔട്ട്പുട്ട്)

ഒന്ന് makefile വേണ്ടി ഓരോന്നും ഡയറക്ടറി: സ്പഷ്ടമായത് ലോഡിങ്

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

# ഉയർന്ന തലത്തിലുള്ള മേക്ക് ഫയൽ:
നിർമ്മാണം := $(വൈൽഡ്കാർഡ് **/Makeppfile) # ഇതിലേക്കുള്ള എല്ലാ ഉപഡയറക്‌ടറികളുടെയും ലിസ്റ്റ്
# നിന്ന് മേക്ക് ഫയലുകൾ നേടുക.

load_makefile $(MAKEFILES) # അവയെല്ലാം ലോഡുചെയ്യുക.

standard_defs.mk ഉൾപ്പെടുത്തുക # main.o-യ്‌ക്കായി കംപൈൽ കമാൻഡ് നേടുക.

പ്രോഗ്രാം : $(ARCH)/main.o */**/$(ARCH)/*.la
$(LIBTOOL) --mode=ലിങ്ക് $(CC) $(CFLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്) $(LIBS)
# */**/$(ARCH) ഉപഡയറക്‌ടറി ഒഴിവാക്കുന്നു
# $(ARCH), ഞങ്ങൾ നിർമ്മിക്കാൻ ആഗ്രഹിക്കാത്ത ഇടം
# ഒരു പങ്കിട്ട ലൈബ്രറി.

ഓരോ മേക്ക് ഫയലും മുമ്പത്തെ പോലെ തന്നെ ആയിരിക്കും:

# ഓരോ ഉപഡയറക്‌ടറിയിലും ഫയൽ സൃഷ്‌ടിക്കുക:
standard_defs.mk ഉൾപ്പെടുത്തുക
# ... വേരിയബിൾ ഇവിടെ അസാധുവാക്കുന്നു

ഒടുവിൽ, standard_defs.mk ഇനിപ്പറയുന്നതുപോലുള്ള എന്തെങ്കിലും അടങ്ങിയിരിക്കും:

# എല്ലാ ഡയറക്‌ടറികൾക്കും പൊതുവായ വേരിയബിൾ ക്രമീകരണങ്ങളും ബിൽഡ് നിയമങ്ങളും.
ആർച്ച് ;= $(ഷെൽ യുനാം -എസ്)-$(ഷെൽ യുനാം -എം)-$(ഷെൽ യുനാം -ആർ)
# ചിലപ്പോൾ ആളുകൾ $(shell uname -m) മാത്രം ഉപയോഗിക്കുന്നു, പക്ഷേ
# ഇത് ഫ്രീബിഎസ്ഡിക്കും ലിനക്സിനും സമാനമായിരിക്കും
# ഒരു x86. ലിനക്സിൽ -r ശരിക്കും ഉപയോഗപ്രദമല്ല,
# എന്നാൽ മറ്റ് OS-കൾക്ക് പ്രധാനമാണ്: ബൈനറികൾ
# SunOS 5.8 സാധാരണയായി SunOS 5.7-ൽ പ്രവർത്തിക്കില്ല.
&mkdir -p $(ARCH) # ഔട്ട്‌പുട്ട് ഡയറക്ടറി നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക.
CFLAGS := -g -O2
INCLUDE_DIR := $(find_upwards ഉൾപ്പെടുന്നു)
# തിരയലുകൾ ., .., ../.., മുതലായവ ഒരു ഫയലിനായി അല്ലെങ്കിൽ
വിളിക്കുന്ന # ഡയറക്ടറി ഉൾപ്പെടുന്നു, അതിനാൽ നിങ്ങൾ ഇട്ടാൽ
# നിങ്ങളുടെ എല്ലാ ഫയലുകളും അതിൽ ഉൾപ്പെടുത്തും, ഇത് ചെയ്യും
# അവരെ കണ്ട് പിടിക്കു.
ഉൾപ്പെടുന്നു := -I$(INCLUDE_DIR)

$(ARCH)/%.lo : %.c
$(LIBTOOL) --mode=compile $(CC) $(CFLAGS) $(ഉൾപ്പെടെ) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

$(ആർച്ച്)/ ലിബ്$(relative_to ., ..).la: $(only_targets *.lo)
$(LIBTOOL) --mode=ലിങ്ക് $(CC) $(CFLAGS) -o $(ഔട്ട്‌പുട്ട്) $(ഇൻപുട്ടുകൾ)
# $(relative_to ., ..) കറന്റിന്റെ പേര് നൽകുന്നു
മുകളിലെ നിലയുമായി ബന്ധപ്പെട്ട # ഉപഡയറക്‌ടറി
# ഉപഡയറക്‌ടറി. അതിനാൽ ഈ makefile xyz/Makefile ആണെങ്കിൽ,
# ഈ നിയമം xyz/$(ARCH)/libxyz.la നിർമ്മിക്കും.

# പബ്ലിക് ഉൾപ്പെടുന്ന ഫയലുകൾ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിലേക്ക് പകർത്തുക:
$(INCLUDE_DIR)/public_%.h : public_%.h
&cp $(ഇൻപുട്ട്) $(ഔട്ട്പുട്ട്)

ഓട്ടോമാറ്റിയ്ക്കായി നിർമ്മാണം The മേക്ക് ഫയലുകൾ

നിങ്ങളുടെ മേക്ക് ഫയലുകൾ എല്ലാം വളരെ സാമ്യമുള്ളതാണെങ്കിൽ (മുകളിലുള്ള ഉദാഹരണത്തിലെന്നപോലെ), നിങ്ങൾക്ക് Makepp-നോട് പറയാം
അവ നിലവിലില്ലെങ്കിൽ അവ യാന്ത്രികമായി നിർമ്മിക്കാൻ. നിങ്ങളുടെ ഉയർന്ന തലത്തിലേക്ക് ഇനിപ്പറയുന്നവ ചേർക്കുക
ഉണ്ടാക്കുക:

SUBDIRS := $(filter_out unwanted_dir1 unwanted_dir2, $(വൈൽഡ്കാർഡ് */**))
$(foreach)/Makeppfile: : foreach $(SUBDIRS)
&echo "include standard_defs.mk" -o $(ഔട്ട്പുട്ട്)
&എക്കോ "_include additional_defs.mk" -o >>$(ഔട്ട്പുട്ട്)
# അധിക_defs.mk ഫയൽ നിലവിലുണ്ടെങ്കിൽ, പിന്നെ
# ഇത് ഉൾപ്പെടുത്തും, പക്ഷേ അത് നിലവിലില്ലെങ്കിൽ,
# _ഉൾക്കൊള്ളുക എന്ന പ്രസ്താവന അവഗണിക്കപ്പെടും.

ഇപ്പോൾ മേക്ക് ഫയലുകൾ സ്വയം നിർമ്മിക്കപ്പെടും.

ഒന്ന് makefile മാത്രം at The മുകളിൽ ലെവൽ

നിങ്ങളുടെ എല്ലാ മേക്ക് ഫയലുകളും സമാനമാണെങ്കിൽ, നിങ്ങൾക്ക് ചോദിക്കാം: ഓരോന്നിലും എനിക്ക് എന്തിന് ഒരു മേക്ക്ഫയൽ ഉണ്ടായിരിക്കണം
നില? എന്തുകൊണ്ടാണ് അതെല്ലാം ഉയർന്ന തലത്തിലുള്ള മേക്ക് ഫയലിൽ ഉൾപ്പെടുത്താത്തത്?

അതെ, ഇത് ചെയ്യാൻ കഴിയും. ഇത് വ്യക്തമാക്കാൻ ബുദ്ധിമുട്ടാണ് എന്നതാണ് പ്രധാന പോരായ്മ
ഓരോ ഉപഡയറക്‌ടറിക്കും വ്യത്യസ്ത ബിൽഡ് ഓപ്‌ഷനുകൾ. രണ്ടാമത്തെ പോരായ്മ നിങ്ങളുടേതാണ്
makefile വായിക്കാൻ അൽപ്പം ബുദ്ധിമുട്ടായിരിക്കും.

അത് ചെയ്യുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

# ഡയറക്‌ടറി ശ്രേണിയ്‌ക്കുള്ള ഉയർന്ന തലത്തിലുള്ള മേക്ക്‌ഫയൽ. പ്രോഗ്രാം നിർമ്മിക്കുന്നു
ഒരു ഉദാഹരണമായി പങ്കിട്ട ലൈബ്രറികളുടെ ഒരു കൂട്ടത്തിൽ നിന്ന് #. (മുകളിലുള്ള മുന്നറിയിപ്പ് കാണുക
# എന്തുകൊണ്ടാണ് നിങ്ങൾ ഇൻക്രിമെന്റൽ ലിങ്കിംഗ് അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നത്
പങ്കിട്ട ലൈബ്രറികളേക്കാൾ # സമീപനം.)
makepp_percent_subdirs := 1 # ഒന്നിലധികം ഡയറക്‌ടറികളുമായി പൊരുത്തപ്പെടാൻ %-നെ അനുവദിക്കുക.
SUBDIRS := $(filter_out *CVS* മറ്റ്-അനാവശ്യ_ദിറുകൾ $(വൈൽഡ്കാർഡ് **))
CFLAGS := -g -O2
ഉൾപ്പെടുന്നു := -ഉൾപ്പെടുന്നു

%.lo: %.c
$(LIBTOOL) --mode=compile $(CC) $(ഉൾപ്പെടുന്നു) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

$(ഫോറച്ച്)/ ലിബ്$(notdir $(foreach)).la: $(foreach)/*.lo : foreach $(SUBDIRS)
$(LIBTOOL) --mode=ലിങ്ക് $(CC) $(CFLAGS) -o $(ഔട്ട്‌പുട്ട്) $(ഇൻപുട്ടുകൾ)
# എല്ലാ ലൈബ്രറികളും നിർമ്മിക്കാൻ നിയമം.

പ്രോഗ്രാം : main.o **/*.la
$(LIBTOOL) --mode=ലിങ്ക് $(CC) $(CFLAGS) -o $(ഔട്ട്‌പുട്ട്) $(ഇൻപുട്ടുകൾ)

ഉൾപ്പെടുന്നു/$(notdir $(foreach)) : $(foreach) : foreach **/public_*.h
&cp $(ഇൻപുട്ട്) $(ഔട്ട്പുട്ട്)
# പൊതുവായി പകർത്തുന്നതിനുള്ള മാതൃകാ നിയമം
# ആക്‌സസ് ചെയ്യാവുന്ന .h ഫയലുകൾ ശരിയായ സ്ഥലത്തേക്ക്.

A വെടിപ്പുള്ള ലക്ഷ്യം

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

1. ശരിയായ ബിൽഡ് ഉറപ്പാക്കാൻ Makepp വളരെയധികം ശ്രമിക്കുന്നു. അതിനാൽ നിരാശനായ "എനിക്കില്ല
തെറ്റ് എന്താണെന്ന് അറിയുക", ആദ്യം മുതൽ ആരംഭിക്കാൻ നിങ്ങളെ പ്രേരിപ്പിക്കുന്നത് പഴയ കാര്യമാണ്.

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

3. "makeppclean" കമാൻഡ് ഉണ്ട്, അത് അതേ കാര്യം ചെയ്യുന്നു, കൂടുതൽ കാര്യക്ഷമമായി.

എന്നിരുന്നാലും, ഈ ചരിത്രപരമായ ഭാഗം ഞങ്ങൾ നിലനിർത്തുന്നു, കാരണം ഇത് നിങ്ങളോട് എന്തെങ്കിലും പറയുന്നു
makepp പ്രവർത്തിക്കുന്ന രീതി: "ക്ലീൻ" എന്ന് വിളിക്കപ്പെടുന്ന ഒരു വ്യാജ ടാർഗെറ്റ് ഒരു കൂട്ടം കമാൻഡുകൾക്കുള്ള ഒരു പേര് മാത്രമാണ്
നിർമ്മാണ പ്രക്രിയയുടെ ഫലമായുണ്ടാകുന്ന എല്ലാ ഫയലുകളും നീക്കം ചെയ്യുക. സാധാരണയായി ഒരു വൃത്തിയുള്ള ലക്ഷ്യം കാണുന്നു
ഇതുപോലൊന്ന്:

$(ഫോണി ക്ലീൻ):
&rm -fm $(വൈൽഡ്കാർഡ് *.o .makepp_log)
# -m, .makepp_log എന്നിവ മേക്കപ്പിന്റെ എല്ലാ ജങ്കുകളും ഒഴിവാക്കുന്നു.

നിങ്ങൾ ഇല്ലാതാക്കാൻ ആഗ്രഹിക്കുന്ന ഫയലുകൾ വ്യക്തമായി ലിസ്റ്റുചെയ്യുന്നതിന് പകരം, നിങ്ങൾക്ക് makepp-നോട് പറയുകയും ചെയ്യാം
എങ്ങനെ നിർമ്മിക്കാമെന്ന് അറിയാവുന്നതെല്ലാം നീക്കം ചെയ്യുക, ഇതുപോലെ:

$(ഫോണി ക്ലീൻ):
&rm -fm .makepp_log $(only_targets *)

നിങ്ങളുടെ ഏതെങ്കിലും സോഴ്സ് ഫയലുകൾ മറ്റ് ഫയലുകളിൽ നിന്ന് നിർമ്മിക്കാൻ കഴിയുമെങ്കിൽ, ഇതിന് പ്രയോജനമുണ്ട്,
അവയും ഇല്ലാതാക്കപ്പെടും; മറുവശത്ത്, പഴകിയ .o ഫയലുകൾ (പണ്ടുണ്ടായിരുന്ന ഫയലുകൾ
ബിൽഡ് ചെയ്യാവുന്നതും എന്നാൽ സോഴ്സ് ഫയൽ നീക്കം ചെയ്തതും) ഇല്ലാതാക്കില്ല.

വ്യത്യസ്ത ഡയറക്‌ടറികളിലെ മേക്ക് ഫയലുകൾ ഉൾപ്പെടുന്ന ഒരു ബിൽഡ് നിങ്ങളുടെ പക്കലുണ്ടെങ്കിൽ, നിങ്ങളുടെ ടോപ്പ്-
ലെവൽ makefile "വൃത്തിയുള്ള" ടാർഗെറ്റിനെ (അല്ലെങ്കിൽ മറ്റേതെങ്കിലും വ്യാജ ടാർഗെറ്റിനെ) വ്യത്യസ്തമായി പരാമർശിച്ചേക്കാം
ഉണ്ടാക്കുക:

# ഉയർന്ന തലത്തിലുള്ള മേക്ക് ഫയൽ
SUBDIRS := sub1 sub2

# ഇവിടെ നിയമങ്ങൾ നിർമ്മിക്കുക

# നിർമ്മാണത്തിന് ശേഷം വൃത്തിയാക്കുക:
$(ഫോണി ക്ലീൻ): $(SUBDIRS)/ക്ലീൻ
&rm -fm .makepp_log $(only_targets *)

പകരമായി, നിങ്ങളുടെ "ക്ലീൻ" ടാർഗെറ്റ് ഉയർന്ന തലത്തിലുള്ള മേക്ക് ഫയലിൽ മാത്രം ഇടാം, അത് സ്വന്തമാക്കാം
എല്ലാ ഡയറക്ടറികളും പ്രോസസ്സ് ചെയ്യുക, ഇതുപോലെ:

$(ഫോണി ക്ലീൻ):
&rm -fm $(only_targets **/*)

ഉപയോഗിക്കുന്നു ക്യൂടിയുടെ മോക് പ്രീപ്രോസസർ
ഈ ഉദാഹരണം നോക്കിയയുടെ Qt GUI ലൈബ്രറി ഉപയോഗിക്കുന്ന ഒരു യൂട്ടിലിറ്റിക്ക് വേണ്ടിയുള്ള ഒരു മേക്ക് ഫയൽ കാണിക്കുന്നു (കാണുക
<http://qt.nokia.com>). ഇതിൽ അൽപ്പം അസാധാരണമായ ഒരേയൊരു കാര്യം നിങ്ങൾ മാത്രമാണ്
വിജറ്റ് നിർവചനങ്ങൾ അടങ്ങിയ മിക്ക ".h" ഫയലുകളിലും "moc" എന്ന് വിളിക്കപ്പെടുന്ന ഒരു പ്രീപ്രൊസസ്സർ പ്രവർത്തിപ്പിക്കണം,
എന്നാൽ "Q_OBJECT" മാക്രോ ഉപയോഗിക്കാത്ത ഏതെങ്കിലും ".h" ഫയലുകളിൽ "moc" പ്രവർത്തിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല.

ഓട്ടോമാറ്റിയ്ക്കായി നിർണ്ണയിക്കുന്നു ഏത് ഫയലുകൾ ആവശ്യം മോക് ഫയലുകൾ

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

MOC := $(QTDIR)/bin/moc
മൊഡ്യൂളുകൾ := നിങ്ങളുടെ പ്രോഗ്രാമിൽ നിങ്ങൾക്കുള്ള മൊഡ്യൂളുകളെല്ലാം
MOC_MODULES := $(patsubst %.h, moc_%, $(&grep -l /Q_OBJECT/ *.h))
# Q_OBJECT മാക്രോയ്‌ക്കായി എല്ലാ .h ഫയലുകളും സ്കാൻ ചെയ്യുന്നു.

my_program: $(MODULES).o $(MOC_MODULES).o
$(CXX) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്പുട്ട്)

moc_%.cxx: %.h # .h ഫയലുകളിൽ നിന്ന് moc ഫയലുകൾ നിർമ്മിക്കുന്നു.
$(MOC) $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

%.o: %.cxx
$(CXX) $(CXXFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

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

# ഉൾപ്പെടുത്തുക The .moc ഫയല്

നിങ്ങളുടെ വിജറ്റിലെ "moc" പ്രീപ്രൊസസറിൽ നിന്നുള്ള ഔട്ട്‌പുട്ട് "#ഉൾപ്പെടുത്തുക" എന്നതാണ് മറ്റൊരു സമീപനം.
നടപ്പിലാക്കൽ ഫയൽ. ഇതിനർത്ഥം "#ഉൾപ്പെടുത്തുക" എഴുതാൻ നിങ്ങൾ ഓർമ്മിക്കേണ്ടതുണ്ട്, പക്ഷേ അതിൽ ഉണ്ട്
കംപൈൽ ചെയ്യാൻ കുറച്ച് മൊഡ്യൂളുകൾ മാത്രമേയുള്ളൂ, അതിനാൽ കംപൈലേഷൻ വേഗത്തിൽ നടക്കുന്നു.
(മിക്ക C++ കംപൈലേഷനും, ഭൂരിഭാഗം സമയവും ഹെഡർ ഫയലുകൾ വായിക്കുന്നതിനാണ് ചിലവഴിക്കുന്നത്
പ്രീപ്രൊസസറിൽ നിന്നുള്ള ഔട്ട്‌പുട്ടിൽ നിങ്ങളുടെ വിജറ്റിന്റെ അത്രയും ഫയലുകൾ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്
എന്തായാലും.) ഉദാഹരണത്തിന്:

// my_widget.h
ക്ലാസ് MyWidget : പൊതു QWidget {
Q_OBJECT
//...
}

// my_widget.cpp

#"my_widget.h" ഉൾപ്പെടുത്തുക
#include "my_widget.moc" // my_widget.moc ആണ് ഇതിൽ നിന്നുള്ള ഔട്ട്പുട്ട്
// മോക് പ്രീപ്രോസസർ.
// മറ്റ് നടപ്പിലാക്കൽ കാര്യങ്ങൾ ഇവിടെ.
MyWidget::MyWidget(QWidget * പേരന്റ്, കോൺസ്റ്റ് ചാർ * പേര്) :
QWidget(മാതാവ്, പേര്)
{
//...
}

ഇതുപോലെയുള്ള എല്ലാ ".moc" ഫയലുകളും നിർമ്മിക്കുന്നതിന് ഇപ്പോൾ നിങ്ങളുടെ മേക്ക് ഫയലിൽ ഒരു നിയമം ഉണ്ടായിരിക്കണം:

MOC := $(QTDIR)/bin/moc
# .moc ഫയലുകൾ നിർമ്മിക്കുന്നതിനുള്ള നിയമം:
%.moc: %.h
$(MOC) $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

ഇല്ലെങ്കിൽ "my_widget.moc" ഉണ്ടാക്കേണ്ടതുണ്ടെന്ന് മനസ്സിലാക്കാൻ Makepp മിടുക്കനാണ്
ഇതിനകം നിലവിലുണ്ട്, അല്ലെങ്കിൽ അത് കാലഹരണപ്പെട്ടതാണെങ്കിൽ.

ഈ രണ്ടാമത്തെ സമീപനമാണ് ഞാൻ സാധാരണയായി ഉപയോഗിക്കുന്നത്, കാരണം ഇത് സമാഹാരം വേഗത്തിലാക്കുന്നു.

വയ്ക്കലുകൾ വേണ്ടി നിരാകരിച്ചു ഉണ്ടാക്കുക പദപ്രയോഗങ്ങൾ
MAKECMD ഗോളുകൾ

ചിലപ്പോഴൊക്കെ ആളുകൾക്ക് അവരുടെ മേക്ക്ഫയലിൽ നിയമങ്ങളുണ്ട്, അവർ നിർമ്മിക്കുന്ന ലക്ഷ്യത്തെ ആശ്രയിച്ചിരിക്കുന്നു,
"MAKECMDGOALS" എന്ന പ്രത്യേക വേരിയബിൾ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരാൾ ചിലപ്പോൾ ഇതുപോലുള്ള കാര്യങ്ങൾ കാണുന്നു
ഈ:

ifneq ($(ഫിൽട്ടർ പ്രൊഡക്ഷൻ, $(MAKECMDGOALS)),)
CFLAGS := -O2
മറ്റാരെങ്കിലും
CFLAGS := -g
endif

മേക്കപ്പിനൊപ്പം ഇത് നന്നായി പ്രവർത്തിക്കും. എന്നിരുന്നാലും, അത്തരം കാര്യങ്ങൾക്കായി "MAKECMDGOALS" ഉപയോഗിക്കരുതെന്ന് ഞാൻ ശുപാർശ ചെയ്യുന്നു
കേസുകൾ (അങ്ങനെ ഗ്നു മാനുവൽ ഉണ്ടാക്കുന്നു). നിങ്ങളുടെ ഒപ്റ്റിമൈസ് ചെയ്ത് ഇടുന്നതാണ് നല്ലത്
ഡീബഗ്-കംപൈൽ .o പ്രത്യേക ഡയറക്‌ടറികളിലെ ഫയലുകൾ, അല്ലെങ്കിൽ അവയ്‌ക്ക് വ്യത്യസ്‌ത പ്രിഫിക്‌സുകൾ നൽകുക അല്ലെങ്കിൽ
പ്രത്യയങ്ങൾ, അല്ലെങ്കിൽ അവയെ വേറിട്ടു നിർത്താൻ ശേഖരണങ്ങൾ ഉപയോഗിക്കുന്നു.

നിങ്ങൾ യഥാർത്ഥത്തിൽ "MAKECMDGOALS" റഫറൻസ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഒരേയൊരു സമയം അത് മാത്രമായിരിക്കാം
നിങ്ങളുടെ മേക്ക് ഫയലുകൾ ലോഡുചെയ്യാൻ വളരെ സമയമെടുക്കും, നിങ്ങളുടെ "വൃത്തിയുള്ള" ലക്ഷ്യത്തിന് അത് ആവശ്യമില്ല
(പക്ഷേ നിങ്ങൾക്ക് ഒരു വൃത്തിയുള്ള ലക്ഷ്യം ആവശ്യമില്ല). ഉദാഹരണത്തിന്,

ifneq ($(MAKECMDGOALS),വൃത്തിയാക്കുക)
load_makefile $(വൈൽഡ്കാർഡ് **/Makeppfile)
മറ്റാരെങ്കിലും
no_inmplicit_load . # മറ്റേതെങ്കിലും മേക്ക് ഫയലുകൾ സ്വയമേവ ലോഡ് ചെയ്യുന്നത് തടയുക.
endif

$(ഫോണി ക്ലീൻ):
&rm -f $(വൈൽഡ്കാർഡ് **/*.o)

ആവർത്തന ഉണ്ടാക്കുക ലേക്ക് പണിയുക in വ്യത്യസ്ത ഡയറക്ടറികൾ

makepp_cookbook-ൽ "ഒന്നിലധികം ഡയറക്ടറികൾക്കുള്ള നുറുങ്ങുകൾ" കാണുക.

ആവർത്തന ഉണ്ടാക്കുക ലേക്ക് മാറ്റം മൂല്യം of a വേരിയബിൾ

ചില മേക്ക് ഫയലുകൾ ഒരു വേരിയബിളിന്റെ മറ്റൊരു മൂല്യം ഉപയോഗിച്ച് സ്വയം വീണ്ടും വിളിക്കുന്നു, ഉദാ, ഡീബഗ്
ഇനിപ്പറയുന്ന makefile ശകലത്തിൽ ലക്ഷ്യം

.PHONY: എല്ലാ ഡീബഗ്

ഒപ്റ്റിമൈസ് ചെയ്തത്:
$(MAKE) പ്രോഗ്രാം CFLAGS=-O2

ഡീബഗ്:
$(MAKE) പ്രോഗ്രാം CFLAGS=-g

പ്രോഗ്രാം: ao bo
$(CC) $(CFLAGS) $^ -o $@

%.o : %.c
$(CC) $(CFLAGS) -c $< -o $@

ഉപയോക്താവ് "മേക്ക് ഡീബഗ്" എന്ന് ടൈപ്പ് ചെയ്യുകയാണെങ്കിൽ, അത് ഡീബഗ് പ്രവർത്തനക്ഷമമാക്കി ഡിഫോൾട്ട് മോഡിൽ പ്രോഗ്രാം നിർമ്മിക്കുന്നു.
ഒപ്റ്റിമൈസേഷനുപകരം.

അതിനുള്ള ഒരു മികച്ച മാർഗം രണ്ട് വ്യത്യസ്ത പ്രോഗ്രാമുകൾ നിർമ്മിക്കുക എന്നതാണ്
ഒബ്ജക്റ്റ് ഫയലുകൾ, ഇതുപോലെ:

CFLAGS := -O2
DEBUG_FLAGS := -g
മൊഡ്യൂളുകൾ := എബി

പ്രോഗ്രാം: $(MODULES).o
$(CC) $(CFLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്പുട്ട്)

ഡീബഗ്/പ്രോഗ്രാം: debug/$(MODULES).o
$(CC) $(DEBUG_FLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്)

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

ഡീബഗ്/%.o : %.c
$(CC) $(DEBUG_FLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

$(ഫോണി ഡീബഗ്): ഡീബഗ്/പ്രോഗ്രാം

ഈ രീതിയിൽ ചെയ്യുന്നതിന്റെ പ്രയോജനം (എ) നിങ്ങൾ എല്ലാം പുനർനിർമ്മിക്കേണ്ടതില്ല എന്നതാണ്
ഡീബഗ്ഗിൽ നിന്ന് ഒപ്റ്റിമൈസ് ചെയ്‌ത് വീണ്ടും തിരികെ; (ബി)

ശേഖരണങ്ങൾ ഉപയോഗിച്ച് മുകളിൽ പറഞ്ഞവ കുറച്ചുകൂടി സംക്ഷിപ്തമായി എഴുതാം. ഇനിപ്പറയുന്നവ
makefile കൃത്യമായി തുല്യമാണ്:

റിപ്പോസിറ്ററി ഡീബഗ്=. # ഡീബഗ് ഉപഡയറക്‌ടറിയുടെ ഒരു പകർപ്പ് പോലെ തോന്നിപ്പിക്കുന്നു
# നിലവിലെ ഉപഡയറക്‌ടറി.
load_makefile ഡീബഗ് CFLAGS=-g
# ഡീബഗ് ഉപഡയറക്‌ടറിയിൽ ഉൾപ്പെടുത്തുമ്പോൾ CFLAGS അസാധുവാക്കുക
CFLAGS := -O2 # ഈ ഉപഡയറക്‌ടറിയിൽ ഉൾപ്പെടുത്തുമ്പോൾ CFLAGS-ന്റെ മൂല്യം

പ്രോഗ്രാം: ao bo
$(CC) $(CFLAGS) $^ -o $@

%.o : %.c
$(CC) $(CFLAGS) -c $< -o $@

$(ഫോണി ഡീബഗ്): ഡീബഗ്/പ്രോഗ്രാം
# ഉപയോക്താവ് "makepp debug" എന്ന് ടൈപ്പ് ചെയ്യുകയാണെങ്കിൽ, ബിൽഡുകൾ
പ്രോഗ്രാമിന് പകരം # ഡീബഗ്/പ്രോഗ്രാം.

കലര്പ്പായ നുറുങ്ങുകൾ
എങ്ങനെ do I പണിയുക ഒന്ന് ഭാഗം വ്യത്യസ്തമായി വെറും ഒരിക്കല്?

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

makepp DEBUG=3 buggy.o # മറ്റൊരു ഓപ്ഷൻ ഉപയോഗിച്ച് ഇത് നിർമ്മിക്കുക.
makepp --dont-build=buggy.o buggy # "തെറ്റായ" ബിൽഡ് ഓപ്ഷൻ ഉണ്ടായിരുന്നിട്ടും ഇത് ഉപയോഗിക്കുക.

എങ്ങനെ do I ഉണ്ടാക്കുക ഉറപ്പാക്കുക my ഔട്ട്പുട്ട് ഡയറക്ടറികൾ നിലവിലുണ്ടോ?

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

# ക്ലാസിക്കൽ വഴി
ഡമ്മി := $(ഷെൽ ടെസ്റ്റ് -d $(OUTPUT_DIRECTORY) || mkdir -p $(OUTPUT_DIRECTORY))
# എല്ലാ ഫയലുകളും ആശ്രയിക്കുന്നതിനേക്കാൾ ഇത് സാധാരണയായി എളുപ്പമാണ്
# $(OUTPUT_DIRECTORY) കൂടാതെ അതുണ്ടാക്കാൻ ഒരു നിയമമുണ്ട്.
# നിർബന്ധിക്കാൻ = എന്നതിന് പകരം നിങ്ങൾ := ഉപയോഗിക്കണം എന്നത് ശ്രദ്ധിക്കുക
# ഉടനടി നടപ്പിലാക്കുക.
# ഒരു ഇതര സമീപനം: പേൾ കോഡ് ഉപയോഗിച്ച്, OUTPUT_DIRECTORY ലോക്കൽ var
perl_begin
-d $OUTPUT_DIRECTORY അല്ലെങ്കിൽ mkdir $OUTPUT_DIRECTORY;
perl_end
# ആധുനിക രീതി, നിലവിലുള്ള ഡയറക്ടറികൾക്കായി ഒന്നും ചെയ്യുന്നില്ല
&mkdir -p $(OUTPUT_DIRECTORY)

ഈ പ്രസ്താവനകളിലൊന്ന് നിങ്ങളുടെ മേക്ക് ഫയലിന്റെ മുകൾഭാഗത്തായിരിക്കണം, അതിനാൽ അവ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും
ഡയറക്‌ടറി ആവശ്യമായി വന്നേക്കാവുന്ന എന്തിനും മുമ്പ്.

എങ്ങനെ do I ശക്തിയാണ് a കമാൻഡ് ലേക്ക് നിർവ്വഹിക്കുക on ഓരോ പണിയണോ?

റൂൾ മെക്കാനിസം ഉപയോഗിക്കുന്നില്ല, മറിച്ച് അത് നടപ്പിലാക്കുക എന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗം
ഈ:

ഡമ്മി := $(ഷെൽ തീയതി > last_build_timestamp)

അല്ലെങ്കിൽ ഇതുപോലെ ഒരു perl ബ്ലോക്കിൽ ഇടുക:

perl_begin
സിസ്റ്റം ("നിർവ്വഹിക്കാനുള്ള കമാൻഡ്");
perl_end

ഈ സമീപനത്തിന് ഒരു പോരായ്മയുണ്ട്, ബന്ധമില്ലാത്ത ലക്ഷ്യമാണെങ്കിൽപ്പോലും അത് നടപ്പിലാക്കും
പ്രവർത്തിപ്പിക്കപ്പെടുന്നു.

രണ്ടാമത്തെ സമീപനം, അത് ഒരു യഥാർത്ഥ ഫയലാണെങ്കിൽപ്പോലും, അത് ഒരു വ്യാജ ലക്ഷ്യമായി പ്രഖ്യാപിക്കുക എന്നതാണ്.
ഓരോ തവണയും ഇത് നിർമ്മിക്കാനുള്ള കമാൻഡ് വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യാൻ ഇത് makepp-നെ പ്രേരിപ്പിക്കും, പക്ഷേ അങ്ങനെയാണെങ്കിൽ മാത്രം
ചില നിയമങ്ങളുടെ ഡിപൻഡൻസി ലിസ്റ്റിൽ ദൃശ്യമാകുന്നു.

എങ്ങനെ do I ചെറുതാക്കുക The പ്രദർശിപ്പിക്കുന്നു പണിയുക കമാൻഡുകൾ?

കംപൈലേഷൻ കമാൻഡുകൾക്ക് പലപ്പോഴും നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്, അത് പ്രദർശിപ്പിക്കും
സ്ക്രീൻ വായിക്കാൻ പറ്റാത്തതാണ്. എന്നതിന്റെ ഡിസ്പ്ലേ അടിച്ചമർത്തുന്നതിലൂടെ നിങ്ങൾക്ക് പ്രദർശിപ്പിക്കുന്നത് മാറ്റാനാകും
മുഴുവൻ കമാൻഡ്, തുടർന്ന് കമാൻഡിന്റെ രസകരമായ ഭാഗം വ്യക്തമായി പ്രിന്റ് ചെയ്യുക. അത്
"$(filter_out )" ഉപയോഗിച്ച് കമാൻഡിന്റെ പ്രസക്തമായ ഭാഗം മാത്രം പ്രിന്റ് ചെയ്യാൻ എളുപ്പമാണ്
ഈ:

ALL_CFLAGS = $(CFLAGS) $(ഉൾപ്പെടെ) $(ADDL_CXX_FLAGS) $(DEBUG_FLAGS)

%.o : %.c
@&echo $(notdir $(CC)) ... \
$(filter_out -I* $(ADDL_CXX_FLAGS), $(ALL_CFLAGS)) \
-c $(ഇൻപുട്ട്)
@$(CC) $(ALL_CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

(കമാൻഡിന് മുന്നിലുള്ള "@" കമാൻഡ് പ്രിന്റുചെയ്യുന്നത് തടയുന്നു.)

രസകരമായ മിക്ക ഓപ്ഷനുകളും കാണാൻ ഇത് നിങ്ങളെ അനുവദിക്കുമെങ്കിലും എല്ലാം പ്രദർശിപ്പിക്കില്ല
ഡയറക്ടറികൾ ഉൾപ്പെടുത്തുക (അവയിൽ പലപ്പോഴും ധാരാളം ഉണ്ട്!). നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ഭാഗമാണെങ്കിൽ
in നിങ്ങളുടെ കമാൻഡിൽ അടുത്തടുത്താണ്, നിങ്ങൾക്ക് "പ്രിന്റ്" ഫംഗ്‌ഷനും ഉപയോഗിക്കാം (അത് ചേർക്കുന്നു
newline, അതിനാൽ നിങ്ങൾക്ക് അവയിൽ പലതും ആവശ്യമില്ല):

ലക്ഷ്യം:
@... $(രസകരമായ ഭാഗം അച്ചടിക്കുക) ...

എങ്ങനെ do I മാറ്റുക a ഫയല് കടന്നു ആശ്രിതത്വം?

ചില അവ്യക്തമായ ഫയൽ ഫോർമാറ്റുകൾക്ക് ഒരു സ്കാനർ നടപ്പിലാക്കുന്നത് മൂല്യവത്തല്ല. ഒരു പദ്ധതിയിൽ
ഞങ്ങൾക്ക് xml ഫയലുകൾ ഉണ്ട്, പറയുക foobar.xml എന്നതിന്റെ ഡിപൻഡൻസികൾ അടങ്ങിയിരിക്കുന്നു foobar.out:


എ
ബി
സി


ഈ ലളിതമായ ലേഔട്ട് പാലിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു, അതിനാൽ ഞങ്ങൾക്ക് xml പാഴ്‌സ് ചെയ്യേണ്ടതില്ല. കൂടെ
ബിൽട്ടിൻ & സെഡ്, മൂന്ന് തരങ്ങൾക്കുള്ള ലളിതമായ മൂന്ന് പകരം വയ്ക്കലുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ ചെയ്യുന്നത് ഇതാ
ലൈനുകൾ:

%.d: %.xml
&സെഡ് ന്റെ! !$(തണ്ട്).ഔട്ട്: \\! || എസ്! (.+) !$$1 \\! || എസ്! !# ശൂന്യം!' \
$(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

foobar.d ഉൾപ്പെടുന്നു

ഇത് ഉൾപ്പെടുത്താൻ ശ്രമിക്കുമ്പോൾ, ആദ്യം "foobar.d" നിർമ്മിക്കുന്നു:

foobar.out: \
ഒരു \
b \
c \
# ശൂന്യം

ശൂന്യമായ (വെറും ഒരു അഭിപ്രായം അല്ലെങ്കിൽ ശരിക്കും ശൂന്യമായ) ലൈൻ ട്രെയിലിംഗിനെക്കുറിച്ച് വിഷമിക്കുന്നത് ഒഴിവാക്കുന്നു
ബാക്ക്സ്ലാഷ്. ഒരു മൾട്ടിലൈൻ ലിസ്റ്റ് നിർമ്മിക്കുന്ന ഒരു ബദൽ ഇതാണ്:

%.d: %.xml
&സെഡ് ന്റെ! !$(തണ്ട്).പുറത്ത്: \$$((! || എസ്! !))! || s!<.+?>!!g' \
$(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

foobar.d ഉൾപ്പെടുന്നു

ഇത് തുല്യമായ ഒന്ന് ഉത്പാദിപ്പിക്കുന്നു:

foobar.out: $((
a
b
c
))

നിങ്ങൾക്ക് കൂടുതൽ സങ്കീർണ്ണമായ റീറൈറ്റിംഗ് ചെയ്യാനുണ്ടെങ്കിൽ, makefile-ൽ അല്ലെങ്കിൽ a-ൽ ഒരു ഫംഗ്ഷൻ നിർവചിക്കുക
നിങ്ങൾ ഉൾപ്പെടുന്ന മൊഡ്യൂൾ. ഉദാ $_ നിർവചിക്കാതിരിക്കുന്നത് ഇൻപുട്ട് ലൈനുകൾ ഒഴിവാക്കും:

സബ് മൈഫിൽറ്റർ {
എങ്കിൽ /
എന്റെ $ stem = f_stem;
എസ്! !$stem.out: \$((! || s! !))! || s!<.+?>!!g;
}

%.d: %.xml
&സെഡ് ന്റെ! !$(തണ്ട്).പുറത്ത്: \$$((! || എസ്! !))! || s!<.+?>!!g' \
$(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

foobar.d ഉൾപ്പെടുന്നു

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