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

പട്ടിക:

NAME

makepp_variables -- makepp-ൽ വേരിയബിളുകൾ എങ്ങനെ ഉപയോഗിക്കാം

വിവരണം

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ആർഫ്ലാഗുകൾ,
AS, C: DC,
CFLAGS,
"മാറ്റം_ആശ്രിതത്വം",
മാറ്റിയ_ഇൻപുട്ടുകൾ,
CURDIR,
CXX,
CXXFLAGS, D: "ആശ്രിതത്വം",
"ആശ്രിതത്വം", F: F77,
എഫ്സി,
"ഫോറച്ച്", I: ഇൻപുട്ട്,
ഇൻപുട്ടുകൾ, L: LD,
LEX,
LIBTOOL, M: ഉണ്ടാക്കുക,
ലക്ഷ്യങ്ങൾ ഉണ്ടാക്കുക,
മേക്ക്ഫ്ലാഗുകൾ,
MAKEINFO,
MAKEPP_DEBUG,
മേക്ക്ഫ്ലാഗുകൾ,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "ഔട്ട്പുട്ട്",
"ഔട്ട്പുട്ടുകൾ", P: പേൾ,
പിഡബ്ല്യുഡി, R: ആർഎം,
റൂട്ട്, S: ഷെൽ,
"ക്രമീകരിച്ച_ആശ്രിതത്വങ്ങൾ",
അടുക്കിയ_ഇൻപുട്ടുകൾ,
"തണ്ട്", T: ലക്ഷ്യം,
ടാർഗെറ്റുകൾ, V: VPATH, Y: YACC

മേക്ക് ഫയലുകൾ സാധാരണയായി പല സ്ഥലങ്ങളിലും വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു. ഉപയോഗിക്കുന്നതിനുള്ള ഒരു പ്രധാന കാരണം
variables എന്നത് makefile-ൽ ഒരിടത്ത് മാത്രമേ വിവരങ്ങൾ അടങ്ങിയിട്ടുള്ളൂ എന്ന് ഉറപ്പാക്കാനാണ്
അത് മാറിയാൽ, വിവരങ്ങളുടെ രണ്ട് പകർപ്പുകൾ പുറത്തുപോകുന്നതിന് ഒരു അപകടവുമില്ല
സമന്വയം.

വേരിയബിൾ പേരുകൾ കേസ് സെൻസിറ്റീവ് ആണ്. സിദ്ധാന്തത്തിൽ, വേരിയബിൾ പേരുകൾ പലതും ഉണ്ടാക്കാം
കഥാപാത്രങ്ങൾ, പക്ഷേ നിങ്ങൾ അല്ലാതെ മറ്റെന്തെങ്കിലും ചെയ്താൽ മേക്കപ്പിന് ഒരുപക്ഷേ അത് തട്ടിമാറ്റാൻ കഴിയില്ല
ആൽഫാന്യൂമെറിക് പ്രതീകങ്ങൾ, "_", "-" എന്നിവ.

ഓരോ മേക്ക് ഫയലിനും അതിന്റേതായ വേരിയബിളുകൾ ഉണ്ട്, ഒരു വേരിയബിൾ ഒരു മേക്ക് ഫയലിൽ സജ്ജീകരിക്കും
മറ്റേതൊരു മേക്ക് ഫയലിലും അതിന്റെ മൂല്യത്തെ ബാധിക്കില്ല. നിങ്ങൾക്ക് വേരിയബിളുകൾ സജ്ജീകരിക്കണമെങ്കിൽ
നിരവധി മേക്ക് ഫയലുകൾ, അതിനുള്ള ഏറ്റവും നല്ല മാർഗം അവയിൽ ഓരോന്നിനും പൊതുവായ നിർവചനങ്ങൾ ഉൾപ്പെടുത്തുക എന്നതാണ്
ഫയൽ (ഉൾക്കൊള്ളുന്ന പ്രസ്താവന കാണുക) അല്ലെങ്കിൽ "ഗ്ലോബൽ" വേരിയബിളുകൾ ഉപയോഗിക്കുക.

വേരിയബിൾ അസൈൻമെന്റ്
ഒരു വേരിയബിളിന് വ്യത്യസ്ത രീതികളിൽ ഒരു മൂല്യം അനുമാനിക്കാം:

· ഒരു മേക്ക് ഫയലിനുള്ളിൽ ഒരു വേരിയബിൾ സജ്ജമാക്കിയേക്കാം. വ്യത്യസ്തമായ നിരവധി മാർഗങ്ങളുണ്ട്
ഈ; താഴെ നോക്കുക.

ഒരു വേരിയബിളിന്റെ മൂല്യം കമാൻഡ് ലൈനിൽ ഇതുപോലെ വ്യക്തമാക്കിയേക്കാം:

makepp CFLAGS=-O2 my_program

ഒന്നിലധികം മേക്ക്ഫയലുകൾ ലോഡ് ചെയ്താൽ, CFLAGS വേരിയബിൾ എല്ലാവരിലേക്കും പ്രചരിപ്പിക്കപ്പെടും
മേക്ക് ഫയലുകൾ. കമാൻഡ് ലൈനിൽ സജ്ജീകരിച്ചിരിക്കുന്ന വേരിയബിളുകൾ ഏതെങ്കിലും ക്രമീകരണം സ്വയമേവ അസാധുവാക്കുന്നു
ഏതെങ്കിലും മേക്ക് ഫയലുകളിലെ വേരിയബിൾ.

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

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

ഇതുപോലുള്ള നിരവധി അസൈൻമെന്റ് എക്‌സ്‌പ്രഷനുകളിലൊന്നിലാണ് വേരിയബിളുകൾ നൽകിയിരിക്കുന്നത്

X = 1
മൊഡ്യൂളുകൾ := abcd
CC ?= gcc
CFLAGS += -മതിൽ
VAR നിർവ്വചിക്കുക
var ലൈൻ 1
var ലൈൻ 2
enddef
കയറ്റുമതി PATH := $(PWD):$(PATH)
ആഗോള MYPROJECT.INFO = എല്ലാ മേക്ക് ഫയലുകളിലും കാണേണ്ട വിവരങ്ങൾ

മൂല്യങ്ങൾക്ക് ചുറ്റുമുള്ള വൈറ്റ്‌സ്‌പെയ്‌സ് നയിക്കുന്നതും പിന്നിൽ നിൽക്കുന്നതും എല്ലായ്പ്പോഴും നീക്കം ചെയ്യപ്പെടും.

വ്യത്യസ്ത അസൈൻമെന്റ് ഓപ്പറേറ്റർമാർക്ക് കുറച്ച് വ്യത്യസ്ത അർത്ഥങ്ങളുണ്ട്.

ലഘുവായ നിയമനം ഓപ്പറേറ്റർമാർ

=
VARIABLE = ടെക്സ്റ്റ് സ്ട്രിംഗ്
വേരിയബിൾ = ടെക്സ്റ്റ് സ്ട്രിംഗ് അസാധുവാക്കുക

എല്ലാ നടപ്പാക്കലുകളും പിന്തുണയ്ക്കുന്ന സാധാരണ അസൈൻമെന്റ് പ്രസ്താവനയാണിത്. ദി
"$(VARIABLE)" എന്നതിന്റെ മൂല്യം ആകുന്നത് വരെ വലതുവശത്തുള്ള എക്സ്പ്രഷൻ മൂല്യനിർണ്ണയം ചെയ്യപ്പെടുന്നില്ല
യഥാർത്ഥത്തിൽ എവിടെയോ ഉപയോഗിച്ചു. അതിനാൽ, നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യുകയാണെങ്കിൽ:

X = 1
Y = $(X)
X = 2

പിന്നീട് മേക്ക് ഫയലിൽ "$(Y)" എന്നത് "2" ആയി വിലയിരുത്തും.

പൊതുവേ, നിങ്ങൾ സാധാരണയായി "=" എന്നതിന് പകരം ":=" (ചുവടെ കാണുക) ഉപയോഗിക്കണം, കാരണം അത്
കൂടുതൽ പ്രവചിക്കാവുന്ന വേരിയബിൾ മൂല്യനിർണ്ണയം നൽകുന്നു. എന്നിരുന്നാലും, നിങ്ങൾക്ക് ആവശ്യമുള്ള സമയങ്ങളുണ്ട്
വേരിയബിൾ മൂല്യനിർണ്ണയം മാറ്റിവയ്ക്കാൻ. കൂടാതെ, നിങ്ങൾ ഒരു മേക്ക് ഫയൽ എഴുതുകയാണെങ്കിൽ അത് ആയിരിക്കണം
GNU make അല്ലാതെ മേക്കിന്റെ ചില പതിപ്പുകളുമായി ബാക്ക്വേർഡ്-അനുയോജ്യമാണ്, അപ്പോൾ നിങ്ങൾക്കില്ല
ചോയ്സ്: നിങ്ങൾക്ക് "=" മാത്രമേ ഉപയോഗിക്കാനാകൂ.

:=
വേരിയബിൾ := expr
വേരിയബിൾ അസാധുവാക്കുക := expr

ഇത് "VARIABLE = expr" എന്നതിന് തുല്യമാണ്, വലത് വശം വിലയിരുത്തുന്നത് ഒഴികെ
അസൈൻമെന്റിന്റെ സമയത്ത് ഒരിക്കൽ എന്നേക്കും. അങ്ങനെ എങ്കിൽ

