makepp_variables - Online sa Cloud

PROGRAMA:

NAME

makepp_variables -- Paano gumamit ng mga variable sa makepp

DESCRIPTION

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAGS,
AS, C: DC,
CFLAGS,
"changed_dependencies",
binagong_input,
CURDIR,
CXX,
CXXFLAGS, D: "mga dependency",
"dependency", F: F77,
F.C.,
"foreach", I: input,
input, L: LD,
LEX,
LIBTOOL, M: GUMAGAWA,
MAKECMDGOALS,
MAKEFLAGS,
MAKEINFO,
MAKEPP_DEBUG,
MAKEPFLAGS,
_MAKEPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "output",
"mga output", P: PERL,
PWD, R: RM,
UGAT, S: SHELL,
"sorted_dependencies",
sorted_inputs,
"stem", T: target,
target, V: VPATH, Y: YACC

Ang mga makefile ay karaniwang gumagamit ng mga variable sa maraming lugar. Isang mahalagang dahilan sa paggamit
variable ay upang matiyak na ang impormasyon ay nakapaloob sa isang lugar lamang sa makefile, kaya
na kung ito ay magbago, walang panganib na makuha ang dalawang kopya ng impormasyon
magkasabay

Case sensitive ang mga pangalan ng variable. Sa teorya, ang mga variable na pangalan ay maaaring gawin ng marami
mga character, ngunit malamang na hindi ito ma-grok ni makepp kung may gagawin ka maliban sa
mga alphanumeric na character, "_", at "-".

Ang bawat makefile ay may sariling hanay ng mga variable, at ang pagtatakda ng variable sa isang makefile ay
walang epekto sa halaga nito sa anumang ibang makefile. Kung gusto mong magkaroon ng mga variable na nakatakda
maraming mga makefile, ang pinakamahusay na paraan upang gawin ito ay ang bawat isa sa kanila ay may kasamang karaniwang mga kahulugan
file (tingnan ang include statement) o gumamit ng "global" na mga variable.

Paiba-iba Trabaho
Ang isang variable ay maaaring maglagay ng isang halaga sa maraming iba't ibang paraan:

· Ang isang variable ay maaaring itakda sa loob ng isang makefile. Mayroong maraming iba't ibang paraan upang gawin
ito; tingnan sa ibaba.

· Maaaring tukuyin ang value ng variable sa command line, tulad nito:

makepp CFLAGS=-O2 my_program

Kung higit sa isang makefile ang na-load, ang CFLAGS variable ay ipapalaganap sa lahat ng
makefiles. Awtomatikong na-override ng mga variable na nakatakda sa command line ang anumang setting ng
ang variable sa alinman sa mga makefile.

Kung kinakailangan, dapat na tahasang i-override ng makefile ang mga setting ng command line.
Ang layunin ay hindi balewalain kung ano ang hinihiling ng user, ngunit isang paraan upang baguhin ito.
Maaaring mauna ang "override" modifier sa anumang statement ng pagtatalaga. Ngunit sa kaso ng
keyword statement, ang pagkakasunud-sunod ay mahalaga, kung kaya't ang override na variant ay
palaging ipinapakita sa ibaba. Nalalapat lang ang "override" modifier sa anumang mga takdang-aralin kung saan ito
ay naroroon, at hindi nakakaimpluwensya sa mga susunod na takdang-aralin sa variable.

· Kung ang isang variable ay nakatakda sa kapaligiran, maaari itong i-reference bilang isang makepp variable.
Karaniwan ang mga pagtatalaga sa mga variable sa loob ng isang makefile ay nag-o-override sa mga setting mula sa
environment, ngunit maaari mo itong baguhin sa pamamagitan ng paggamit ng "-e" o "--environment-overrides"
opsyon na command line.

Ang mga variable ay itinalaga sa isa sa ilang mga expression ng pagtatalaga, tulad nito

X = 1
MGA MODULE := abcd
CC ?= gcc
CFLAGS += -Pader
tukuyin ang VAR
var linya 1
var linya 2
enddef
i-export ang PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = impormasyon na makikita sa lahat ng makefiles

Palaging inaalis ang nangunguna at sumusunod na whitespace sa paligid ng mga value.

Ang iba't ibang mga operator ng pagtatalaga ay may iba't ibang kahulugan.

Simple trabaho operator

=
VARIABLE = string ng teksto
i-override ang VARIABLE = string ng teksto

Ito ang karaniwang pahayag ng pagtatalaga na ginagawang suporta ng lahat ng pagpapatupad. Ang
ang expression sa kanang bahagi ay hindi sinusuri hanggang ang halaga ng "$(VARIABLE)" ay
ginamit talaga sa isang lugar. Kaya, kung gagawin mo ang sumusunod:

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

Pagkatapos "$(Y)" mamaya sa makefile ay susuriin sa "2".

Sa pangkalahatan, karaniwang gusto mong gamitin ang ":=" (tingnan sa ibaba) sa halip na "=" dahil ito
nagbibigay ng mas predictable na variable na pagsusuri. Gayunpaman, may mga pagkakataon na kailangan mo
upang ipagpaliban ang variable na pagsusuri. Gayundin, kung nagsusulat ka ng isang makefile na dapat na
backwards-compatible sa ilang bersyon ng make maliban sa GNU make, pagkatapos ay wala kang
pagpipilian: maaari mo lamang gamitin ang "=".

