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

പട്ടിക:

NAME

makepp_statements -- ഒരു മേക്ക് ഫയലിലെ വിവിധ പ്രസ്താവനകൾ

വിവരണം

A: ഓട്ടോലോഡ്, B: ബിൽഡ്_കാഷെ,
ബിൽഡ്_ചെക്ക്, D: "നിർവചിക്കുക", E: കയറ്റുമതി, G: ആഗോള, I: ifdef,
ifeq,
ifmakeperl,
ifndef,
ifneq,
ifnsys,
ശരിയാണെങ്കിൽ,
ifperl,
ifsys,
സത്യമാണെങ്കിൽ,
-ഉൾപ്പെടുന്നു,
ഉൾപ്പെടുന്നു,
_ഉൾപ്പെടുന്നു, L: load_makefile, M: ഉണ്ടാക്കുക,
മേക്കപ്പർ,
മേക്കബ്, N: "no_inmplicit_load", P: perl,
"perl_begin",
മുൻകൂട്ടി നിർമ്മിക്കുക, R: register_command_parser,
രജിസ്റ്റർ_ഇൻപുട്ട്_സഫിക്സ്,
രജിസ്റ്റർ_പാർസർ,
സംഭരണിയാണ്,
റൺടൈം, S: കയ്യൊപ്പ്,
"ഉപ", V: vpath

ഒരു ":" ഇല്ലാത്ത ഒരു വാക്കിൽ ആരംഭിക്കുന്ന ഏതൊരു വരിയും ഒരു പ്രസ്താവനയാണ്. (ഒരു കോളൻ
വരി ഒരു നിയമമാണെന്ന് സൂചിപ്പിക്കുന്നു.) ഉദാഹരണത്തിന്, ഇവയാണ് പ്രസ്താവനകൾ:

extra_rules.mk ഉൾപ്പെടുത്തുക
load_makefile subdir

നിങ്ങൾ ഇടയ്ക്കിടെ ഉപയോഗിക്കേണ്ടി വന്നേക്കാവുന്ന നിരവധി ബിൽട്ടിൻ പ്രസ്താവനകൾ Makepp-ൽ ഉണ്ട്.

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

