makepp_functions - Dalam Talian di Awan

JADUAL:

NAMA

makepp_functions -- Fungsi dalam makepp

DESCRIPTION

A: nama fail_mutlak,
absolute_filename_nolink,
abspath,
tambah awalan,
akhiran tambah,
dan, B: nama asas, C: memanggil, D: adalah,
dir_noslash, E: kesilapan, F: filesubst,
penapis,
Tapis keluar,
filter_out_dirs,
findfile,
cari_dahulu_ke atas,
program_cari,
findstring,
find_upwards,
first_available,
perkataan pertama,
untuk setiap, I: jika,
jika benar,
infer_linker,
infer_objects,
maklumat, J: sertai, M: buat,
makemap,
makeperl,
peta,
"mktemp", N: notdir, O: only_generated,
only_nontargets,
only_phony_targets,
hanya_lapuk,
only_targets,
atau,
asal usul, P: pasubst,
perl,
palsu,
prabina,
cetak, R: jalan sebenar,
relative_filename,
relatif kepada, S: tempurung,
macam,
jalur,
pengganti,
akhiran, T: Sementara, W: amaran,
kad bebas,
perkataan,
senarai perkataan,
perkataan, X: xargs

Sebarang ungkapan format "$(nama)", dengan "nama" bukan nama pembolehubah, atau
"$(nama arg1 arg2 arg3)" ditafsirkan sebagai panggilan fungsi. Nama mungkin mengandungi huruf,
garis bawah, atau tanda sempang; untuk mengelakkan kekeliruan, anda boleh menggunakan tanda sempang atau garis bawah
secara bergantian, kerana sempang dalaman ditukar kepada garis bawah. Menilai sedemikian
ungkapan hanya memanggil subrutin Perl. Jika "nama" didahului oleh "&" ia menjalankan
arahan terbina dalam atau skrip nama itu dalam proses makepp, dan mengembalikan standard
pengeluaran. Ini memerlukan perl dibina untuk PerlIO. Jika nama tidak menamakan fungsi
ia diubah menjadi seruan panggilan.

