makepp_statements - Online sa Cloud

PROGRAMA:

NAME

makepp_statements -- Iba't ibang mga pahayag sa isang makefile

DESCRIPTION

A: autoload, B: build_cache,
build_check, D: "tukuyin", E: export, G: pandaigdigan, I: ifdef,
ifeq,
ifmakeperl,
ifndef,
ifneq,
ifnsys,
kung hindi totoo,
ifperl,
ifsys,
kung totoo,
-isama,
isama,
_isama, L: load_makefile, M: gumawa,
makeperl,
makesub, N: "walang_implicit_load", P: perl,
"perl_begin",
prebuild, R: register_command_parser,
register_input_suffix,
register_parser,
imbakan,
runtime, S: lagda,
"sub", V: vpath

Ang pahayag ay anumang linya na nagsisimula sa isang salita na walang ":" dito. (Isang colon
ay nagpapahiwatig na ang linya ay isang panuntunan.) Halimbawa, ito ay mga pahayag:

isama ang extra_rules.mk
load_makefile subdir

Ang Makepp ay may ilang builtin na pahayag na maaaring kailanganin mong gamitin paminsan-minsan.

Tandaan na kahit saan ka makakita ng underscore, maaari ka ring gumamit ng gitling, dahil nagko-convert ang makepp
mga gitling sa mga salungguhit sa mga pangalan ng pahayag.

Mga kalagayan
Ang mga kondisyon ay mga espesyal na pahayag, na kumokontrol kung anong mga linya ng Makeppfile
nakita talaga. Ang pinakasimpleng anyo (kung saan ang "ifxxx" ay kumakatawan sa alinman sa conditional
mga pahayag na nakadokumento sa ibaba) ay:

ifxxx...
mga linyang makikita kung ang pahayag ay nasusuri bilang totoo
endif

o:

ifxxx...
mga linyang makikita kung ang pahayag ay nasusuri bilang totoo
iba
makikita ang mga linya kung ang pahayag ay nasusuri bilang mali
endif

Mayroon ding posibilidad na gumawa ng mga kumplikadong kumbinasyon tulad nito:

ifxxx...
at ifxxx...
at ifxxx...
o kungxxx...
at ifxxx...
mga linyang makikita kung ang pinagsamang mga pahayag ay sinusuri bilang totoo
iba ifxxx...
o kungxxx...
at ifxxx...
makikita ang mga linya kung ang unang kumbinasyon ay nasusuri bilang mali
at ang mga pinagsamang pahayag na ito ay sinusuri bilang totoo
iba
mga linyang makikita kung ang mga pahayag sa itaas ay sinusuri bilang mali
endif