:=
VARIABLE := expr
i-override ang VARIABLE := expr

Ito ay kapareho ng "VARIABLE = expr" maliban na ang kanang bahagi ay sinusuri
minsan at para sa lahat sa oras ng takdang-aralin. Kaya kung

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

pagkatapos ay "$(Y)" mamaya sa makefile ay susuriin sa "1" dahil iyon ang "$(X)" noon
kapag ang "$(Y)" ay tinukoy.

;=
VARIABLE ;= expr
i-override ang VARIABLE ;= expr

Ito ay kapareho ng "VARIABLE := expr" maliban na ang kanang bahagi ay sinusuri
lamang sa oras ng unang paggamit at pagkatapos ay naalala. Ito ay kapaki-pakinabang para sa mahal
mga command, na palaging nagbabalik ng parehong halaga, ngunit hindi mo gustong gawin kung kailan
pagbuo ng hindi nauugnay na mga target:

VAR1 ;= $(perl mahal na kalkulasyon)
VAR2 ;= $(shell external command)

Tandaan na ang mga lumang makefile ay karaniwang gagamit ng ":=" dito, upang gawin ito kahit isang beses lang.
Ngunit sa operator na ito ay maaari mo ring dagdagan na hindi gawin ito, kung kasalukuyan mong hindi
kailangan ang halaga. Para sa mga halaga na magkapareho sa ilang mga direktoryo, maaari mong
i-optimize ito nang higit pa gamit ang "global", na tinalakay sa ibaba.

Gayunpaman, hindi ito inilaan bilang isang matalinong paraan upang pilitin ang pagkakasunud-sunod ng pagsusuri. Kung ang
variable na tinukoy tulad nito kasama ang halaga ng isa pang variable, at ang isa pa
ay may partikular na target na halaga, at ang unang pagpapalawak ay para sa target na iyon, pagkatapos ay ang
mananatili din ang target na partikular na halaga para sa lahat ng iba pang konteksto. Ito ay isang bug at
sana ay maayos sa hinaharap.

+=
VARIABLE += expr
i-override ang VARIABLE += expr

Idinaragdag ang string sa mga nakaraang nilalaman ng variable, na pinaghihiwalay ng isang puwang. Kung
ang variable ay dating itinalaga ng ":=", pagkatapos ay sinusuri ang kanang bahagi
bago idugtong.

&=
VARIABLE &= expr
i-override ang VARIABLE &= expr

Inilalagay ang string sa mga nakaraang nilalaman ng variable, na pinaghihiwalay ng isang puwang.
Kung ang variable ay dating nakatalaga sa ":=", ang kanang bahagi ay
sinusuri bago idugtong.

Halimbawa isang paraan ng paggarantiya na "CFLAGS", anuman ang maaaring ilagay ng user,
laging nagsisimula sa "-Wall" ang dalawang linyang ito:

CFLAGS = -O2 # Posibleng ma-override sa command line
i-override ang CFLAGS &= -Wall # Walang kundisyon na inihanda

Sa mga lumang makefile ay karaniwang kailangan mong gawin ang isang bagay na tulad nito, na may panig
epekto ng pagpilit sa uri sa ":=" upang maiwasan ang walang katapusang recursion:

VARIABLE := expr $(VARIABLE)

?=
VARIABLE ?= expr
override VARIABLE ?= expr # Useless, pero legal

Itinatakda ang halaga ng variable, ngunit kung ang variable ay hindi tinukoy sa mas maaga
ang makefile, sa command line, o sa kapaligiran. Ang takdang-aralin sa itaas ay
eksaktong katumbas ng

ifndef VARIABLE
VARIABLE = expr
endif

!=
VARIABLE != utos ng shell
i-override ang VARIABLE != shell command

Pinapatakbo ang shell command at itinatakda ang variable na naglalaman ng karaniwang output ng command.
Ito ay eksaktong katumbas ng

VARIABLE := $(shell command)

multiline mga variable

Ang "define" na pahayag ay ang multiline na katumbas ng mga simpleng pahayag sa itaas. Ang
operator pagkatapos ng variable ay opsyonal. Kung nawawala, ito ay katumbas ng "define VARIABLE
=". Ang mga operator na "&=" at "+=" ay bahagyang naiiba dito, dahil pinagdikit nila ito
ang lumang halaga na may bagong linya, sa halip na isang espasyo. Dapat ay walang anuman maliban sa a
komento pagkatapos ng pahayag, ibig sabihin, ang halaga ay magsisimula sa susunod na linya.

tukuyin ang VARIABLE :=
unang linya ng halaga ng variable
pangalawang linya ng halaga ng variable
ikatlong linya ng halaga ng variable
endef

override define VARIABLE
...
enddef

Ang mga keyword bago ang "define" ay maaaring mga kumbinasyon ng alinman sa "export" o "global" at
"override".

Kung kailangan mo ng value ng variable para maglaman ng mga bagong linya, dapat mong gamitin ang "define" na statement bilang
ipinapakita (o maaari mong italaga ang halaga nang direkta sa Perl). (Ang "endef" ay pinili para sa
pagiging tugma sa GNU make. Maaari mo ring gamitin ang "enddef".) Ito ay pangunahing kapaki-pakinabang para sa
"mga de-latang pagkakasunud-sunod ng utos", hal., tulad nito:

tukuyin ang COMPILE_C_PROGRAM
@&echo "Pagsasama-sama ng $(input)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(KASAMA) -c $(input) -o $(output)
endef