Seperti pembolehubah, anda mempunyai pilihan "$(nama ...)" atau "${nama ...}". Jika anda mahu
benamkan kurungan yang sama, ia mesti dipasangkan, yang lain tidak penting: "$(name
...(){..." atau "${name ...{}(...}". (Walau bagaimanapun untuk peta dan perl, kurung penutup pertama berakhir
ungkapan.) Penggandaan membenarkan hujah-hujah menjangkau beberapa baris. Barisan baharu ialah
kemudian dianggap sebagai ruang, kecuali mungkin dalam "define". Terdapat juga sintaks "$[name ...]"
atau $[[nama ...]], yang akan dinilai semasa membaca fail make, sebelum peraturan grokking
dan binaan lain.

Makepp mempunyai beberapa fungsi terbina yang mungkin berguna. Ia menyokong hampir semua
Fungsi teks GNU make (lihat dokumentasi GNU make untuk butiran), dan beberapa daripadanya
sendiri. Anda boleh menentukan subrutin Perl untuk melakukan apa sahaja yang anda suka. Lihat pernyataan "sub".
dan bahagian memanjangkan makepp untuk butiran lanjut.

bersyarat Fungsi
and syarat1[,syarat2[,syarat3...]]
Fungsi dan menyediakan operasi DAN "litar pintas". Setiap hujah adalah
diperluaskan, mengikut urutan. Jika hujah berkembang kepada rentetan kosong pemprosesan berhenti dan
hasil pengembangan ialah rentetan kosong. Jika semua hujah berkembang kepada bukan
rentetan kosong maka hasil pengembangan ialah pengembangan hujah terakhir.

if tali, result-if-string-not-blank[, result-if-string-blank]
jika benar tali, result-if-string-true[, result-if-string-false]
Alternatif kepada pernyataan "ifeq", dll., Jika rentetan tidak kosong (iaitu
keadaan adalah benar), hujah kedua (klausa "kemudian") dikembalikan (selepas
pengembangan berubah-ubah); jika rentetan kosong, hujah ketiga (klausa "lain") ialah
kembali.

Sebagai contoh,

CFLAGS := $(jika $(tapis gcc egcc, $(CC)), -g -Wall, -g)

mentakrifkan CFLAGS sebagai "-g -Wall" jika pembolehubah CC sama ada "gcc" atau "egcc", dan "-g"
sebaliknya. (Inilah yang dilakukan oleh peraturan binaan lalai.)

"iftrue" adalah serupa dengan "jika", kecuali rentetan 0 dianggap kosong.

or syarat1[,syarat2[,syarat3...]]
Fungsi atau menyediakan operasi ATAU "litar pintas". Setiap hujah diperluaskan,
mengikut tertib. Jika argumen berkembang kepada rentetan bukan kosong, pemprosesan akan berhenti dan
hasil pengembangan ialah rentetan itu. Jika, selepas semua hujah dikembangkan, semua
mereka adalah palsu (kosong), maka hasil pengembangan adalah rentetan kosong.

File and Filename Fungsi
nama fail_mutlak fail
abspath fail
Menukar nama fail relatif kepada mutlak tanpa . or ... Sebagai contoh,
"$(absolute_filename xyz.c)" mungkin mengembalikan "/usr/src/our_project/subdir/xyz.c".

absolute_filename_nolink fail
jalan sebenar fail
Seperti absolute_filename, tetapi memastikan bahawa pautan simbolik diselesaikan.

nama asas nama fail
Nama asas ialah keseluruhan nama fail (dengan direktori), tolak teks selepas dan
termasuk tempoh terakhir. Cth, "$(basename myfile/version-1.0-module.c)" ialah
"myfile/versi-1.0-modul"

dir nama fail
Mengekstrak bahagian direktori setiap fail dalam senarai nama fail, termasuk trailing
tetak. Mengembalikan "./" jika tiada direktori dalam nama fail.

dir_noslash nama fail
Sama seperti "$(dir )" kecuali ia tidak mengembalikan garis miring di belakang.

failsubst corak, pengganti, perkataan
Lakukan penggantian corak pada nama fail. Ini berbeza dengan pasubst dalam hal itu
ia akan berfungsi dengan betul apabila nama ganti untuk direktori diberikan (selagi
mereka mendahului tanda peratus). Sebagai contoh,

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

akan berfungsi dengan filesubst tetapi tidak dengan pasubst.

filter_out_dirs nama fail
Mengembalikan semua nama fail yang tidak merujuk kepada direktori.

findfile nama fail, jalan
Mencari fail dalam laluan yang ditentukan, atau dalam PATH pembolehubah persekitaran jika tiada
ditentukan. Ini boleh berguna untuk mencari binari atau memasukkan fail. Sebagai contoh,

TCL_INCLUDE := -I$(dir_noslash $(cari fail 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))

Ini mencari fail tcl.h dengan mencari semua direktori di atas. Yang mutlak
laluan ke fail dikembalikan. Kemudian "$(dir_noslash )" mengekstrak direktori itu, dan ia
dimasukkan ke dalam laluan termasuk.

program_cari nama
Kembalikan program pertama dalam senarai yang boleh didapati dalam PATH. Ini berguna
apabila terdapat berbilang program setara yang boleh digunakan, dan anda hanya mahu
pilih salah satu daripada mereka. Sebagai contoh, berikut ialah takrifan lalai beberapa perkara biasa
pembolehubah yang makepp membekalkan jika anda tidak meletakkan satu dalam fail make anda:

CC = $(find_program gcc egcc pgcc c89 cc) # dan banyak lagi, bergantung pada mesin
F77 = $(cari_program f77 g77 fort77)
CXX = $(cari_program g++ c++ pg++ cxx CC aCC)

Jika tiada atur cara ditemui, "$(find_program )" mengembalikan rentetan yang tidak ditemui dan
mencatat apa yang tidak ditemui. Ini biasanya tidak akan menghasilkan makefile berfungsi, tetapi ia
akan cenderung untuk membuat mesej ralat yang lebih baik. Sebagai contoh, jika anda melakukan sesuatu seperti
ini:

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

dan makepp tidak dapat mencari pengkompil C dalam senarai di atas, ia akan menggantikan not-found.
Jika tidak shell akan cuba untuk melaksanakan fail sumber dan ralat yang terhasil
mesej mungkin sangat pelik.

cari_atas nama fail
Mencari fail dengan nama yang diberikan dalam direktori ., .., ../ ..../../.., Dan sebagainya,
sehingga fail ditemui atau direktori akar dicapai atau direktori terletak
pada sistem fail yang berbeza. (Keperluan terakhir ini adalah untuk mengelakkan masalah dengan
automounters atau sistem fail rangkaian gantung.) Jika anda mempunyai a RootMakeppfile, itu juga
halangan yang menghalang carian lebih tinggi.

Sebagai contoh, jika anda mempunyai projek dengan banyak peringkat subdirektori, anda boleh
sertakan serpihan biasa ini dalam semua makefiles (cth, dengan menggunakan "include"
kenyataan):

TOP_LEVEL_INCLUDE_DIR := $(find_upwards include)
# Mencari direktori yang mengandungi
# termasuk subdirektori.

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

Satu lagi masalah yang "find_upwards" boleh membantu menyelesaikan ialah mencari direktori peringkat atas
daripada binaan. Selalunya ia berguna untuk menentukan pembolehubah seperti ini:

ATAS := ../../..

jika anda mempunyai beberapa maklumat penting yang terletak hanya dalam direktori peringkat atas. Tetapi
ini sukar untuk dikekalkan, kerana bilangan ".." adalah berbeza untuk tahap yang berbeza
daripada pokok direktori. Sebaliknya, anda boleh menggunakan "find_upwards" untuk mencari fail iaitu
diketahui hanya terdapat dalam direktori peringkat atas. Katakan, sebagai contoh, bahawa
fail "LESEN" terletak hanya dalam direktori peringkat atas. Kemudian anda boleh melakukan ini:

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

"$(find_upwards LICENSE)" mengembalikan laluan penuh fail lesen;
"$(dir_noslash ...)" menanggalkan nama fail, hanya mengembalikan direktori.

(Perhatikan bahawa pernyataan "termasuk" mencari fail secara automatik ke atas, jadi di sana
tidak perlu melakukan sesuatu seperti ini:

sertakan $(find_upwards top_level_rules.mk)

Sebaliknya, anda boleh lakukan

sertakan top_level_rules.mk

dan ia akan berfungsi dengan baik.)

Jika fail tidak ditemui, "find_upwards" akan membatalkan binaan dengan mesej ralat.

Jika anda menentukan lebih daripada satu fail, find_upwards akan mencari yang pertama, kemudian
yang kedua, dan seterusnya. Dalam kata lain,

$(find_upwards file1 file2)

adalah bersamaan dengan

$(find_upwards file1) $(find_upwards file2)

Jika anda ingin mencari mana-mana fail, kemudian gunakan "find_first_upwards" sebaliknya.

cari_dahulu_ke atas file1 file2 ...
Fungsi ini berkelakuan seperti "find_upwards" kecuali ia mengembalikan fail pertama mana-mana
fail dalam senarai yang ditemuinya. Khususnya, ia menyemak direktori semasa untuk
mana-mana fail dalam senarai, dan mengembalikan fail pertama yang wujud atau boleh dibina.
Jika tiada fail wujud atau boleh dibina dalam direktori itu, ia akan menyemak .., Maka
../ .., dsb., sehingga ia mencapai sama ada direktori akar atau direktori iaitu
terletak pada sistem fail yang berbeza.

first_available file1 file2 ...
Kembalikan fail pertama dalam senarai yang wujud atau boleh dibina. Ini boleh berguna untuk
menyesuaikan makefiles anda untuk berfungsi pada beberapa mesin atau rangkaian yang berbeza, di mana
fail penting mungkin terletak di tempat yang berbeza. Sebagai contoh, berikut ialah baris daripada
salah satu makefile saya:

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)