X := 1
Y:= $(X)
X := 2

"$(Y)" പിന്നീട് മേക്ക് ഫയലിൽ "1" ആയി മൂല്യനിർണ്ണയം ചെയ്യും, കാരണം അതാണ് "$(X)"
"$(Y)" നിർവചിക്കപ്പെട്ടപ്പോൾ.

;=
വേരിയബിൾ ;= expr
വേരിയബിൾ അസാധുവാക്കുക ;= expr

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

VAR1 ;= $(പേൾ ചെലവേറിയ കണക്കുകൂട്ടലുകൾ)
VAR2 ;= $(ഷെൽ ബാഹ്യ കമാൻഡ്)

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

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

+=
VARIABLE += expr
VARIABLE += expr അസാധുവാക്കുക

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

&=
വേരിയബിൾ &= എക്സ്പിആർ
VARIABLE &= expr അസാധുവാക്കുക

ഒരു സ്‌പെയ്‌സ് കൊണ്ട് വേർതിരിക്കുന്ന വേരിയബിളിന്റെ മുമ്പത്തെ ഉള്ളടക്കങ്ങളിലേക്ക് സ്‌ട്രിംഗിനെ മുൻനിറുത്തുന്നു.
വേരിയബിൾ മുമ്പ് ":=" എന്നതിനൊപ്പം നൽകിയിരുന്നെങ്കിൽ, വലത് വശമാണ്
ചേർക്കുന്നതിന് മുമ്പ് വിലയിരുത്തി.

ഉദാഹരണത്തിന്, "CFLAGS" എന്ന് ഉറപ്പുനൽകുന്നതിനുള്ള ഒരു മാർഗ്ഗം, ഉപയോക്താവ് മറ്റെന്തെങ്കിലും ഉൾപ്പെടുത്തിയേക്കാം,
എല്ലായ്‌പ്പോഴും "-വാൾ" എന്നതിൽ ആരംഭിക്കുന്നത് ഈ രണ്ട് വരികളാണ്:

CFLAGS = -O2 # കമാൻഡ് ലൈനിൽ അസാധുവാക്കപ്പെട്ടിരിക്കാം
CFLAGS അസാധുവാക്കുക &= -വാൾ # നിരുപാധികമായി മുൻകൂട്ടി നിശ്ചയിച്ചിരിക്കുന്നു

പഴയ മേക്ക്‌ഫയലുകളിൽ നിങ്ങൾ സാധാരണയായി ഇതുപോലെ എന്തെങ്കിലും ചെയ്യേണ്ടതുണ്ട്, അതിന് വശമുണ്ടായിരുന്നു
അനന്തമായ ആവർത്തനം തടയാൻ ":=" എന്നതിലേക്ക് തരം നിർബന്ധിക്കുന്നതിന്റെ ഫലം:

വേരിയബിൾ := എക്സ്പ്രർ $(വേരിയബിൾ)

?=
വേരിയബിൾ ?= expr
അസാധുവാക്കുക VARIABLE ?= expr # ഉപയോഗശൂന്യമാണ്, പക്ഷേ നിയമപരമാണ്

വേരിയബിളിന്റെ മൂല്യം സജ്ജമാക്കുന്നു, എന്നാൽ വേരിയബിൾ നേരത്തെ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ മാത്രം
makefile, കമാൻഡ് ലൈനിൽ, അല്ലെങ്കിൽ പരിസ്ഥിതിയിൽ. മുകളിലുള്ള അസൈൻമെന്റ് ആണ്
കൃത്യമായി തുല്യമാണ്

ifndef വേരിയബിൾ
വേരിയബിൾ = എക്സ്പ്രർ
endif

!=
വേരിയബിൾ != ഷെൽ കമാൻഡ്
വേരിയബിൾ != ഷെൽ കമാൻഡ് അസാധുവാക്കുക

ഷെൽ കമാൻഡ് പ്രവർത്തിപ്പിക്കുകയും കമാൻഡിന്റെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് ഉൾക്കൊള്ളുന്നതിനായി വേരിയബിളിനെ സജ്ജമാക്കുകയും ചെയ്യുന്നു.
ഇത് കൃത്യമായി തുല്യമാണ്

വേരിയബിൾ := $(ഷെൽ കമാൻഡ്)

മൾട്ടിലൈൻ വേരിയബിളുകൾ

"നിർവചിക്കുക" എന്ന പ്രസ്താവന മുകളിലുള്ള ലളിതമായ പ്രസ്താവനകളുടെ മൾട്ടിലൈൻ തുല്യമാണ്. ദി
വേരിയബിളിന് ശേഷമുള്ള ഓപ്പറേറ്റർ ഓപ്ഷണലാണ്. നഷ്‌ടമായാൽ, അത് "വേരിയബിൾ നിർവചിക്കുന്നതിന് തുല്യമാണ്
=". "&=", "+=" ഓപ്പറേറ്റർമാർ ഇവിടെ അല്പം വ്യത്യസ്തമാണ്, അവർ ഇത് ഒട്ടിക്കുന്നു
ഒരു സ്‌പെയ്‌സിനേക്കാൾ പുതിയ വരിയുള്ള പഴയ മൂല്യം. എ ഒഴികെ മറ്റൊന്നും ഉണ്ടാകരുത്
പ്രസ്താവനയ്ക്ക് ശേഷം കമന്റ് ചെയ്യുക, അതായത് മൂല്യം അടുത്ത വരിയിൽ ആരംഭിക്കുന്നു.

വേരിയബിൾ നിർവ്വചിക്കുക :=
വേരിയബിളിന്റെ മൂല്യത്തിന്റെ ആദ്യ വരി
വേരിയബിളിന്റെ മൂല്യത്തിന്റെ രണ്ടാമത്തെ വരി
വേരിയബിളിന്റെ മൂല്യത്തിന്റെ മൂന്നാം വരി
endef

അസാധുവാക്കുക വേരിയബിൾ നിർവ്വചിക്കുക
...
enddef

"നിർവചിക്കുന്നതിന്" മുമ്പുള്ള കീവേഡുകൾ "കയറ്റുമതി" അല്ലെങ്കിൽ "ഗ്ലോബൽ" എന്നിവയിൽ ഒന്നിന്റെ സംയോജനമാകാം
"അസാധുവാക്കുക".

ന്യൂലൈനുകൾ ഉൾക്കൊള്ളാൻ നിങ്ങൾക്ക് ഒരു വേരിയബിളിന്റെ മൂല്യം ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾ "നിർവചിക്കുക" എന്ന പ്രസ്താവന ഉപയോഗിക്കണം
കാണിച്ചിരിക്കുന്നു (അല്ലെങ്കിൽ നിങ്ങൾക്ക് നേരിട്ട് Perl-ൽ മൂല്യം നൽകാം). ("endef" ഇതിനായി തിരഞ്ഞെടുത്തു
GNU നിർമ്മാണവുമായുള്ള അനുയോജ്യത. നിങ്ങൾക്ക് "enddef" ഉപയോഗിക്കാം.) ഇത് പ്രാഥമികമായി ഉപയോഗപ്രദമാണ്
"കാൻഡ് കമാൻഡ് സീക്വൻസുകൾ", ഉദാ., ഇതുപോലുള്ള ഒന്ന്:

COMPILE_C_PROGRAM നിർവ്വചിക്കുക
@&എക്കോ "കമ്പൈൽ ചെയ്യുന്നു $(ഇൻപുട്ട്)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(ഉൾപ്പെടുന്നു) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)
endef

തുടർന്ന് നിങ്ങൾക്ക് ഈ മൾട്ടി-ലൈൻ വേരിയബിൾ നിരവധി നിയമങ്ങളിൽ ഉപയോഗിക്കാം, ഇതുപോലുള്ള:

%.o : %.c
$(COMPILE_C_PROGRAM)

$(ARCH)/%.o : $(ARCH)/%.c
$(COMPILE_C_PROGRAM)

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

COMPILE_C_PROGRAM = @echo "കംപൈലിംഗ് $(ഇൻപുട്ട്)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(ഉൾപ്പെടുന്നു) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

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

"define" എന്നതിനുള്ളിൽ വികസിപ്പിക്കുമ്പോൾ ഒരു പ്രത്യേകതയുണ്ട്, അതായത് "define X :=" അല്ലെങ്കിൽ a-ൽ
ഇതിനകം ":=", "എക്സ് &=" നിർവചിക്കുകയും "എക്സ് +=" നിർവചിക്കുകയും ചെയ്ത വേരിയബിൾ. ഈ സാഹചര്യത്തിൽ ദി
"$(ഷെൽ കമാൻഡ് ...)" അല്ലെങ്കിൽ ബിൽട്ടിൻ "$(&കമാൻഡ് ...)" എന്നതിലേക്ക് പുതിയ ലൈനുകൾ രൂപാന്തരപ്പെടില്ല
ഇടങ്ങൾ.

എക്സ്പോർട്ടുചെയ്യുന്നു വേരിയബിളുകൾ ലേക്ക് ഉപപ്രക്രിയകൾ

VAR കയറ്റുമതി...
കയറ്റുമതി VAR = മൂല്യം
കയറ്റുമതി VAR += മൂല്യം അസാധുവാക്കുക