Gaya ng iminungkahi ng indentation, "at" may mas mataas na precedence kaysa "o". Sa ibang salita
an "o" naghahalal sa pagitan ng dalawang grupo ng "at"`s. Maaaring mayroong anumang bilang ng mga "at ifxxx",
"o ifxxx"`s at "else ifxxx"`s.

Ang "ifxxx" na mga conditional na pahayag ay natatangi dahil maaaring mangyari ang mga ito sa gitna ng panuntunan
mga aksyon, tulad ng sa halimbawa sa itaas, nang hindi nakakagambala sa panuntunan.

ifeq string1, string2
ifneq string1, string2
ifeq ($(STR1),$(STR2))
makefile lines kung totoo
iba
makefile lines kung mali
endif

Kung eksaktong magkatugma ang dalawang string (maliban sa nangunguna o sumusunod na whitespace), ang
ginamit ang unang hanay ng mga linya; kung hindi ay ginagamit ang pangalawa. Ang ibang sugnay ay
opsyonal.

Mayroong dalawang iba pang mga katanggap-tanggap na syntax para sa "ifeq" at "ifneq" na mga pahayag:

ifeq string1, string2
ifeq string1 string2

na katumbas. Siyempre maaari mong i-quote ang mga string kung kinakailangan.

"ifeq" at mga kaibigan nito na "ifneq", "ifdef", "ifndef", "ifperl", "ifmakeperl", "ifsys" at
Ang "iftrue" ay pangunahing kapaki-pakinabang kapag kailangan mong bumuo ng isang programa sa ilalim ng maraming iba't ibang
kundisyon Halimbawa,

BUILD_TYPE := debug # "debug" o "produksyon"

ifeq ($(BUILD_TYPE), debug)
CFLAGS := -g
iba
CFLAGS := -O2
endif

programa : *.o
$(CC) $(CFLAGS) $(inputs) -o $(output) $(LIBS)
ifeq ($(BUILD_TYPE), produksyon)
strip $(output)
endif

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

Kung ito ay isang production build, ang lahat ng mga file ay pinagsama-sama sa "-O2" na opsyon sa halip na
ang "-g" na opsyon. Higit pa rito, ang program na "strip" ay pinapatakbo sa resultang binary (sa
kaso nagkataon na nag-link ka sa ilang mga aklatan na naipon sa debug mode).

Minsan mas madaling gamitin ang function na "$(if)" o function na "$(perl)".
sa halip na isang "ifeq" na pahayag.

Kung gusto mo lang makita kung blangko ang isang simbolo o hindi, kailangan mo lang magbigay ng a
iisang argumento, tulad nito:

ifneq $(EXE_SUFFIX)
# kung ano ang gagawin kung ang $(EXE_SUFFIX) ay hindi blangko
endif

ifdef VARIABLE ...
ifndef VARIABLE ...
Gumagana ang mga pahayag na ito nang magkatulad sa mga pahayag na "ifeq" at "ifneq", maliban doon
sinusubok nila kung ang alinman sa mga variable ay tinukoy o hindi ang alinman ay (ibig sabihin wala
tinukoy). Tinutukoy ang isang variable kung:

· Binigyan ito ng value na may assignment kanina sa makefile. Tingnan mo
makepp_variables para sa mga detalye.

· Binigyan ito ng value bilang Perl variable sa isang "perl_begin" block.

· Ang variable ay naroroon sa kapaligiran.

· Ang variable ay naroroon sa command line, hal, para i-invoke ang iyong makefile, ikaw
nag-type

makepp CFLAGS=-O2

Halimbawa,

ifndef CFLAGS
CFLAGS := -g
endif

Sa kasong ito, nakatakda lang ang "CFLAGS" sa "-g" kung hindi pa ito natukoy. Tandaan na
ang pahayag na ito ay maaaring kasing dali lang naisulat gamit ang "?=" assignment, tulad ng
ito:

CFLAGS ?= -g

ifperl perlcode
ifmakeperl perlcode
Gumagana ang mga pahayag na ito nang magkatulad sa mga pahayag na "ifeq" at "ifneq", maliban doon
ang mga pagsusulit ay nasa Perl. Ang unang variant ay plain Perl code, habang ang pangalawang variant
unang ipinapasa ang pahayag sa pamamagitan ng Make-style variable expansion.

BERSYON:= 3.0
Ang # VERSION ay awtomatikong isang Perl variable din:
ifperl $VERSION <= 2
CPPFLAGS := -DNEW
endif
# quotes na kailangan para sa CFLAGS, dahil nakikita lang ni Perl ang halaga:
ifmakeperl aking $$x = '$(CFLAGS)'; $$x =~ /-g/
CFLAGS := -g -O2
endif

ifsys wildcard ...
ifnsys wildcard ...
Sinusuri kung ang kasalukuyang system makepp ay tumatakbo sa tumutugma sa alinman sa mga wildcard o hindi
anumang (ibig sabihin wala).

ifsys i[3-6]86
at ifsys Linux SunOS
... # Isang Intel platform na may Linux o Solaris
else ifnsys sparc power*
... # Ni Sparc o PowerPC
endif

Mayroong hanggang anim na magkakaibang string na maaari mong itugma. Ang aktwal na mga string ay
hindi standardized. Tatlo sa kanila ang sumasalamin kung para saan ang Perl instance ay binuo (hindi
kinakailangang pareho sa kung saan ito tumatakbo), at ang iba ay nagmula sa system at
lahat ay nag-iiba-iba sa anyo. Mahahanap mo ang lahat ng kung ano ang tumutugma sa kasalukuyang platform
pag-type ng sumusunod na command sa Shell:

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

kung totoo pagpapahayag
kung hindi totoo pagpapahayag
Sinusuri kung ang expression ay nagsusuri sa ilang halaga maliban sa zero o ang walang laman na string.

iba multiline Pahayag
Maaaring kontrolin ng mga kondisyon ang isang buong multiline na pahayag, ngunit hindi sila maaaring nasa loob ng naturang a
pahayag.

magtakda
{export|global|override}* tukuyin
tukuyin ang VARIABLE [assignment-operator]
linya ng variable na halaga 1
linya ng variable na halaga 2
endef

Tinutukoy ang halaga ng $(VARIABLE) na lahat ng linya sa pagitan ng "define" na pahayag at ng
"endef" na pahayag. Tingnan ang mga multiline na variable. Ang mga keyword na "export" at "global" ay maaaring
hindi ibibigay ng sabay.

perl_begin
Ito ay kapareho ng "perl", ngunit gamit ang GNU gumawa ng style statement syntax. Ang pahayag na ito
nagpapakilala ng isang bloke ng code na binibigyang kahulugan ng verbatim ng perl. Maaari itong maging kapaki-pakinabang
para sa pagtukoy ng mga function, ngunit magagawa mo ito nang mas maigsi gamit ang "sub" na pahayag.
Ang isang bloke ng Perl code sa iyong makefile ay maaaring maging kapaki-pakinabang upang magsagawa ng mga aksyon na mas madali
sa Perl kaysa sa mga function at panuntunan ng makepp.

Ang natitira sa linya na sumusunod sa "perl_begin" na pahayag ay binabalewala. Lahat ng text
hanggang sa isang linya na nagsisimula sa kaliwang margin na may "perl_end" ay ipinadala sa verbatim sa
perl interpreter. Maaaring walang mga puwang bago ang "perl_end".

Isang halimbawa kung saan ginagamit ko ito ay ang paggawa ng mga direktoryo na maaaring hindi kinakailangan
umiral. Karaniwan sa makefiles na ilagay ang lahat ng .o file sa isang subdirectory (hal., a
direktoryo na may pangalan i386, O sparc, o isang bagay na depende sa uri ng makina).
Ngunit paano kung ang direktoryo ay wala pa? Maaari mong gawing depende ang bawat .o file sa
subdirectory, at maglagay ng panuntunan para buuin ang subdirectory. Pero mas madali lang
na gawin ito:

OBJDIR := $(ARCH) # Kung saan namin inilalagay ang mga .o file.
perl_begin
-d $OBJDIR o mkdir $OBJDIR; # Tiyaking umiiral ang direktoryo.
perl_end

Sa ganitong paraan, sa tuwing tatakbo ang makefile, malilikha ang subdirectory kung gagawin nito
hindi umiiral.

Ang ilang mga operasyon ay mas mahusay na ipinahayag sa mga tuntunin ng mga regular na expression kaysa sa makepp
mga function ng teksto. Halimbawa,

perl_begin
if ($ARCH =~ /^i[56]86/) { # Magagawa mo ito sa: ifsys i[56]86
$CFLAGS = '-O6 -malign-double'; # Sa mga intel machine > 486, doon
Ang # ay isang malaking parusa sa bilis
# para sa mga double na hindi quadword
# nakahanay.
} Iba pa {
$CFLAGS = '-O6';
}
perl_end

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

Maaaring direktang ma-access ang anumang make variable bilang isang Perl scalar. Sa kasong ito, itinakda namin
ang halaga ng "CFLAGS" na naiiba batay sa isang regular na expression na tugma sa
mga bandila ng arkitektura.

Bilang huling halimbawa, ang ilang piraso ng impormasyon ay mas madaling ma-access nang direkta mula sa Perl
kaysa sa makepp. Halimbawa, maa-access mo ang lahat ng impormasyon sa pagsasaayos
na alam ng perl tungkol sa iyong system, kabilang ang kung paano bumuo ng mga shared library, atbp.
(I-type ang "perldoc Config" kung gusto mong makita kung anong impormasyon sa pagsasaayos ang mayroon si Perl
magagamit.)

perl_begin

gumamit ng Config;

$ARCH = $Config{'archname'}; # Gumamit ng kaalaman ni perl sa arkitektura.
$CC = $Config{'cc'}; # Gamitin ang parehong C compiler gaya ng ginawa ni Perl.
$SHARED_OBJ_CFLAGS = $Config{'cccdlflags'};
# Mga flag na kailangan upang mag-compile ng mga bagay na gagawin
# pumunta sa isang shared library.
$SHARED_OBJ_LDFLAGS = $Config{'ccdlflags'} . " " . $Config{'lddlflags'};
# Linker na nag-flag para gumawa ng shared library.
$SHARED_CC_LINK = $Config{'ld'}; # Command na gumawa ng mga shared library.

$SHARED_EXTENSION = $Config{'dlext'}; # Extension ng mga shared library.
perl_end

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

libmylib.$(DLEXT): *.o
$(SHARED_CC_LINK) $(inputs) -o $(output) $(SHARED_OBJ_LDFLAGS)

Tandaan kung paano namin tinukoy ang isang grupo ng mga variable sa Perl block, at pagkatapos ay ginagamit namin ang mga ito
pagkatapos sa natitirang bahagi ng makefile. Maaari mong gamitin ang buong kapangyarihan ng perl
interpreter upang itakda ang iyong mga variable sa arbitraryong kumplikadong mga paraan. Maaari mong patakbuhin ang shell
mga utos mula sa iyong Perl code, i-access ang isang database, o anumang gusto mo.

perlas perlcode
makeperl perlcode
Ito ay kapareho ng "perl_begin", ngunit gumagamit ng Perl-style braces. Ang unang variant ay
plain Perl code, habang ang pangalawang variant ay unang ipinapasa ang pahayag sa pamamagitan ng Make-
pagpapalawak ng variable ng estilo. Tandaan na ang kahirapan ng pag-parse ng mga braces ni Perl ay may lead
sa sumusunod na simpleng heuristic:

· Kung ang isang double opening brace ay matatagpuan sa pareho o susunod na linya, isang double closing
wawakasan ng brace ang block. Ito ay dapat sa simula ng isang linya, ngunit maaaring
pinangungunahan ng whitespace.

· Kung hindi, kung ang closing brace ay nasa pinakadulo ng "perl" na linya ito ay isa
liner

· Kung hindi, ang closing brace ay dapat nasa pinakadulo simula ng isang sumusunod na linya,
ibig sabihin, walang nangungunang whitespace.

Para sa isang mahusay na paraan upang tawagan ang mga script ng Perl, tingnan ang "run". Hindi tulad ng "$(perl)" function,
binabalewala ang return value ng block na ito.

perl { print "ipinasa ang puntong ito sa makefile\n" }

perlas
{
print "at ito rin\n";
}

ifdef MAIINGAY
perl {{
i-print ang "pati na rin ang isang ito\n"
}}
endif

Maaari mong gamitin ang Perl debugger para sa iyong naka-embed na code, sa pamamagitan ng pagpapatakbo mismo ng makepp sa
debugger, kung saan ... ang mga argumento, kung mayroon man, karaniwan mong ipinapasa:

perl -d -S mpp ...

Mahirap magtakda ng mga breakpoint sa Perl code na hindi pa na-load. Maaari kang magtrabaho
sa paligid nito sa pamamagitan ng paglalagay ng linyang ito sa iyong naka-embed na Perl, bago kung saan mo gusto
Baliin:

$DB::single = 1;

Pagkatapos ay maaari mong i-type ang "c" sa prompt ng debugger, upang magpatuloy hanggang sa puntong iyon.

sub
makesub
Ang pahayag na ito ay nagbibigay ng paraan upang tukuyin ang isang Perl subroutine sa loob ng iyong makefile. Ang
ang unang variant ay plain Perl code, habang ang pangalawang variant ay unang pumasa sa statement
sa pamamagitan ng Make-style variable expansion. Ang syntax ay kapareho ng sa Perl
sub statement, maliban na ang mga prototype ay walang kahulugan.

Para sa tatlong posibilidad ng paglalagay ng braces ng katawan, tingnan ang paliwanag sa
ang "perl" na pahayag.

Ang isang subroutine ng Perl ay ginagamit sa tuwing makikita ang isang pahayag, o kapag may isang expression na gusto
"$(pangalan salita)" ay makikita. Halimbawa, ipagpalagay na sa ilang kadahilanan kailangan mong mag-load
ang mga nilalaman ng isang file sa isang make variable. (Maaari mong gawin ito sa pamamagitan ng pagsasabi
"$(shell cat filename)" ngunit posible itong gawin nang hindi kailanman ginagamit ang shell.)
Magagawa ito sa pamamagitan ng paglalagay ng sumusunod sa iyong makefile:

sub f_file_contents {
aking ($file) = @_; # Pangalanan ang argumento.
buksan ang aking $fh, $file o mamatay "$file: $!\n";
lokal na $/ = undef; # Slurp file sa isang pagbasa.
<$fh>;
}

ifdef NEWSUB
makesub f_VAR2
{{
$(VAR) * 2;
}}
endif

makesub f_VAR1 { $(VAR) + 1 }

Ngayon, sa tinukoy na function na ito, maaari kang magsulat

X = $(file_contents filename) # katumbas ng builtin na $(&cat filename)

at ang variable na "$(X)" ay kukuha ng mga nilalaman ng ibinigay na file sa tuwing makukuha ito
pinalawak. Gamitin ang ":=" para gawin ito nang eksaktong isang beses, o ";=" para gawin ito nang hindi hihigit sa isang beses.

Tingnan ang makepp_extending para sa higit pang mga detalye at halimbawa.

Simple Pahayag
autoload filename ...
Tinutukoy ang isa o higit pang mga makefile na ilo-load kung sakaling subukang maghanap ng panuntunan para sa isang file
kung hindi man ay nabigo ang direktoryo na ito. Ito ay kapaki-pakinabang kapag ang makefile ay may mga panuntunan kung saan
ang mga kahulugan ay nakasalalay (maaaring hindi direkta) sa isang file sa isa pang direktoryo na nakasalalay
(maaaring hindi direkta) sa iba pang mga file sa direktoryo na ito (na binuo ng mga panuntunan na ginagawa hindi
depende sa file sa ibang direktoryo).

Halimbawa, ang iyong Makeppfile maaaring ganito ang hitsura:

rules-to-build-files-that-otherdir/x-depends-on

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

autoload more_rules.makeppfile

Tandaan na hindi namin mapagkakatiwalaang palitan ang "autoload" ng "isama" dito, dahil kung
isang bagay maliban sa panuntunan para sa more_rules.makeppfile sinusubukang magtayo otherdir/x
una, pagkatapos more_rules.makeppfile malamang mabibigo dahil otherdir/x hindi iiral
gayon pa man, dahil mayroon nang pagtatangka na itayo ito kung kailan Makeppfile is
tahasang na-load sa ngalan nito.

BABALA: Maging maingat sa paggawa ng mga bagay sa isang autoloaded makefile na nagbabago sa
pag-uugali ng mga panuntunan sa iba pang (mga) makefile ng direktoryo, dahil ito ang magiging sanhi nito
pag-uugali na nakasalalay sa kung ang ilang dating binuo na target ay nagdulot ng mga makefile
ma-autoload.

build_cache /path/to/build/cache
[global] build_cache /path/to/build/cache
Tinutukoy ang isang path sa isang build cache. Tingnan ang makepp_build_cache para sa mga detalye. Ang build
ang cache ay dapat na mayroon na; tingnan ang "Paano pamahalaan ang isang build cache" sa makepp_build_cache para sa
kung paano gawin ito sa unang lugar. Ang isang "build_cache" na pahayag sa isang makefile ay na-override
ang "--build-cache" na opsyon sa command line para sa mga panuntunan sa makefile, ngunit maaaring ito ay
na-override ng ":build_cache" na modifier ng panuntunan sa bawat panuntunan.

Ang keyword na "global" ay maaaring mauna sa pahayag na ito na may parehong epekto sa command
line na opsyon, ibig sabihin, ang build cache ay nalalapat sa bawat makefile. Ito dapat ang pinakamahusay
ibinigay sa a RootMakeppfile upang matiyak na ito ay nakikita nang maaga.

Tukuyin ang "wala" sa halip na isang path sa isang direktoryo kung gusto mong i-disable ang build cache
para sa lahat ng panuntunan sa makefile na ito.

build_check build_check_method
[global] build_check build_check_method
Tinutukoy ang default na paraan ng pagsusuri ng build para sa lahat ng mga panuntunan sa makefile na ito. Tingnan mo
makepp_build_check para sa mga detalye. Ino-override ng statement na "build_check" ang
"--build-check-method" na opsyon sa command line para sa lahat ng panuntunan sa makefile, ngunit maaaring
na-override ng ":build_check" modifier sa batayan ng bawat panuntunan.

Ang keyword na "global" ay maaaring mauna sa pahayag na ito na may parehong epekto sa command
line na opsyon, ibig sabihin, ang build check method ay nalalapat sa bawat makefile na hindi
tukuyin ang sarili nito. Pinakamabuting ibigay ito sa a RootMakeppfile para makasigurado
nakita nang maaga.

Tukuyin ang "build_check default" sa halip na isang pangalan kung gusto mong bumalik sa default.
Sa keyword na "global" ang ibig sabihin nito ay ang "exact_match" na paraan, kung hindi, ibinabalik nito ang
kasalukuyang makefile sa hindi pagkakaroon ng sarili nitong partikular na pamamaraan.

i-export Var ...
i-export trabaho
i-export ang PATH := $(PWD):$(PATH)

Minarkahan ang ibinigay na mga variable para sa pag-export sa mga subprocess. Tingnan ang mga variable ng setting.

global Var ...
global trabaho
global MYPROJECT.INFO = impormasyon na makikita sa lahat ng makefiles

Minamarkahan ang mga ibinigay na variable bilang global sa lahat ng makefiles. Tingnan ang mga variable ng setting.

isama makefile
Ipinapasok nito ang mga nilalaman ng isa pang makefile sa kasalukuyang makefile. Maaari itong maging
kapaki-pakinabang kung mayroon kang mga file ng boilerplate na may ilang mga panuntunan o variable, at bawat isa
ang direktoryo ay kailangan lamang gumawa ng ilang mga pagbabago. Ginamit din ang "isama" na pahayag
na karaniwang ginagamit sa mga tradisyonal na gawa kasabay ng awtomatikong pagsasama ng file
scanner, ngunit hindi na ito kailangan sa makepp.

Isinasaalang-alang muna ng "isama" ang kasalukuyang direktoryo, pagkatapos ay ang magulang ng kasalukuyang
direktoryo, pagkatapos ang magulang nito, atbp. Huminto ito sa pagsasaalang-alang sa mga direktoryo kapag naabot nito ang
ugat ng file system o kapag nagbago ang file system device ID. (Ibig sabihin nito
hindi ito makakahanap ng mga file na matatagpuan sa iba pang mga mount ng NFS. Ito ay upang maiwasan ang mga problema sa
network file system o automounters at mga patay na server.) Kung wala itong mahanap na file ng
ang ibinigay na pangalan sa oras na huminto ang paghahanap nito, pagkatapos ay tumingin ito sa data ng makepp
direktoryo (/usr/local/share/makepp kung nag-install ka ng makepp / usr / lokal) para sa isa sa
ang isama ang mga file na kasama ng makepp.

Kung gusto mong magsama ng template file sa bawat makefile sa isang buong direktoryo
hierarchy, maaari mong ilagay ang iyong makefile template sa tuktok na direktoryo. Ang makefiles
hindi kailangang malaman nang eksakto kung nasaan sila sa hierarchy; maaaring maglaman ang bawat makefile
isang linya tulad nito:

isama ang standard_definitions.mk

sa halip na isang bagay na mas kumplikado, tulad nito:

isama ang ../../../standard_definitions.mk # Ito ba ang tamang bilang ng ..?

Maaari mong tukuyin ang maraming mga file hangga't gusto mo, at pinapayagan ang mga variable:

isama ang file1 file2 file3 $(other_include_files)

Kung gumagawa ka ng isang build na kailangang gumana sa parehong GNU make at makepp,
minsan maginhawang magkaroon ng eksaktong magkaparehong mga makefile ngunit ibang kasama
file. Halimbawa, ang lahat ng iyong makefile ay maaaring maglaman ng linyang tulad nito:

isama ang $(TOPDIR)/standard_rules.mk

at gusto mo standard_rules.mk upang maging iba para sa GNU make at makepp. Para mapadali
ito, ang "isama" na pahayag una naghahanap ng file na may suffix ng .makepp bago
hinahanap ang file na iyong hiniling. Sa kasong ito, maghahanap muna ito ng file
tinatawag standard_rules.mk.makepp, at kung mayroon iyon, ilo-load ito sa halip na
standard_rules.mk. Sa ganitong paraan, kapag pinatakbo mo ang makefile gamit ang GNU make, naglo-load ito
standard_rules.mk, ngunit sa makepp, naglo-load ito standard_rules.mk.makepp.

Dahil maraming legacy na file ang naglalagay ng panuntunan upang bumuo ng isang kasamang file pagkatapos ng pagsasama
pahayag, ipagpapaliban ng makepp ang mga pagpapasya tungkol sa hindi umiiral o lipas na kasama hanggang sa katapusan
ng makefile loading. Iyon ay, maliban kung ito ay tinatawag na "--rm-stale". Para kasing marami
beses habang bumuti ang sitwasyon noon (dahil may lumabas na panuntunan) makepp will
i-reload ang makefile, na maaaring muling magpakita ng higit pang mga naturang panuntunan. Ito ay malinaw naman
isang hindi mahusay na paraan upang mag-load ng mga makefile, kaya subukang iwasan iyon. Mas masahol pa, kung ang iyong makefile
Ang paglo-load ay may mga side-effects (tulad ng pagdaragdag sa isang global variable o isang linya tulad ng
"do_it_now := $(shell cat a >>b)" o ang katumbas nitong makepp na "&cat a -o>>b") ay gagawin nila
mangyari nang maraming beses na kailangang i-load ang makefile, kaya, muli, subukang iwasan iyon!

_isama makefile
-isama makefile
Ang isang minor na variant sa "include", ang "_include" na statement ay kinabibilangan ng file kung mayroon ito
ngunit hindi gumagawa ng nakamamatay na error kung hindi. Ang "_include" na pahayag dati
maging mahalaga para isama ang pag-scan ng file gamit ang GNU make, ngunit hindi gaanong kapaki-pakinabang para sa makepp.

load_makefile /some/directory/somewhere/Makefile
load_makefile subdir
load_makefile VAR1=halaga1 VAR2=halaga2 subdir
Ang pahayag na ito ay nagiging sanhi ng makepp sa cd sa direktoryo na naglalaman ng makefile at pag-load
ang mga panuntunan nito sa panloob na database ng makepp. Kung tinukoy mo lamang ang isang direktoryo sa halip na
Ang isang makefile, "load_makefile" ay naghahanap para sa "Makeppfile", "makefile", o "Makefile" doon
direktoryo.

Anumang mga variable na iyong tinukoy na may syntax na "VAR=value" (o "VAR="value1 value2"") ay
ipinasa sa mga na-load na makefile. Ino-override nila ang anumang mga setting sa mga makefile na iyon, basta
na parang nai-type mo ang mga ito sa command line.

Ang paggamit ng "load_makefile" ay iba sa command

isama ang dir/makefile

sa dalawang paraan. Una, ang "load_makefile" ay hindi naglilipat ng anumang mga variable mula sa itaas-
level makefile sa subordinate makefile; bawat makefile ay umiiral sa sarili nitong
namespace. Ang subordinate makefile ay hindi makakaimpluwensya sa mga variable sa pinakamataas na antas
makefile sa anumang paraan.

Pangalawa, ang bawat build command ay naka-tag sa direktoryo ng makefile na ito ay dumating
mula sa. Kapag ang makepp ay nagsagawa ng isang panuntunan mula sa ibang makefile, ito ay unang cd sa
direktoryo na naglalaman ng makefile na iyon bago isagawa ang utos. Makefiles na
nakikita na may "isama" na pahayag ay aktwal na itinuturing bilang bahagi ng makefile na
isinama sila, at samakatuwid ang kanilang mga panuntunan ay hindi na-tag ng ibang direktoryo.

Karaniwang hindi mo kailangang mag-load ng makefile nang tahasan, maliban kung mayroon itong hindi pangkaraniwang pangalan,
o mayroon itong mga target na hindi nakapaloob sa parehong direktoryo ng makefile
mismo, o hindi mo pinagana ang implicit na pag-load ng makefile. Bilang default, kung ang makepp ay
sinusubukang bumuo ng isang file at walang panuntunan upang buuin ito, o kung ito ay sinusuri ang a
wildcarded filename sa isang direktoryo, awtomatiko itong susubukang mag-load ng makefile
mula sa direktoryo na iyon. Tingnan ang "Mga tip para sa maraming direktoryo" sa makepp_cookbook para sa impormasyon
sa pagbuo na may maraming direktoryo.

Hindi mo maaaring gamitin ang "load_makefile" upang mag-load ng ilang makefile na nalalapat sa pareho
direktoryo. Gamitin ang "isama" para sa ilang piraso ng makefile na nalalapat sa pareho
direktoryo, at "load_makefile" para sa mga makefile na nalalapat sa iba't ibang mga direktoryo.

walang_implicit_load
Ino-off ng pahayag na ito ang implicit na pag-load ng mga makefile mula sa isang set ng mga direktoryo.
Maaari itong maging kapaki-pakinabang kung gusto mong awtomatikong mag-load ng mga makefile mula sa karamihan ng mga direktoryo,
ngunit may ilang mga direktoryo na para sa iba't ibang mga kadahilanan ay hindi mo gustong makepp
subukang mag-update. (Hal, marahil ang direktoryo ay may makefile para sa ilang iba pang bersyon
ng make na hindi maintindihan ni makepp.) Halimbawa,

walang_implicit_load dir1 dir2/*

I-o-off ng statement sa itaas ang implicit loading para sa mga makefile sa "dir1" at lahat of
nito mga subdirectory. Ito ay magkakaroon din ng implicit makefile loading para sa lahat
mga subdirectory ng "dir2" (at lahat ng kanilang mga subdirectory), ngunit hindi para sa "dir2" mismo.

Maaari kang gumamit ng mga wildcard sa pahayag. Mga file na hindi direktoryo na tumutugma sa wildcard
ay hindi pinapansin. Maaari ka ring gumamit ng mga function upang higit pang tukuyin ang mga direktoryo na ikaw
ay interesado sa, hal,

walang_implicit_load $(filter-out dir1 dir2, *)

ay i-off ang implicit loading para sa lahat ng mga subdirectory maliban ikaw1 at ikaw2 at ang kanilang mga
mga subdirectory.

prebuild target
gumawa target
Ang mga argumento (na sumasailalim sa Make-style variable expansion) ay binuo kaagad.
Ito ay kapaki-pakinabang kapag ang listahan ng mga target na maaaring buuin ng Makefile ay depende sa a
nabuong file sa ibang direktoryo.

Sa kasalukuyan, tahimik itong mabibigo sa pagbuo ng mga target kung mayroong dependency loop sa pagitan
ang mga prebuilt na target at ang Makefiles na dapat i-load para mabuo ang mga ito, ngunit iyon
ay dapat ituring bilang isang pagkakamali.

register_command_parser command_word pares
register_parser command_word pares
Kapag sinusuri sa leksikal na paraan ang mga pagkilos ng panuntunan, gamitin pares para command_word, na maaaring ang
buong path o basename lang. Ang basename ay kadalasang sapat dahil ang lexer
sinusubukan pareho.

Ang pares maaaring isang classname na mayroon o walang nangunguna
"Mpp::CommandParser::". Ang nasabing klase ay dapat magkaroon ng function ng miyembro na tinatawag na "pabrika"
na nagbabalik ng isang bagay ng klase na iyon. Kung ang classname ay naglalaman ng mga tutuldok, ito ay dapat
sinipi, upang hindi gawing isang panuntunan ang linyang ito.

O, dahil ang klase na iyon ay karaniwang hindi pa na-load, sa halip ay maaaring ang factory function
naninirahan sa namespace ng Makefile. Ang mga function na ito ay may prefix ng "p_" na dapat
hindi ibibigay. Ito ang kaso ng mga builtin na parser.

Ang epekto ay maihahambing sa ": parser" na opsyon sa panuntunan. Ngunit para sa multi-command rules
ito ang mas magandang paraan.

register_input_suffix command_word suffix ...
Magdagdag ng "suffix" ... sa listahan ng mga input file suffix na kinikilala kapag may aksyon
na nagsisimula sa "command_word" ay na-parse. Karaniwang kukunin ito ng parser sa pamamagitan ng
Mpp::CommandParser::input_filename_regexp, ngunit maaaring balewalain ito nang buo.

Hindi karaniwang kinukuha ng mga parser ang lahat ng argumento na hindi kinikilala bilang mga opsyon,
dahil maaaring ang mga ito ay mga argumento ng hindi nakikilalang mga opsyon. (Halimbawa, i386v is hindi
isang input file ng command na "gcc -b i386v foo.c".) Sa halip, kinukuha lang nila
mga positional na argumento na mukhang mga input filename.

Karaniwang gumamit ng mga karaniwang tool na may mga hindi karaniwang suffix na tukoy sa site
upang ipahiwatig na ang mga file na iyon ay nangangailangan ng espesyal na paghawak, tulad ng ibang utos
mga opsyon at/o mga hakbang sa postprocessing. Halimbawa:

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

repositoryo direktoryo
repositoryo destdir=srcdir
Tinutukoy ang isa o higit pang mga direktoryo ng repositoryo. Ang unang imbakan na tinukoy ay may
nangunguna sa iba kung ang parehong file ay umiiral sa maraming mga repositoryo at doon
ay walang build command para dito. Tingnan ang makepp_repositories para sa higit pang mga detalye tungkol sa
repositoriya.

Kung tumukoy ka lamang ng isang direktoryo pagkatapos ng "imbakan", ang mga nilalaman nito ay naka-link sa
kasalukuyang direktoryo. Maaari mong i-link ang mga nilalaman nito sa anumang arbitrary na lugar sa file
system sa pamamagitan ng pagtukoy sa lokasyon bago ang isang katumbas na tanda, hal,

repositoryo subdir1/subdir2=/users/joe/joes_nifty_library

Dapat mong ilagay ang repositoryong pahayag malapit sa tuktok ng iyong makefile, bago ang anuman
mga tuntunin na maaaring kailanganing gamitin ito.

runtime programa, aklatan
I-store ang "library" bilang isang runtime dependency ng "program". Parehong "programa" at "library"
maaaring maglaman ng maraming salita, kung saan ang bawat salita sa "aklatan" ay nakaimbak bilang a
runtime dependency ng bawat salita sa "program". Kapag ang "program" ay awtomatikong idinagdag
bilang executable dependency ng isang command ng base class na "Mpp::CommandParser", ang
Ang mga dependency ng runtime (kung mayroon man) ay idinagdag din. Upang mangyari ito,
Dapat na tukuyin ang "program" sa panuntunang may bahagi ng direktoryo, at walang anuman
mga character ng shell meta. Ang layunin ng pahayag na ito ay upang makuha ang mga dependency sa
mga aklatan at iba pang mga executable na kadalasang nilo-load ng program, nang hindi nagkakaroon
upang tahasang tukuyin ang mga ito bilang mga dependency ng bawat panuntunan na humihiling ng "program", o sa
i-scan ang "program" upang matukoy ang mga dependency na iyon (na maaaring maging prohibitively
mahirap.)

Ang mga dependency ng runtime ay binabagtas nang pabalik-balik, kaya kung ang "a" ay may runtime dependency sa
Ang "b" at "b" ay may runtime dependency sa "c", kung gayon ang anumang panuntunan na gumagamit ng "./a" ay magkakaroon ng
implicit dependencies sa parehong "b" at "c" (maliban kung ito ay gumagamit ng isang espesyal na
"Mpp::CommandParser" na klase na nag-o-override sa gawi na ito).

Tandaan na ang mga nawawalang dependency ay hindi kinakailangang idagdag pagkatapos mong idagdag ang pahayag na ito
sa isang makefile, maliban kung muling na-scan ang panuntunan. Gamitin ang command line na "--force-rescan".
opsyon upang matiyak na mangyayari ito.

lagda pangalan
[global] [override] lagda pangalan
lagda md5
lagda C
lagda c_compilation_md5
lagda xml
lagda xml-space
default ng lagda

Itinatakda ang paraan ng lagda para sa lahat ng mga panuntunan na sumusunod sa "pirma" na pahayag, kung saan
walang command parser ang pumipili ng paraan. Maaari mong i-override ito para sa mga indibidwal na panuntunan gamit ang
ang ":signature" na modifier ng panuntunan.

Kung idinagdag mo ang keyword na "override", ang paraang ito ay mag-o-override kahit na ang pagpipilian
ginawa ng mga command parser, ngunit hindi ang mga tinukoy na may ":signature" rule modifier.
Kung idinagdag mo ang keyword na "global", ang epekto ay nalalapat sa lahat ng mga panuntunang babasahin pa,
maliban kung ang kanilang makefile ay mayroon ding sariling "pirma" na pahayag. Ito ay katumbas ng
ang "--signature" command line na opsyon kung ibinigay bago basahin ang anumang panuntunan, hal sa a
RootMakeppfile upang matiyak na ito ay nakikita nang maaga. Gayundin ang mga keyword na "global
override" para sa pahayag na ito ay katumbas ng "--override-signature" command line
pagpipilian.

Tukuyin ang "signature default" sa halip na isang pangalan kung gusto mong bumalik sa default.
Gamit ang keyword na "global" nangangahulugan ito ng simpleng oras ng pagbabago at laki ng file
paraan. Kung hindi, ibabalik nito ang kasalukuyang makefile sa hindi pagkakaroon ng sarili nitong partikular na pamamaraan,
gamit ang isang pandaigdigang pamamaraan kung ang isa ay itinakda.

Para sa higit pang impormasyon tungkol sa mga pamamaraan ng lagda, tingnan ang makepp_signatures.

vpath huwaran direktoryo ...
Kunin ang lahat ng mga file na tumutugma sa pattern mula sa bawat ibinigay na direktoryo. Maaaring naglalaman ang pattern sa
karamihan sa isang "%" wildcard. Ginagamit nito ang transparent na mekanismo ng repositoryo (hindi tulad ng gmake
na muling nagsusulat ng mga filename), ngunit hindi ito umuulit sa mga subdirectory.

Command
Ang lahat ng builtin at self-determined command (tingnan ang builtin commands at pagpapalawak ng makepp), pati na rin
dahil ang mga panlabas na malinis na naka-program na Perl script ay maaaring gamitin tulad ng mga pahayag. Sa kasong ito
naiiba sila sa mga pagkilos ng panuntunan dahil tumatakbo ang mga ito sa parehong proseso tulad ng makepp at anumang input
o ang mga output file ay hindi nabanggit bilang mga dependency o bilang na binuo ng makepp.

Tulad ng lahat ng mga pahayag, ang mga ito ay itinuturing na ganoon, kung ang mga ito ay naka-indent na mas mababa kaysa sa
mga aksyon ng nakaraang tuntunin, kung mayroon man.

Ito ay maaaring gamitin para sa mga mensahe upang maging output habang binabasa ang makefile:

&echo Ang halaga ng $$(VAR) ay $(VAR)

O sa halip na gumawa ng maraming panuntunan na ang bawat isa ay nakadepende sa isang panuntunan sa paggawa ng direktoryo, maaari mo nang simple
likhain ito nang mabilis. Tandaan na ang mga utos na lumilikha ng mga file ay muling pinoproseso bawat
oras na nabasa ang makefile., Kaya naman pinoprotektahan namin ang isang ito gamit ang isang pagsubok -- bagaman dito
espesyal na kaso na hindi kinakailangan, dahil ang utos na ito ay hindi makakasama kapag paulit-ulit:

ifperl !-d 'isama'
&mkdir -p isama ang # Lumikha lamang kung wala
endif

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