Baris ini akan menyemak perpustakaan Tcl di semua tempat di atas, berhenti di
pertama yang ditemuinya. Perintah pautan kemudiannya termasuk $(TCL_LIB) jadi kami mendapat
perpustakaan Tcl yang sesuai.

infer_linker file1 file2 ...
Diberi senarai fail objek mula-mula bina mereka jika mereka belum lagi. Kemudian cari
sama ada mereka bergantung pada sumber Fortran, C++ atau C dan mengembalikan yang sepadan
pengkompil (yang lebih tahu cara memaut daripada "ld").

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

Jika anda menggunakan konvensyen standard mengenai nama fail pengepala, makepp mampu
meneka fail ".o" atau ".lo" mana yang perlu dipautkan dengan program anda. Saya menggunakan ini untuk
pilih fail daripada direktori perpustakaan yang mengandungi modul yang digunakan dalam pelbagai jenis
program. Daripada membuat perpustakaan ".a" fail dan meminta pemaut memilih fail
modul yang berkaitan, makepp boleh memilih modul yang berkaitan untuk anda. Dengan cara ini, sahaja
modul yang berkaitan disusun.

Algoritma Makepp untuk membuat kesimpulan kebergantungan objek bergantung pada konvensyen itu
pelaksanaan semua kelas atau fungsi yang ditakrifkan dalam fail pengepala "xyz.h" adalah
disusun ke dalam fail objek yang dipanggil "xyz.o" (atau "xyz.lo"). Jadi algoritma makepp untuk
membuat kesimpulan kebergantungan objek bermula dengan satu atau beberapa objek yang kita tahu perlu
dikaitkan dengan program. Ia melihat fail mana yang disertakan dengan "#include" dalam
sumber tersebut, dan cuba mencari fail objek yang sepadan untuk setiap termasuk
fail.

"$(infer_objects )" perlu disebut dalam senarai pergantungan program, seperti
ini:

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

Fungsi "$(infer_objects)" mengambil dua argumen (dipisahkan dengan koma, seperti yang ditunjukkan).
Yang pertama ialah satu atau beberapa fail objek yang diketahui diperlukan (wildcards
dibenarkan di sini). Yang kedua ialah senarai objek yang mungkin (biasanya anda akan menggunakan a
kad bebas di sini) yang boleh dipautkan jika perlu. Nilai pulangan daripada ini
fungsi ialah senarai yang mengandungi pertama semua objek dalam hujah pertama, dan
kemudian selepas itu, semua objek tambahan yang terkandung dalam hujah kedua
yang diperlukan oleh objek dalam hujah pertama.

Sebagai contoh, katakan "main.o" berasal daripada "main.cpp", yang merangkumi "my_class.h".
"$(infer_objects)" mencari fail dengan nama "my_class.o". Jika betul-betul seperti itu
fail ditemui, ia ditambah ke senarai. (Jika dua fail objek "my_class.o" ditemui
dalam direktori yang berbeza, mesej amaran dicetak.) "infer_objects" juga
memeriksa "my_class.cpp" untuk melihat perkara yang disertakan dan apakah fail objek tambahan
tersirat.

mktemp
mktemp awalan
mktemp awalanXXX
mktemp /
Mengembalikan nama fail sementara yang tidak dapat diramalkan, yang tidak wujud pada masa ini. Tiada nama
menunjuk ke fail yang sama dikembalikan dua kali, walaupun dengan laluan relatif yang berbeza,
dalam satu larian makepp (kecuali mungkin dengan make rekursif tradisional, atau jika Perl
kod berjalan dalam panggilan tindakan peraturan "f_mktemp"). Di akhir makepp jalankan semua
fail yang dikembalikan oleh fungsi ini dipadamkan, jika ia wujud (sekali lagi kecuali untuk fail tersebut
dikembalikan oleh fungsi ini dalam kod Perl yang berjalan dalam peraturan).