ആദ്യ ഫോം ഉപപ്രോസസ്സുകളിലേക്ക് കയറ്റുമതി ചെയ്യുന്നതിനായി നൽകിയിരിക്കുന്ന വേരിയബിളുകൾ അടയാളപ്പെടുത്തുന്നു, ഏത് മൂല്യത്തിലും
വേരിയബിളിന് അപ്പോൾ ഉണ്ട്. രണ്ടാമത്തെ ഫോം, ഒരു വേരിയബിളിന് മാത്രം ബാധകമാണ്
ഉടൻ തന്നെ ഒരു മൂല്യം നൽകുന്നു. അസൈൻമെന്റിന്റെ എല്ലാ വകഭേദങ്ങളും അനുവദനീയമാണ്.

പങ്കിടുന്നു വേരിയബിളുകൾ ഉടനീളം മേക്ക് ഫയലുകൾ

ആഗോള VAR...
ആഗോള VAR = മൂല്യം
ആഗോള VAR &= മൂല്യം അസാധുവാക്കുക

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

രണ്ടാമത്തെ ഫോം, ഒരു വേരിയബിളിന് മാത്രം ബാധകമാണ്, അധികമായി ഒരു മൂല്യം അവകാശം നൽകുന്നു
ദൂരെ. അസൈൻമെന്റിന്റെ എല്ലാ വകഭേദങ്ങളും അനുവദനീയമാണ്. ":=" ഉടൻ തന്നെ വികസിക്കും എന്നത് ശ്രദ്ധിക്കുക
പ്രാദേശിക മെയ്ക്ക് ഫയലിലെ മൂല്യങ്ങളിലേക്ക്. നേരെമറിച്ച് "=" വേരിയബിളുകൾ വികസിക്കും
ഉപയോഗ ഘട്ടത്തിൽ മൂല്യങ്ങൾ.

ഗ്ലോബൽ വേരിയബിളുകൾ കൈകാര്യം ചെയ്യുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്, കാരണം makepp ഏതെങ്കിലും മേക്ക് ഫയലുകൾ ലോഡ് ചെയ്തേക്കാം
റൂളുകളോ മേക്ക് ഫയലുകളോ ലോഡ് ചെയ്യാത്ത ചില ടാർഗെറ്റ് നിർമ്മിക്കേണ്ടതിന്റെ ആവശ്യകത ഉയരുന്നതിനാൽ ഓർഡർ ചെയ്യുക.
ഇക്കാരണത്താൽ, ഒരു ഉണ്ടായിരിക്കാൻ ശുപാർശ ചെയ്യുന്നു RootMakeppfile എല്ലാം വ്യക്തമായി ലോഡുചെയ്യാനും
"load-makefile" ഉപയോഗിച്ച് വേരിയബിൾ പരിഷ്ക്കരിക്കുന്നതോ ഉപയോഗിക്കുന്നതോ ആയ മറ്റുള്ളവ.

ആഗോള GLIBLIBS ;= $(shell pkg-config --libs glib-2.0)

നിങ്ങളുടെ പ്രോജക്‌റ്റ് ഒരു ദിവസം മറ്റ് പ്രോജക്‌റ്റുകൾക്കൊപ്പം നിർമ്മിക്കപ്പെട്ടേക്കാം എന്നതും ശ്രദ്ധിക്കുക. ഇതിനായി
പ്രോജക്റ്റ് നാമം എല്ലായ്‌പ്പോഴും ഏതെങ്കിലും ആഗോള വേരിയബിൾ നാമത്തിന്റെ ഭാഗമാക്കാൻ ശുപാർശ ചെയ്യുന്നതിന്റെ കാരണം.

ടാർഗെറ്റ്-നിർദ്ദിഷ്ട അസൈൻമെന്റുകൾ

ലക്ഷ്യം: വേരിയബിൾ = സ്ട്രിംഗ്
ലക്ഷ്യം: വേരിയബിൾ:= സ്ട്രിംഗ്
ലക്ഷ്യം: വേരിയബിൾ += സ്ട്രിംഗ് അസാധുവാക്കുക

വേരിയബിളിന്റെ ടാർഗെറ്റ്-നിർദ്ദിഷ്ട മൂല്യം സജ്ജമാക്കുന്നു. ഒരു ടാർഗെറ്റ്-നിർദ്ദിഷ്ട മൂല്യം പ്രാബല്യത്തിൽ ഉണ്ട് മാത്രം
തന്നിരിക്കുന്ന ലക്ഷ്യം സൃഷ്ടിക്കുന്ന ഒരു പ്രവർത്തനത്തിൽ. ഇതുപോലുള്ള കാര്യങ്ങൾക്കാണ് ഇത് പ്രാഥമികമായി ഉപയോഗിക്കുന്നത്
ഈ:

CFLAGS := -O2

my_prog: file1.o file2.o special_file.o

special_file.o : CFLAGS := -g

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

ഇവിടെ സംഭവിക്കുന്നത് എല്ലാ ".c" ഫയലുകളും ഒപ്റ്റിമൈസേഷൻ ഉപയോഗിച്ച് കംപൈൽ ചെയ്യപ്പെടും ("-O2") ഒഴികെ
"special_file.c", ഇത് ഡീബഗ് മോഡിൽ സമാഹരിച്ചിരിക്കുന്നു ("-g"). ഇത് സൗകര്യപ്രദമായ മാർഗമാണ്
കുറച്ച് ഫയലുകൾക്കായി മാത്രം വ്യത്യസ്ത കംപൈലേഷൻ ഓപ്ഷനുകൾ വ്യക്തമാക്കുക.

ഇതുപോലുള്ള ടാർഗെറ്റ്-നിർദ്ദിഷ്ട വേരിയബിൾ അസൈൻമെന്റുകൾ റൂളിന്റെ പ്രവർത്തനങ്ങൾക്ക് മാത്രം ബാധകമാണ്; അവർ
ഒരു നിയമത്തിന്റെ ലക്ഷ്യങ്ങളെയോ ആശ്രിതത്വങ്ങളെയോ വിലയിരുത്തുമ്പോൾ അവ പ്രാബല്യത്തിൽ വരുന്നില്ല. ഒരു ഭരണം ആണെങ്കിൽ
ഒന്നിൽ കൂടുതൽ ടാർഗെറ്റ് ഉണ്ട്, ടാർഗെറ്റ്-നിർദ്ദിഷ്ട വേരിയബിൾ അസൈൻമെന്റുകൾ എന്നതിൽ നിന്ന് മാത്രം എടുക്കുന്നു
ആദ്യം ലക്ഷ്യം. makepp-ന്റെ ടാർഗെറ്റ്-നിർദ്ദിഷ്ട വേരിയബിളുകൾ അൽപ്പം വ്യത്യസ്തമാണെന്നതും ശ്രദ്ധിക്കുക
GNU make's-ൽ നിന്ന്, അവ പരാമർശിച്ചിരിക്കുന്ന ഒരു ഫയലിന്റെ നിയമത്തിന് മാത്രമേ ബാധകമാകൂ, അല്ല
അതിന്റെ മുൻഗാമികളിൽ ഏതെങ്കിലും.

വൈൽഡ്കാർഡ് വിപുലീകരണം ടാർഗെറ്റിലാണ് നടത്തുന്നത്, അതിനാൽ നിങ്ങൾക്ക് ഇതുപോലൊന്ന് ചെയ്യാൻ കഴിയും:

test_*.o : CFLAGS += -DTEST

ഗ്നു നിർമ്മാണവുമായി പൊരുത്തപ്പെടുന്നതിന്, "*" എന്നതിന് പകരം "%" ഉപയോഗിക്കാം.

വേരിയബിൾ ഉപവിഭാഗം
മേക്കപ്പിന്റെ വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ നിയമങ്ങൾ മറ്റ് നിർമ്മാണങ്ങളുടേതിന് സമാനമാണ്, എന്നാൽ കുറച്ച്
കൂടുതല് ശക്തം. എല്ലാ നിർമ്മാണങ്ങളിലേയും പോലെ, "$(CC)" അല്ലെങ്കിൽ "${CC}" രണ്ടും ഇതിന്റെ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു
വേരിയബിൾ CC. നിങ്ങൾക്ക് അക്ഷരാർത്ഥത്തിൽ ഡോളർ ചിഹ്നം ആവശ്യമുണ്ടെങ്കിൽ, ഒരു ഇരട്ട ഡോളർ ചിഹ്നം ($$) ഇടുക
ഈ:

ലക്ഷ്യം: dep1 dep2 dep3 dep4
&rm -f $(ഔട്ട്പുട്ട്)
$(ഇൻപുട്ടുകൾ) എന്നതിലെ ഫയലിനായി; പൂച്ച $$ ഫയൽ >> $(ഔട്ട്പുട്ട്); ചെയ്തു

കൂടാതെ makepp-ന് ഒരു "$[VARIABLE]" വാക്യഘടനയുണ്ട്, അത് മറ്റൊന്നിന്റെ അതേ കാര്യം ചെയ്യുന്നു
രണ്ട്, പക്ഷേ മേപ്പ് മറ്റെന്തെങ്കിലും ഗ്രോക്ക് ചെയ്യുന്നതിന് മുമ്പ്. പൂർണ്ണമായ നിയമങ്ങൾക്കായി ഇത് ഉപയോഗിക്കാൻ ഇത് അനുവദിക്കുന്നു
കൂടാതെ/അല്ലെങ്കിൽ വ്യവസ്ഥകൾ:

ബ്രാക്കറ്റ്_റൂൾ = നിർവ്വചിക്കുക
ifdef SOME_VAR
ബ്രാക്കറ്റ്:
&എക്കോ ഇതൊരു നിയമമാണ് -o $(ഔട്ട്പുട്ട്)
endif
enddef

$[bracket_rule]

ആർസി ശൈലി ബദൽ

സ്വതവേ, makepp ആർസി-സ്റ്റൈൽ സബ്സ്റ്റിറ്റ്യൂഷൻ ഉപയോഗിക്കുന്നു (ഇത് മുൻകൈയെടുത്തത്
ആർസി ഷെൽ). ഒരു ഉദാഹരണത്തിലൂടെ ഇത് നന്നായി ചിത്രീകരിക്കുന്നു:

മൊഡ്യൂളുകൾ = a b c d

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(ആശ്രിതത്വം) -o $(ലക്ഷ്യം)

"module_dir/" എന്ന പ്രിഫിക്‌സ് MODULES-ലെ ഓരോ പദത്തിനും മുൻകൂറായി നൽകിയിരിക്കുന്നു, കൂടാതെ ".o" എന്ന പ്രത്യയം
ഓരോ വാക്കിലും ചേർത്തു.

പദങ്ങളുടെ ലിസ്റ്റ് പോലും a-യിൽ ഇടാതെ തന്നെ നിങ്ങൾക്ക് rc-style substitution ഉപയോഗിക്കാനും കഴിയും
വേരിയബിൾ; വാക്യഘടന "$( word1 word2)" ആണ്. പരാന്തീസിസിനും ദിക്കും ഇടയിലുള്ള ഇടം ശ്രദ്ധിക്കുക
ആദ്യ വാക്ക്. അതിനാൽ മുകളിലുള്ള ഉദാഹരണം ഇങ്ങനെ എഴുതാമായിരുന്നു:

mylib.a : module_dir/$(abcd).o $(OTHER_OBJECTS)
$(CXX) $(ആശ്രിതത്വം) -o $(ലക്ഷ്യം)

ഒരു വേരിയബിളിൽ ഒന്നിൽ കൂടുതൽ വാക്കുകൾ ഉള്ളപ്പോൾ മാത്രമേ rc-സ്റ്റൈൽ സബ്സ്റ്റിറ്റ്യൂഷൻ നൽകൂ.
ഒറ്റവാക്കിൽ പറഞ്ഞാൽ അത് പരമ്പരാഗതമായി ഉണ്ടാക്കുന്നത് പോലെയാണ്. അയ്യോ, വേരിയബിൾ ശൂന്യമാകുമ്പോൾ, ഒരു ഉണ്ട്
സംഘർഷം. പരമ്പരാഗതമായത് അതിനെ ശൂന്യമായ സ്ട്രിംഗിലേക്ക് വികസിപ്പിക്കുന്നു. എന്നാൽ നിങ്ങൾ ചിന്തിക്കുമ്പോൾ
ഇത് ഒരു പട്ടികയായി, "-I$(DIRLIST)" അപ്രത്യക്ഷമാകണമെന്നാണ് നിങ്ങൾ ആഗ്രഹിക്കുന്നത്, ഒരു ഏകാന്തമായ "-I" നൽകരുത്. ദി
"-I$( $(DIRLIST))" നിങ്ങൾക്ക് നൽകുന്ന ഒരു സ്‌പെയ്‌സിൽ തുടങ്ങുന്ന ഒരു ലിസ്റ്റിലേക്ക് അതിനെ പൊതിയുക എന്നതാണ് പരിഹാരം
ലിസ്റ്റിൽ വാക്കുകൾ ഉള്ളതുപോലെ തന്നെ നിരവധി ഓപ്ഷനുകൾ.

ഒരേ വാക്കിൽ നിങ്ങൾ നിരവധി വേരിയബിളുകൾ ഇടുകയാണെങ്കിൽ, അത് പദങ്ങളുടെ നിരകളിലേക്ക് വികസിക്കുന്നു, rc-style
പകരം വയ്ക്കുന്നത് യഥാർത്ഥത്തിൽ കാർട്ടീഷ്യൻ ഉൽപ്പന്നമാണ്, അതിനാൽ നിങ്ങൾക്ക് ഇതുപോലെ എന്തെങ്കിലും ചെയ്യാൻ കഴിയും
നിനക്കു വേണം:

DIRS = s1 s2
മൊഡ്യൂളുകൾ = a b c
സഫിക്സുകൾ = .o .c
ഫയലുകൾ := $(DIRS)/$(മൊഡ്യൂളുകൾ)$(സഫിക്സുകൾ)

കൂടാതെ FILES എന്നതിൽ സ്ട്രിംഗ് അടങ്ങിയിരിക്കും

s1/ao s1/ac s1/bo s1/bc s1/co s1/cc s2/ao s2/ac s2/bo s2/bc s2/co s2/cc

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

മോശം := [A-Z]*/**/*.$( hpp h) # [A-Z]*/**/*.hpp */**/*.h
നല്ലത് := $( [A-Z]*/**/*.)$( hpp h) # [A-Z]*/**/*.hpp [A-Z]*/**/*.h

ആർസി-സ്റ്റൈൽ സബ്സ്റ്റിറ്റ്യൂഷൻ തടസ്സപ്പെടുകയാണെങ്കിൽ, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ലീഡ് അല്ലെങ്കിൽ ട്രെയിലിംഗ് വേണമെങ്കിൽ
നിങ്ങളുടെ മേക്ക് വേരിയബിളിലെ വൈറ്റ്‌സ്‌പെയ്‌സ്, തുടർന്ന് സജ്ജീകരിച്ച് നിങ്ങൾക്ക് ആർസി-സ്റ്റൈൽ സബ്‌സ്റ്റിറ്റ്യൂഷൻ ഓഫ് ചെയ്യാം
"makepp_simple_concatenation=1" എന്ന വേരിയബിൾ. കമാൻഡിൽ നിങ്ങൾക്ക് ഇത് ആഗോളതലത്തിൽ ഓഫ് ചെയ്യാം
ലൈൻ അല്ലെങ്കിൽ ഒരു പരിസ്ഥിതി വേരിയബിൾ ആയി. അല്ലെങ്കിൽ വേരിയബിൾ സജ്ജീകരിച്ച് ഓരോ മേക്ക് ഫയലിനും
നിങ്ങളുടെ മെയ്ക്ക് ഫയൽ. നിങ്ങൾ ഇത് മേക്ക്‌ഫൈലിന്റെ മുകൾഭാഗത്ത് ചെയ്യണം, അല്ലെങ്കിൽ നിങ്ങൾ ഓടിച്ചേക്കാം
ചില മൂല്യനിർണ്ണയങ്ങൾക്കായി ആർസി-സ്റ്റൈൽ സബ്സ്റ്റിറ്റ്യൂഷൻ ഉപയോഗിക്കുന്ന രസകരമായ സാഹചര്യങ്ങൾ മറ്റുള്ളവയല്ല.
(അസൈൻമെന്റിന് മുമ്പ് വിലയിരുത്തിയ എല്ലാ എക്സ്പ്രഷനുകളും ആർസി-സ്റ്റൈൽ സബ്സ്റ്റിറ്റ്യൂഷനുകൾ ഉപയോഗിക്കും, കൂടാതെ എല്ലാം
ശേഷം വിലയിരുത്തിയ പദപ്രയോഗങ്ങൾ ചെയ്യില്ല. എക്സ്പ്രഷനുകളുടെ മൂല്യനിർണ്ണയ സമയം മുതൽ
makefiles സങ്കീർണ്ണവും എല്ലായ്‌പ്പോഴും പ്രസ്‌താവനകളുടെ ക്രമത്തിൽ നിന്ന് വ്യക്തമല്ല
makefile, "makepp_simple_concatenation" എത്രയും വേഗം സജ്ജീകരിക്കുന്നതാണ് നല്ലത്.) നിങ്ങൾക്ക് കഴിയും
ഒരു ലക്ഷ്യത്തിനായി അത് സജ്ജമാക്കുക പോലും:

ലക്ഷ്യം: makepp_simple_concatenation = 1
ലക്ഷ്യം:
&echo before_first$(LIST)after_last -o $(ഔട്ട്‌പുട്ട്)

കാരണം "$[VARIABLE]" എന്നത് "$(VARIABLE)" എന്നതിനേക്കാൾ നേരത്തെ മൂല്യനിർണ്ണയം ചെയ്യപ്പെടുന്നു, rc- ൽ ഇവ രണ്ടും സംയോജിപ്പിച്ച്
പകരം വയ്ക്കുന്നത് നിങ്ങൾ പ്രതീക്ഷിക്കുന്ന ഫലം നൽകില്ല, നിങ്ങൾ അത് വ്യക്തമായ രൂപത്തിൽ പൊതിയുന്നില്ലെങ്കിൽ
പട്ടിക:

എ = എ ബി
N = 1 2
മോശം := $(A)$[N]
നല്ലത് := $(A)$( $[N])

അവസാന വരികൾ ഇങ്ങനെ വായിക്കാം

മോശം := $(A)1 2 # a1 b1 2
നല്ലത് := $(A)$( 1 2) # a1 a2 b1 b2

ഉപവിഭാഗം അവലംബം