Pagkatapos ay maaari mong gamitin ang multi-line na variable na ito sa ilang panuntunan, tulad nito:

%.o : %.c
$(COMPILE_C_PROGRAM)

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

Tandaan na madalas mong makakamit ang parehong epekto sa pamamagitan ng paggamit ng semicolon sa halip na isang bagong linya,
dahil binibigyang kahulugan iyon ng shell bilang isang command delimeter din. Halimbawa,

COMPILE_C_PROGRAM = @echo "Pagsasama-sama ng $(input)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(KASAMA) -c $(input) -o $(output)

magkakaroon ng parehong epekto, maliban na pinipilit ng semicolon na ipasa ito sa shell,
sa halip na isagawa ang utos nang direkta at mas mahusay. Kailangan mo ring ilagay ang bawat isa
builtin sa sarili nitong linya, ibig sabihin kailangan mong lumipat sa panlabas na echo sa
kaso ng semicolon.

May isang espesyalidad kapag lumalawak sa loob ng "define", ibig sabihin, "define X :=" o sa a
variable na dati nang ":=", "define X &=" at "define X +=". Sa kasong ito ang
Ang "$(shell command ...)" o builtin na "$(&command ...)" ay hindi nagpapalit ng mga bagong linya sa
mga puwang.

Ine-export mga variable sa mga subprocess

i-export ang VAR...
i-export ang VAR = halaga
i-override ang pag-export ng VAR += value

Ang unang form ay nagmamarka ng mga ibinigay na variable para sa pag-export sa mga subprocess, na may anumang halaga
ang variable pagkatapos ay mayroon. Ang pangalawang anyo, na nalalapat lamang sa isang variable, bilang karagdagan
nagtatalaga kaagad ng halaga. Ang lahat ng mga variant ng pagtatalaga ay pinapayagan.

Pagbabahagi mga variable sa kabila makefiles

pandaigdigang VAR ...
pandaigdigang VAR = halaga
i-override ang pandaigdigang halaga ng VAR &=

Ang unang form ay nagmamarka sa mga ibinigay na variable bilang global sa lahat ng makefiles. Kung sino man sa kanila
mayroon nang value, ang value na iyon ay inilipat mula sa makefile local variable patungo sa global
isa. Gayunpaman kung, sa oras na makita ang pahayag na ito, ang anumang iba pang mga makefile ay mayroon nang a
halaga para sa alinman sa mga ito, kung gayon ang mga makefile na iyon ay hindi makikita ang pandaigdigan.

Ang pangalawang anyo, na nalalapat lamang sa isang variable, ay nagtatalaga din ng tamang halaga
malayo. Ang lahat ng mga variant ng pagtatalaga ay pinapayagan. Tandaan na ang ":=" ay lalawak kaagad
sa mga halaga sa lokal na makefile. Sa kabilang banda, lalawak ang mga variable na "=" sa
mga halaga sa punto ng paggamit.

Ang mga pandaigdigang variable ay maaaring mahirap hawakan, dahil ang makepp ay maaaring mag-load ng mga makefile sa alinman
pagkakasunud-sunod, dahil ang pangangailangan ay lumitaw upang bumuo ng ilang target kung saan walang tuntunin o makefile na na-load.
Para sa kadahilanang ito inirerekomenda na magkaroon ng isang RootMakeppfile at tahasang i-load ang lahat
iba na nagbabago o gumagamit ng variable na may "load-makefile".

pandaigdigang GLIBLIBS ;= $(shell pkg-config --libs glib-2.0)

Tandaan din na ang iyong proyekto ay maaaring balang araw ay mabuo kasama ng iba pang mga proyekto. Para dito
dahilan na inirerekomenda na palaging gawing bahagi ang pangalan ng proyekto ng anumang pandaigdigang pangalan ng variable.

Partikular sa target mga takdang-aralin

target: VARIABLE = string
target: VARIABLE := string
target: i-override ang VARIABLE += string

Nagtatakda ng value na tukoy sa target ng variable. May bisa ng value na tukoy sa target lamang
sa isang aksyon na gumagawa ng ibinigay na target. Pangunahing ginagamit ito para sa mga bagay tulad ng
ito:

CFLAGS := -O2

my_prog: file1.o file2.o special_file.o

special_file.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

Ang nangyayari dito ay ang lahat ng ".c" na file ay isasama sa pag-optimize ("-O2") maliban
"special_file.c", na pinagsama-sama sa debug mode ("-g"). Ito ay isang maginhawang paraan upang
tukuyin ang iba't ibang mga opsyon sa compilation para sa ilang mga file lamang.

Ang mga takdang-aralin na partikular sa target na tulad nito ay nalalapat lang sa mga pagkilos ng panuntunan; sila
ay walang bisa kapag sinusuri ang mga target o dependency ng isang panuntunan. Kung isang tuntunin
ay may higit sa isang target, ang mga takdang variable na tukoy sa target ay kinukuha lamang mula sa
una target. Tandaan din na bahagyang naiiba ang mga variable na partikular sa target ng makepp
mula sa GNU make's na nalalapat lamang sila sa panuntunan para sa isang file na nabanggit, at hindi sa
alinman sa mga nauna nito.

Isinasagawa ang pagpapalawak ng wildcard sa target, para magawa mo ang isang bagay tulad nito:

pagsubok_*.o : CFLAGS += -DTEST

