makepp_functions - Online sa Cloud

PROGRAMA:

NAME

makepp_functions -- Mga function sa makepp

DESCRIPTION

A: absolute_filename,
absolute_filename_nolink,
abspath,
addprefix,
addsuffix,
at, B: basename, C: tumawag, D: ay,
dir_noslash, E: pagkakamali, F: filesubst,
salain,
filter_out,
filter_out_dirs,
findfile,
find_first_upwards,
find_program,
findstring,
find_upwards,
first_available,
unang salita,
foreach, I: kung,
kung totoo,
infer_linker,
infer_objects,
impormasyon, J: sumali, M: gumawa,
makemap,
makeperl,
mapa,
"mktemp", N: notdir, O: only_generated,
only_nontargets,
only_phony_targets,
only_stale,
only_targets,
o,
pinanggalingan, P: pasubst,
perl,
huwad,
prebuild,
i-print, R: realpath,
relative_filename,
may kaugnayan sa, S: shell,
pag-uuri,
guhitan,
subst,
panlapi, T: pansamantala, W: babala,
wildcard,
salita,
listahan ng salita,
salita, X: xargs

Anumang expression ng format na "$(name)", kung saan ang "name" ay hindi pangalan ng isang variable, o
Ang "$(pangalan arg1 arg2 arg3)" ay binibigyang kahulugan bilang isang function na tawag. Ang pangalan ay maaaring naglalaman ng mga titik,
mga salungguhit, o mga gitling; upang maiwasan ang pagkalito, maaari kang gumamit ng mga gitling o salungguhit
salitan, dahil ang mga panloob na gitling ay ginagawang mga salungguhit. Pagsusuri ng ganyan
ang isang expression ay nagpapatawag lamang ng isang subroutine ng Perl. Kung ang "pangalan" ay pinangungunahan ng "&" pinapatakbo nito ang
builtin command o script ng pangalang iyon sa loob ng proseso ng makepp, at ibinabalik ang pamantayan
output. Ito ay nangangailangan ng perl na mabuo para sa PerlIO. Kung ang pangalan ay hindi pinangalanan ang isang function
ito ay binago sa isang panawagan ng tawag.