ഒരു സബ്സ്റ്റിറ്റ്യൂഷൻ റഫറന്സിന് "$(VAR:A=B)" എന്ന ഫോം ഉണ്ട്, ഇവിടെ A എന്നത് പൊരുത്തപ്പെടുന്ന പാറ്റേണും B ആണ്
അത് മാറ്റിസ്ഥാപിക്കാനുള്ള ഒരു പാറ്റേൺ. സബ്സ്റ്റിറ്റ്യൂഷൻ റഫറൻസുകൾ എന്നതിന്റെ ചുരുക്കെഴുത്താണ്
"patsubst" ഫംഗ്ഷൻ. ഉദാഹരണത്തിന്:

source_files = ac bc cc dc
object_files = $(source_files:%.c=%.o)

"$(object_files)" എന്നത് "a.o b.o c.o d.o" ആയി സജ്ജീകരിക്കും. "%" എന്നത് ഒരു പ്രത്യേക പ്രതീക പൊരുത്തമാണ്
ഏതെങ്കിലും അനിയന്ത്രിതമായ സ്ട്രിംഗ്. A, B എന്നിവ "%" എന്നതിൽ ആരംഭിക്കുകയാണെങ്കിൽ, മാറ്റിസ്ഥാപിക്കുമ്പോൾ ഒരു സാധാരണ കേസ്
പ്രത്യയങ്ങൾ, അവ ഒഴിവാക്കാവുന്നതാണ്:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # അതേ, കാരണം . പ്രത്യേകിച്ചല്ല

വൈറ്റ്‌സ്‌പെയ്‌സ് in വേരിയബിളുകൾ

നിങ്ങൾക്ക് ഒരു വേരിയബിളിൽ വൈറ്റ്‌സ്‌പെയ്‌സ് നിയന്ത്രിക്കണമെങ്കിൽ, നിങ്ങൾ (നിലവിൽ) rc-style പ്രവർത്തനരഹിതമാക്കണം
സബ്സ്റ്റിറ്റ്യൂഷൻ ("makepp_simple_concatenation=1" സജ്ജീകരിക്കുന്നതിലൂടെ) തുടർന്ന് ഇതുപോലുള്ള ഒരു വാക്യഘടന ഉപയോഗിക്കുക:

ശൂന്യം =
T = -o $(ശൂന്യം)

അല്ലെങ്കിൽ, ഒരു ശൂന്യമായ വിലയിരുത്തലിനൊപ്പം:

T = -o $()

നിങ്ങൾ ഇത് ചെയ്യുമ്പോൾ, "T" എന്ന വേരിയബിളിൽ "-o" ഒരു സ്‌പെയ്‌സും അടങ്ങിയിരിക്കുന്നു.

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

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

ifeq ($(ARCH),weirdarch)
O := /OUTPUT=
മറ്റാരെങ്കിലും
null :=
O := -o $(ശൂന്യം)
endif

%.o : %.c
$(കംപൈലർ) $(ഇൻപുട്ട്) $(O)$(ഔട്ട്‌പുട്ട്)

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

ifeq ($(ARCH),weirdarch)
%.o : %.c
$(WEIRD_COMPILER) $(ഇൻപുട്ട്) /OUTPUT=$(ഔട്ട്‌പുട്ട്)
മറ്റാരെങ്കിലും
%.o : %.c
$(CC) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)
endif

വൈറ്റ്‌സ്‌പെയ്‌സ് ഒരിക്കലും വേരിയബിൾ നാമങ്ങളിൽ അനുവദനീയമല്ല, അവയുടെ മൂല്യങ്ങളിൽ മാത്രം. ഇത് വ്യത്യസ്തമാണ്
ചിലതിൽ നിന്ന് നടപ്പാക്കലുകൾ നടത്തുന്നു.

ഓട്ടോമാറ്റിക് വേരിയബിളുകൾ
ഏത് റൂളിനെ ആശ്രയിച്ച് വ്യത്യസ്ത മൂല്യങ്ങൾ അനുമാനിക്കുന്ന വേരിയബിളുകളാണ് ഓട്ടോമാറ്റിക് വേരിയബിളുകൾ
അവ വിലയിരുത്തപ്പെടുന്നു. മറ്റുള്ളവയിലെ മിക്ക ഓട്ടോമാറ്റിക് വേരിയബിളുകളെയും Makepp പിന്തുണയ്ക്കുന്നു
ഉപയോഗത്തിന്റെ പതിപ്പുകൾ. കൂടാതെ, അവയിൽ മിക്കതിനും ഇതിന് കുറച്ച് നിഗൂഢമായ, നീളമുള്ള പേരുകളുണ്ട്
പകരം നിങ്ങൾക്ക് ഉപയോഗിക്കാം. (ഈ പേരുകൾ പുനർ നിർവചിക്കാൻ സംഭവിക്കുന്ന ലെഗസി മേക്ക് ഫയലുകൾക്കായി,
makefile-ലെ നിർവചനം സ്ഥിരസ്ഥിതി അർത്ഥത്തെ മറികടക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾ പറഞ്ഞാൽ
നിങ്ങളുടെ മേക്ക് ഫയലിൽ "ടാർഗെറ്റ് = എബിസി", തുടർന്ന് "$(ടാർഗെറ്റ്)" എല്ലായ്പ്പോഴും "എബിസി" ലേക്ക് വികസിക്കും, ഇല്ല
ഇനി $@ എന്നതിന് തുല്യമായിരിക്കും.)

makepp പിന്തുണയ്ക്കുന്ന എല്ലാ ഓട്ടോമാറ്റിക് വേരിയബിളുകളുടെയും പൂർണ്ണമായ ലിസ്റ്റ് ഇനിപ്പറയുന്നതാണ്:

ഔട്ട്പുട്ട്
ലക്ഷ്യം
$@ നിലവിലെ നിയമത്തിന്റെ ലക്ഷ്യം. യഥാർത്ഥത്തിൽ, makepp ഒന്നിലധികം ലക്ഷ്യങ്ങളെ പിന്തുണയ്ക്കുന്നതിനാൽ
ഏതെങ്കിലും നിയമം, ഇതാണ് ആദ്യം ലക്ഷ്യം. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന നിയമത്തിൽ

y.tab.c y.tab.h : parser.y
$(YACC) -o $(ഔട്ട്‌പുട്ട്) $(YFLAGS) $(ഇൻപുട്ട്)

"$(ഔട്ട്പുട്ട്)" എന്നതിൽ മൂല്യം അടങ്ങിയിരിക്കും y.tab.c. ഈ മാന്ത്രിക വേരിയബിളുകൾ യഥാർത്ഥത്തിൽ ഉള്ളതിനാൽ
ഫംഗ്‌ഷനുകൾ, നിങ്ങൾക്ക് ഒരു സൂചിക ആർഗ്യുമെന്റായി കൈമാറാനും കഴിയും. ഇത് 1 മുതൽ അല്ലെങ്കിൽ പിന്നോട്ട് കണക്കാക്കുന്നു
-1 മുതൽ. അതിനാൽ "$(ഔട്ട്പുട്ട് 2)" അല്ലെങ്കിൽ "$(ഔട്ട്പുട്ട് -1)" എന്നതിൽ മൂല്യം അടങ്ങിയിരിക്കും y.tab.h.

ഈ വേരിയബിളിന്റെ മൂന്ന് രൂപങ്ങൾക്കും ഒരേ മൂല്യമാണെങ്കിലും, അതിൽ വ്യത്യാസമുണ്ട്
മൾട്ടിടാർഗെറ്റ് നിയമങ്ങൾക്കുള്ള വ്യാഖ്യാനം. നിങ്ങൾ പഴയ രീതിയിലുള്ള നിഗൂഢ നാമം $@ ഉപയോഗിക്കുകയാണെങ്കിൽ,
makepp ഒരു ആധുനിക നിയമത്തിന് പകരം പഴയ രീതിയിലുള്ള ഒരു റൂൾ സെറ്റ് ആയി വ്യാഖ്യാനിക്കും
ആ ലക്ഷ്യങ്ങളെല്ലാം ഒറ്റയടിക്ക് നിർമ്മിക്കുന്നു:

a b: # ശരിക്കും: a, b എന്നിവയ്‌ക്കായി ഓരോ നിയമം
$@ സ്‌പർശിക്കുക

c d: # പിശക്: ഇത് d നിർമ്മിച്ചിട്ടില്ലെന്ന് mpp പരാതിപ്പെടുന്നു
$(ഔട്ട്‌പുട്ട്) സ്‌പർശിക്കുക

ഔട്ട്പുട്ട്
ലക്ഷ്യങ്ങൾ
നിലവിലെ നിയമത്തിന്റെ എല്ലാ ലക്ഷ്യങ്ങളും. ഒന്നിൽ കൂടുതൽ ഇല്ലെങ്കിൽ "$(ലക്ഷ്യം)" പോലെ തന്നെ
ലക്ഷ്യം. മുകളിലെ ഉദാഹരണത്തിൽ, "$(ഔട്ട്പുട്ടുകൾ)" എന്നത് y.tab.c y.tab.h ആയിരിക്കും. നിങ്ങൾക്ക് ഒന്ന് കടന്നുപോകാം
സൂചിക ലിസ്റ്റ്, അതിനാൽ "$(ഔട്ട്പുട്ടുകൾ 2 1)" എന്നത് y.tab.h y.tab.c ആയിരിക്കും.