Para sa pagiging tugma sa GNU make, ang "%" ay maaaring gamitin bilang kapalit ng "*".

Paiba-iba Paghalili
Ang mga alituntunin ng variable na pagpapalit ng Makepp ay katulad ng sa iba pang mga gawa, ngunit medyo
mas makapangyarihan. Tulad ng lahat ng mga gawa, ang "$(CC)" o "${CC}" ay parehong kumakatawan sa halaga ng
variable na CC. Kung kailangan mo ng literal na dollar sign, ilagay sa double dollar sign ($$), like
ito:

target: dep1 dep2 dep3 dep4
&rm -f $(output)
para sa file sa $(inputs); gawin cat $$file >> $(output); tapos na

Bukod pa rito, ang makepp ay may "$[VARIABLE]" na syntax, na ginagawa ang parehong bagay tulad ng iba
dalawa, ngunit bago makepp groks anumang bagay. Nagbibigay-daan ito sa paggamit nito para sa kumpletong mga panuntunan
at/o mga kondisyon:

tukuyin ang bracket_rule =
ifdef SOME_VAR
bracket:
&echo ito ay isang panuntunan -o $(output)
endif
enddef

$[bracket_rule]

rc-style paghalili

Bilang default, ang makepp ay gumagamit ng rc-style substitution (tinatawag na dahil ito ay pinasimunuan ng
rc shell). Ito ay pinakamahusay na inilalarawan ng isang halimbawa:

MODULE = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(target)

Ang prefix na "module_dir/" ay inilalagay sa bawat salita sa MODULES, at ang suffix na ".o" ay
idinagdag sa bawat salita.

Maaari ka ring gumamit ng rc-style substitution nang hindi inilalagay ang listahan ng mga salita sa a
variable; ang syntax ay "$( word1 word2)". Pansinin ang espasyo sa pagitan ng panaklong at ng
unang salita. Kaya't ang halimbawa sa itaas ay maaaring isulat bilang:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(target)

Ang isang variable ay magbibigay lamang ng rc-style substitution kapag mayroong higit sa isang salita sa loob nito.
Sa isang salita ito ay tulad ng tradisyonal na paggawa. Naku, kapag ang variable ay walang laman, mayroong isang
tunggalian. Pinapalawak lang ito ng tradisyonal sa walang laman na string. Pero kapag naiisip mo
ito bilang isang listahan, gugustuhin mong mawala ang "-I$(DIRLIST)", hindi ang magbigay ng malungkot na "-I". Ang
Ang solusyon ay ang balutin ito sa isang listahan na nagsisimula sa isang puwang: "-I$( $(DIRLIST))" ay nagbibigay sa iyo
eksaktong bilang ng maraming mga pagpipilian, tulad ng may mga salita sa listahan.

Kung maglalagay ka ng ilang mga variable sa parehong salita na lumalawak sa array ng mga salita, rc-style
ang pagpapalit ay talagang tumatagal ng produkto ng cartesian, kaya maaari mong gawin ang isang bagay na tulad nito kung
gusto mo:

DIRS = s1 s2
MODULE = abc
MGA SUFFIX = .o .c
FILES := $(DIRS)/$(MODULES)$(SUFFIXES)

at ang FILES ay maglalaman ng string

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

Bukod sa puting espasyo, humihinto ang rc-style na pagpapalit sa anumang quote, anumang bilog, kulot o parisukat
panaklong, at alinman sa ", : ; = # @". Tandaan na ito ay maaaring nakakagulat, at muli kailangan
isang tahasang listahan. Sabihin na gusto mong maghanap ng mga header ayon sa wildcard sa lahat ng mga direktoryo
nagsisimula sa malaking titik:

MASAMA := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
MAGANDANG := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Kung hahadlang ang rc-style substitution, o kung kailangan mong magkaroon ng leading or trailing
whitespace sa iyong gumawa ng mga variable, pagkatapos ay maaari mong i-off ang rc-style substitution sa pamamagitan ng pagtatakda
ang variable na "makepp_simple_concatenation=1". Maaari mo itong i-off sa buong mundo sa command
linya o bilang variable ng kapaligiran. O sa isang per-makefile na batayan sa pamamagitan ng pagtatakda ng variable sa
iyong makefile. Dapat mong gawin ito malapit sa tuktok ng makefile, kung hindi, maaari kang makasagasa
mga nakakatawang sitwasyon kung saan ginagamit ang rc-style substitution para sa ilang pagsusuri at hindi sa iba.
(Lahat ng expression na sinusuri bago ang takdang-aralin ay gagamit ng rc-style substitutions, at lahat
mga expression na sinusuri pagkatapos ay hindi. Mula noong panahon ng pagsusuri ng mga expression sa
Ang makefiles ay kumplikado at hindi palaging halata mula sa pagkakasunud-sunod ng mga pahayag sa
makefile, pinakamahusay na itakda ang "makepp_simple_concatenation" sa lalong madaling panahon.) Maaari mo
kahit na itakda ito para lamang sa isang target:

target: makepp_simple_concatenation = 1
target:
&echo before_first$(LIST)after_last -o $(output)

Dahil ang "$[VARIABLE]" ay sinusuri nang mas maaga kaysa sa "$(VARIABLE)", pinagsasama ang dalawa sa rc-
ang pagpapalit ay hindi magbibigay ng resulta na maaari mong asahan, maliban kung ibalot mo ito sa isang tahasang
listahan:

A = ab
N = 1 2
MASAMA := $(A)$[N]
MABUTI := $(A)$( $[N])

Ang mga huling linya ay nababasa bilang

MASAMA := $(A)1 2 # a1 b1 2
MABUTI := $(A)$( 1 2) # a1 a2 b1 b2

Paghalili Mga sanggunian

Ang isang sanggunian sa pagpapalit ay may form na "$(VAR:A=B)", kung saan ang A ay isang pattern upang tumugma at ang B ay
isang pattern na palitan ito ng. Ang mga sanggunian sa pagpapalit ay isang pagdadaglat para sa
"patsubst" function. Halimbawa:

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

ay itatakda ang "$(object_files)" sa "ao bo co do". Ang "%" ay isang espesyal na tugma ng character
anumang arbitrary string. Kung ang parehong A at B ay nagsisimula sa "%", isang karaniwang kaso kapag pinapalitan
mga suffix, maaari silang alisin:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # pareho, dahil . ay hindi espesyal

Whitespace in mga variable

Kung kailangan mong kontrolin ang whitespace sa isang variable, dapat mong (sa kasalukuyan) huwag paganahin ang rc-style
pagpapalit (sa pamamagitan ng pagtatakda ng "makepp_simple_concatenation=1") at pagkatapos ay gumamit ng syntax na tulad nito:

null =
T = -o $(null)

o, na may walang laman na pagsusuri:

T = -o $()

Kapag ginawa mo ito, ang variable na "T" ay naglalaman ng "-o" na sinusundan ng isang puwang.

Ang ganitong uri ng diskarte sa paghawak ng whitespace ay hindi inirerekomenda. Kung kailangan mo ng mga variable
sa iyong makefile upang maglaman ng mga puwang, dapat mong pag-isipang mabuti ang iyong ginagawa.
Kung kailangan mong hawakan ang mga puwang, kadalasan ay mas mahusay na ilagay ang Perl code sa iyong
makefile upang alagaan ito (gamit ang "perl_begin" o "sub" na mga pahayag), o upang pangasiwaan ito
sa mga pahayag ng shell sa mga aksyon ng mga panuntunan.

Karaniwang lumalabas ang mga kasong ito kapag sinubukan ng mga tao na gamitin ang parehong mga panuntunan para sa iba
mga arkitektura na hindi gumagamit ng karaniwang Unix command syntax. Hal, minsan may nakikita
mga bagay na tulad nito sa makefiles:

ifeq ($(ARCH),weirdarch)
O := /OUTPUT=
iba
null :=
O := -o $(null)
endif

%.o : %.c
$(COMPILER) $(input) $(O)$(output)

Magagawa mo ito sa makepp kung talagang gusto mo, ngunit malamang na makikita mo na ang iyong
makefiles ay higit na nababasa kung mayroon kang hindi gaanong kumplikadong variable
pagpapalit, hal,

ifeq ($(ARCH),weirdarch)
%.o : %.c
$(WEIRD_COMPILER) $(input) /OUTPUT=$(output)
iba
%.o : %.c
$(CC) -c $(input) -o $(output)
endif

Ang whitespace ay hindi kailanman pinapayagan sa mga variable na pangalan, sa kanilang mga halaga lamang. Iba ito
mula sa ilang gumawa ng mga pagpapatupad.

Awtomatik Variable
Ang mga awtomatikong variable ay mga variable na nagpapalagay ng iba't ibang mga halaga depende sa kung aling panuntunan
sinusuri ang mga ito. Sinusuportahan ng Makepp ang karamihan sa mga awtomatikong variable na iba
mga bersyon ng gamitin. Bilang karagdagan, mayroon itong hindi gaanong misteryo, mas mahabang mga pangalan para sa karamihan sa kanila
na maaari mong gamitin sa halip. (Para sa mga legacy na makefile na nangyayaring muling tukuyin ang mga pangalang ito, ang
Ino-override ng kahulugan sa makefile ang default na kahulugan. Halimbawa, kung sasabihin mo
"target = abc" sa iyong makefile, pagkatapos ay palaging lalawak ang "$(target)" sa "abc", at hindi
mas mahaba ay katumbas ng $@.)

Ang sumusunod ay isang kumpletong listahan ng lahat ng mga awtomatikong variable na sinusuportahan ng makepp:

output
target
$@ Ang target ng kasalukuyang panuntunan. Sa totoo lang, dahil sinusuportahan ng makepp ang maraming target para sa
anumang tuntunin, ito ang una target. Halimbawa, sa sumusunod na panuntunan

y.tab.c y.tab.h : parser.y
$(YACC) -o $(output) $(YFLAGS) $(input)

Ang "$(output)" ay maglalaman ng halaga y.tab.c. Dahil ang mga magic variable na ito ay sa katunayan
function, maaari mo ring ipasa ang isang index bilang argumento. Ito ay binibilang mula sa 1 o pabalik
mula sa -1. Kaya ang "$(output 2)" o "$(output -1)" ay maglalaman ng halaga y.tab.h.

Habang ang lahat ng tatlong anyo ng variable na ito ay may parehong halaga, may pagkakaiba sa
interpretasyon para sa multitarget na mga panuntunan. Kung gagamitin mo ang lumang istilong misteryosong pangalan na $@,
Ipapakahulugan iyon ng makepp bilang isang lumang istilong hanay ng panuntunan, sa halip na isang modernong panuntunan na
gumagawa ng lahat ng mga target nang sabay-sabay:

ab: # talaga: isang panuntunan bawat isa para sa a at b
pindutin ang $@

cd: # error: nagreklamo ang mpp na hindi ito nakagawa ng d
pindutin ang $(output)

output
target
Lahat ng mga target ng kasalukuyang panuntunan. Pareho sa "$(target)" maliban kung mayroong higit sa isa
target. Sa halimbawa sa itaas, ang "$(outputs)" ay magiging y.tab.c y.tab.h. Maaari kang makapasa sa isang
listahan ng index, kaya ang "$(outputs 2 1)" ay magiging y.tab.h y.tab.c.

pagpapasustento
input
$< Ang unang tahasang dependency ng panuntunan. Halimbawa, sa panuntunang ito

%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

"$(input)" ang magiging pangalan ng .c file, anuman ang .h file makepp
natuklasan. Kung tumukoy ka ng higit sa isang dependency, maaari mong makuha ang mga ito sa pamamagitan ng pagpasa ng isang
index: "$(input $(INDEX))" ay ang INDEXth dependency.

dependencies
input
$^ Lahat ng tahasang dependencies ng target, hindi kasama .h mga file na natuklasan ni
makepp_scanning para sa kasama.

Halimbawa, sa panuntunan

myprog.o : *.o
$(CC) $(CFLAGS) $(input) -o $(output)

Ang "$(inputs)" ay ang lahat ng .o file sa direktoryo. Maaari mo lamang piliin ang mga ikaw
gusto sa pamamagitan ng pagpasa ng isang listahan ng index. Kung tahasan mong tinukoy ang iba't ibang uri ng mga file,
maaari mong piliin ang mga ito tulad ng sa "$(inputs 2 3 4)" (ngunit sa isang wildcard hindi ito masyadong
nangangako).

sorted_dependencies
sorted_inputs
$+ Lahat ng mga dependency ng target, sa pinagsunod-sunod na pagkakasunud-sunod, na may mga duplicate na inalis.
Katumbas ng "$(sort $(inputs))".

nagbago_dependencies
binago_mga_input
$? Ang mga dependency ng target na nagbago. Kasama lang dito ang tahasan
dependencies (ibig sabihin, ang mga inilista mo sa makefile), hindi tuwirang natuklasan
dependencies mula sa pag-scan (tulad ng mga .h file).

Ito ay karaniwang ginagamit sa mga utos tulad nito:

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

ibig sabihin, ar ay sinabi na palitan lamang ang mga module na nagbago. (Tandaan ang
"ignore_action" build check rule. Kung hindi mo ito tinukoy, pipilitin ng makepp ang
aksyon na isasagawa sa tuwing magbabago ito. Kung walang mga dependency na nagbago, ang
Ang action string ay magiging "ar ru libmine.a" na malamang ay iba sa kung ano ito noon
huling beses mo itong pinatakbo, kaya nang walang "ignore_action" ay ipapatupad ito ng makepp. Dito sa
kaso, hindi ito nakakapinsala, ngunit sa iba pang mga utos, maaari itong maging isang problema. Tingnan mo
makepp_build_check para sa mga detalye sa "ignore_action".)

Ang pagbuo ng mga archive na tulad nito ay hindi magandang ideya dahil ito ay magpapababa sa iyong mga build
maaasahan. Ang problema dito ay kung bubuo ka ng archive, pagkatapos ay alisin ang isa sa
ang mga module mula sa listahan ng mga MODULE, ang mga module ay mananatili pa rin sa archive at
makepp