Tulad ng mga variable mayroon kang pagpipilian ng "$(pangalan ...)" o "${pangalan ...}". Kung gusto mo
i-embed ang parehong panaklong, dapat itong ipares, ang isa ay hindi mahalaga: "$(name
...(){..." o "${name ...{}(...}". (Gayunpaman para sa mapa at perl ang unang pagsasara ng paren ay nagtatapos
ang expression.) Ang pagdodoble ay nagbibigay-daan sa mga argumento na sumasaklaw sa ilang linya. Ang mga bagong linya ay
pagkatapos ay itinuturing bilang mga puwang, maliban sa marahil sa "tukuyin". Mayroon ding syntax na "$[name ...]"
o $[[pangalan ...]], na sinusuri habang binabasa ang makefile, bago ang mga panuntunan sa grokking
at iba pang mga konstruksyon.

Ang Makepp ay may ilang builtin na function na maaaring maging kapaki-pakinabang. Sinusuportahan nito ang halos lahat ng
Tekstuwal na function ng GNU make (tingnan ang dokumentasyon ng GNU make para sa mga detalye), at ilan sa mga ito
sariling. Maaari mong tukuyin ang mga subroutine ng Perl upang gawin ang anumang gusto mo. Tingnan ang "sub" na pahayag
at ang seksyon sa pagpapalawak ng makepp para sa higit pang mga detalye.

kondisyonal Pag-andar
at kundisyon1[,kondisyon2[,kondisyon3...]]
Ang at function ay nagbibigay ng "short-circuiting" AT operasyon. Ang bawat argumento ay
pinalawak, sa pagkakasunud-sunod. Kung ang isang argumento ay lumawak sa isang walang laman na string ang pagproseso ay hihinto at
ang resulta ng pagpapalawak ay ang walang laman na string. Kung ang lahat ng mga argumento ay lumawak sa isang hindi-
walang laman na string kung gayon ang resulta ng pagpapalawak ay ang pagpapalawak ng huling argumento.

if string, resulta-kung-string-hindi-blangko[, resulta-kung-string-blangko]
kung totoo string, resulta-if-string-true[, resulta-kung-string-false]
Isang kahalili sa "ifeq", atbp., mga pahayag. Kung ang string ay hindi blangko (ibig sabihin, ang
kondisyon ay totoo), ang pangalawang argumento (ang "pagkatapos" sugnay) ay ibinalik (pagkatapos
variable na pagpapalawak); kung ang string ay blangko, ang ikatlong argumento (ang "iba" na sugnay) ay
bumalik.

Halimbawa,

CFLAGS := $(if $(filter gcc egcc, $(CC)), -g -Wall, -g)

tinutukoy ang CFLAGS na "-g -Wall" kung ang variable na CC ay alinman sa "gcc" o "egcc", at "-g"
kung hindi. (Ito ang ginagawa ng mga default na panuntunan sa pagbuo.)

Ang "iftrue" ay katulad ng "if", maliban na ang string 0 ay itinuturing na blangko.

or kundisyon1[,kondisyon2[,kondisyon3...]]
Ang or function ay nagbibigay ng "short-circuiting" OR operation. Ang bawat argumento ay pinalawak,
sa ayos. Kung ang isang argumento ay lumawak sa isang hindi walang laman na string ang pagpoproseso ay hihinto at ang
resulta ng pagpapalawak ay ang string na iyon. Kung, pagkatapos ng lahat ng mga argumento ay pinalawak, lahat ng
ang mga ito ay mali (walang laman), kung gayon ang resulta ng pagpapalawak ay ang walang laman na string.

talaksan at Filename Pag-andar
absolute_filename file
abspath file
Kino-convert ang mga kamag-anak na filename sa ganap na wala . or ... Halimbawa,
Maaaring ibalik ng "$(absolute_filename xyz.c)" ang "/usr/src/our_project/subdir/xyz.c".

absolute_filename_nolink file
realpath file
Tulad ng absolute_filename, ngunit tinitiyak na naresolba ang mga simbolikong link.

basename mga filename
Ang basename ay ang buong pangalan ng file (kasama ang direktoryo), minus ang teksto pagkatapos at
kabilang ang huling yugto. Hal, "$(basename myfile/version-1.0-module.c)" ay
"myfile/version-1.0-module"

dir mga filename
Kinukuha ang bahagi ng direktoryo ng bawat file sa listahan ng filename, kasama ang trailing
slash. Ibinabalik ang "./" kung walang direktoryo sa filename.

dir_noslash filename
Kapareho ng "$(dir )" maliban na hindi nito ibinabalik ang trailing slash.

filesubst pattern, kapalit, mga salita
Magsagawa ng pagpapalit ng pattern sa mga pangalan ng file. Ito ay naiiba sa pasubst sa iyon
ito ay gagana nang tama kapag ang mga kahaliling pangalan para sa mga direktoryo ay ibinigay (hangga't
nauuna ang mga ito sa tandang porsyento). Halimbawa,

$(filesubst ./src/%.c, %.o, $(wildcard src/*.c))

gagana sa filesubst ngunit hindi sa pasubst.

filter_out_dirs mga filename
Ibinabalik ang lahat ng mga filename na hindi tumutukoy sa mga direktoryo.

findfile filename, landas
Nakahanap ng file sa tinukoy na path, o sa environment variable PATH kung wala
tinukoy. Maaari itong maging kapaki-pakinabang para sa paghahanap ng mga binary o pagsama ng mga file. Halimbawa,

TCL_INCLUDE := -I$(dir_noslash $(findfile tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/include \
/usr/include/tcl8.4 /usr/include/tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

Hinahanap nito ang file tcl.h sa pamamagitan ng paghahanap sa lahat ng mga direktoryo sa itaas. Ang ganap
ibinalik ang path sa file. Pagkatapos ay kinukuha ng "$(dir_noslash )" ang direktoryong iyon, at ito
ay inilalagay sa isamang landas.

find_program pangalan
Ibalik ang unang programa sa listahan na makikita sa PATH. Ito ay kapaki-pakinabang
kapag mayroong maraming katumbas na programa na maaaring gamitin, at gusto mo lang
pumili ng isa sa kanila. Halimbawa, narito ang default na kahulugan ng ilang karaniwan
mga variable na ibinibigay ng makepp kung hindi ka maglalagay ng isa sa iyong makefile:

CC = $(find_program gcc egcc pgcc c89 cc) # at higit pa, depende sa makina
F77 = $(find_program f77 g77 fort77)
CXX = $(find_program g++ c++ pg++ cxx CC aCC)

Kung wala sa mga programa ang nahanap, ibinabalik ng "$(find_program )" ang string na hindi natagpuan, at
nag-log kung ano ang hindi natagpuan. Karaniwang hindi ito magreresulta sa isang functional na makefile, ngunit ito
ay may posibilidad na gumawa para sa mas mahusay na mga mensahe ng error. Halimbawa, kung gumawa ka ng isang bagay tulad ng
ito:

%.o : %.c
$(CC) $(inputs) -o $(outputs)

at hindi mahanap ng makepp ang isang C compiler sa listahan sa itaas, papalitan nito ang hindi nahanap.
Kung hindi, susubukan ng shell na isagawa ang source file at ang resultang error
maaaring kakaiba ang mensahe.

find_upwards filename
Naghahanap ng file ng ibinigay na pangalan sa direktoryo ., .., ../..,../../.., Atbp,
hanggang sa matagpuan ang file o maabot ang root directory o matatagpuan ang direktoryo
sa ibang file system. (Ang huling kinakailangan na ito ay upang maiwasan ang mga problema sa
automounters o hung network filesystems.) Kung mayroon kang a RootMakeppfile, iyon din
isang hadlang na pumipigil sa paghahanap sa mas mataas.

Halimbawa, kung mayroon kang proyekto na may maraming antas ng mga subdirectory, magagawa mo
isama ang karaniwang fragment na ito sa lahat ng mga makefile (hal., sa pamamagitan ng paggamit ng "isama"
pahayag):

TOP_LEVEL_INCLUDE_DIR := $(kasama ang find_upwards)
# Naghahanap para sa isang direktoryo na naglalaman ng
# may kasamang subdirectory.

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

Ang isa pang problema na maaaring makatulong sa paglutas ng "find_upwards" ay ang paghahanap sa direktoryo sa nangungunang antas
ng isang build. Kadalasan ito ay kapaki-pakinabang upang tukuyin ang isang variable na tulad nito:

TOP := ../../..

kung mayroon kang ilang mahalagang impormasyon na matatagpuan lamang sa nangungunang antas na direktoryo. Pero
mahirap itong panatilihin, dahil ang bilang ng ".." ay iba para sa iba't ibang antas
ng puno ng direktoryo. Sa halip, maaari mong gamitin ang "find_upwards" upang mahanap ang isang file na kung saan ay
kilala na naroroon lamang sa nangungunang antas na direktoryo. Ipagpalagay, halimbawa, na ang
Ang file na "LICENSE" ay matatagpuan lamang sa pinakamataas na antas ng direktoryo. Pagkatapos ay maaari mong gawin ito:

TOP := $(dir_noslash $(find_upwards LICENSE))

Ang "$(find_upwards LICENSE)" ay nagbabalik ng buong landas ng file ng lisensya;
Tinatanggal ng "$(dir_noslash ...)" ang filename, ibinabalik lamang ang direktoryo.

(Tandaan na ang "isama" na pahayag ay awtomatikong naghahanap pataas para sa mga file, kaya doon
ay hindi na kailangang gumawa ng isang bagay tulad nito:

isama ang $(find_upwards top_level_rules.mk)

Sa halip, magagawa mo lang

isama ang top_level_rules.mk

at ito ay gagana rin.)

Kung hindi mahanap ang file, iaabort ng "find_upwards" ang build na may mensahe ng error.

Kung tumukoy ka ng higit sa isang file, hahanapin ng find_upwards ang una, pagkatapos
ang pangalawa, at iba pa. Sa ibang salita,

$(find_upwards file1 file2)

ay katumbas ng

$(find_upwards file1) $(find_upwards file2)

Kung gusto mong hanapin ang alinman sa mga file, pagkatapos ay gamitin ang "find_first_upwards" sa halip.

find_first_upwards file1 file2 ...
Ang function na ito ay kumikilos tulad ng "find_upwards" maliban na ibinabalik nito ang unang file ng anuman
mga file sa listahan na nahahanap nito. Sa partikular, sinusuri nito ang kasalukuyang direktoryo para sa
alinman sa mga file sa listahan, at ibinabalik ang unang file na umiiral o maaaring itayo.
Kung wala sa mga file ang umiiral o maaaring itayo sa direktoryo na iyon, ito ay nagsusuri .., Pagkatapos
../.., atbp., hanggang sa maabot nito ang alinman sa root directory o isang directory which is
matatagpuan sa ibang file system.

first_available file1 file2 ...
Ibalik ang unang file sa isang listahan na umiiral o maaaring itayo. Ito ay maaaring maging kapaki-pakinabang para sa
pag-angkop sa iyong mga makefile upang gumana sa maraming iba't ibang mga makina o network, kung saan
maaaring matatagpuan ang mahahalagang file sa iba't ibang lugar. Halimbawa, narito ang isang linya mula sa
isa sa aking mga makefile:

TCL_LIB = $(first_available \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

Susuriin ng linyang ito ang Tcl library sa lahat ng mga lugar sa itaas, humihinto sa
unang nahanap nito. Kasama sa link na command ang $(TCL_LIB) upang makuha namin ang
naaangkop na Tcl library.

infer_linker file1 file2 ...
Dahil sa isang listahan ng mga object file, buuin muna ang mga ito kung hindi pa sila nagagawa. Pagkatapos ay hanapin
kung umaasa sila sa isang Fortran, C++ o isang C source at ibabalik ang katumbas
compiler (na mas nakakaalam kung paano mag-link kaysa sa "ld").

infer_objects file1 file2 ..., huwaran
$(infer_objects object1.o object2.o, *.o)

Kung gumagamit ka ng mga karaniwang kumbensyon tungkol sa mga pangalan ng file ng header, kaya ng makepp
paghula kung aling mga ".o" o ".lo" na mga file ang kailangang i-link sa iyong programa. Ginagamit ko ito sa
pumili ng mga file mula sa isang direktoryo ng library na naglalaman ng mga module na ginagamit sa maraming iba't ibang
mga programa. Sa halip na gumawa ng library na ".a" na file at pilitin ang linker ng
kaugnay na mga module, maaaring piliin ng makepp ang mga nauugnay na module para sa iyo. Sa ganitong paraan, lamang
ang mga nauugnay na module ay naipon.

Ang algorithm ng Makepp para sa paghihinuha ng mga dependencies ng object ay depende sa convention na
ang pagpapatupad ng lahat ng mga klase o function na tinukoy sa isang header file na "xyz.h" ay
pinagsama-sama sa isang object file na tinatawag na "xyz.o" (o "xyz.lo"). Kaya ang algorithm ng makepp para sa
ang paghihinuha ng mga dependency ng object ay nagsisimula sa isa o ilang bagay na alam nating dapat
naka-link sa programa. Tinitingnan nito kung aling mga file ang kasama sa "#include".
ang mga mapagkukunang iyon, at sinusubukang maghanap ng kaukulang mga object file para sa bawat isa sa mga kasama
file.

Ang "$(infer_objects )" ay kailangang banggitin sa listahan ng dependency ng isang programa, tulad ng
ito:

myprog: $(infer_objects main.o another_object.o, \
**/*.o /other/library/dirs/**/*.o)
$(CXX) $(input) -o $(output) $(LIBS)

Ang function na "$(infer_objects)" ay tumatagal ng dalawang argumento (na pinaghihiwalay ng kuwit, gaya ng ipinapakita).
Ang una ay isa o ilang object file na kilala na kinakailangan (wildcards ay
pinahihintulutan dito). Ang pangalawa ay isang listahan ng mga posibleng bagay (karaniwan ay gagamit ka ng a
wildcard dito) na maaaring maiugnay kung kinakailangan. Ang return value mula dito
Ang function ay isang listahan na naglalaman muna ng lahat ng mga bagay sa unang argumento, at
pagkatapos ng mga iyon, lahat ng karagdagang mga bagay na nakapaloob sa pangalawang argumento
na kinakailangan ng mga bagay sa unang argumento.

Halimbawa, ipagpalagay na ang "main.o" ay nagmula sa "main.cpp", na kinabibilangan ng "my_class.h".
Ang "$(infer_objects)" ay naghahanap ng mga file na may pangalang "my_class.o". Kung eksakto ang isang tulad
Ang file ay natagpuan, ito ay idinagdag sa listahan. (Kung ang dalawang object file na "my_class.o" ay natagpuan
sa iba't ibang mga direktoryo, may naka-print na mensahe ng babala.) "infer_objects" din
sinusuri ang "my_class.cpp" upang makita kung ano ang kasama nito, at kung ano ang mga karagdagang object file
ipinahiwatig.

mktemp
mktemp unlapi
mktemp unlapiXXX
mktemp /
Nagbabalik ng hindi nahuhulaang pansamantalang filename, na kasalukuyang hindi umiiral. Walang pangalan
ang pagturo sa parehong file ay ibinalik ng dalawang beses, kahit na may iba't ibang mga kamag-anak na landas,
sa loob ng isang makepp run (maliban sa posibleng may tradisyonal na recursive make, o kung ang Perl
code na tumatakbo sa loob ng isang panuntunan sa pagkilos na tinatawag na "f_mktemp"). Sa dulo ng makepp tumakbo lahat
Ang mga file na ibinalik ng function na ito ay tatanggalin, kung mayroon sila (muli maliban sa mga
ibinalik ng function na ito sa Perl code na tumatakbo sa loob ng isang panuntunan).

Anumang bilang ng malalaking titik na "X" sa dulo ng argumento ay papalitan ng ganoon karami
random na mga titik at digit. Kung mas marami, mas maliit ang posibilidad na ito ay mabangga
sa iba pang mga proseso, kaya kung magbibigay ka ng prefix tulad ng "/tmp/abc.", dapat sapat ka
"X" s. Kung mayroong higit sa isang X, ang unang character ay nagmumula sa process id. Kung
wala, para bang mayroong sampu, na dapat ay sapat na (8.4e17
mga posibilidad o 3.7e15 sa Windows). Kung walang argumento, ang prefix ay magiging default sa
"tmp." sa kasalukuyang direktoryo.

Tandaan na hindi mo gustong magbigay ng ganoong pangalan bilang mga target ng panuntunan at dependencies. Ang
magiging tama ang resulta, ngunit ito ay muling gagawin sa tuwing magpapatakbo ka ng makepp.

Gayundin, dahil ito ay palaging naiiba, dapat mong gamitin ito sa isang pagkilos ng panuntunan kung gagamitin mo lamang
":build_check ignore_action":

TMFILE ;= $(mktemp) # 1 tawag; "=" ay nangangahulugang 3 tawag: 3 file
A-count B-count: :build_check ignore_action
produce-As-and-Bs >$(TMFILE)
&grep -c /A/ $(TMFILE) -o A-count
&grep -c /B/ $(TMFILE) -o B-count

O dapat mong i-export ito at hayaan ang Shell na suriin ito:

i-export ang TMFILE ;= $(mktemp)
A-count B-count:
produce-As-and-Bs >$$TMFILE # makepp ay hindi nakikita ang var value
fgrep -c Isang $$TMFILE >A-count
fgrep -c B $$TMFILE >B-count

Inuulit ng huling form ang dating halaga ng pagbabalik, para magamit mo ito sa isang panuntunan ng pattern:

%.x: %.y
&grep foo $(input) -o $(mktemp)
&sed bar $(mktemp /) -o $(output) # Magpatakbo sa output ng &grep

notdir mga filename
Ibinabalik ang hindi direktoryo na bahagi ng (mga) filename, ibig sabihin, lahat pagkatapos ng huli
slash kung mayroong isa, o ang buong filename kung hindi man.

only_generated mga filename
Ibinabalik lamang ang mga filename sa listahan na nabuo ng makepp at hindi mula noon
binago, ayon sa file ng impormasyon ng build.

Ang function na ito ay kapaki-pakinabang sa malinis na target na mga panuntunan (bagaman siyempre ang "makeppclean" ay ang
gustong variant):

$(huwad na malinis):
&rm -f $(only_generated **/*)

only_nontargets mga filename
Ibinabalik lamang ang mga filename sa listahan na hindi mga target ng anumang panuntunan (alinman sa
tahasan o pattern na mga panuntunan). Maaari kang tumukoy ng wildcard (tingnan ang "$(wildcard )"
function para sa higit pang mga detalye sa mga wildcard ng makepp). Ito ay maaaring gamitin para sa pagbuo ng a
target ng pamamahagi, halimbawa:

.PHONY: pamamahagi

pamamahagi:
&mkdir our_product-$(VERSION)
&cp $(filter-out %~, $(only_nontargets *)) our_product-$(VERSION)
tar cf - our_product-$(VERSION) | gzip -9c > our_product-$(VERSION).tar.gz

Sa kasong ito, ibinabalik ng "$(only_nontargets *)" ang bawat file sa kasalukuyang direktoryo
hindi iyon target ng ilang tuntunin. Ang "$(filter_out %~, ...)" ay nag-aalis ng editor
mga backup.

Katulad ng "only_targets" (tingnan sa itaas), "only_nontargets" lang ang nakakaalam tungkol sa mga target na
ay tinukoy na. Ito ay isang problema lamang kung gagamitin mo ito upang tukuyin ang mga variable
gamit ang ":=" takdang-aralin; kung gagamitin mo ito sa listahan ng dependency o sa katawan ng a
panuntunan, makikita na ang lahat ng iba pang panuntunan.

only_stale mga filename
Ibinabalik lamang ang mga filename sa listahan na nabuo ng makepp at hindi mula noon
binago, ayon sa build info file, ngunit hindi na mga target ng anumang panuntunan.

Ang function na ito ay kapaki-pakinabang para sa pagtiyak na walang dependencies sa naturang mga file,
nang hindi pinipilit ang isang malinis na build ng lahat ng mga target:

$(phony flush):
&rm -f $(only_stale **/*)

Sa totoo lang, mas mabuti sigurong magsulat ng script na tumatawag sa makepp para makabuo
ang listahan ng mga lipas na file, at pagkatapos ay ipaalis sa script na iyon ang lahat ng nakalistang file na iyon
Kasalukuyang hindi nasa ilalim ng kontrol ng source, kung sakaling maging source ang nabuong file
file. Ang Makepp ay walang ganoong function na naka-built in dahil ang makepp ay (at malamang
dapat manatili) agnostiko tungkol sa kontrol ng pinagmulan.

only_targets mga filename
Ibinabalik lamang ang mga filename sa listahan na talagang mga target ng ilang panuntunan
(alinman sa tahasan o pattern na mga panuntunan). Maaari mong tukuyin ang mga wildcard (kabilang ang makepp's
espesyal na wildcard, "**") sa mga filename. (Tingnan ang function na "$(wildcard )" para sa higit pa
mga detalye. Magagamit ito para sa isang malinis na target, halimbawa:

.PHONY: malinis

malinis:
&rm -f $(mga_target lamang *)

Ngayon kung ita-type mo ang "makepp clean", tatanggalin nito ang lahat ng alam nito kung paano bumuo. Pero
huwag gumawa ng malinis na target, gamitin ang "makeppclean" sa halip!

Ang isa pang lugar kung saan ito ay maaaring maging kapaki-pakinabang ay upang maiwasan ang pagsasama ng lipas .o mga file sa iyong
magtayo. Halimbawa, kung gagawa ka ng isang library tulad nito:

mylib.a: *.o
&rm -f $(output)
$(AR) cr $(output) $(inputs)

at pagkatapos ay tanggalin mo ang ilang mga source file ngunit nakalimutan mong tanggalin ang katumbas .o mga file,
ang .o mananatili pa rin ang mga file. Nangangahulugan ito na sila ay isasama pa rin sa
ang silid-aklatan sa kabila ng katotohanang hindi na sila kapaki-pakinabang. Kung babaguhin mo ang iyong
panuntunan tulad nito:

mylib.a: $(only_targets *.o)
&rm -f $(output)
$(AR) cr $(output) $(inputs)

pagkatapos ang problemang ito ay hindi mangyayari.

Tandaan na ito ay tumutukoy lamang sa mga file na kilala bilang mga target at ang oras ikaw
tumawag sa diyos "lamang-target". Kung lumilitaw ang "only_targets" sa mga dependency o aksyon ng a
rule, kung gayon ang lahat ng posibleng target ay malalaman dahil ang mga dependency at aksyon ay hindi
sinusuri hanggang sa maisakatuparan ang panuntunan. Gayunpaman, kung susuriin mo subukang suriin ito
mas maaga sa makefile na may ":=" variable na ganito:

ALL_TARGETS := $(only_targets *)

target1: dependency1
pagkilos

target2: dependency2
pagkilos

pagkatapos ay hindi malalaman ng "only_targets" ang tungkol sa mga kasunod na panuntunan.

Katulad nito, hindi alam ng "only_targets" ang tungkol sa mga target na ginawa sa mga makefile na iyon
puno ng recursive make. (Ngunit hindi ka dapat gumamit ng recursive make pa rin; gamitin
gamitin ang "load_makefile" na pahayag, o implicit makefile loading sa halip.)

relative_filename file1 file2 file3[, slash]
Ibinabalik ang pangalan ng mga file na iyon na nauugnay sa kasalukuyang direktoryo (ang isa ang
nasa makefile). Magagamit din ito upang linisin ang hindi kinakailangang "./" at iba pang basura mula sa
ang landas:

DIR := .
SUBDIR := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/files
X := $(relative_filename $(FNAME))

If iwa ay totoo (karaniwang 1) ang mga ibinalik na filename ay garantisadong naglalaman ng slash
sa pamamagitan ng paglalagay ng "./" kung kinakailangan, upang magamit mo ito bilang isang executable na pangalan nang wala
nag-aalala tungkol sa landas ng paghahanap ng command na na-override ang lokasyon ng direktoryo.

Kung ang path ay pupunta sa root directory, ang magulang ng alinman sa iyong home directory o
ang "$(ROOT)" ng iyong build system, o sa Windows root ng isang drive (depende sa
kapaligiran, nangyayari rin ito para sa /cygdrive/c or /c), magiging isang ganap na landas
ibinalik sa halip.

may kaugnayan sa file1 file2 file3[, direktoryo]
Ibinabalik ang pangalan ng mga file na iyon na nauugnay sa tinukoy na direktoryo. Ito ay
karaniwang kapaki-pakinabang kapag sa anumang dahilan kailangan mong magsagawa ng utos mula sa a
ibang direktoryo (default na kasalukuyang direktoryo):

source_backup.tar:
cd .. && tar cf $(relative_to $(output), ..) $(relative_to ., ..)

suffix mga pangalan...
Kinukuha ang suffix ng bawat pangalan ng file sa mga pangalan. Kung ang pangalan ng file ay naglalaman ng tuldok,
ang suffix ay ang lahat ng bagay na nagsisimula sa huling tuldok. Kung hindi, ang suffix ay ang
walang laman na string. Ito ay madalas na nangangahulugan na ang resulta ay walang laman kapag ang mga pangalan ay hindi,
at kung ang mga pangalan ay naglalaman ng maraming mga pangalan ng file, ang resulta ay maaaring maglaman ng mas kaunting mga pangalan ng file.

Halimbawa,

$(suffix src/foo.c src-1.0/bar.c hacks)

gumagawa ng resulta ".c .c".

pansamantala mga salita
Ipaalam sa makepp na ang mga tinukoy na target ay maaaring alisin ng panuntunang bubuo
sila. Katulad ng "phony", maliban sa inaasahan ng makepp na isang tunay na file ng pangalang iyon
ay maaaring maapektuhan ng panuntunan. Ang isang tuntunin ay hindi naisakatuparan kung ito ay pansamantala lamang
hindi napapanahon ang mga target.

wildcard huwaran
Ibinabalik ang pinagsunod-sunod na mga pangalan ng lahat ng mga file na tumutugma sa ibinigay na pattern na umiiral, o mga iyon
mga file na hindi pa umiiral ngunit maaaring itayo batay sa mga patakaran na alam ng makepp
tungkol sa punto kung kailan sinusuri nito ang expression. Sa huling puntong ito ay naiiba ito
mula sa mga wildcard ng input ng panuntunan, na nalalapat kahit sa mga file na ginawa ng mga panuntunang makikita sa ibang pagkakataon.

Sinusuportahan ng Makepp ang lahat ng karaniwang mga wildcard ng shell ("*", "?", at "[]"). Mayroon din itong isang
wildcard na "**" na tumutugma sa anumang bilang ng mga intervening directory. (Ang ideyang ito ay
ninakaw mula sa zsh.) Halimbawa, ang "**/*.c" ay tumutugma sa lahat ng .c mga file sa buong pinagmulan
puno. Ang "objects/**/*.o" ay tumutugma sa lahat ng .o mga file na nakapaloob saanman sa
subdirectory bagay o alinman sa mga subdirectory nito o alinman sa kanilang mga subdirectory. Ang
Hindi susundan ng "**" wildcard ang mga soft link sa mga direktoryo sa anumang antas, gayundin
subukang magpasok ng mga direktoryo na umiiral ngunit hindi mababasa. Gayundin ang mga file at
ang mga direktoryo na umiiral ngunit hindi nababasa ay hindi ibabalik ng "$(wildcard )".

Pisi Pag-andar
addprefix prefix, mga salita
Inilalagay ang prefix string sa bawat isa sa mga salita. Ito ay kadalasang para sa GNU make
pagiging tugma; gamit ang rc-style expansion, ito ay maaaring gawin sa mas nababasang paraan
ganito:

MGA MODULE := abcd
X_OLD_STYLE := $(addprefix $(OBJDIR)/, $(addsuffix .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # Hindi ba mas madaling basahin iyon?

magdagdag ng panlapi panlapi, mga salita
Idinaragdag ang suffix string sa bawat isa sa mga salita. Ito ay kadalasang para sa GNU make
pagiging tugma; gamit ang rc-style expansion, ito ay maaaring gawin sa mas nababasang paraan
ganito:

X_OLD_STYLE := $(addsuffix .o, $(MODULES))
X_NEW_STYLE := $(MODULES).o

tawag variable [, salita]...
Ang function na "call" ay natatangi dahil maaari itong gamitin upang isaalang-alang nagbabago bilang isang
parameterized function. Maaari kang magtalaga ng isang kumplikadong expression sa nagbabago at gamitin
"tawag" upang palawakin ang mga nilalaman nito sa iba't ibang mga halaga na na-parametrize ng mga salita sa ibang Pagkakataon. Sa
iba pang gumagawa ng mga sistema, isang variable na pangunahing ginagamit para sa layuning mapalawak sa pamamagitan ng
"tawag", ay tinatawag na a macro.

Sa panahon ng pagpapalawak ng macro, ang mga pansamantalang variable $1, $2, "..." sumangguni sa
mga argumentong ibinigay sa "tawag" sa panahon ng panawagan nito. Ang variable $0 ay palalawakin sa
ang pangalan ng macro (hal nagbabago) na ang "tawag" ay kasalukuyang lumalawak.

Walang limitasyon, kung gaano karaming mga argumento ang maaaring "tawagan" ng isang macro o kung gaano karami
mga parameter na maaaring asahan ng isang macro. Kung magpapasa ka ng higit pang mga argumento sa "tumawag" bilang macro
kailangan, lahat ng lumalampas na argumento ay itatapon. Kung pumasa ka ng mas kaunting mga argumento kaysa sa a
inaasahan ng macro, lahat ng lumalampas sa mga parameter ay bumagsak sa walang laman na string.

Una isang simpleng halimbawa:

pahinga = $(listahan ng salita 2, $(mga salita $(1)),$(1))
listahan = ABCDE
butfirst := $(call rest,$(list))

Dito, ang variable na "$(butfirst)" ay maglalaman ng listahang "BCDE".

At ngayon para sa isang mas kumplikadong halimbawa upang ipakita kung ano ang posible:

pahinga = $(listahan ng salita 2,$(mga salita $(1)),${1})
mymap = $(kung $2,$(tawagan ang $1,$(unang salita $2)) $(tawagan ang $0,$1,$(call rest,$2)))
downcase = ${makeperl lc("$1")}

UCWORDS = LAHAT NG MGA SALITANG ITO AY NABABAW
DCWORDS := $(tawagan ang mymap,downcase,$(UCWORDS))

Ngayon ang "$(DCWORDS)" ay naglalaman ng "lahat ng mga salitang ito ay upcase". Sa pamamagitan ng paraan: ito ay gumagawa ng hindi
pagkakaiba, kung ma-access natin ang mga argumento sa pamamagitan ng $1, "${1}" or "$(1)" sa loob ng isang macro.

Maaari mong direktang gamitin ang variable na parang ito ay isang function, kung wala
function ng pangalang iyon. Ito ay panloob na na-convert sa "tawag", kaya ito ay
katumbas:

talakayan = Ang $0 ay naging $1 $2.
direct = $(talakayan an,argumento)
tinatawag = $(tawag sa talakayan,an,argumento)

Maaaring mukhang mapagtatalunan kung dapat ding palawakin ng "$[call]" ang "$[]" ng macro
expression, o kung ang isang function ay dapat palaging gawin ang parehong bagay, gaano man ito
ay tinatawag na. Ang huli ay pinili, dahil ito ay may normal na make syntax
imposibleng makuha ang "$[1], $[2]..." sa isang variable (papalitan sila ng wala,
bago pa man maganap ang takdang-aralin.) Samakatuwid, kung mayroon kang macro para sa pagtukoy ng a
panuntunan, gusto mong makita ang mga expression tulad ng "$(output)" kapag na-parse ang panuntunan, kaya
dapat mong protektahan sila mula sa "tawag":

tukuyin ang myrule
$2: $1
mycommand $$(input) -o $$(output)
endef
$[myrule myinput,myoutput]

filter mga pattern, mga salita
Ibinabalik ang lahat ng salita sa listahan na tumutugma sa mga pattern. Ang mga pattern ay maaaring iba lang
mga salita, o mga wildcard ng filename (ibig sabihin, "*", "?", at "[az]" ay kinikilala), o maaari silang
magkaroon ng "%" na character, na nangangahulugang tumugma sa anumang string sa puntong iyon (katulad ng "*").

filter_out mga pattern, mga salita
Ibinabalik ang lahat ng salita sa listahan na hindi tumutugma sa mga pattern. Ang mga pattern ay maaaring maging simple
ibang salita, o mga wildcard ng filename (ibig sabihin, "*", "?", at "[az]" ay kinikilala), o
maaaring mayroon silang "%" na character, na nangangahulugang tumugma sa anumang string sa puntong iyon (katulad ng
"*").

Halimbawa:

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

ilalagay lahat .o mga file na umiiral o maaaring itayo, maliban sa mga nagsisimula sa pagsusulit_,
sa libproduction.a.

findstring hanapin, in
Bumalik mahanap, kung ito ay isang substring ng in.

unang salita mga salita
Ibalik ang unang salita.

mapa salita, perlcode
makemap salita, perlcode
Katulad sa mapa ni Perl, nalalapat perlcode sa bawat salita sa turn at ibinabalik ang
resulta. Ang unang variant ay plain Perl code, habang ang pangalawang variant ay unang pumasa
ang perlcode sa pamamagitan ng Make-style variable expansion. Ang mga salita ay pinalawak sa pareho
mga kaso.

Ang mga salita ay nasa $_ at ibinalik maliban kung na-undef mo ang $_. Ito ay inilaan para sa
mga pagbabago na hindi madaling mahawakan ng "patsubst". Tanging ang unang kuwit ay isang separator,
sinumang iba pa ay itinuturing na bahagi ng perlcode.

# Magpalit ng salita. Double parens, para payagan ang parens sa perlcode, o gumamit ng ${}:
X = $((mapa $(VALUES), s/(.+)-(.+)/$2-$1/))
# Maaari kang gumamit ng make expression, ngunit dapat mong gamitin ang $$ para sa Perl $:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ o $$_ = 'bigo')
# Maaari mong alisin ang mga kandidato:
Y = $(mapa $(VALUES), undef $_ kung /no_good/)

sumali salita1, salita2
Gawin ang magkapares na pagdugtong ng mga unang salita at ang pangalawang salita.

pasubst pattern, kapalit, mga salita
Nagsasagawa ng pagpapalit sa bawat salita sa listahan ng salita. Ang isang "%" na character ay tumutugma sa alinman
string. Ito ay pinakamahusay na inilalarawan ng isang halimbawa:

OBJS = $(patsubst %.c, object_dir/%.o, $(C_SOURCES))

kinukuha ang bawat file sa C_SOURCES at ibinabalik ang pangalan ng isang object file sa object_dir.
Minsan ito ay mas maigsi na gumamit ng isang sanggunian sa pagpapalit, hal, ang nasa itaas ay maaaring
ay isinulat bilang

OBJS = $(C_SOURCES:%.c=object_dir/%.o)

uri salita1 salita2 salita3 ...
Pag-uuri-uriin ang mga salita sa lexical na pagkakasunud-sunod at inaalis ang mga duplicate.

alisan ng pisi
Tinatanggal ang nangunguna at sumusunod na whitespace mula sa string at pinapalitan ang bawat panloob
pagkakasunud-sunod ng isa o higit pang mga whitespace na character na may iisang espasyo. Kaya, "$(strip ab
c )" ay nagreresulta sa "abc".

subst mula, hanggang, teksto
Nagsasagawa ng textual na pagpapalit sa text text: ang bawat paglitaw ng from ay pinapalitan
sa pamamagitan ng sa. Ang resulta ay pinapalitan para sa function na tawag. Halimbawa,

$(subst ee,EE,mga paa sa kalye)

pinapalitan ang string na "fEEt on the street".

salita n, teksto
Nagbabalik ang nika salita ng teksto. Ang mga lehitimong halaga ng n magsimula sa 1 sa simula
o pabalik mula -1 sa dulo. Kung n ay mas malaki kaysa sa bilang ng mga salita sa teksto, ang
walang laman ang halaga.

listahan ng salita indexlist, mga salita
listahan ng salita firstindex, lastindex, mga salita
Sa unang anyo ay nagbibigay ka ng isang listahan ng mga indeks (nagbibilang mula sa 1 sa simula o
pabalik mula -1 sa dulo) upang piliin ang mga salitang gusto mo. Sa pangalawang anyo mo
tukuyin ang hanay ng mga salita na gusto mong ibalik.

mga salita teksto
Ibinabalik ang bilang ng mga salita sa teksto.

sari-sari Pag-andar
unahan var, listahan, teksto
Ang unang dalawang argumento, ay at listahan, ay pinalawak bago ang anumang bagay ay tapos na; tala
na ang huling argumento, teksto, ay hindi pinalawak nang sabay. Pagkatapos para sa bawat salita ng
ang pinalawak na halaga ng listahan, ang variable na pinangalanan ng pinalawak na halaga ng var ay nakatakda sa
ang salitang iyon, at ang teksto ay pinalawak. Marahil ang teksto ay naglalaman ng mga sanggunian sa variable na iyon,
kaya ang pagpapalawak nito ay magkakaiba sa bawat pagkakataon.

Ang simpleng halimbawang ito ay nagtatakda ng variable file sa listahan ng lahat ng mga file sa
mga direktoryo sa listahan dirs:

dirs := abcd
mga file := $(foreach dir,$(dirs),$(wildcard $(dir)/*))

Narito ang teksto ay "$(wildcard $(dir)/*)". Hinahanap ng unang pag-uulit ang halagang "a" para sa dir,
kaya ito ay gumagawa ng parehong resulta bilang "$(wildcard a/*)"; ang pangalawang pag-uulit ay gumagawa
ang resulta ng "$(wildcard b/*)"; at ang pangatlo, ang sa "$(wildcard c/*)".

Ang halimbawang ito ay may parehong resulta (maliban sa pagtatakda ng "dirs") gaya ng sumusunod na halimbawa:

mga file := $(wildcard a/* b/* c/* d/*)

Kapag kumplikado ang text, mapapabuti mo ang pagiging madaling mabasa sa pamamagitan ng pagbibigay dito ng pangalan, na may isang
karagdagang variable:

find_files = $(wildcard $(dir)/*)
dirs := abcd
mga file := $(foreach dir,$(dirs),$(find_files))

Dito ginagamit namin ang variable find_files sa ganitong paraan. Ginagamit namin ang plain "=" upang tukuyin ang a
recursively-expanding variable, upang ang value nito ay naglalaman ng aktwal na function call to
muling palawakin sa ilalim ng kontrol ng foreach; hindi gagawin ng isang simpleng pinalawak na variable,
dahil isang beses lang tatawagin ang wildcard sa oras ng pagtukoy sa find_files.

Tandaan: Huwag ipagkamali ito sa espesyal na variable na "$(foreach)".

info teksto
babala teksto
mali teksto
Output text na nagbabalik ng wala. Ang una ay napupunta sa STDOUT, ang pangalawa sa STDERR,
ang pangatlo ay tinatanggal din ang pagproseso.

prebuild target
gumawa target
Ibinabalik ang argumentong verbatim nito, ngunit binubuo muna ang lahat ng nakalistang file. Ito ay kapaki-pakinabang
kapag ang isang naibigay na file ay kailangan kapag sinusuri ang isang make expression. Karaniwang nangyayari ito
kapag mayroon kang isang build kung saan ang hanay ng mga file na kasangkot ay nakalkula ng ilang shell
mga utos. Halimbawa,

file_list :
# shell command upang makalkula ang isang listahan ng mga file na ilalagay sa programa

my_program : $(&cat $(prebuild file_list))

Kung kailangan mo ang listahan sa higit sa isang panuntunan, magiging mas mahusay na gumamit ng isang
palawakin nang hindi hihigit sa isang beses na variable:

file_list ;= $(&cat $(prebuild file_list))

my_program1 : ao $(file_list)

my_program2 : bo $(file_list)

Kung sa halip ay tinukoy mo lang ang "$(&cat file_list)", hindi pipilitin ng makepp
file_list upang maging up-to-date bago ito isagawa ang shell command. Gamit ang "$(prebuild )"
ay ang pinakamahusay na paraan upang malutas ang problemang ito. Maaari kang matukso na subukan ang iba pang mga bagay, tulad ng
ito:

my_program : file_list $(&cat file_list)

ngunit hindi ito gagana dahil sinusuri ang "$(&cat file_list)" bago tangkaing gawin ito ng makepp
bumuo ng "file_list".

only_phony_targets pangalan
Ibinabalik lamang ang mga pangalan sa listahan na mga huwad na target ng ilang panuntunan (alinman sa
tahasan o pattern na mga panuntunan). Maaari mong tukuyin ang mga wildcard (kabilang ang espesyal na makepp
wildcard, "**") sa mga filename. (Tingnan ang function na "$(wildcard )" para sa higit pang mga detalye.
Magagamit ito para sa pagpapangkat ng mga target, halimbawa:

$(phony tests): $(only_phony_targets */**/tests)

pinagmulan nagbabago
Dahil sa pangalan ng isang variable, sasabihin sa iyo kung saan nagmumula ang halaga nito.

perlas perlcode
makeperl perlcode
Sinusuri ang perlcode sa isang block at ibinabalik ang resulta. Ang unang variant ay plain Perl
code, habang ang pangalawang variant ay unang ipinapasa ang perlcode sa pamamagitan ng Make-style variable
expansion.

Tandaan, na, tulad ng lahat ng mga function, ang function delimiter na ginamit ay maaaring hindi lumitaw sa loob
ang perlcode sa labas ng single o double quoted string. Ngunit maaari mong i-double ito bilang in
ang huling halimbawa:

VAR = 1
VAR1 = ${perl ($VAR + 1) * 3}
VAR2 = $(perl do { $VAR *= 3; ibalik ang $VAR + 1 } kung $VAR)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # isa Gumawa ng var at isang Perl var
VAR = $((perl if( ... ) { ... }))

hindi pagkakasundo mga salita
Isinasaad na ang listahan ng mga salita ay talagang huwad na mga target, at ibinabalik ang listahan ng
mga target. Ito ay nilayon na gamitin tulad nito:

$(phony all): my_program

$(huwad na malinis):
&rm -f *.o my_program

Maaari mo ring ideklara ang isa o higit pang mga target bilang huwad na may linyang tulad nito kahit saan
iyong makefile:

.PHONY: malinis lahat

i-print teksto
Inilalabas ang teksto at ibinabalik ito. Ito ay kadalasang kapaki-pakinabang para sa pag-debug, kapag hindi mo ginagawa
unawain kung bakit ang variable na pagpapalit ay may resulta na ginagawa nito. Halimbawa,

XYZ := $(print $(patsubst %.c, %o, $(SOURCE_FILES)))

ay magpi-print ng resulta ng "patsubst" na tawag.

XYZ := $(patsubst %.c, %o, $(print $(SOURCE_FILES)))

ay i-print ang huling argumento sa "patsubst" na tawag.

talukap ng alimango shell-utos
Ibinabalik ang output mula sa ibinigay na shell command, na may mga bagong linya na pinalitan ng mga puwang.

Tandaan, na, tulad ng lahat ng mga function, ang function delimiter na ginamit ay maaaring hindi lumitaw sa loob
ang shell-command sa labas ng single o double quoted string. Ngunit maaari mong doblehin ito
tulad ng sa pangalawang halimbawa:

date = $(shell date) # better: $(perl scalar localtime)
VAR = ${{shell f() { echo hello; }; f}}

xargs command,arguments[,suffix[,haba]]
Nagbabalik ng listahan ng mga command na pinaghihiwalay ng bagong linya na nagsisimula sa tinukoy
command, at magtatapos sa pinakamaraming elemento ng listahan hangga't maaari nang hindi lalampas
haba (default 1000) na mga character.

Ang layunin nito ay upang maiwasan ang paglipas ng limitasyon sa haba ng command sa iyong system.
Halimbawa, kung mayroong maraming nabuong mga file, malamang na gusto mo ang iyong
malinis na target (na hindi dapat mayroon ka, dahil ang "makeppclean" ay mas mahusay) sa
magmukhang ganito:

$(huwad na malinis):
$(xargs $(RM), $(only_targets **/*))

Mayroon din itong side-effect na walang utos na nabuo kung ang listahan
nagkataon na walang laman. Ngunit sa kasong ito, mas mainam na gamitin ang builtin &rm,
dahil ang mga argumento sa mga builtin na utos ay limitado lamang ng memorya ni Perl:

$(huwad na malinis):
&rm -f $(only_targets **/*)

Kung ang isang ikatlong argumento ay tinukoy, pagkatapos ito ay ginagamit upang i-postfix ang bawat command. Ito ay
kapaki-pakinabang para sa pagtukoy ng mga redirector, hal (bagaman dito muli &echo ay makakatulong):

manifest:
&rm -f $@
&touch $@
$(xargs echo, $(only_nontargets **/*), >> $@)

Ang ilan sa dokumentasyong ito ay batay sa GNU make documentation.

Pakitandaan na kung ang isang function ay tatawag sa panahon ng pagsisimula ng makefile, hal
Ang pagpapalawak ng mga variable sa pag-export, error o mga mensahe ng babala ay mag-uulat ng numero ng linya 0.

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