ആശ്രിതത്വം
ഇൻപുട്ട്
$< നിയമത്തിന്റെ ആദ്യ വ്യക്തമായ ആശ്രിതത്വം. ഉദാഹരണത്തിന്, ഈ നിയമത്തിൽ

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

"$(ഇൻപുട്ട്)" എന്നതിന്റെ പേര് ആയിരിക്കും .c ഫയൽ, എന്തുതന്നെയായാലും .h ഫയലുകൾ makepp
കണ്ടെത്തുന്നു. നിങ്ങൾ ഒന്നിലധികം ഡിപൻഡൻസികൾ വ്യക്തമാക്കുകയാണെങ്കിൽ, ഒരു പാസായി നിങ്ങൾക്ക് അവ നേടാനാകും
സൂചിക: "$(ഇൻപുട്ട് $(INDEX))" എന്നത് INDEX-ാമത്തെ ആശ്രിതത്വമാണ്.

ഡിപൻഡൻസികൾ
ഇൻപുട്ടുകൾ
$^ ടാർഗെറ്റിന്റെ എല്ലാ വ്യക്തമായ ആശ്രിതത്വങ്ങളും, ഉൾപ്പെടുന്നില്ല .h ഫയലുകൾ കണ്ടെത്തിയത്
ഉൾപ്പെടുത്തുന്നതിന് makepp_scanning.

ഉദാഹരണത്തിന്, നിയമത്തിൽ

myprog.o : *.o
$(CC) $(CFLAGS) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്പുട്ട്)

ഡയറക്‌ടറിയിലെ എല്ലാ .o ഫയലുകളും "$(ഇൻപുട്ടുകൾ)" ആയിരിക്കും. നിങ്ങളുടേത് മാത്രം തിരഞ്ഞെടുക്കാം
ഒരു സൂചിക ലിസ്റ്റ് പാസാക്കി വേണം. വ്യത്യസ്ത തരത്തിലുള്ള ഫയലുകൾ നിങ്ങൾ വ്യക്തമായി വ്യക്തമാക്കുകയാണെങ്കിൽ,
നിങ്ങൾക്ക് അവ "$(ഇൻപുട്ടുകൾ 2 3 4)" എന്നതിലെ പോലെ തിരഞ്ഞെടുക്കാം (എന്നാൽ ഒരു വൈൽഡ്കാർഡ് ഉപയോഗിച്ച് ഇതും അങ്ങനെയല്ല.
വാഗ്ദാനം ചെയ്യുന്നു).

അടുക്കിയ_ആശ്രിതത്വങ്ങൾ
അടുക്കിയ_ഇൻപുട്ടുകൾ
$+ ടാർഗെറ്റിന്റെ എല്ലാ ഡിപൻഡൻസികളും, അടുക്കിയ ക്രമത്തിൽ, ഡ്യൂപ്ലിക്കേറ്റുകൾ നീക്കം ചെയ്തു.
"$(sort $(inputs))" എന്നതിന് തുല്യമാണ്.

മാറിയ_ആശ്രിതത്വം
മാറ്റിയ_ഇൻപുട്ടുകൾ
$? മാറിയ ലക്ഷ്യത്തിന്റെ ആശ്രിതത്വങ്ങൾ. ഇതിൽ വ്യക്തമായത് മാത്രം ഉൾപ്പെടുന്നു
ഡിപൻഡൻസികൾ (അതായത്, നിങ്ങൾ മേക്ക് ഫയലിൽ ലിസ്റ്റ് ചെയ്യുന്നവ), പരോക്ഷമായി കണ്ടെത്തിയില്ല
സ്കാനിംഗിൽ നിന്നുള്ള ആശ്രിതത്വങ്ങൾ (.h ഫയലുകൾ പോലുള്ളവ).

ഇതുപോലുള്ള കമാൻഡുകളിൽ ഇത് സാധാരണയായി ഉപയോഗിക്കുന്നു:

libmine.a : $(MODULES) : build_checkignign_action
$(AR) ru $@ $?

അതായത്, ar മാറിയ മൊഡ്യൂളുകൾ മാത്രം മാറ്റിസ്ഥാപിക്കാൻ പറയുന്നു. (ശ്രദ്ധിക്കുക
"ignore_action" ബിൽഡ് ചെക്ക് റൂൾ. നിങ്ങൾ ഇത് വ്യക്തമാക്കിയില്ലെങ്കിൽ, makepp നിർബന്ധിക്കും
അത് മാറുമ്പോഴെല്ലാം നടപ്പിലാക്കേണ്ട നടപടി. ആശ്രിതത്വങ്ങളൊന്നും മാറിയിട്ടില്ലെങ്കിൽ,
ആക്ഷൻ സ്ട്രിംഗ് "ar ru libmine.a" ആയിരിക്കും, അത് അത് ആയിരുന്നതിൽ നിന്ന് വ്യത്യസ്തമായിരിക്കും
അവസാനമായി നിങ്ങൾ ഇത് പ്രവർത്തിപ്പിച്ചപ്പോൾ, "ignore_action" ഇല്ലാതെ makepp അത് എക്സിക്യൂട്ട് ചെയ്യും. ഇതിൽ
കേസ്, ഇത് നിരുപദ്രവകരമാണ്, എന്നാൽ മറ്റ് കമാൻഡുകൾക്കൊപ്പം, ഇത് ഒരു പ്രശ്നമാകാം. കാണുക
"ignore_action" എന്നതിന്റെ വിശദാംശങ്ങൾക്കായി makepp_build_check.)

ഇത്തരത്തിൽ ആർക്കൈവുകൾ നിർമ്മിക്കുന്നത് നല്ല ആശയമല്ല, കാരണം ഇത് നിങ്ങളുടെ ബിൽഡുകൾ കുറയ്ക്കും
വിശ്വസനീയമായ. നിങ്ങൾ ആർക്കൈവ് നിർമ്മിക്കുകയാണെങ്കിൽ, അതിലൊന്ന് നീക്കം ചെയ്യുക എന്നതാണ് ഇതിന്റെ പ്രശ്നം
മൊഡ്യൂളുകളുടെ ലിസ്റ്റിൽ നിന്നുള്ള മൊഡ്യൂളുകൾ, മൊഡ്യൂളുകൾ ഇപ്പോഴും ആർക്കൈവിൽ ആയിരിക്കും
makepp

ശബ്ദം
$* ഒരു പാറ്റേൺ നിയമത്തിലെ തണ്ട് (അതായത്, '%' പൊരുത്തപ്പെടുന്നതെന്തും). പകരമായി, ഇതാണെങ്കിൽ
ഒരു പാറ്റേൺ നിയമമല്ല, വിപുലീകരണമില്ലാതെ ഫയലിന്റെ പേര് നൽകുന്നു (അതായത്, അത്
"$(അടിസ്ഥാന നാമം $(ഇൻപുട്ട്))" എന്നതിന് തുല്യമാണ്.

ഇത് കൂടുതലും പിന്നോക്ക അനുയോജ്യതയ്ക്കാണ്. ഉദാഹരണത്തിന്, നിർമ്മിക്കുന്നതിന്റെ പഴയ പതിപ്പുകളിൽ
ഏത് കംപൈൽ ചെയ്യാമെന്ന് പറയാനുള്ള ഒരേയൊരു മാർഗ്ഗം .c ബന്ധപ്പെട്ട ഫയലിലേക്ക് ഫയൽ ചെയ്യുക .o ഫയൽ പോലെയായിരുന്നു
ഈ:

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

റൂൾ എഴുതാനുള്ള ഒരു മോശം മാർഗമാണിത്. ഗ്നു നിർമ്മിത ശൈലി ഉപയോഗിക്കുന്നത് കൂടുതൽ വ്യക്തമാണ്
പാറ്റേൺ നിയമങ്ങൾ, ഇതുപോലെ:

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

foreach
"ഫോറച്ച്" ക്ലോസിൽ നിന്നുള്ള നിലവിലെ ഫയലിന്റെ പേര്. "foreach" ഉപവാക്യങ്ങൾ വളരെ അപൂർവമായി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ,
പക്ഷേ, makepp പിന്തുണയ്‌ക്കുന്ന പാറ്റേൺ റൂളിന്റെ ഏറ്റവും പൊതുവായ ഉദ്ദേശ്യങ്ങളാണിവ. വേണ്ടി
ഉദാഹരണത്തിന്,

#
# ഒരു പ്രത്യേക പ്രീപ്രൊസസ്സർ ഉപയോഗിച്ച് .c ഫയലുകൾ നിർമ്മിക്കുക:
#
%.c : %.k
$(പ്രിപ്രൊസസ്സർ) $(ഇൻപുട്ട്) > $(ഔട്ട്പുട്ട്)

#
# .c ഫയലുകൾ .o ഫയലുകളിലേക്ക് കംപൈൽ ചെയ്യുക:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

#
# ഉരുത്തിരിഞ്ഞ .c ഫയലുകൾക്കായുള്ള പ്രത്യേക ഇതര കംപൈലേഷൻ ഫ്ലാഗുകൾ
.k ഫയലുകളിൽ നിന്ന് #:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(ഇൻപുട്ട്) -o $(ഔട്ട്‌പുട്ട്)

കൂടുതൽ വിശദാംശങ്ങൾക്കും ഉദാഹരണങ്ങൾക്കും നിയമങ്ങളിലെ ഫോർച്ച് ക്ലോസിലെ ഡോക്യുമെന്റേഷൻ കാണുക.

$/ ഇത് അടിസ്ഥാനപരമായി ഒരു സ്ഥിരാങ്കമാണ്, ഒന്നുകിൽ "/", അല്ലെങ്കിൽ നേറ്റീവ് വിൻഡോസ് "\". നിങ്ങൾക്കത് ആവശ്യമാണ്, എങ്കിൽ
നിങ്ങൾ ഒരു പ്രോഗ്രാം പോർട്ടബിൾ ആയി ആരംഭിക്കാൻ ആഗ്രഹിക്കുന്നു, ഉദാ. നിലവിലെ ഡയറക്‌ടറിയിൽ നിങ്ങൾ നിർമ്മിച്ച ഒന്ന്:

myoutput:
.$/myprog >$(ഔട്ട്പുട്ട്)

ഫയൽനാമങ്ങൾ ആർഗ്യുമെന്റായി പാസ്സാക്കിയതിന്, വിൻഡോസിന് Unix കൈകാര്യം ചെയ്യാൻ കഴിയുന്നതിനാൽ അത് ആവശ്യമില്ല
അവിടെ വാക്യഘടന.

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

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

A = $A # മാറ്റിവെച്ച മൂല്യനിർണ്ണയം, ആവശ്യം :=
B = $C
C = $B

MAKEPP_LN_CP
&ln എന്നതിന് താഴെയുള്ള കുറിപ്പ് കാണുക.

makepp_percent_subdirs
ടാർഗെറ്റുകളിലോ ഡിപൻഡൻസികളിലോ "%" ഉണ്ടായിരിക്കാൻ ഇത് ചില യഥാർത്ഥ മൂല്യമായി (1 പോലെ) സജ്ജമാക്കുക
ഒന്നിലധികം ഡയറക്‌ടറികളിലുടനീളം.

makepp_require_phony
പരോക്ഷമായ വ്യാജം തടയാൻ (അതായത് ഒരു നിയമമാണെങ്കിൽ) ഇത് ചില യഥാർത്ഥ മൂല്യമായി (1 പോലെ) സജ്ജമാക്കുക
അതിന്റെ ലക്ഷ്യം ഉൽപ്പാദിപ്പിക്കാതെ വിജയിക്കുന്നു). ഈ വേരിയബിൾ സ്ഥിരസ്ഥിതിയായി ശരിയായിരിക്കണം, to
തകർന്ന ആശ്രിതത്വ ശൃംഖലകളെ തടയുക, എന്നാൽ അത് പിന്നോട്ട് അനുയോജ്യത തകർക്കും
sloppy makefiles.