Sebarang bilangan huruf besar "X" pada penghujung hujah digantikan dengan sebanyak itu
huruf rawak dan digit. Semakin banyak, semakin kecil kemungkinan ini bertembung
dengan proses lain, jadi jika anda memberikan awalan seperti "/tmp/abc.", anda sepatutnya cukup
"X" s. Jika terdapat lebih daripada satu X, aksara pertama datang daripada id proses. Jika
tidak ada, seolah-olah terdapat sepuluh, yang sepatutnya cukup (8.4e17
kemungkinan atau 3.7e15 pada Windows). Jika tiada hujah, awalan lalai kepada
"tmp." dalam direktori semasa.

Ambil perhatian bahawa anda tidak mahu memberikan nama sedemikian sebagai sasaran peraturan dan kebergantungan. The
keputusan adalah betul, tetapi ia akan dicipta semula setiap kali anda menjalankan makepp.

Selain itu, kerana ia sentiasa berbeza, anda harus menggunakan ini dalam tindakan peraturan hanya jika anda menggunakan
":build_check ignore_action":

TMFILE ;= $(mktemp) # 1 panggilan; "=" bermaksud 3 panggilan: 3 fail
A-count B-count: :build_check ignore_action
hasilkan-Sebagai-dan-B >$(TMFILE)
&grep -c /A/ $(TMFILE) -o A-count
&grep -c /B/ $(TMFILE) -o B-count

Atau anda harus mengeksportnya dan biarkan Shell menilainya:

eksport TMFILE ;= $(mktemp)
A-kiraan B-kiraan:
produce-As-and-Bs >$$TMFILE # makepp tidak melihat nilai var
fgrep -c A $$TMFILE >A-count
fgrep -c B $$TMFILE >B-count

Borang terakhir mengulangi nilai pulangan sebelumnya, jadi anda boleh menggunakannya dalam peraturan corak:

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

notdir nama fail
Mengembalikan bahagian bukan direktori nama fail, iaitu, semuanya selepas yang terakhir
slash jika ada satu, atau keseluruhan nama fail sebaliknya.

only_generated nama fail
Mengembalikan hanya nama fail dalam senarai yang dijana oleh makepp dan bukan sejak itu
diubah suai, mengikut fail maklumat binaan.

Fungsi ini berguna dalam peraturan sasaran bersih (walaupun sudah tentu "makeppclean" ialah
varian pilihan):

$(palsu bersih):
&rm -f $(hanya_dijana **/*)

only_nontargets nama fail
Mengembalikan hanya nama fail dalam senarai yang bukan sasaran mana-mana peraturan (sama ada
peraturan eksplisit atau corak). Anda boleh menentukan wildcard (lihat "$(wildcard )"
fungsi untuk butiran lanjut tentang kad bebas makepp). Ini boleh digunakan untuk menjana a
sasaran pengedaran, contohnya:

.FONI: pengedaran

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

Dalam kes ini, "$(only_nontargets *)" mengembalikan setiap fail dalam direktori semasa
itu bukan sasaran beberapa peraturan. "$(filter_out %~, ...)" mengalih keluar editor
sandaran.

Sama seperti "sasaran_sahaja" (lihat di atas), "sasaran_sahaja" hanya mengetahui tentang sasaran yang
telah pun ditakrifkan. Ini hanya masalah jika anda menggunakannya untuk menentukan pembolehubah
dengan tugasan ":="; jika anda menggunakannya dalam senarai tanggungan atau dalam badan a
peraturan, semua peraturan lain sudah pun dilihat.

hanya_lapuk nama fail
Mengembalikan hanya nama fail dalam senarai yang dijana oleh makepp dan bukan sejak itu
diubah suai, mengikut fail maklumat binaan, tetapi tidak lagi menjadi sasaran sebarang peraturan.

Fungsi ini berguna untuk memastikan tiada kebergantungan pada fail tersebut,
tanpa memaksa membina bersih semua sasaran:

$(siram palsu):
&rm -f $(hanya_basi **/*)

Sebenarnya, mungkin lebih baik untuk menulis skrip yang memanggil makepp untuk dijana
senarai fail lapuk, dan kemudian minta skrip itu mengalih keluar semua fail tersenarai itu
tidak berada di bawah kawalan sumber pada masa ini, sekiranya fail yang dijana menjadi sumber
fail. Makepp tidak mempunyai fungsi sedemikian terbina dalam kerana makepp adalah (dan mungkin
sepatutnya kekal) agnostik tentang kawalan sumber.