വ്യവസ്ഥകൾ
കണ്ടീഷനലുകൾ പ്രത്യേക പ്രസ്താവനകളാണ്, അത് Makeppfile-ന്റെ ലൈനുകൾ ഏതൊക്കെയാണെന്ന് നിയന്ത്രിക്കുന്നു
യഥാർത്ഥത്തിൽ കണ്ടു. ഏറ്റവും ലളിതമായ രൂപം ("ifxxx" എന്നത് ഏതെങ്കിലും സോപാധികമായതിനെ സൂചിപ്പിക്കുന്നു
താഴെ രേഖപ്പെടുത്തിയിരിക്കുന്ന പ്രസ്താവനകൾ:

ifxxx...
പ്രസ്താവന ശരിയാണെന്ന് വിലയിരുത്തിയാൽ കാണുന്ന വരികൾ
endif

അഥവാ:

ifxxx...
പ്രസ്താവന ശരിയാണെന്ന് വിലയിരുത്തിയാൽ കാണുന്ന വരികൾ
മറ്റാരെങ്കിലും
പ്രസ്താവന തെറ്റാണെന്ന് വിലയിരുത്തിയാൽ കാണുന്ന വരികൾ
endif

ഇതുപോലുള്ള സങ്കീർണ്ണമായ കോമ്പിനേഷനുകൾ ചെയ്യാനുള്ള സാധ്യതയും ഉണ്ട്:

ifxxx...
ഒപ്പം ifxxx...
ഒപ്പം ifxxx...
അല്ലെങ്കിൽ ifxxx...
ഒപ്പം ifxxx...
സംയോജിത പ്രസ്താവനകൾ ശരിയാണെന്ന് വിലയിരുത്തിയാൽ കാണുന്ന വരികൾ
വേറെ ifxxx...
അല്ലെങ്കിൽ ifxxx...
ഒപ്പം ifxxx...
ആദ്യ കോമ്പിനേഷൻ തെറ്റായി വിലയിരുത്തിയാൽ കാണുന്ന വരികൾ
ഈ സംയുക്ത പ്രസ്താവനകൾ ശരിയാണെന്ന് വിലയിരുത്തുന്നു
മറ്റാരെങ്കിലും
മുകളിലെ പ്രസ്താവനകൾ തെറ്റാണെന്ന് വിലയിരുത്തിയാൽ കാണുന്ന വരികൾ
endif

ഇൻഡന്റേഷൻ നിർദ്ദേശിച്ചതുപോലെ, "ഒപ്പം" ഇതിനേക്കാൾ ഉയർന്ന മുൻഗണനയുണ്ട് "അഥവാ". മറ്റൊരു വാക്കിൽ
an "അഥവാ" രണ്ട് ഗ്രൂപ്പുകൾക്കിടയിൽ തിരഞ്ഞെടുക്കുന്നു "ഒപ്പം"`കൾ. "ഒപ്പം ifxxx" കളുടെ എത്ര വേണമെങ്കിലും ഉണ്ടായിരിക്കാം,
"അല്ലെങ്കിൽ ifxxx"`s, "else ifxxx"`s.

"ifxxx" സോപാധിക പ്രസ്‌താവനകൾ റൂളിന്റെ മധ്യത്തിൽ ഉണ്ടായേക്കാവുന്ന സവിശേഷമാണ്
മേൽപ്പറഞ്ഞ ഉദാഹരണത്തിലെന്നപോലെ, നിയമത്തെ തടസ്സപ്പെടുത്താതെയുള്ള പ്രവർത്തനങ്ങൾ.

ifeq സ്ട്രിംഗ്1, string2
ifneq സ്ട്രിംഗ്1, string2
ifeq ($(STR1),$(STR2))
ശരിയാണെങ്കിൽ ഫയൽ ലൈനുകൾ ഉണ്ടാക്കുക
മറ്റാരെങ്കിലും
തെറ്റാണെങ്കിൽ ഫയൽ ലൈനുകൾ ഉണ്ടാക്കുക
endif

രണ്ട് സ്ട്രിംഗുകളും കൃത്യമായി പൊരുത്തപ്പെടുന്നുവെങ്കിൽ (മുൻനിര അല്ലെങ്കിൽ പിന്നിലുള്ള വൈറ്റ്‌സ്‌പെയ്‌സ് ഒഴികെ), പിന്നെ
ആദ്യ വരികൾ ഉപയോഗിക്കുന്നു; അല്ലെങ്കിൽ രണ്ടാമത്തേത് ഉപയോഗിക്കുന്നു. മറ്റൊരു ക്ലോസ്
ഓപ്ഷണൽ.

"ifeq", "ifneq" എന്നീ പ്രസ്താവനകൾക്ക് സ്വീകാര്യമായ മറ്റ് രണ്ട് വാക്യഘടനകളുണ്ട്:

ifeq string1, string2
ifeq string1 string2

തുല്യമായവ. തീർച്ചയായും നിങ്ങൾക്ക് ആവശ്യാനുസരണം സ്ട്രിംഗുകൾ ഉദ്ധരിക്കാം.

"ifeq" ഉം അതിന്റെ സുഹൃത്തുക്കളായ "ifneq", "ifdef", "ifndef", "ifperl", "ifmakeperl", "ifsys" എന്നിവയും
"iftrue" എന്നത് നിങ്ങൾക്ക് വ്യത്യസ്തമായ ഒരു പ്രോഗ്രാം നിർമ്മിക്കേണ്ടി വരുമ്പോൾ പ്രാഥമികമായി ഉപയോഗപ്രദമാണ്
വ്യവസ്ഥകൾ. ഉദാഹരണത്തിന്,

BUILD_TYPE := ഡീബഗ് # "ഡീബഗ്" അല്ലെങ്കിൽ "പ്രൊഡക്ഷൻ"

ifeq ($(BUILD_TYPE), ഡീബഗ്)
CFLAGS := -g
മറ്റാരെങ്കിലും
CFLAGS := -O2
endif

പ്രോഗ്രാം: *.o
$(CC) $(CFLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്) $(LIBS)
ifeq ($(BUILD_TYPE), ഉത്പാദനം)
സ്ട്രിപ്പ് $(ഔട്ട്പുട്ട്)
endif

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

ഇതൊരു പ്രൊഡക്ഷൻ ബിൽഡ് ആണെങ്കിൽ, എല്ലാ ഫയലുകളും "-O2" എന്ന ഓപ്‌ഷൻ ഉപയോഗിച്ചാണ് കംപൈൽ ചെയ്യുന്നത്
"-g" ഓപ്ഷൻ. കൂടാതെ, "സ്ട്രിപ്പ്" എന്ന പ്രോഗ്രാം ഫലമായുണ്ടാകുന്ന ബൈനറിയിൽ പ്രവർത്തിക്കുന്നു (ഇൻ
ഡീബഗ് മോഡിൽ കംപൈൽ ചെയ്‌ത ചില ലൈബ്രറികളുമായി നിങ്ങൾ ലിങ്ക് ചെയ്‌ത സാഹചര്യത്തിൽ).

ചിലപ്പോൾ "$(if)" ഫംഗ്‌ഷൻ അല്ലെങ്കിൽ "$(perl)" ഫംഗ്‌ഷൻ ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നത് എളുപ്പമാണ്
"ifeq" പ്രസ്താവനയ്ക്ക് പകരം.

ഒരു ചിഹ്നം ശൂന്യമാണോ അല്ലയോ എന്ന് നിങ്ങൾക്ക് കാണണമെങ്കിൽ, നിങ്ങൾ a മാത്രം നൽകിയാൽ മതി
ഒറ്റ വാദം, ഇതുപോലെ:

ifneq $(EXE_SUFFIX)
# $(EXE_SUFFIX) ശൂന്യമല്ലെങ്കിൽ എന്ത് ചെയ്യണം
endif

ifdef വേരിയബിൾ ...
ifndef വേരിയബിൾ ...
ഈ പ്രസ്‌താവനകൾ "ifeq", "ifneq" എന്നീ പ്രസ്‌താവനകൾക്ക് സമാനമായി പ്രവർത്തിക്കുന്നു
ഏതെങ്കിലും വേരിയബിളുകൾ നിർവചിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്ന് അവർ പരിശോധിക്കുന്നു (അതായത് ഒന്നുമില്ല
നിർവചിച്ചിരിക്കുന്നത്). ഇനിപ്പറയുന്നവയാണെങ്കിൽ ഒരു വേരിയബിൾ നിർവചിച്ചിരിക്കുന്നു:

· ഇതിന് മുമ്പ് മേക്ക് ഫയലിൽ ഒരു അസൈൻമെന്റ് ഉള്ള ഒരു മൂല്യം നൽകിയിരുന്നു. കാണുക
വിശദാംശങ്ങൾക്ക് makepp_variables.

ഒരു "perl_begin" ബ്ലോക്കിൽ ഒരു Perl വേരിയബിളായി ഇതിന് ഒരു മൂല്യം നൽകി.

· പരിസ്ഥിതിയിൽ വേരിയബിൾ ഉണ്ട്.

· കമാൻഡ് ലൈനിൽ വേരിയബിൾ ഉണ്ട്, ഉദാ, നിങ്ങളുടെ മേക്ക്ഫയലിനെ അഭ്യർത്ഥിക്കാൻ
ടൈപ്പുചെയ്തു

makepp CFLAGS=-O2

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

ifndef CFLAGS
CFLAGS := -g
endif

ഈ സാഹചര്യത്തിൽ, "CFLAGS" ഇതിനകം നിർവചിച്ചിട്ടില്ലെങ്കിൽ മാത്രം "-g" ആയി സജ്ജീകരിക്കും. അതല്ല
"?=" എന്ന അസൈൻമെന്റ് ഉപയോഗിച്ച് ഈ പ്രസ്താവന വളരെ എളുപ്പത്തിൽ എഴുതാമായിരുന്നു
ഈ:

CFLAGS ?= -g

ifperl പെർൽകോഡ്
ifmakeperl പെർൽകോഡ്
ഈ പ്രസ്‌താവനകൾ "ifeq", "ifneq" എന്നീ പ്രസ്‌താവനകൾക്ക് സമാനമായി പ്രവർത്തിക്കുന്നു
പരിശോധനകൾ പേർളിലാണ്. ആദ്യത്തെ വേരിയന്റ് പ്ലെയിൻ പെർൾ കോഡാണ്, രണ്ടാമത്തെ വേരിയന്റ്
മേക്ക്-സ്റ്റൈൽ വേരിയബിൾ എക്സ്പാൻഷനിലൂടെയാണ് ആദ്യം പ്രസ്താവന കൈമാറുന്നത്.

പതിപ്പ് := 3.0
# പതിപ്പ് സ്വയമേവ ഒരു പേൾ വേരിയബിൾ കൂടിയാണ്:
ifperl $VERSION <= 2
CPPFLAGS := -DNEW
endif
CFLAGS-ന് ആവശ്യമായ # ഉദ്ധരണികൾ, കാരണം പേൾ മൂല്യം മാത്രമേ കാണുന്നുള്ളൂ:
ifmakeperl my $$x = '$(CFLAGS)'; $$x =~ /-g/
CFLAGS := -g -O2
endif

ifsys വൈൽഡ്കാർഡ് ...
ifnsys വൈൽഡ്കാർഡ് ...
നിലവിലെ മേക്കപ്പ് സിസ്റ്റം ഏതെങ്കിലും വൈൽഡ്കാർഡുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ ഇല്ലയോ എന്ന് പരിശോധിക്കുന്നു
ഏതെങ്കിലും (അതായത് ഒന്നുമില്ല).

ifsys i[3-6]86
ഒപ്പം ifsys Linux SunOS
... # Linux അല്ലെങ്കിൽ Solaris ഉള്ള ഒരു ഇന്റൽ പ്ലാറ്റ്ഫോം
അല്ലെങ്കിൽ ifnsys സ്പാർക്ക് പവർ*
... # Sparc അല്ലെങ്കിൽ PowerPC
endif

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

perl -MConfig -e'print "$^O @Config{qw(archname myarchname)} "'; uname -mps

സത്യമാണെങ്കിൽ പദപ്രയോഗം
സത്യമാണെങ്കിൽ പദപ്രയോഗം
പദപ്രയോഗം പൂജ്യമോ ശൂന്യമായ സ്‌ട്രിംഗോ അല്ലാതെ മറ്റെന്തെങ്കിലും മൂല്യത്തിലേക്ക് മൂല്യനിർണ്ണയം നടത്തുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു.

മറ്റു മൾട്ടിലൈൻ പ്രസ്താവനകൾ
കണ്ടീഷണലുകൾക്ക് ഒരു മുഴുവൻ മൾട്ടിലൈൻ സ്റ്റേറ്റ്‌മെന്റും നിയന്ത്രിക്കാനായേക്കാം, എന്നാൽ അത്തരത്തിലുള്ള ഒരു പ്രസ്താവനയ്ക്കുള്ളിൽ അവ ഉണ്ടാകില്ല
പ്രസ്താവന.

നിര്വചിക്കുക
{കയറ്റുമതി|ആഗോള|അവർറൈഡ്}* നിർവ്വചിക്കുക
വേരിയബിൾ നിർവ്വചിക്കുക [അസൈൻമെന്റ്-ഓപ്പറേറ്റർ]
വേരിയബിൾ മൂല്യ വരി 1
വേരിയബിൾ മൂല്യ വരി 2
endef

$(VARIABLE) ന്റെ മൂല്യം "നിർവചിക്കുക" എന്ന പ്രസ്‌താവനയ്‌ക്കിടയിലുള്ള എല്ലാ വരികളും
"endef" പ്രസ്താവന. മൾട്ടിലൈൻ വേരിയബിളുകൾ കാണുക. "കയറ്റുമതി", "ഗ്ലോബൽ" എന്നീ കീവേഡുകൾ ഉണ്ടാകാം
ഒരേ സമയം നൽകരുത്.

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

"perl_begin" പ്രസ്താവനയ്ക്ക് ശേഷമുള്ള വരിയുടെ ശേഷിക്കുന്ന ഭാഗം അവഗണിച്ചിരിക്കുന്നു. എല്ലാ ടെക്സ്റ്റ്
ഇടത് മാർജിനിൽ "perl_end" എന്ന് തുടങ്ങുന്ന ഒരു വരി പദത്തിലേക്ക് അയക്കുന്നത് വരെ
perl വ്യാഖ്യാതാവ്. "perl_end"-ന് മുമ്പ് സ്‌പെയ്‌സുകളൊന്നും ഉണ്ടാകില്ല.

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

OBJDIR := $(ARCH) # ഞങ്ങൾ .o ഫയലുകൾ ഇടുന്നിടത്ത്.
perl_begin
-d $OBJDIR അല്ലെങ്കിൽ mkdir $OBJDIR; # ഡയറക്ടറി നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക.
perl_end

ഈ രീതിയിൽ, ഓരോ തവണയും makefile പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ചെയ്താൽ ഉപഡയറക്‌ടറി സൃഷ്ടിക്കപ്പെടും
നിലവിലില്ല.

ചില പ്രവർത്തനങ്ങൾ മേക്കപ്പിനേക്കാൾ സാധാരണ എക്സ്പ്രഷനുകളുടെ അടിസ്ഥാനത്തിൽ നന്നായി പ്രകടിപ്പിക്കുന്നു
ടെക്സ്റ്റ് ഫംഗ്ഷനുകൾ. ഉദാഹരണത്തിന്,

perl_begin
എങ്കിൽ ($ARCH =~ /^i[56]86/) { # നിങ്ങൾക്ക് ഇത് ഇതുപയോഗിച്ച് ചെയ്യാം: ifsys i[56]86
$CFLAGS = '-O6 -malign-double'; # ഇന്റൽ മെഷീനുകളിൽ> 486, അവിടെ
# ഒരു ഗണ്യമായ വേഗത പിഴയാണ്
# ക്വാഡ്‌വേഡ് അല്ലാത്ത ഇരട്ടകൾക്ക്
# വിന്യസിച്ചു.
} else {
$CFLAGS = '-O6';
}
perl_end

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

ഏത് മേക്ക് വേരിയബിളും ഒരു പേൾ സ്കെയിലറായി നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ സജ്ജമാക്കി
"CFLAGS"-ന്റെ മൂല്യം വ്യത്യസ്തമായി ഒരു സാധാരണ എക്സ്പ്രഷൻ പൊരുത്തത്തെ അടിസ്ഥാനമാക്കി
വാസ്തുവിദ്യാ പതാകകൾ.

അവസാന ഉദാഹരണമായി, ചില വിവരങ്ങൾ പേളിൽ നിന്ന് നേരിട്ട് ആക്സസ് ചെയ്യാൻ എളുപ്പമാണ്
മേക്കപ്പിൽ നിന്നുള്ളതിനേക്കാൾ. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് എല്ലാ കോൺഫിഗറേഷൻ വിവരങ്ങളും ആക്സസ് ചെയ്യാൻ കഴിയും
പങ്കിട്ട ലൈബ്രറികൾ എങ്ങനെ നിർമ്മിക്കാം എന്നതുൾപ്പെടെ നിങ്ങളുടെ സിസ്റ്റത്തെക്കുറിച്ച് perl-ന് അറിയാം.
(Perl-ന്റെ കോൺഫിഗറേഷൻ വിവരങ്ങൾ എന്താണെന്ന് കാണണമെങ്കിൽ "perldoc Config" എന്ന് ടൈപ്പ് ചെയ്യുക
ലഭ്യമാണ്.)

perl_begin

കോൺഫിഗറേഷൻ ഉപയോഗിക്കുക;

$ARCH = $Config{'archname'}; # വാസ്തുവിദ്യയെക്കുറിച്ചുള്ള perl-ന്റെ അറിവ് ഉപയോഗിക്കുക.
$CC = $Config{'cc'}; # പേൾ ചെയ്ത അതേ സി കമ്പൈലർ ഉപയോഗിക്കുക.
$SHARED_OBJ_CFLAGS = $Config{'cccdlflags'};
# ഒബ്‌ജക്‌റ്റുകൾ കംപൈൽ ചെയ്യാൻ ഫ്ലാഗുകൾ ആവശ്യമാണ്
# പങ്കിട്ട ലൈബ്രറിയിലേക്ക് പോകുക.
$SHARED_OBJ_LDFLAGS = $Config{'ccdlflags'} . " " . $Config{'lddlflags'};
# പങ്കിട്ട ലൈബ്രറി നിർമ്മിക്കാൻ ലിങ്കർ ഫ്ലാഗുകൾ.
$SHARED_CC_LINK = $Config{'ld'}; # പങ്കിട്ട ലൈബ്രറികൾ നിർമ്മിക്കാനുള്ള കമാൻഡ്.

$SHARED_EXTENSION = $Config{'dlext'}; # പങ്കിട്ട ലൈബ്രറികളുടെ വിപുലീകരണം.
perl_end

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

libmylib.$(DLEXT): *.o
$(SHARED_CC_LINK) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്) $(SHARED_OBJ_LDFLAGS)

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

മുത്ത് പെർൽകോഡ്
makeperl പെർൽകോഡ്
ഇത് "perl_begin" പോലെയാണ്, പക്ഷേ Perl-style braces ഉപയോഗിക്കുന്നു. ആദ്യത്തെ വേരിയന്റ് ആണ്
പ്ലെയിൻ പേൾ കോഡ്, രണ്ടാമത്തെ വേരിയൻറ് ആദ്യം മെയ്ക്ക്-ലൂടെ സ്റ്റേറ്റ്മെന്റ് കൈമാറുന്നു.
ശൈലി വേരിയബിൾ വികാസം. പേളിന്റെ ബ്രേസുകൾ പാഴ്‌സ് ചെയ്യുന്നതിനുള്ള ബുദ്ധിമുട്ട് ലീഡ് ആണെന്ന് ശ്രദ്ധിക്കുക
ഇനിപ്പറയുന്ന ലളിതമായ ഹ്യൂറിസ്റ്റിക്കിലേക്ക്:

· അതേ അല്ലെങ്കിൽ അടുത്ത വരിയിൽ ഇരട്ട ഓപ്പണിംഗ് ബ്രേസ് കണ്ടെത്തിയാൽ, ഒരു ഇരട്ട ക്ലോസിംഗ്
ബ്രേസ് ബ്ലോക്ക് അവസാനിപ്പിക്കും. ഇത് ഒരു വരിയുടെ തുടക്കത്തിലായിരിക്കണം, പക്ഷേ ആയിരിക്കാം
വൈറ്റ്‌സ്‌പെയ്‌സിന് മുമ്പായി.

· അല്ലെങ്കിൽ, ക്ലോസിംഗ് ബ്രേസ് "പേൾ" ലൈനിന്റെ ഏറ്റവും അവസാനം ആണെങ്കിൽ ഇത് ഒന്നാണ്
ലൈനർ.

· അല്ലെങ്കിൽ ക്ലോസിംഗ് ബ്രേസ് ഇനിപ്പറയുന്ന വരിയുടെ തുടക്കത്തിൽ ആയിരിക്കണം,
അതായത് മുൻനിര വൈറ്റ്‌സ്‌പേസ് ഇല്ല.

പേൾ സ്ക്രിപ്റ്റുകളെ വിളിക്കുന്നതിനുള്ള കാര്യക്ഷമമായ മാർഗ്ഗത്തിന്, "റൺ" കാണുക. "$(perl)" ഫംഗ്‌ഷൻ പോലെയല്ല,
ഈ ബ്ലോക്കിന്റെ റിട്ടേൺ മൂല്യം അവഗണിക്കപ്പെട്ടിരിക്കുന്നു.

perl {print "makefile-ൽ ഈ പോയിന്റ് കടന്നുപോയി\n"}

മുത്ത്
{
പ്രിന്റ് "കൂടാതെ ഇതും\n";
}

ifdef NOISY
perl {{
"അതുപോലെ ഇതും\n" എന്ന് അച്ചടിക്കുക
}}
endif

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

perl -d -S mpp ...

ലോഡ് ചെയ്യാത്ത, പേൾ കോഡിൽ ബ്രേക്ക്‌പോയിന്റുകൾ സജ്ജീകരിക്കുന്നത് ബുദ്ധിമുട്ടാണ്. നിങ്ങൾക്ക് പ്രവർത്തിക്കാം
നിങ്ങൾക്ക് ആവശ്യമുള്ളിടത്ത് തൊട്ടുമുമ്പ്, നിങ്ങളുടെ എംബഡഡ് പേളിലേക്ക് ഈ ലൈൻ ഇടുക
തകർക്കാൻ:

$DB:: സിംഗിൾ = 1;

അതിനുശേഷം നിങ്ങൾക്ക് ഡീബഗ്ഗറിന്റെ പ്രോംപ്റ്റിൽ "c" എന്ന് ടൈപ്പ് ചെയ്യാം, അത് വരെ തുടരുക.

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

ശരീരത്തിന്റെ ബ്രേസുകൾ ഇടുന്നതിനുള്ള മൂന്ന് സാധ്യതകൾക്കായി, ഇവിടെ വിശദീകരണം കാണുക
"perl" പ്രസ്താവന.

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

ഉപ f_file_contents {
എന്റെ ($ ഫയൽ) = @_; # വാദത്തിന് പേര് നൽകുക.
എന്റെ $fh, $file തുറക്കുക അല്ലെങ്കിൽ മരിക്കുക "$file: $!\n";
പ്രാദേശിക $/ = undef; # സ്ലർപ്പ് ഫയൽ ഒറ്റ വായനയിൽ.
<$fh>;
}

ifdef NEWSUB
മേക്കബ് f_VAR2
{{
$(VAR) * 2;
}}
endif

makeub f_VAR1 { $(VAR) + 1 }

ഇപ്പോൾ, ഈ ഫംഗ്ഷൻ നിർവചിച്ചുകൊണ്ട്, നിങ്ങൾക്ക് എഴുതാം

X = $(file_contents ഫയൽനാമം) # ബിൽട്ടിൻ $(&cat ഫയൽനാമം) എന്നതിന് തുല്യമാണ്

കൂടാതെ "$(X)" എന്ന വേരിയബിൾ ഓരോ തവണയും തന്നിരിക്കുന്ന ഫയലിന്റെ ഉള്ളടക്കം ലഭ്യമാക്കും
വിപുലപ്പെടുത്തി. ഇത് കൃത്യമായി ഒരു പ്രാവശ്യം ചെയ്യാൻ ":=" ഉപയോഗിക്കുക, അല്ലെങ്കിൽ പരമാവധി ഒരു തവണ ഇത് ചെയ്യാൻ ";=" ഉപയോഗിക്കുക.

കൂടുതൽ വിശദാംശങ്ങൾക്കും ഉദാഹരണങ്ങൾക്കും makepp_extending കാണുക.

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

ഉദാഹരണത്തിന്, നിങ്ങളുടെ Makeppfile ഇത് ഇങ്ങനെയായിരിക്കാം:

റൂൾസ്-ടു-ബിൽഡ്-ഫയലുകൾ-അതർദിർ/എക്സ്-ഡിപെൻഡഡ്സ്-ഓൺ

more_rules.makeppfile: otherdir/x
action-to-build-more_rules.makeppfile

autoload more_rules.makeppfile

ഇവിടെ "ഓട്ടോലോഡ്" എന്നതിന് പകരം "ഉൾപ്പെടുത്തുക" എന്ന് നമുക്ക് വിശ്വസനീയമായി മാറ്റാൻ കഴിയില്ല, കാരണം എങ്കിൽ
നിയമമല്ലാതെ മറ്റെന്തെങ്കിലും more_rules.makeppfile നിർമ്മിക്കാൻ ശ്രമിക്കുന്നു otherdir/x
ആദ്യം, പിന്നെ more_rules.makeppfile കാരണം ഒരുപക്ഷേ പരാജയപ്പെടും otherdir/x നിലനിൽക്കില്ല
എന്നിട്ടും, എപ്പോൾ അത് നിർമ്മിക്കാനുള്ള ശ്രമം ഇതിനകം നടക്കുന്നതിനാൽ Makeppfile is
അതിന്റെ പേരിൽ പരോക്ഷമായി ലോഡ് ചെയ്തു.

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

ബിൽഡ്_കാഷെ /പാത്ത്/ടു/ബിൽഡ്/കാഷെ
[ആഗോള] ബിൽഡ്_കാഷെ /പാത്ത്/ടു/ബിൽഡ്/കാഷെ
ഒരു ബിൽഡ് കാഷെയിലേക്കുള്ള പാത വ്യക്തമാക്കുന്നു. വിശദാംശങ്ങൾക്ക് makepp_build_cache കാണുക. നിർമ്മാണം
കാഷെ ഇതിനകം നിലവിലുണ്ടാകണം; ഇതിനായി makepp_build_cache-ൽ "ഒരു ബിൽഡ് കാഷെ എങ്ങനെ കൈകാര്യം ചെയ്യാം" കാണുക
ആദ്യം അത് എങ്ങനെ ഉണ്ടാക്കാം. ഒരു മേക്ക് ഫയലിലെ "build_cache" പ്രസ്താവന അസാധുവാക്കുന്നു
makefile-ലെ നിയമങ്ങൾക്കായുള്ള "--build-cache" കമാൻഡ് ലൈൻ ഓപ്ഷൻ, പക്ഷേ അങ്ങനെയായിരിക്കാം
ഓരോ റൂൾ അടിസ്ഥാനത്തിൽ ":build_cache" റൂൾ മോഡിഫയർ ഉപയോഗിച്ച് അസാധുവാക്കുന്നു.

"ഗ്ലോബൽ" എന്ന കീവേഡ് ഈ പ്രസ്താവനയ്ക്ക് മുമ്പുള്ള കമാൻഡിന് സമാനമായ ഫലമുണ്ടാകാം
ലൈൻ ഓപ്ഷൻ, അതായത് ബിൽഡ് കാഷെ എല്ലാ മേക്ക് ഫയലിലും ബാധകമാണ്. ഇതായിരിക്കണം ഏറ്റവും നല്ലത്
എയിൽ നൽകിയിരിക്കുന്നു RootMakeppfile അത് നേരത്തെ തന്നെ കാണുമെന്ന് ഉറപ്പിക്കാം.

നിങ്ങൾക്ക് ബിൽഡ് കാഷെ അപ്രാപ്‌തമാക്കണമെങ്കിൽ ഒരു ഡയറക്‌ടറിയിലേക്കുള്ള പാതയ്‌ക്ക് പകരം "ഒന്നുമില്ല" എന്ന് വ്യക്തമാക്കുക
ഈ മേക്ക് ഫയലിലെ എല്ലാ നിയമങ്ങൾക്കും.

ബിൽഡ്_ചെക്ക് ബിൽഡ്_ചെക്ക്_രീതി
[ആഗോള] ബിൽഡ്_ചെക്ക് ബിൽഡ്_ചെക്ക്_രീതി
ഈ മേക്ക് ഫയലിലെ എല്ലാ നിയമങ്ങൾക്കും ഡിഫോൾട്ട് ബിൽഡ് ചെക്ക് രീതി വ്യക്തമാക്കുന്നു. കാണുക
വിശദാംശങ്ങൾക്ക് makepp_build_check. "build_check" പ്രസ്താവനയെ അസാധുവാക്കുന്നു
"--build-check-method", makefile-ലെ എല്ലാ നിയമങ്ങൾക്കുമുള്ള കമാൻഡ് ലൈൻ ഓപ്ഷൻ, പക്ഷേ അങ്ങനെയായിരിക്കാം
ഓരോ റൂൾ അടിസ്ഥാനത്തിൽ ":build_check" മോഡിഫയർ ഉപയോഗിച്ച് അസാധുവാക്കുന്നു.

"ഗ്ലോബൽ" എന്ന കീവേഡ് ഈ പ്രസ്താവനയ്ക്ക് മുമ്പുള്ള കമാൻഡിന് സമാനമായ ഫലമുണ്ടാകാം
ലൈൻ ഓപ്‌ഷൻ, അതായത് ബിൽഡ് ചെക്ക് രീതി അല്ലാത്ത എല്ലാ മേക്ക് ഫയലിലും ബാധകമാണ്
സ്വന്തം വ്യക്തമാക്കുക. ഇത് എയിൽ നൽകണം RootMakeppfile അത് ഉറപ്പിക്കാൻ
നേരത്തെ കണ്ടു.

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

കയറ്റുമതി ചെയ്യുക VAR ൽ ...
കയറ്റുമതി ചെയ്യുക നിയമനം
കയറ്റുമതി PATH := $(PWD):$(PATH)

ഉപപ്രോസസ്സുകളിലേക്ക് കയറ്റുമതി ചെയ്യുന്നതിനായി നൽകിയിരിക്കുന്ന വേരിയബിളുകൾ അടയാളപ്പെടുത്തുന്നു. ക്രമീകരണ വേരിയബിളുകൾ കാണുക.

ഗ്ലോബൽ VAR ൽ ...
ഗ്ലോബൽ നിയമനം
ആഗോള MYPROJECT.INFO = എല്ലാ മേക്ക് ഫയലുകളിലും കാണേണ്ട വിവരങ്ങൾ

നൽകിയിരിക്കുന്ന വേരിയബിളുകൾ എല്ലാ മേക്ക് ഫയലുകൾക്കും ആഗോളമായി അടയാളപ്പെടുത്തുന്നു. ക്രമീകരണ വേരിയബിളുകൾ കാണുക.

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

"ഉൾപ്പെടുത്തുക" ആദ്യം നിലവിലെ ഡയറക്‌ടറിയെ പരിഗണിക്കുന്നു, തുടർന്ന് കറന്റിന്റെ പാരന്റ്
ഡയറക്‌ടറി, പിന്നെ അതിന്റെ പാരന്റ്, മുതലായവ. ഡയറക്‌ടറികളിൽ എത്തുമ്പോൾ അത് പരിഗണിക്കുന്നത് നിർത്തുന്നു
ഫയൽ സിസ്റ്റത്തിന്റെ റൂട്ട് അല്ലെങ്കിൽ ഫയൽ സിസ്റ്റം ഡിവൈസ് ഐഡി മാറുമ്പോൾ. (എന്ന് വച്ചാൽ അത്
മറ്റ് NFS മൗണ്ടുകളിൽ ഉള്ള ഫയലുകൾ അത് കണ്ടെത്തുകയില്ല. ഇതുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾ തടയാനാണിത്
നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റങ്ങൾ അല്ലെങ്കിൽ ഓട്ടോമൗണ്ടറുകളും ഡെഡ് സെർവറുകളും.) ഇത് ഒരു ഫയൽ കണ്ടെത്തിയില്ലെങ്കിൽ
സെർച്ച് നിർത്തിയ സമയത്ത് നൽകിയ പേര്, പിന്നീട് അത് makepp ഡാറ്റയിൽ നോക്കും
ഡയറക്ടറി (/usr/local/share/makepp നിങ്ങൾ makepp ഇൻ ഇൻസ്റ്റാൾ ചെയ്താൽ / usr / local) ഒന്നിന്
makepp-നൊപ്പം വരുന്ന ഫയലുകൾ ഉൾപ്പെടുന്നു.

ഒരു മുഴുവൻ ഡയറക്‌ടറിയിലെയും എല്ലാ മേക്ക്‌ഫൈലിലും ഒരു ടെംപ്ലേറ്റ് ഫയൽ ഉൾപ്പെടുത്തണമെങ്കിൽ
ശ്രേണി, മുകളിലെ ഡയറക്‌ടറിയിൽ നിങ്ങളുടെ മേക്ക്‌ഫയൽ ടെംപ്ലേറ്റ് സ്ഥാപിക്കാം. മേക്ക് ഫയലുകൾ
അവർ ശ്രേണിയിൽ എവിടെയാണെന്ന് കൃത്യമായി അറിയേണ്ടതില്ല; ഓരോ മേക്ക് ഫയലിലും അടങ്ങിയിരിക്കാം
ഇതുപോലുള്ള ഒരു വരി:

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

ഇതുപോലുള്ള കൂടുതൽ സങ്കീർണ്ണമായ ഒന്നിന് പകരം:

ഉൾപ്പെടുത്തുക ../../../standard_definitions.mk # ഇത് ശരിയായ സംഖ്യയാണോ ..?

നിങ്ങൾക്ക് ആവശ്യമുള്ളത്ര ഫയലുകൾ വ്യക്തമാക്കാൻ കഴിയും, വേരിയബിളുകൾ അനുവദനീയമാണ്:

ഫയൽ1 ഫയൽ2 ഫയൽ3 $(other_include_files) ഉൾപ്പെടുത്തുക

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

$(TOPDIR)/standard_rules.mk ഉൾപ്പെടുന്നു

നിങ്ങൾ ആഗ്രഹിക്കുന്നു standard_rules.mk ഗ്നു നിർമ്മാണത്തിനും മേക്കപ്പിനും വ്യത്യസ്തമായിരിക്കും. സുഗമമാക്കുന്നതിന്
ഇതാണ് "ഉൾപ്പെടുത്തുക" എന്ന പ്രസ്താവന ആദ്യം എന്ന പ്രത്യയമുള്ള ഒരു ഫയലിനായി തിരയുന്നു .makepp മുമ്പ്
നിങ്ങൾ ആവശ്യപ്പെട്ട ഫയലിനായി തിരയുന്നു. ഈ സാഹചര്യത്തിൽ, അത് ആദ്യം ഒരു ഫയലിനായി നോക്കും
വിളിച്ചു standard_rules.mk.makepp, അത് നിലവിലുണ്ടെങ്കിൽ, പകരം അത് ലോഡ് ചെയ്യും
standard_rules.mk. ഈ രീതിയിൽ, നിങ്ങൾ GNU make ഉപയോഗിച്ച് makefile പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ലോഡ് ചെയ്യുന്നു
standard_rules.mk, എന്നാൽ makepp ഉപയോഗിച്ച്, അത് ലോഡ് ചെയ്യുന്നു standard_rules.mk.makepp.

കാരണം പല ലെഗസി ഫയലുകളും ഉൾപ്പെടുത്തിയതിന് ശേഷം ഒരു ഉൾപ്പെടുത്തൽ ഫയൽ ജനറേറ്റ് ചെയ്യുന്നതിനുള്ള നിയമം നൽകുന്നു
പ്രസ്‌താവന, മേക്കെപ്പ് നിലവിലില്ലാത്തതോ പഴകിയതോ ആയ തീരുമാനങ്ങൾ അവസാനം വരെ മാറ്റിവയ്ക്കും
makefile ലോഡിംഗ്. അതായത്, അത് "--rm-stale" ഉപയോഗിച്ച് വിളിച്ചിട്ടില്ലെങ്കിൽ. പലർക്കും
അപ്പോഴേക്കും സ്ഥിതി മെച്ചപ്പെടുമ്പോൾ (ഒരു നിയമം പ്രത്യക്ഷപ്പെട്ടതിനാൽ) makepp ചെയ്യും
makefile വീണ്ടും ലോഡുചെയ്യുക, ഇത് വീണ്ടും അത്തരം നിയമങ്ങൾ ദൃശ്യമാക്കിയേക്കാം. ഇത് വ്യക്തമാണ്
മേക്ക് ഫയലുകൾ ലോഡുചെയ്യുന്നതിനുള്ള കാര്യക്ഷമമല്ലാത്ത മാർഗ്ഗം, അതിനാൽ അത് ഒഴിവാക്കാൻ ശ്രമിക്കുക. മോശം, നിങ്ങളുടെ മെയ്ക്ക് ഫയൽ ആണെങ്കിൽ
ലോഡിംഗിന് പാർശ്വഫലങ്ങളുണ്ട് (ഒരു ഗ്ലോബൽ വേരിയബിളിലേക്ക് ചേർക്കുന്നത് പോലെ അല്ലെങ്കിൽ ഒരു വരി പോലെ
"do_it_now := $(shell cat a >>b)" അല്ലെങ്കിൽ അതിന്റെ makepp തത്തുല്യമായ "&cat a -o>>b") അവർ ചെയ്യും
മേക്ക്‌ഫൈൽ ലോഡുചെയ്യേണ്ട പല തവണയും സംഭവിക്കുന്നു, അതിനാൽ, അത് ഒഴിവാക്കാൻ വീണ്ടും ശ്രമിക്കുക!

_ഉൾപ്പെടുന്നു makefile
-ഉൾപ്പെടുന്നു makefile
"ഉൾപ്പെടുത്തുക" എന്നതിലെ ഒരു ചെറിയ വേരിയന്റ്, "_include" പ്രസ്താവനയിൽ ഫയൽ ഉണ്ടെങ്കിൽ അത് ഉൾപ്പെടുന്നു
പക്ഷേ, ഇല്ലെങ്കിൽ മാരകമായ ഒരു പിശക് സൃഷ്ടിക്കില്ല. "_include" എന്ന പ്രസ്താവന ഉപയോഗിച്ചിരുന്നു
ഗ്നു മേക്കിനൊപ്പം ഫയൽ സ്കാനിംഗ് ഉൾപ്പെടുത്തുന്നത് പ്രധാനമാണ്, എന്നാൽ makepp-ന് ഇത് വളരെ ഉപയോഗപ്രദമല്ല.

load_makefile /ചിലത്/ഡയറക്‌ടറി/എവിടെയോ/നിർമ്മിക്കുക
load_makefile സബ്ദിർ
load_makefile VAR1=മൂല്യം1 VAR2=മൂല്യം2 സബ്ദിർ
ഈ പ്രസ്താവന, makepp-നെ, makefile ഉം ലോഡും അടങ്ങുന്ന ഡയറക്ടറിയിലേക്ക് cd-ലേക്ക് നയിക്കുന്നു
makepp-ന്റെ ആന്തരിക ഡാറ്റാബേസിലേക്ക് അതിന്റെ നിയമങ്ങൾ. എന്നതിനുപകരം നിങ്ങൾ ഒരു ഡയറക്ടറി മാത്രം വ്യക്തമാക്കിയാൽ
ഒരു makefile, "load_makefile" അതിൽ "Makeppfile", "makefile", അല്ലെങ്കിൽ "Makefile" എന്നിവയ്ക്കായി തിരയുന്നു
ഡയറക്ടറി.

"VAR=value" (അല്ലെങ്കിൽ "VAR="value1 value2"") എന്ന വാക്യഘടന ഉപയോഗിച്ച് നിങ്ങൾ വ്യക്തമാക്കുന്ന ഏതെങ്കിലും വേരിയബിളുകൾ
ലോഡുചെയ്ത മേക്ക് ഫയലുകളിലേക്ക് കൈമാറി. ആ മേക്ക് ഫയലുകളിലെ ഏത് ക്രമീകരണങ്ങളും അവർ അസാധുവാക്കുന്നു
നിങ്ങൾ അവ കമാൻഡ് ലൈനിൽ ടൈപ്പ് ചെയ്തതുപോലെ.

"load_makefile" ഉപയോഗിക്കുന്നത് കമാൻഡിൽ നിന്ന് വ്യത്യസ്തമാണ്

dir/makefile ഉൾപ്പെടുത്തുക

രണ്ടു തരത്തിൽ. ആദ്യം, "load_makefile" മുകളിൽ നിന്ന് വേരിയബിളുകളൊന്നും കൈമാറുന്നില്ല-
കീഴ്വഴക്കമുള്ള മേക്ക്ഫയലിലേക്ക് ലെവൽ മേക്ക്ഫിൽ; ഓരോ മേക്ക് ഫയലും അതിന്റേതായ നിലയിലാണ്
നെയിംസ്പേസ്. സബോർഡിനേറ്റ് മേക്ക് ഫയലിന് ഉയർന്ന തലത്തിലുള്ള വേരിയബിളുകളെ സ്വാധീനിക്കാൻ കഴിയില്ല
ഏതെങ്കിലും വിധത്തിൽ ഫയൽ ഉണ്ടാക്കുക.

രണ്ടാമതായി, ഓരോ ബിൽഡ് കമാൻഡും അത് വന്ന മേക്ക് ഫയലിന്റെ ഡയറക്ടറിയുമായി ടാഗ് ചെയ്തിരിക്കുന്നു
നിന്ന്. മറ്റൊരു മേക്ക് ഫയലിൽ നിന്ന് makepp ഒരു റൂൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, അത് ആദ്യം സി.ഡി
കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് ആ makefile അടങ്ങുന്ന ഡയറക്ടറി. മേക്ക് ഫയലുകൾ
"ഉൾപ്പെടുത്തുക" എന്ന പ്രസ്താവനയ്‌ക്കൊപ്പം കാണുന്നത് യഥാർത്ഥത്തിൽ മേക്ക്‌ഫയലിന്റെ ഭാഗമായാണ് പരിഗണിക്കുന്നത്
അവ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, അതിനാൽ അവരുടെ നിയമങ്ങൾ മറ്റൊരു ഡയറക്‌ടറിയിൽ ടാഗ് ചെയ്‌തിട്ടില്ല.

നിങ്ങൾക്ക് സാധാരണയായി ഒരു മേക്ക്ഫയലിന് അസാധാരണമായ പേരില്ലെങ്കിൽ അത് വ്യക്തമായി ലോഡ് ചെയ്യേണ്ടതില്ല,
അല്ലെങ്കിൽ മേക്ക് ഫയലിന്റെ അതേ ഡയറക്‌ടറിയിൽ അടങ്ങിയിരിക്കാത്ത ടാർഗെറ്റുകൾ ഇതിന് ഉണ്ട്
അത് തന്നെ, അല്ലെങ്കിൽ നിങ്ങൾ ഇംപ്ലിസിറ്റ് മേക്ക് ഫയൽ ലോഡിംഗ് പ്രവർത്തനരഹിതമാക്കി. സ്വതവേ, makepp ആണെങ്കിൽ
ഒരു ഫയൽ നിർമ്മിക്കാൻ ശ്രമിക്കുന്നു, അത് നിർമ്മിക്കാൻ ഒരു നിയമവുമില്ല, അല്ലെങ്കിൽ അത് വിലയിരുത്തുകയാണെങ്കിൽ a
ഒരു ഡയറക്‌ടറിയിൽ വൈൽഡ്‌കാർഡ് ചെയ്‌ത ഫയലിന്റെ പേര്, അത് ഒരു മേക്ക് ഫയൽ ലോഡുചെയ്യാൻ സ്വയമേവ ശ്രമിക്കും
ആ ഡയറക്ടറിയിൽ നിന്ന്. വിവരങ്ങൾക്ക് makepp_cookbook-ൽ "ഒന്നിലധികം ഡയറക്ടറികൾക്കുള്ള നുറുങ്ങുകൾ" കാണുക
ഒന്നിലധികം ഡയറക്ടറികളുള്ള നിർമ്മാണത്തിൽ.

നിങ്ങൾക്ക് "load_makefile" ഉപയോഗിക്കുന്നതിന് ഒരേ പോലെയുള്ള നിരവധി മേക്ക് ഫയലുകൾ ലോഡുചെയ്യാൻ കഴിയില്ല
ഡയറക്ടറി. ഒരേ ഫയലിന് ബാധകമാകുന്ന നിരവധി മേക്ക് ഫയലുകൾക്കായി "ഉൾപ്പെടുത്തുക" ഉപയോഗിക്കുക
ഡയറക്‌ടറി, കൂടാതെ വ്യത്യസ്‌ത ഡയറക്‌ടറികൾക്ക് ബാധകമായ മേക്ക്‌ഫയലുകൾക്കായി "load_makefile".

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

no_implicit_load dir1 dir2/*

മുകളിലെ പ്രസ്‌താവന "dir1"-ലെ മേക്ക്‌ഫയലുകൾക്കുള്ള പരോക്ഷമായ ലോഡിംഗ് ഓഫാക്കും ഒപ്പം എല്ലാം of
ഐസിടി ഉപഡയറക്‌ടറികൾ. ഇത് എല്ലാവർക്കുമായി അവ്യക്തമായ മേക്ക്‌ഫൈൽ ലോഡിംഗ് മാറ്റുകയും ചെയ്യും
"dir2" ന്റെ ഉപഡയറക്‌ടറികൾ (അവരുടെ എല്ലാ ഉപഡയറക്‌ടറികളും), എന്നാൽ "dir2" ന് വേണ്ടിയല്ല.

പ്രസ്താവനയിൽ നിങ്ങൾക്ക് വൈൽഡ്കാർഡുകൾ ഉപയോഗിക്കാം. വൈൽഡ്കാർഡുമായി പൊരുത്തപ്പെടുന്ന നോൺ-ഡയറക്‌ടറി ഫയലുകൾ
അവഗണിക്കപ്പെടുന്നു. നിങ്ങൾ ചെയ്യുന്ന ഡയറക്‌ടറികൾ കൂടുതൽ വ്യക്തമാക്കുന്നതിന് നിങ്ങൾക്ക് ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കാനും കഴിയും
താൽപ്പര്യമുണ്ട്, ഉദാ.

no_implicit_load $(filter-out dir1 dir2, *)

ഒഴികെയുള്ള എല്ലാ ഉപഡയറക്‌ടറികൾക്കും ഇൻപ്ലിസിറ്റ് ലോഡിംഗ് ഓഫാക്കും നിങ്ങൾ1 ഒപ്പം നിങ്ങൾ2 അവരുടെ
ഉപഡയറക്‌ടറികൾ.

മുൻകൂട്ടി നിർമ്മിക്കുക ലക്ഷ്യം
ഉണ്ടാക്കുക ലക്ഷ്യം
ആർഗ്യുമെന്റുകൾ (മേക്ക്-സ്റ്റൈൽ വേരിയബിൾ വിപുലീകരണത്തിന് വിധേയമാകുന്നു) ഉടനടി നിർമ്മിക്കപ്പെടുന്നു.
Makefile-ന് നിർമ്മിക്കാൻ കഴിയുന്ന ടാർഗെറ്റുകളുടെ ലിസ്റ്റ് a-യെ ആശ്രയിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്
മറ്റൊരു ഡയറക്ടറിയിൽ സൃഷ്ടിച്ച ഫയൽ.

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

register_command_parser കമാൻഡ്_വേഡ് പാഴ്‌സർ
രജിസ്റ്റർ_പാർസർ കമാൻഡ്_വേഡ് പാഴ്‌സർ
റൂൾ പ്രവർത്തനങ്ങൾ ലെക്സിക്കലായി വിശകലനം ചെയ്യുമ്പോൾ, ഉപയോഗിക്കുക പാഴ്‌സർ വേണ്ടി കമാൻഡ്_വേഡ്, ഏത് ആയിരിക്കാം
പൂർണ്ണ പാത അല്ലെങ്കിൽ അടിസ്ഥാന നാമം. ലെക്‌സർ ആയതിനാൽ അടിസ്ഥാനനാമം മതിയാകും
രണ്ടും ശ്രമിക്കുന്നു.

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

അല്ലെങ്കിൽ, ആ ക്ലാസ് സാധാരണയായി ഇതുവരെ ലോഡ് ചെയ്യാത്തതിനാൽ, പകരം ഫാക്ടറി ഫംഗ്‌ഷൻ ആയിരിക്കാം
Makefile നെയിംസ്പേസിൽ താമസിക്കുന്നു. ഈ ഫംഗ്‌ഷനുകൾക്ക് "p_" എന്ന പ്രിഫിക്‌സ് ഉണ്ടായിരിക്കണം
കൊടുക്കില്ല. ബിൽഡിൻ പാർസറുകളുടെ കാര്യമാണിത്.

പ്രഭാവം ": പാർസർ" റൂൾ ഓപ്ഷനുമായി താരതമ്യപ്പെടുത്താവുന്നതാണ്. എന്നാൽ മൾട്ടി-കമാൻഡ് നിയമങ്ങൾക്കായി
ഇതാണ് നല്ല വഴി.

രജിസ്റ്റർ_ഇൻപുട്ട്_സഫിക്സ് കമാൻഡ്_വേഡ് സഫിക്സ് ...
ഒരു പ്രവർത്തന സമയത്ത് തിരിച്ചറിഞ്ഞ ഇൻപുട്ട് ഫയൽ പ്രത്യയങ്ങളുടെ പട്ടികയിലേക്ക് "സഫിക്സ്" ... ചേർക്കുക
"command_word" ൽ തുടങ്ങുന്നത് പാഴ്‌സ് ചെയ്‌തു. പാഴ്‌സർ സാധാരണയായി ഇത് വഴി എടുക്കും
Mpp::CommandParser::input_filename_regexp, പക്ഷേ ഇത് പൂർണ്ണമായും അവഗണിക്കാം.

ഓപ്‌ഷനുകളായി അംഗീകരിക്കപ്പെടാത്ത എല്ലാ ആർഗ്യുമെന്റുകളും പാഴ്‌സറുകൾ സാധാരണയായി എടുക്കാറില്ല,
കാരണം അവ തിരിച്ചറിയപ്പെടാത്ത ഓപ്ഷനുകളുടെ വാദങ്ങളായിരിക്കാം. (ഉദാഹരണത്തിന്, i386v is അല്ല
"gcc -b i386v foo.c" എന്ന കമാൻഡിന്റെ ഒരു ഇൻപുട്ട് ഫയൽ.) പകരം, അവർ മാത്രം എടുക്കുക
ഇൻപുട്ട് ഫയൽനാമങ്ങൾ പോലെ കാണപ്പെടുന്ന സ്ഥാനപരമായ ആർഗ്യുമെന്റുകൾ.

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

register_input_suffix cpp .vpp
%.v: %.vpp
cpp $< > $@

സംഭരണിയാണ് ഡയറക്ടറി
സംഭരണിയാണ് destdir=srcdir
ഒന്നോ അതിലധികമോ റിപ്പോസിറ്ററി ഡയറക്ടറികൾ വ്യക്തമാക്കുന്നു. വ്യക്തമാക്കിയ ആദ്യ ശേഖരണമുണ്ട്
ഒരേ ഫയൽ ഒന്നിലധികം റിപ്പോസിറ്ററികളിലും അവിടെയും നിലവിലുണ്ടെങ്കിൽ മറ്റുള്ളവയേക്കാൾ മുൻഗണന
അതിനുള്ള ബിൽഡ് കമാൻഡ് ഇല്ല. കൂടുതൽ വിവരങ്ങൾക്ക് makepp_repositories കാണുക
സംഭരണികൾ.

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

ശേഖരം subdir1/subdir2=/users/joe/joes_nifty_library

നിങ്ങളുടെ മേക്ക്‌ഫയലിന്റെ മുകൾഭാഗത്ത്, ഏതെങ്കിലും ഒന്നിന് മുമ്പായി നിങ്ങൾ റിപ്പോസിറ്ററി സ്റ്റേറ്റ്‌മെന്റ് ഇടണം
അത് ഉപയോഗിക്കേണ്ട നിയമങ്ങൾ.

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

റൺടൈം ഡിപൻഡൻസികൾ ആവർത്തിച്ച് കടന്നുപോകുന്നു, അതിനാൽ "a" എന്നതിന് റൺടൈം ഡിപൻഡൻസി ഉണ്ടെങ്കിൽ
"b", "b" എന്നിവയ്ക്ക് "c"-ൽ ഒരു റൺടൈം ഡിപൻഡൻസി ഉണ്ട്, തുടർന്ന് "./a" ഉപയോഗിക്കുന്ന ഏത് നിയമവും ഉണ്ടായിരിക്കും.
"b", "c" എന്നിവയിൽ പരോക്ഷമായ ആശ്രിതത്വം (അത് ഒരു പ്രത്യേകം ഉപയോഗിക്കുന്നില്ലെങ്കിൽ
ഈ സ്വഭാവത്തെ മറികടക്കുന്ന "Mpp:: CommandParser" ക്ലാസ്).

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

കയ്യൊപ്പ് പേര്
[ആഗോള] [അസാധുവാക്കുക] ഒപ്പ് പേര്
ഒപ്പ് md5
ഒപ്പ് സി
ഒപ്പ് c_compilation_md5
ഒപ്പ് xml
ഒപ്പ് xml-സ്പെയ്സ്
ഒപ്പ് സ്ഥിരസ്ഥിതി

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

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

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

സിഗ്നേച്ചർ രീതികളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, makepp_signatures കാണുക.

vpath പാറ്റേൺ ഡയറക്ടറി ...
നൽകിയിരിക്കുന്ന ഓരോ ഡയറക്‌ടറിയിൽ നിന്നും പാറ്റേൺ പൊരുത്തപ്പെടുന്ന എല്ലാ ഫയലുകളും ലഭ്യമാക്കുക. പാറ്റേണിൽ അടങ്ങിയിരിക്കാം
മിക്കതും ഒരു "%" വൈൽഡ്കാർഡ്. ഇത് സുതാര്യമായ റിപ്പോസിറ്ററി മെക്കാനിസം ഉപയോഗിക്കുന്നു (gmake പോലെയല്ല
ഫയൽനാമങ്ങൾ തിരുത്തിയെഴുതുന്നു), എന്നാൽ ഇത് ഉപഡയറക്‌ടറികളിലേക്ക് ആവർത്തിക്കില്ല.

കമാൻഡുകൾ
എല്ലാ ബിൽറ്റിൻ, സ്വയം നിർവചിക്കപ്പെട്ട കമാൻഡുകൾ (ബിൽട്ടിൻ കമാൻഡുകളും വിപുലീകരിക്കുന്ന makepp എന്നിവയും കാണുക), അതുപോലെ
ബാഹ്യമായി വൃത്തിയായി പ്രോഗ്രാം ചെയ്തിരിക്കുന്ന പേൾ സ്ക്രിപ്റ്റുകൾ പ്രസ്താവനകൾ പോലെ ഉപയോഗിക്കാം. ഈ സാഹചര്യത്തിൽ
മേക്കപ്പിന്റെയും ഏതെങ്കിലും ഇൻപുട്ടിന്റെയും അതേ പ്രക്രിയയിൽ പ്രവർത്തിക്കുന്നതിനാൽ അവ റൂൾ പ്രവർത്തനങ്ങളിൽ നിന്ന് വ്യത്യസ്തമാണ്
അല്ലെങ്കിൽ ഔട്ട്‌പുട്ട് ഫയലുകൾ ഡിപൻഡൻസികളായോ makepp നിർമ്മിച്ചവയായോ രേഖപ്പെടുത്തിയിട്ടില്ല.

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

makefile വായിക്കുമ്പോൾ സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ആകുന്നതിന് ഇത് ഉപയോഗിക്കാം:

&എക്കോ $$(VAR) ന്റെ മൂല്യം $(VAR) ആണ്

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

ifperl !-d 'ഉൾപ്പെടുത്തുക'
&mkdir -p ഉൾപ്പെടുന്നു # ഇല്ലെങ്കിൽ മാത്രം സൃഷ്ടിക്കുക
endif

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