makepp_signature_C_flat
ഇത് സി സിഗ്നേച്ചർ ചെയ്യാനുള്ള ഒരു ഓപ്ഷനാണ്. നിങ്ങളുടേത് കൈകാര്യം ചെയ്യാൻ ഇത് ചില യഥാർത്ഥ മൂല്യത്തിലേക്ക് (1 പോലെ) സജ്ജമാക്കുക
പരന്ന സ്രോതസ്സുകൾ, അതായത് എല്ലാ ന്യൂലൈനുകളും (പ്രീപ്രൊസസ്സർ പ്രസ്താവനകൾ ഒഴികെ)
വൈറ്റ്‌സ്‌പെയ്‌സ് പോലെ പരിഗണിക്കുകയും "#ലൈൻ" നിർദ്ദേശങ്ങൾ അവഗണിക്കുകയും ചെയ്യുന്നു.

makepp_simple_concatenation
"rc-style substitution" തടയാൻ ഇത് ചില യഥാർത്ഥ മൂല്യത്തിലേക്ക് (1 പോലെ) സജ്ജമാക്കുക.

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

VPATH
ഈ വേരിയബിളിനെ കുറച്ച് മൂല്യത്തിലേക്ക് സജ്ജീകരിക്കുന്നത് "vpath % മൂല്യം" എന്ന് വിളിക്കുന്നു.

മുൻ‌നിശ്ചയിച്ചത് വേരിയബിളുകൾ
നിങ്ങൾക്ക് അസാധുവാക്കാൻ കഴിയുന്ന കുറച്ച് വേരിയബിളുകൾ Makepp മുൻകൂട്ടി നിർവചിക്കുന്നു:

AR സ്ഥിരസ്ഥിതി: "ar".

ആർഫ്ലാഗുകൾ
സ്ഥിരസ്ഥിതി: "rv".

AS സ്ഥിരസ്ഥിതി: "ആയി".

CC സ്ഥിരസ്ഥിതി: "gcc", "egcc", "pgcc", "c89" അല്ലെങ്കിൽ "cc" എന്നിവയിൽ അല്ലെങ്കിൽ വിൻഡോസിൽ ആദ്യം കണ്ടെത്തിയത്
കൂടാതെ "cl" അല്ലെങ്കിൽ "bcc32".

CFLAGS
സ്ഥിരസ്ഥിതി: "$(CC)" ഒരു ഗ്നു കമ്പൈലർ "-g -Wall" ആണെങ്കിൽ, അത് രണ്ട് വിൻഡോകളിൽ ഒന്നാണെങ്കിൽ
കംപൈലറുകൾ ഒന്നും ഇല്ല, "-g".

CURDIR
നിലവിലെ Makefile താമസിക്കുന്ന ഡയറക്ടറി.

CXX സ്ഥിരസ്ഥിതി: "g++", "c++", "pg++", "cxx", "C""C" അല്ലെങ്കിൽ "aCC", അല്ലെങ്കിൽ ഓൺ എന്നിവയിൽ ആദ്യം കണ്ടെത്തിയത്
വിൻഡോസ് അധികമായി "cl" അല്ലെങ്കിൽ "bcc32".

CXXFLAGS
സ്ഥിരസ്ഥിതി: "$(CXX)" ഒരു ഗ്നു കമ്പൈലർ "-g -Wall" ആണെങ്കിൽ, അത് രണ്ട് വിൻഡോകളിൽ ഒന്നാണെങ്കിൽ
കംപൈലറുകൾ ഒന്നും ഇല്ല, "-g".

F77 സ്ഥിരസ്ഥിതി: "f77", "g77" അല്ലെങ്കിൽ "fort77" എന്നിവയിൽ ആദ്യത്തേത് കണ്ടെത്തി.

FC സ്ഥിരസ്ഥിതി: "$(F77)".

LD സ്ഥിരസ്ഥിതി: "ld".

EX സ്ഥിരസ്ഥിതി: "ലെക്സ്" അല്ലെങ്കിൽ "ഫ്ലെക്സ്" എന്നതിൽ ആദ്യം കണ്ടെത്തിയത്.

LIBTOOL
സ്ഥിരസ്ഥിതി: "ലിബ്ടൂൾ".

വരുത്തിയേക്കാവുന്ന
ഈ വേരിയബിളിന് സാന്നിധ്യമോ ഇല്ലയോ എന്നതിനെ ആശ്രയിച്ച് രണ്ട് വ്യത്യസ്ത മൂല്യങ്ങളുണ്ട്
"--പരമ്പരാഗത-ആവർത്തന-നിർമ്മാണം". ഈ വേരിയബിൾ ഉപയോഗിക്കുമ്പോൾ Makepp തിരിച്ചറിയുന്നു
ആവർത്തനം യഥാർത്ഥത്തിൽ സംഭവിക്കുന്നതിന് മുമ്പുതന്നെ ചില സവിശേഷതകൾ ഓഫാക്കുന്നു. ഇത് ആകാം
നിങ്ങൾ അത് ക്രമേണ ഇല്ലാതാക്കുമ്പോൾ അഭികാമ്യമല്ല, അതിനാൽ ആദ്യം കോളുകൾ a ആയി പരിവർത്തനം ചെയ്യുക
makepp നിർദ്ദിഷ്ട "$((ഉണ്ടാക്കുക))", അത് സവിശേഷതകൾ ഓഫാക്കില്ല. നിങ്ങൾ അത് സജ്ജമാക്കാൻ പാടില്ല
കാരണം അത് ഞങ്ങളുടെ മികച്ച ആവർത്തന പ്രവർത്തനത്തെ തകർക്കുന്നു.

MAKECMD ഗോളുകൾ
ഈ വേരിയബിൾ സജ്ജമാക്കിയെങ്കിലും makepp ഉപയോഗിക്കുന്നില്ല. എങ്കിൽ മാത്രമേ എന്തെങ്കിലും ചെയ്യാൻ നിങ്ങൾക്ക് അത് അന്വേഷിക്കാൻ കഴിയൂ
ഒരു നിശ്ചിത ലക്ഷ്യം അഭ്യർത്ഥിച്ചു.

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

ifneq $(പ്രത്യേക ലക്ഷ്യം ഫിൽട്ടർ ചെയ്യുക, $(MAKECMDGOALS))
# സ്പെഷ്യൽ ടാർഗെറ്റ് എന്നത് നിലവിലെ വ്യക്തമായ ലക്ഷ്യങ്ങളിലൊന്നാണ്
അല്ലെങ്കിൽ ifeq $(MAKECMDGOALS)
# വ്യക്തമായ ലക്ഷ്യങ്ങളൊന്നുമില്ല
endif