only_targets nama fail
Mengembalikan hanya nama fail dalam senarai yang sebenarnya menjadi sasaran beberapa peraturan
(sama ada peraturan eksplisit atau corak). Anda boleh menentukan wildcard (termasuk makepp's
kad bebas khas, "**") dalam nama fail. (Lihat fungsi "$(wildcard )" untuk maklumat lanjut
butiran. Ini boleh digunakan untuk sasaran yang bersih, contohnya:

.FONI: bersih

bersih:
&rm -f $(sasaran_sahaja *)

Sekarang jika anda menaip "makepp clean", ia akan memadamkan semua yang ia tahu bagaimana untuk membina. Tetapi
jangan buat sasaran bersih, gunakan "makeppclean" sebaliknya!

Satu lagi tempat di mana ia mungkin berguna adalah untuk mengelakkan termasuk basi .o fail dalam anda
membina. Sebagai contoh, jika anda membina perpustakaan seperti ini:

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

dan kemudian anda memadam beberapa fail sumber tetapi terlupa untuk memadam yang sepadan .o fail,
yang .o fail masih ada. Ini bermakna mereka masih akan dimasukkan ke dalam
perpustakaan walaupun pada hakikatnya ia tidak berguna lagi. Jika anda mengubah suai anda
peraturan seperti ini:

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

maka masalah ini tidak akan berlaku.

Ambil perhatian bahawa ini hanya merujuk kepada fail yang diketahui sebagai sasaran at yang masa anda
sembah "sasaran sahaja". Jika "sasaran_sahaja" muncul dalam kebergantungan atau tindakan a
peraturan, maka semua sasaran yang mungkin akan diketahui kerana kebergantungan dan tindakan tidak
dinilai sehingga peraturan itu dilaksanakan. Namun, jika anda menilai cuba menilai
lebih awal dalam makefile dengan pembolehubah ":=" seperti ini:

SEMUA_SASARAN := $(sasaran_sahaja *)

sasaran1: kebergantungan1
tindakan

sasaran2: kebergantungan2
tindakan

maka "only_targets" tidak akan tahu tentang peraturan seterusnya.

Begitu juga, "only_targets" tidak tahu tentang sasaran yang dihasilkan dalam makefiles itu
dimuatkan dengan membuat rekursif. (Tetapi anda tidak sepatutnya menggunakan rekursif make; gunakan
gunakan pernyataan "load_makefile", atau sebaliknya memuatkan makefile tersirat.)

relative_filename file1 file2 fail3[, tebas]
Mengembalikan nama fail tersebut berbanding dengan direktori semasa (yang
makefile berada dalam). Ini juga boleh digunakan untuk membersihkan "./" yang tidak perlu dan sampah lain daripadanya
Jalan itu:

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

If slash adalah benar (biasanya 1) nama fail yang dikembalikan dijamin mengandungi garis miring
dengan menambahkan "./" jika perlu, supaya anda boleh menggunakannya sebagai nama boleh laku tanpa
bimbang tentang laluan carian arahan mengatasi lokasi direktori.

Jika laluan melalui direktori akar, induk sama ada direktori rumah anda atau
"$(ROOT)" sistem binaan anda, atau pada Windows akar pemacu (bergantung pada
persekitaran, ini juga berlaku untuk /cygdrive/c or /c), jalan mutlak akan menjadi
dikembalikan sebaliknya.

relatif kepada file1 file2 fail3[, direktori]
Mengembalikan nama fail tersebut berbanding dengan direktori yang ditentukan. Ini adalah
biasanya berguna apabila atas sebab apa pun anda perlu melaksanakan arahan daripada a
direktori yang berbeza (direktori semasa lalai):

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

akhiran nama...
Mengekstrak akhiran setiap nama fail dalam nama. Jika nama fail mengandungi noktah,
akhiran ialah segala-galanya bermula dengan noktah terakhir. Jika tidak, akhiran ialah
rentetan kosong. Ini selalunya bermakna bahawa keputusan akan kosong apabila nama tidak,
dan jika nama mengandungi berbilang nama fail, hasilnya mungkin mengandungi lebih sedikit nama fail.

Sebagai contoh,

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

menghasilkan hasil ".c .c".

sementara perkataan
Beritahu makepp bahawa sasaran yang ditentukan mungkin dialih keluar oleh peraturan yang menjana
mereka. Sama seperti "palsu", kecuali makepp menjangkakan bahawa fail sebenar nama itu
kehendak mungkin dipengaruhi oleh peraturan. Sesuatu peraturan tidak dilaksanakan jika hanya bersifat sementara
sasaran sudah lapuk.

wildcard pola
Mengembalikan nama yang diisih semua fail yang sepadan dengan corak yang diberikan yang wujud, atau yang
fail yang belum wujud tetapi boleh dibina berdasarkan peraturan yang makepp tahu
kira-kira pada ketika ia menilai ungkapan. Dalam perkara terakhir ini ia berbeza
daripada kad bebas input peraturan, yang digunakan walaupun pada fail yang dibuat oleh peraturan yang ditemui kemudian.

Makepp menyokong semua kad bebas shell biasa ("*", "?", dan "[]"). Ia juga mempunyai a
kad bebas "**" yang sepadan dengan mana-mana bilangan direktori campur tangan. (Idea ini ialah
dicuri daripada zsh.) Contohnya, "**/*.c" sepadan dengan semua .c fail dalam keseluruhan sumber
pokok. "objek/**/*.o" sepadan dengan semua .o fail yang terkandung di mana-mana dalam
subdirektori objek atau mana-mana subdirektorinya atau mana-mana subdirektorinya. The
Kad bebas "**" tidak akan mengikuti pautan lembut ke direktori pada mana-mana peringkat, begitu juga
cuba untuk memasukkan direktori yang wujud tetapi tidak boleh dibaca. Juga fail dan
direktori yang wujud tetapi tidak boleh dibaca tidak akan dikembalikan oleh "$(wildcard )".

Rentetan Fungsi
tambah awalan awalan, perkataan
Menandakan rentetan awalan pada setiap perkataan. Ini kebanyakannya untuk pembuatan GNU
keserasian; menggunakan pengembangan gaya rc, ini boleh dilakukan dengan cara yang lebih mudah dibaca
seperti ini:

MODUL := abcd
X_OLD_STYLE := $(tambah awalan $(OBJDIR)/, $(tambahan akhiran .o, $(MODUL)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # Bukankah itu lebih mudah untuk dibaca?

akhiran tambah akhiran, perkataan
Menambah rentetan akhiran pada setiap perkataan. Ini kebanyakannya untuk pembuatan GNU
keserasian; menggunakan pengembangan gaya rc, ini boleh dilakukan dengan cara yang lebih mudah dibaca
seperti ini:

X_OLD_STYLE := $(tambahan akhiran .o, $(MODUL))
X_NEW_GAYA := $(MODUL).o

memanggil pembolehubah [, perkataan]...
Fungsi "panggilan" adalah unik kerana ia boleh digunakan untuk menganggap berubah-ubah sebagai
fungsi parameter. Anda boleh menetapkan ungkapan kompleks kepada berubah-ubah Dan gunakan
"panggilan" untuk mengembangkan kandungannya kepada nilai berbeza yang diparameterkan oleh perkataan kemudian. Dalam
sistem buatan lain, pembolehubah yang digunakan terutamanya untuk tujuan dikembangkan melalui
"panggilan", dipanggil a makro.

Semasa pengembangan makro, pembolehubah sementara $1, $2, "..." merujuk kepada
hujah yang diberikan untuk "memanggil" semasa seruannya. Pembolehubah $0 akan diperluaskan kepada
nama makro (cth berubah-ubah) bahawa "panggilan" sedang berkembang.

Tiada had, berapa banyak argumen yang boleh "dipanggil" oleh makro atau berapa banyak
parameter yang mungkin dijangkakan oleh makro. Jika anda menghantar lebih banyak hujah untuk "panggil" sebagai makro
perlu, semua hujah yang melebihi akan dibuang. Jika anda meluluskan kurang hujah daripada a
jangkaan makro, semua melebihi parameter runtuh ke dalam rentetan kosong.

Pertama contoh mudah:

rehat = $(senarai perkataan 2, $(perkataan $(1)),$(1))
senarai = ABCDE
butfirst := $(call rest,$(list))

Di sini, pembolehubah "$(butfirst)" akan mengandungi senarai "BCDE".

Dan sekarang untuk contoh yang lebih kompleks untuk menunjukkan apa yang mungkin:

rehat = $(senarai perkataan 2,$(perkataan $(1)),${1})
mymap = $(jika $2,$(panggilan $1,$(perkataan pertama $2)) $(panggil $0,$1,$(panggilan rehat,$2)))
huruf kecil = ${makeperl lc("$1")}

UCWORDS = SEMUA PERKATAAN INI ADALAH UPCASE
DCWORDS := $(panggil mymap,huruf kecil,$(UCWORDS))

Kini "$(DCWORDS)" mengandungi "semua perkataan ini dalam huruf besar". By the way: ia membuat tidak
perbezaan, sama ada kita mengakses hujah melalui $1, "${1}" or "$(1)" dalam makro.

Anda boleh terus menggunakan pembolehubah seolah-olah ia adalah fungsi, jika tiada
fungsi nama itu. Ini ditukar secara dalaman kepada "panggilan", jadi ini adalah
bersamaan:

perbincangan = $0 bertukar menjadi $1 $2.
langsung = $(perbincangan an,hujah)
dipanggil = $(panggilan perbincangan,an,hujah)

Nampaknya boleh dipertikaikan sama ada "$[panggilan]" juga harus mengembangkan "$[]" makro
ungkapan, atau sama ada fungsi harus sentiasa melakukan perkara yang sama, tidak kira bagaimana ia
dipanggil. Yang terakhir dipilih, kerana dengan sintaks make biasa ia akan menjadi
mustahil untuk mendapatkan "$[1], $[2]..." ke dalam pembolehubah (mereka tidak akan digantikan dengan apa-apa,
sebelum tugasan berlaku.) Oleh itu, jika anda mempunyai makro untuk mentakrifkan a
peraturan, anda mahu ungkapan seperti "$(output)" dilihat apabila peraturan itu dihuraikan, jadi
anda mesti melindungi mereka daripada "panggilan":

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

menapis corak, perkataan
Mengembalikan semua perkataan dalam senarai yang sepadan dengan corak. Corak mungkin lain
perkataan, atau kad bebas nama fail (iaitu, "*", "?", dan "[az]" dikenali), atau ia mungkin
mempunyai aksara "%", yang bermaksud untuk memadankan mana-mana rentetan pada ketika itu (sama seperti "*").

Tapis keluar corak, perkataan
Mengembalikan semua perkataan dalam senarai yang tidak sepadan dengan corak. Corak mungkin begitu sahaja
perkataan lain, atau kad bebas nama fail (iaitu, "*", "?", dan "[az]" diiktiraf), atau
mereka mungkin mempunyai aksara "%", yang bermaksud untuk memadankan sebarang rentetan pada ketika itu (sama seperti
"*").

Sebagai contoh:

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

akan meletakkan semua .o fail yang wujud atau boleh dibina, kecuali yang bermula dengan ujian_,
ke dalam libproduction.a.

findstring cari, in
Pulangkan mencari, jika ia adalah subrentetan daripada in.

perkataan pertama perkataan
Kembalikan perkataan pertama.

peta perkataan, perlcode
makemap perkataan, perlcode
Begitu juga dengan peta Perl, terpakai perlcode kepada setiap perkataan secara bergilir-gilir dan mengembalikan
keputusan. Varian pertama ialah kod Perl biasa, manakala varian kedua lulus pertama
perlcode melalui pengembangan pembolehubah gaya Make. Perkataan diperluaskan dalam kedua-duanya
Kes.

Perkataan berada dalam $_ dan dikembalikan melainkan anda membatalkan $_. Ini bertujuan untuk
pengubahsuaian tidak mudah dikendalikan oleh "patsubst". Hanya koma pertama sebagai pemisah,
mana-mana yang lain dianggap sebagai sebahagian daripada perlcode.

# Tukar perkataan. Induk berganda, untuk membenarkan ibu bapa dalam kod perl, atau gunakan ${}:
X = $((peta $(VALUES), s/(.+)-(.+)/$2-$1/))
# Anda boleh menggunakan make expression, tetapi kemudian anda mesti menggunakan $$ untuk Perl $:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ atau $$_ = 'gagal')
# Anda boleh menghapuskan calon:
Y = $(peta $(VALUES), undef $_ jika /no_good/)

menyertai perkataan1, perkataan2
Buat cantuman berpasangan bagi perkataan pertama dan perkataan kedua.

patutubst corak, pengganti, perkataan
Melakukan penggantian pada setiap perkataan dalam senarai perkataan. Aksara "%" sepadan dengan mana-mana
tali. Ini paling baik digambarkan oleh contoh:

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

mengambil setiap fail dalam C_SOURCES dan mengembalikan nama fail objek dalam object_dir.
Kadangkala adalah lebih ringkas untuk menggunakan rujukan penggantian, contohnya, di atas boleh
telah ditulis sebagai

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

jenis word1 word2 word3 ...
Menyusun perkataan dalam susunan leksikal dan mengalih keluar pendua.

jalur rentetan
Mengalih keluar ruang putih di hadapan dan di belakang daripada rentetan dan menggantikan setiap dalaman
jujukan satu atau lebih aksara ruang putih dengan satu ruang. Oleh itu, "$(jalur ab
c )" menghasilkan "abc".

subst daripada,kepada,teks
Melakukan penggantian teks pada teks teks: setiap kejadian daripada diganti
oleh kepada. Hasilnya digantikan dengan panggilan fungsi. Sebagai contoh,

$(subst ee,EE,kaki di jalan)

menggantikan rentetan "fEEt on the stEEt".

perkataan n, teks
Mengembalikan nperkataan ke teks. Nilai sah bagi n bermula dari 1 pada permulaan
atau ke belakang dari -1 pada akhir. Jika n adalah lebih besar daripada bilangan perkataan dalam teks, yang
nilai kosong.

senarai perkataan senarai indeks, perkataan
senarai perkataan indeks pertama, indeks terakhir, perkataan
Dalam bentuk pertama anda membekalkan senarai indeks (mengira dari 1 pada permulaan atau
ke belakang dari -1 di hujung) untuk memilih perkataan yang anda mahu. Dalam bentuk kedua anda
nyatakan julat perkataan yang anda mahu dikembalikan.

perkataan teks
Mengembalikan bilangan perkataan dalam teks.

Lain-lain Fungsi
foreach var, senarai, teks
Dua hujah pertama, var and senarai, dikembangkan sebelum perkara lain dilakukan; Nota
bahawa hujah terakhir, teks, tidak dikembangkan pada masa yang sama. Kemudian untuk setiap perkataan
nilai dikembangkan senarai, pembolehubah yang dinamakan oleh nilai dikembangkan var ditetapkan kepada
perkataan itu, dan teks diperluaskan. Mungkin teks mengandungi rujukan kepada pembolehubah itu,
jadi pengembangannya akan berbeza setiap kali.

Contoh mudah ini menetapkan pembolehubah fail ke senarai semua fail dalam
direktori dalam senarai dirs:

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

Teks di sini ialah "$(wildcard $(dir)/*)". Ulangan pertama mencari nilai "a" untuk dir,
jadi ia menghasilkan hasil yang sama seperti "$(wildcard a/*)"; ulangan kedua menghasilkan
hasil daripada "$(wildcard b/*)"; dan yang ketiga, "$(wildcard c/*)".

Contoh ini mempunyai hasil yang sama (kecuali untuk menetapkan "dirs") seperti contoh berikut:

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

Apabila teks rumit, anda boleh meningkatkan kebolehbacaan dengan memberikannya nama, dengan
pembolehubah tambahan:

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

Di sini kita menggunakan find_files pembolehubah dengan cara ini. Kami menggunakan biasa "=" untuk mentakrifkan a
pembolehubah berkembang secara rekursif, supaya nilainya mengandungi panggilan fungsi sebenar ke
dikembangkan semula di bawah kawalan foreach; pembolehubah yang dikembangkan secara mudah tidak akan berfungsi,
kerana kad bebas akan dipanggil sekali sahaja pada masa menentukan find_files.

Nota: Jangan mengelirukan ini dengan pembolehubah khas "$(foreach)".

maklumat teks
amaran teks
kesilapan teks
Teks output mengembalikan apa-apa. Yang pertama pergi ke STDOUT, yang kedua ke STDERR,
yang ketiga juga membatalkan pemprosesan.

prabina sasaran
membuat sasaran
Mengembalikan hujahnya verbatim, tetapi mula-mula membina semua fail yang disenaraikan. Ini berguna
apabila fail yang diberikan diperlukan semasa menilai ekspresi make. Ini biasanya berlaku
apabila anda mempunyai binaan di mana set fail yang terlibat dikira oleh beberapa shell
arahan. Sebagai contoh,

senarai_fail :
# perintah shell untuk mengira senarai fail untuk dimasukkan ke dalam program

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

Jika anda memerlukan senarai dalam lebih daripada satu peraturan, adalah lebih cekap untuk menggunakan satu
kembangkan paling banyak sekali pembolehubah:

senarai_fail ;= $(&cat $(prabina senarai_fail))

my_program1 : ao $(senarai_fail)

my_program2 : bo $(senarai_fail)

Jika sebaliknya anda hanya menentukan "$(&cat file_list)", maka makepp tidak akan memaksa
file_list untuk dikemas kini sebelum ia melaksanakan arahan shell. Menggunakan "$(prebuild )"
adalah cara terbaik untuk menyelesaikan masalah ini. Anda mungkin tergoda untuk mencuba perkara lain, seperti
ini:

my_program : senarai_fail $(&senarai_fail kucing)

tetapi ini tidak akan berfungsi kerana "$(&cat file_list)" dinilai sebelum makepp cuba melakukannya
bina "senarai_fail".

only_phony_targets nama
Mengembalikan hanya nama-nama dalam senarai yang merupakan sasaran palsu bagi sesetengah peraturan (sama ada
peraturan eksplisit atau corak). Anda boleh menentukan wildcard (termasuk makepp's special
kad bebas, "**") dalam nama fail. (Lihat fungsi "$(wildcard )" untuk butiran lanjut.
Ini boleh digunakan untuk mengumpulkan sasaran, contohnya:

$(ujian palsu): $(only_phony_targets */**/tests)

asal berubah-ubah
Memandangkan nama pembolehubah, memberitahu anda dari mana nilainya berasal.

perl perlcode
makeperl perlcode
Menilai perlcode dalam blok dan mengembalikan hasilnya. Varian pertama ialah Perl biasa
kod, manakala varian kedua terlebih dahulu menghantar perlcode melalui pembolehubah gaya Make
pengembangan.

Ambil perhatian, bahawa, seperti semua fungsi, pembatas fungsi yang digunakan mungkin tidak muncul di dalamnya
perlcode di luar rentetan petikan tunggal atau berganda. Tetapi anda boleh menggandakannya seperti dalam
contoh terakhir:

VAR = 1
VAR1 = ${perl ($VAR + 1) * 3}
VAR2 = $(perl lakukan { $VAR *= 3; kembalikan $VAR + 1 } jika $VAR)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # satu Buat var dan satu Perl var
VAR = $((perl jika( ... ) { ... }))

palsu perkataan
Menunjukkan bahawa senarai perkataan sebenarnya adalah sasaran palsu dan mengembalikan senarai
sasaran. Ia bertujuan untuk digunakan seperti ini:

$(palsu semua): my_program

$(palsu bersih):
&rm -f *.o my_program

Anda juga boleh mengisytiharkan satu atau lebih sasaran sebagai palsu dengan garisan seperti ini di mana-mana sahaja
makefile anda:

.FONI: semua bersih

cetak teks
Mengeluarkan teks dan mengembalikannya. Ini kebanyakannya berguna untuk nyahpepijat, apabila anda tidak melakukannya
fahami mengapa penggantian pembolehubah mempunyai keputusan yang sama. Sebagai contoh,

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

akan mencetak hasil panggilan "patsubst".

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

akan mencetak hujah terakhir untuk panggilan "patsubst".

shell perintah shell
Mengembalikan output daripada arahan shell yang diberikan, dengan baris baharu digantikan dengan ruang.

Ambil perhatian, bahawa, seperti semua fungsi, pembatas fungsi yang digunakan mungkin tidak muncul di dalamnya
perintah shell di luar rentetan petikan tunggal atau berganda. Tetapi anda boleh menggandakannya
seperti dalam contoh kedua:

tarikh = $(tarikh shell) # lebih baik: $(perl skalar masa tempatan)
VAR = ${{shell f() { echo hello; }; f}}

xargs perintah, hujah[, akhiran [, panjang]]
Mengembalikan senarai perintah yang dipisahkan baris baharu yang setiap satu bermula dengan yang ditentukan
perintah, dan diakhiri dengan seberapa banyak elemen senarai yang mungkin tanpa meneruskan
panjang (lalai 1000) aksara.

Tujuannya adalah untuk mengelak daripada melimpahkan had panjang arahan pada sistem anda.
Sebagai contoh, jika terdapat banyak fail yang dijana, maka anda mungkin mahu fail anda
sasaran bersih (yang tidak sepatutnya anda miliki, kerana "makeppclean" lebih cekap) untuk
lihat sesuatu seperti ini:

$(palsu bersih):
$(xargs $(RM), $(sasaran_sahaja **/*))

Ini juga mempunyai kesan sampingan bahawa tiada arahan yang dihasilkan jika senarai
kebetulan kosong. Tetapi dalam kes ini adalah lebih baik untuk menggunakan builtin &rm,
kerana hujah kepada arahan terbina hanya terhad oleh ingatan Perl:

$(palsu bersih):
&rm -f $(sasaran_sahaja **/*)

Jika hujah ketiga ditentukan, maka ia digunakan untuk membetulkan setiap arahan. Ini adalah
berguna untuk menentukan pengarah semula, cth (walaupun di sini sekali lagi &echo akan membantu):

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

Beberapa dokumentasi ini adalah berdasarkan dokumentasi pembuatan GNU.

Sila ambil perhatian bahawa jika fungsi dipanggil semasa permulaan makefile, cth
pengembangan pembolehubah eksport, ralat atau mesej amaran akan melaporkan baris nombor 0.

Gunakan makepp_functions dalam talian menggunakan perkhidmatan onworks.net