sumalunga
$* Ang stem sa isang pattern na panuntunan (ibig sabihin, anuman ang '%' na tumugma). Bilang kahalili, kung ito
ay hindi isang panuntunan ng pattern, ibinabalik ang pangalan ng file nang walang extension (ibig sabihin, ito ay
katumbas ng "$(basename $(input))".

Ito ay kadalasang para sa backward compatibility. Halimbawa, sa mga lumang bersyon ng make the
tanging paraan upang sabihin dito kung paano mag-compile ng anuman .c file sa kaukulang .o ang file ay tulad ng
ito:

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

Ito ay isang masamang paraan upang isulat ang panuntunan. Mas malinaw na gumamit ng GNU-make style
mga panuntunan sa pattern, tulad nito:

%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

unahan
Ang kasalukuyang filename mula sa sugnay na "foreach". Ang mga sugnay na "foreach" ay bihirang ginagamit,
ngunit sila ang pinaka-pangkalahatang layunin na uri ng panuntunan ng pattern na sinusuportahan ng makepp. Para sa
Halimbawa,

#
# Bumuo ng mga .c na file na may isang uri ng isang espesyal na preprocessor:
#
%.c: %.k
$(preprocessor) $(input) > $(output)

#
# I-compile ang mga .c na file sa mga .o na file:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

#
# Espesyal na kahaliling mga flag ng compilation para sa mga .c na file na hinango
# mula sa .k file:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c): foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(input) -o $(output)

Tingnan ang dokumentasyon sa foreach clause sa mga panuntunan para sa higit pang mga detalye at mga halimbawa.

$/ Ito ay mahalagang pare-pareho, alinman sa "/", o sa katutubong Windows "\". Kailangan mo ito, kung
gusto mong magsimula ng isang programa na portable, hal. isa na binuo mo sa kasalukuyang direktoryo:

myoutput:
.$/myprog >$(output)

Para sa mga filename na ipinasa bilang mga argumento, hindi ito kinakailangan dahil kaya ng Windows ang Unix
syntax doon.

Opsyon Variable
Maaari mong itakda ang mga ito sa lahat ng paraan na ipinaliwanag sa itaas (maliban kung iba ang nakasaad) para baguhin
ang bahaviour ng makepp. Bilang default, lahat sila ay hindi natukoy.

MAKEPP_DEBUG
Kung ine-export mo ito nang may tunay na halaga bago tumawag sa makepp, makakakuha ka ng higit pang pag-debug
impormasyon. Ito ang "RULE_SOURCE" ng mga file na binuo habang ito ay may bisa sa ilalim
makeppinfo, mppi at mga detalye tungkol sa pagpapalawak ng variable at pagtutugma ng panuntunan sa ilalim
makepplog, mppl. Ipapakita rin nito sa iyo kung naubusan ng memory o nag-hang ang makepp,
dahil ito ay walang katapusang pagpapalawak ng parehong mga variable:

A = $A # ipinagpaliban ang pagsusuri, kailangan :=
B = $C
C = $B

MAKEPP_LN_CP
Tingnan ang tala sa ilalim ng &ln.

makepp_percent_subdirs
Itakda ito sa ilang totoong halaga (tulad ng 1) upang magkaroon ng "%" sa mga target o dependency na tumutugma
sa higit sa isang direktoryo.

makepp_require_phony
Itakda ito sa ilang totoong halaga (tulad ng 1) upang maiwasan ang implicit na pagiging huwad (ibig sabihin, kung isang panuntunan
nagtagumpay nang hindi nagagawa ang target nito). Ang variable na ito ay dapat na totoo bilang default, sa
maiwasan ang mga sirang chain ng dependency, ngunit masisira nito ang backward compatibility sa
palpak na makefiles.

makepp_signature_C_flat
Ito ay isang opsyon sa lagda C. Itakda ito sa ilang tunay na halaga (tulad ng 1) upang ituring ang iyong
mga pinagmumulan bilang flattened, ibig sabihin, lahat ng mga bagong linya (maliban sa mga pahayag ng preprocessor) ay
itinuturing na parang whitespace at "#line" na mga direktiba ay binabalewala.

makepp_simple_concatenation
Itakda ito sa ilang totoong value (tulad ng 1) para maiwasan ang "rc-style substitution".

perlas
Maaari mong itakda ito sa eksaktong perl na iyong ginagamit upang patakbuhin ang mga script sa makepp
suite, at i-export ito. Makakatulong ito na magpatakbo ng mga sub-script na may parehong perl. Ito ay
kadalasang kapaki-pakinabang para sa test suite, sa pag-install at para sa recursive build.

VPATH
Ang pagtatakda ng variable na ito sa ilang value ay tahasang tinatawag na "vpath % value."

Naitukoy Variable
Paunang tinukoy ng Makepp ang ilang variable, na maaari mong i-override:

AR Default: "ar".

ARFLAGS
Default: "rv".

AS Default: "bilang".

CC Default: Ang unang nakita sa "gcc", "egcc", "pgcc", "c89" o "cc", o sa Windows
bukod pa sa "cl" o "bcc32".

CFLAGS
Default: Kung ang "$(CC)" ay isang GNU compiler na "-g -Wall", kung isa ito sa dalawang Windows
compiler wala, kung hindi "-g".

CURDIR
Ang direktoryo kung saan nakatira ang kasalukuyang Makefile.

CXX Default: Ang unang natagpuan sa "g++", "c++", "pg++", "cxx", "C""C" o "aCC", o sa
Bilang karagdagan, ang Windows ay "cl" o "bcc32".

CXXFLAGS
Default: Kung ang "$(CXX)" ay isang GNU compiler na "-g -Wall", kung isa ito sa dalawang Windows
compiler wala, kung hindi "-g".

F77 Default: Ang unang natagpuan sa "f77", "g77" o "fort77".

FC Default: "$(F77)".

LD Default: "ld".

LEX Default: Ang unang natagpuan sa "lex" o "flex".

LIBTOOL
Default: "libtool".

GAWIN
May dalawang magkaibang value ang variable na ito, depende sa presensya o hindi ng
"--traditional-recursive-make". Kinikilala ng Makepp kung kailan ginagamit ang variable na ito at
pinapatay ang ilang feature, bago pa man aktwal na maganap ang recursion. Ito ay maaaring
hindi kanais-nais habang unti-unti mo itong inaalis, kaya i-convert muna ang mga tawag sa a
makepp specific "$((MAKE))", na hindi mag-o-off ng mga feature. Hindi mo dapat itakda ito
dahil sinisira nito ang aming smart recursion work around.

MAKECMDGOALS
Ang variable na ito ay nakatakda ngunit hindi ginagamit ng makepp. Maaari mo itong i-query para gumawa lamang ng isang bagay kung
isang tiyak na target ang hiniling.

Default: Anuman ang tahasang pag-target na ibinigay ng user (o isang recursive invocation).
Walang laman kapag tahasan ang pagbuo ng default na target.

ifneq $(filter ang espesyal na-target, $(MAKECMDGOALS))
Ang # special-target ay isa sa mga kasalukuyang tahasang target
else ifeq $(MAKECMDGOALS)
# walang tahasang target
endif

MAKEFLAGS (na-export)
Ang mga karaniwang opsyon kung saan tinawag ang makepp. Yung may iisang letra
ang anyo ay pinagsama sa simula nang walang nangunguna na "-" (alam ng langit kung bakit pinili ng gmake
upang i-drop ang "-").

MAKEINFO
Default: "makeinfo".

MAKEPPFLAGS (na-export)
Ito ay nakatakda sa parehong halaga bilang MAKEFLAGS, ngunit kung ang variable na ito ay nasa
kapaligiran ni makepp.

_MAKEPPFLAGS (na-export)
Ang mga partikular na opsyon sa makepp na kailangan para sa POSIX/gmake compatibility, kung saan ang makepp
ay tinawag. Ang mga ito ay nasa isang hiwalay na variable upang hindi masira ang isang legacy na makefile
compatibility sa pamamagitan ng unsetting MAKEFLAGS. Ito ay nakatakda lamang sa
"--traditional-recursive-make".

MAKEPP_VERSION
Ang bersyon ng makepp na ginagamit mo. Kung ito ay isang beta na bersyon, ito ay magkakaroon ng
gitling na sinusundan ng YYMMDD at ilang higit pang panloob na data. Magagamit mo ito para sa "ifdef"
upang itago ang mga partikular na konstruksyon ng makepp mula sa iba pang mga gawa.

Default: Ang parehong halaga na ipinapakita ng "makepp --version"

PWD Isang alyas para sa "CURDIR".

RM Default: "rm -f". Ito ay para sa legacy na Makefiles. Para sa mga bago mas mabuti gamitin
direkta ang builtin &rm command. Kung gusto mong magsulat ng isang huwad na malinis na panuntunan, tingnan
ang "makeppclean -r" na utos sa halip.

Ugat
Ang kamag-anak na landas sa ugat ng iyong build system, ibig sabihin, ang direktoryo sa itaas
na mayroon kang "RootMakeppfile(.mk)". Kung wala kang isa, ang variable na ito ay
walang laman

KABIBI
Ang variable na ito ay iginagalang lamang kung "i-export" mo ito. Sa kasong iyon, ito ay ang Shell
na ginagamit upang magsagawa ng mga hindi-builtin na aksyon na may ilang espesyal na karakter dito (plain
ang mga direktang isinasagawa). Sa Windows Strawberry o ActiveState Perl, kung mayroon ka
isang Unix-like Shell, dapat mong itakda sa halip ang iyong SHELL variable sa isang value na nagtatapos sa "sh"
o "sh.exe" bago tumatawag kay makepp.

Default: Ang unang natagpuan sa "/usr/xpg4/bin/sh" (hal. Solaris) o "/sbin/xpg4/sh"
(hal. Reliant Unix) o "/ Bin / SH".

YACC
Default: Ang unang natagpuan sa "bison -y" o "yacc".

Variable at Perl
Ang mga variable na halaga ay iniimbak bilang mga ordinaryong Perl scalar, kaya maaari mong direktang ma-access ang mga ito mula sa
Perl code kung kailangan mong gumawa ng anumang kumplikadong pagmamanipula sa kanila; tingnan ang makepp_extending
para sa mga detalye.

Ang pag-access sa mga pandaigdigang variable mula sa Perl ay nakakamit sa pamamagitan ng paglalagay ng prefix sa mga ito ng "Mpp::global"
pakete. Sa katunayan anumang variable, hindi pa naroroon sa kasalukuyang makefile, at kung saan ka
italaga sa sa package na ito ay mula noon ay magiging pandaigdigan, na parang kaka-issue mo lang ng
"global" na pahayag para dito.

Gayunpaman, ang direktang pag-access na ito ay madaling kapitan ng error! Maaaring na-override ng user ang mga variable na ito
sa command line o sa pamamagitan ng kapaligiran. Ang ilang iba pang makefile ay na-load bago ito
maaaring ginawa ng isa ang variable na global o target na tiyak. Sa mga kasong ito, hindi mo gagawin
hanapin ang halaga ng variable, o kapag itinalaga ito, maaaring alisin ang ari-arian nito
(katumbas ng isang "override" modifier, maliban sa mga partikular na target.)

Sa direktang pag-access, malalampasan mo rin ang pagpapalawak ng mga variable na ito, kung ang mga ito ay nasa uri
"=" o ";=". Ang mga espesyal na variable tulad ng "$(CC)" ay nagsisimula bilang mga function, hanggang sa maging sila
nakatalaga sa. Kaya sa maraming pagkakataon ay hindi mo makikita ang kanilang halaga.

Para sa mga kadahilanang ito, mas mahusay na hayaan ang makepp na matukoy ang tamang halaga. Maaari mong gamitin ang
"makeperl" na variant, kung saan nasuri ang variable bago makuha ang Perl code
binibigyang kahulugan:

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

Kung kailangan mo ng variable sa makefile perl blocks ito ay makakamit sa pamamagitan ng Perl variable
$makefile tulad ng sumusunod:

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

Palaging nakukuha ng mga function ang makefile object bilang pangalawang argumento na $_[1]:

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

Ang mga utos ay dapat na tinatawag sa loob ng isang pagkilos ng panuntunan, kung saan ang bagay na makefile ay
maa-access sa pamamagitan ng "$Mpp::Subs::rule->{MAKEFILE}":

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

Gumamit ng makepp_variables online gamit ang mga serbisyo ng onworks.net