മേക്ക്ഫ്ലാഗുകൾ (കയറ്റുമതി ചെയ്തത്)
മേക്കപ്പ് വിളിച്ച സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ. ഒറ്റ അക്ഷരമുള്ളവ
ഫോം ഒരു മുൻനിര "-" ഇല്ലാതെ തുടക്കത്തിൽ സംയോജിപ്പിച്ചിരിക്കുന്നു (gmake തിരഞ്ഞെടുത്തത് എന്തുകൊണ്ടാണെന്ന് സ്വർഗ്ഗത്തിന് അറിയാം
"-" ഡ്രോപ്പ് ചെയ്യാൻ).

MAKEINFO
സ്ഥിരസ്ഥിതി: "നിർമ്മാണം".

MAKEPPFLAGS (കയറ്റുമതി ചെയ്തത്)
ഇത് MAKEFLAGS-ന്റെ അതേ മൂല്യത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു, എന്നാൽ ഈ വേരിയബിൾ ഉണ്ടെങ്കിൽ മാത്രം
makepp ന്റെ പരിസ്ഥിതി.

_MAKEPPFLAGS (കയറ്റുമതി ചെയ്തത്)
POSIX/gmake അനുയോജ്യതയ്ക്ക് ആവശ്യമായ makepp നിർദ്ദിഷ്ട ഓപ്ഷനുകൾ, ഏത് makepp
വിളിപ്പിച്ചു. ഇവ ഒരു പ്രത്യേക വേരിയബിളിലായതിനാൽ ഒരു ലെഗസി മേക്ക് ഫയലിന് തകർക്കാൻ കഴിയില്ല
MAKEFLAGS അൺസെറ്റ് ചെയ്യുന്നതിലൂടെ അനുയോജ്യത. ഇത് ഉപയോഗിച്ച് മാത്രം സജ്ജീകരിച്ചിരിക്കുന്നു
"--പരമ്പരാഗത-ആവർത്തന-നിർമ്മാണം".

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

സ്ഥിരസ്ഥിതി: "makepp --version" പ്രദർശിപ്പിക്കുന്ന അതേ മൂല്യം

PWD "CURDIR" എന്നതിന്റെ അപരനാമം.

RM സ്ഥിരസ്ഥിതി: "rm -f". ഇത് ലെഗസി മേക്ക് ഫയലുകൾക്കുള്ളതാണ്. പുതിയവയ്ക്ക് ഉപയോഗിക്കുന്നത് അഭികാമ്യമാണ്
ബിൽട്ടിൻ & rm കമാൻഡ് നേരിട്ട്. നിങ്ങൾക്ക് ഒരു വ്യാജ വൃത്തിയുള്ള നിയമം എഴുതണമെങ്കിൽ, നോക്കുക
പകരം "makeppclean -r" കമാൻഡ്.

ROOT
നിങ്ങളുടെ ബിൽഡ് സിസ്റ്റത്തിന്റെ റൂട്ടിലേക്കുള്ള ആപേക്ഷിക പാത, അതായത് ഡയറക്‌ടറി കൂടുതൽ മുകളിലേക്ക്
നിങ്ങൾക്ക് ഒരു "RootMakeppfile(.mk)" ഉണ്ട്. നിങ്ങൾക്ക് ഒന്നുമില്ലെങ്കിൽ, ഈ വേരിയബിൾ ആണ്
ശൂന്യമാണ്.

ഷെൽ
നിങ്ങൾ അത് "കയറ്റുമതി" ചെയ്താൽ മാത്രമേ ഈ വേരിയബിൾ മാനിക്കപ്പെടുകയുള്ളൂ. അങ്ങനെയെങ്കിൽ അത് ഷെൽ ആണ്
ചില പ്രത്യേക പ്രതീകങ്ങളുള്ള ബിൽറ്റിൻ ചെയ്യാത്ത പ്രവർത്തനങ്ങൾ നടപ്പിലാക്കാൻ ഇത് ഉപയോഗിക്കുന്നു (പ്ലെയിൻ
നേരിട്ട് നടപ്പിലാക്കുന്നവ). Windows സ്ട്രോബെറി അല്ലെങ്കിൽ ActiveState Perl-ൽ, നിങ്ങൾക്കുണ്ടെങ്കിൽ
ഒരു യുണിക്സ് പോലെയുള്ള ഷെൽ, പകരം നിങ്ങളുടെ ഷെൽ വേരിയബിളിനെ "sh" ൽ അവസാനിക്കുന്ന ഒരു മൂല്യത്തിലേക്ക് സജ്ജമാക്കണം.
അല്ലെങ്കിൽ "sh.exe" മുമ്പ് makepp വിളിക്കുന്നു.

സ്ഥിരസ്ഥിതി: "/usr/xpg4/bin/sh" (ഉദാ. സോളാരിസ്) അല്ലെങ്കിൽ "/sbin/xpg4/sh" എന്നിവയിൽ ആദ്യം കണ്ടെത്തിയത്
(ഉദാ. Reliant Unix) അല്ലെങ്കിൽ "/ bin / sh".

YACC
സ്ഥിരസ്ഥിതി: "ബൈസൺ-വൈ" അല്ലെങ്കിൽ "യാക്ക്" എന്നതിൽ ആദ്യം കണ്ടെത്തിയത്.

വേരിയബിളുകൾ ഒപ്പം പേൾ
വേരിയബിൾ മൂല്യങ്ങൾ സാധാരണ പേൾ ​​സ്കെയിലറുകളായി സംഭരിച്ചിരിക്കുന്നതിനാൽ നിങ്ങൾക്ക് അവ നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയും
നിങ്ങൾക്ക് അവരുമായി എന്തെങ്കിലും സങ്കീർണ്ണമായ കൃത്രിമങ്ങൾ നടത്തണമെങ്കിൽ പേൾ കോഡ്; makepp_extending കാണുക
വിവരങ്ങൾക്ക്.

പേളിൽ നിന്ന് ആഗോള വേരിയബിളുകൾ ആക്‌സസ് ചെയ്യുന്നത് അവയെ "Mpp::global" ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്യുന്നതിലൂടെ നേടാനാകും.
പാക്കേജ്. വാസ്തവത്തിൽ ഏതെങ്കിലും വേരിയബിൾ, നിലവിലുള്ള മേക്ക്ഫയലിൽ ഇതുവരെ നിലവിലില്ല, നിങ്ങൾ ഏത്
ഈ പാക്കേജിൽ അസൈൻ ചെയ്യുന്നത് അന്നുമുതൽ ആഗോളമായിരിക്കും, നിങ്ങൾ ഇപ്പോൾ നൽകിയത് പോലെ
അതിനുള്ള "ആഗോള" പ്രസ്താവന.

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

നേരിട്ടുള്ള ആക്‌സസ് ഉപയോഗിച്ച്, ഈ വേരിയബിളുകൾ തരത്തിലാണെങ്കിൽ അവയുടെ വികാസത്തെയും നിങ്ങൾ മറികടക്കും
"=" അല്ലെങ്കിൽ ";=". "$(CC)" പോലെയുള്ള പ്രത്യേക വേരിയബിളുകൾ ഫംഗ്‌ഷനുകളായി ആരംഭിക്കുന്നത് വരെ
നിയോഗിച്ചിട്ടുള്ള. അതിനാൽ പല കേസുകളിലും നിങ്ങൾ അവയുടെ മൂല്യം കാണില്ല.

ഈ കാരണങ്ങളാൽ ശരിയായ മൂല്യം നിർണ്ണയിക്കാൻ makepp-നെ അനുവദിക്കുന്നതാണ് നല്ലത്. നിങ്ങൾക്ക് ഉപയോഗിക്കാം
"makeperl" വേരിയന്റ്, അതിൽ പേൾ കോഡ് ലഭിക്കുന്നതിന് മുമ്പ് വേരിയബിൾ മൂല്യനിർണ്ണയം നടത്തിയിട്ടുണ്ട്
വ്യാഖ്യാനിച്ചു:

makeperl { $$current_value = '$(MAKEFILE_VAR)'}

നിങ്ങൾക്ക് makefile perl ബ്ലോക്കുകളിൽ ഒരു വേരിയബിൾ വേണമെങ്കിൽ ഇത് Perl വേരിയബിൾ വഴിയാണ് നേടുന്നത്
$makefile ഇനിപ്പറയുന്ന രീതിയിൽ:

perl { $current_value = $makefile->expand_variable('MAKE_VAR' )}

ഫംഗ്‌ഷനുകൾ എല്ലായ്‌പ്പോഴും മേക്ക്‌ഫൈൽ ഒബ്‌ജക്‌റ്റിനെ രണ്ടാമത്തെ ആർഗ്യുമെന്റായി കൈമാറുന്നു $_[1]:

ഉപ f_f { $current_value = $_[1]->expand_variable('MAKE_VAR' )}

മെയ്ക്ക് ഫയൽ ഒബ്‌ജക്റ്റ് ഉള്ള ഒരു റൂൾ ആക്ഷനിലാണ് കമാൻഡുകൾ വിളിക്കേണ്ടത്
"$Mpp::Subs::rule->{MAKEFILE}" വഴി ആക്‌സസ് ചെയ്യാം:

ഉപ c_cmd {$current_value = $Mpp::Subs::rule->{MAKEFILE}->expand_variable('MAKE_VAR' )}

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