makepp_functions - Online di Cloud

PROGRAM:

NAMA

makepp_functions -- Fungsi dalam makepp

DESKRIPSI

A: nama_file absolut,
mutlak_nama file_tidak ada tautan,
abstrak,
tambahkan awalan,
tambahan,
dan, B: nama dasar, C: panggilan, D: aku s,
dir_noslash, E: kesalahan, F: subst file,
Saring,
filter_keluar,
filter_out_dirs,
Mencari berkas,
temukan_pertama_atas,
temukan_program,
menemukan string,
temukan_ke atas,
pertama_tersedia,
kata pertama,
untuk setiap, I: jika,
jika benar,
menyimpulkan_linker,
menyimpulkan_objek,
informasi, J: Ikuti, M: membuat,
membuat peta,
pembuat,
peta,
"mktemp", N: notdir, O: hanya_dihasilkan,
hanya_nontarget,
hanya_target_palsu,
hanya_basi,
hanya_target,
atau,
asal, P: patsub,
perl,
palsu,
membangun sebelumnya,
mencetak, R: jalan nyata,
relatif_namafile,
tergantung pada, S: kulit,
menyortir,
mengupas,
pengganti,
akhiran, T: sementara, W: peringatan,
kartu pengganti,
kata,
Daftar kata,
kata-kata, X: xargs

Ekspresi apa pun dari format "$(name)", di mana "name" bukan nama variabel, atau
"$(name arg1 arg2 arg3)" ditafsirkan sebagai pemanggilan fungsi. Nama dapat berisi huruf,
garis bawah, atau tanda hubung; untuk menghindari kebingungan, Anda dapat menggunakan tanda hubung atau garis bawah
bergantian, karena tanda hubung internal diubah menjadi garis bawah. Mengevaluasi seperti
ekspresi hanya memanggil subrutin Perl. Jika "nama" didahului oleh "&" itu menjalankan
perintah atau skrip bawaan dari nama itu dalam proses makepp, dan mengembalikan standar
keluaran. Ini membutuhkan Perl untuk dibangun untuk PerlIO. Jika nama tidak menyebutkan fungsi
itu diubah menjadi permintaan panggilan.

Seperti halnya variabel, Anda memiliki pilihan "$(name ...)" atau "${name ...}". Jika Anda menghendaki
menyematkan tanda kurung yang sama, itu harus dipasangkan, yang lain tidak masalah: "$(name
...(){..." atau "${name ...{}(...}". (Namun untuk peta dan Perl, tanda kurung penutup pertama berakhir
ekspresi.) Penggandaan memungkinkan argumen untuk menjangkau beberapa baris. Baris baru adalah
kemudian diperlakukan sebagai spasi, kecuali mungkin dalam "define". Ada juga sintaks "$[name ...]"
atau $[[name ...]], yang dievaluasi saat membaca makefile, sebelum aturan grokking
dan konstruksi lainnya.

Makepp memiliki sejumlah fungsi bawaan yang mungkin berguna. Ini mendukung hampir semua
Fungsi tekstual GNU make (lihat dokumentasi GNU make untuk detailnya), dan beberapa di antaranya
memiliki. Anda dapat menentukan subrutin Perl untuk melakukan apa pun yang Anda suka. Lihat pernyataan "sub"
dan bagian tentang memperluas makepp untuk lebih jelasnya.

Bersyarat Fungsi
dan kondisi1[,kondisi2[,kondisi3...]]
Fungsi and menyediakan operasi AND "hubungan arus pendek". Setiap argumen adalah
diperluas, secara berurutan. Jika argumen diperluas ke string kosong, pemrosesan berhenti dan
hasil dari ekspansi adalah string kosong. Jika semua argumen berkembang menjadi non-
string kosong maka hasil ekspansi adalah perluasan dari argumen terakhir.

if rangkaian, hasil-jika-string-tidak-kosong[, hasil-jika-string-kosong]
jika benar rangkaian, hasil-jika-string-benar[, hasil-jika-string-salah]
Sebuah alternatif untuk "ifeq", dll, pernyataan. Jika string tidak kosong (yaitu,
kondisi benar), argumen kedua (klausa "kemudian") dikembalikan (setelah
ekspansi variabel); jika string kosong, argumen ketiga (klausa "lain") adalah
dikembalikan.

Sebagai contoh,

CFLAGS := $(jika $(filter gcc misalnya, $(CC)), -g -Dinding, -g)

mendefinisikan CFLAGS menjadi "-g -Wall" jika variabel CC adalah "gcc" atau "egcc", dan "-g"
jika tidak. (Inilah yang dilakukan oleh aturan build default.)

"iftrue" mirip dengan "jika", kecuali bahwa string 0 diperlakukan sebagai kosong.

or kondisi1[,kondisi2[,kondisi3...]]
Fungsi or menyediakan operasi OR "hubungan arus pendek". Setiap argumen diperluas,
dalam urutan. Jika argumen diperluas ke string yang tidak kosong, pemrosesan berhenti dan
hasil dari ekspansi adalah string itu. Jika, setelah semua argumen diperluas, semua
mereka salah (kosong), maka hasil ekspansi adalah string kosong.

File dan Filename Fungsi
nama_file absolut arsip
abstrak arsip
Mengonversi nama file relatif menjadi absolut tanpa . or ... Sebagai contoh,
"$(absolute_filename xyz.c)" mungkin mengembalikan "/usr/src/our_project/subdir/xyz.c".

absolute_filename_nolink arsip
jalan nyata arsip
Seperti absolute_filename, tetapi memastikan bahwa tautan simbolik diselesaikan.

nama dasar nama file
Nama dasar adalah seluruh nama file (dengan direktori), dikurangi teks setelah dan
termasuk periode terakhir. Misalnya, "$(basename myfile/version-1.0-module.c)" adalah
"myfile/versi-1.0-modul"

dir nama file
Ekstrak bagian direktori dari setiap file dalam daftar nama file, termasuk trailing
memotong. Mengembalikan "./" jika tidak ada direktori dalam nama file.

dir_noslash nama file
Sama seperti "$(dir )" kecuali bahwa itu tidak mengembalikan garis miring.

filesubst pola, pengganti, kata
Lakukan substitusi pola pada nama file. Ini berbeda dari patsubst dalam hal itu
itu akan tampil dengan benar ketika nama alternatif untuk direktori diberikan (selama
mereka mendahului tanda persen). Sebagai contoh,

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

akan bekerja dengan filessubst tetapi tidak dengan patsubst.

filter_out_dirs nama file
Mengembalikan semua nama file yang tidak merujuk ke direktori.

Mencari berkas nama file, path
Menemukan file di jalur yang ditentukan, atau di variabel lingkungan PATH jika tidak ada
ditentukan. Ini dapat berguna untuk menemukan binari atau menyertakan file. Sebagai contoh,

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))

Ini menempatkan file tcl.h dengan mencari semua direktori di atas. Yang mutlak
path ke file dikembalikan. Kemudian "$(dir_noslash )" mengekstrak direktori itu, dan itu
dimasukkan ke dalam jalur include.

temukan_program nama
Kembalikan program pertama dalam daftar yang dapat ditemukan di PATH. Ini berguna
ketika ada beberapa program setara yang dapat digunakan, dan Anda hanya ingin
memilih salah satu dari mereka. Misalnya, berikut adalah definisi default dari beberapa umum
variabel yang disediakan makepp jika Anda tidak memasukkannya ke dalam makefile Anda:

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

Jika tidak ada program yang ditemukan, "$(find_program )" mengembalikan string tidak ditemukan, dan
mencatat apa yang tidak ditemukan. Ini biasanya tidak akan menghasilkan makefile yang fungsional, tetapi itu
akan cenderung membuat pesan kesalahan yang lebih baik. Misalnya, jika Anda melakukan sesuatu seperti
ini:

%.o : %.c
$(CC) $(masukan) -o $(keluaran)

dan makepp tidak dapat menemukan kompiler C dalam daftar di atas, itu akan menggantikan not-found.
Kalau tidak, shell akan mencoba mengeksekusi file sumber dan kesalahan yang dihasilkan
pesan mungkin benar-benar aneh.

temukan_ke atas nama file
Mencari file dengan nama yang diberikan di direktori ., .., ../ ..../../.., Dll,
sampai file ditemukan atau direktori root tercapai atau direktori berada
pada sistem file yang berbeda. (Persyaratan terakhir ini adalah untuk mencegah masalah dengan
automounter atau sistem file jaringan yang digantung.) Jika Anda memiliki File RootMakepp, itu juga
penghalang yang mencegah pencarian lebih tinggi.

Misalnya, jika Anda memiliki proyek dengan banyak tingkat subdirektori, Anda dapat
sertakan fragmen umum ini di semua makefile (misalnya, dengan menggunakan "include"
penyataan):

TOP_LEVEL_INCLUDE_DIR := $(menemukan_meningkat termasuk)
# Mencari direktori yang berisi
# termasuk subdirektori.

%.o : %.c
$(CC) $(CFLAGS) -I$(TOP_LEVEL_INCLUDE_DIR) -c $(masukan) -o $(keluaran)

Masalah lain yang dapat dipecahkan oleh "find_upwards" adalah menemukan direktori tingkat atas
dari sebuah bangunan. Seringkali berguna untuk mendefinisikan variabel seperti ini:

TERATAS := ../../..

jika Anda memiliki beberapa informasi penting yang hanya terletak di direktori tingkat atas. Tetapi
ini sulit dipertahankan, karena jumlah ".." berbeda untuk level yang berbeda
dari pohon direktori. Sebagai gantinya, Anda dapat menggunakan "find_upwards" untuk menemukan file yang
diketahui hanya ada di direktori tingkat atas. Misalkan, misalnya, bahwa
file "LISENSI" hanya terletak di direktori tingkat atas. Maka Anda bisa melakukan ini:

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

"$(find_upwards LICENSE)" mengembalikan path lengkap dari file lisensi;
"$(dir_noslash ...)" menghapus nama file, hanya mengembalikan direktori.

(Perhatikan bahwa pernyataan "sertakan" secara otomatis mencari file ke atas, jadi ada
tidak perlu melakukan sesuatu seperti ini:

sertakan $(find_upwards top_level_rules.mk)

Sebagai gantinya, Anda bisa melakukannya

sertakan top_level_rules.mk

dan itu akan bekerja dengan baik.)

Jika file tidak ditemukan, "find_upwards" akan membatalkan pembangunan dengan pesan kesalahan.

Jika Anda menentukan lebih dari satu file, find_upwards akan mencari yang pertama, lalu
yang kedua, dan seterusnya. Dengan kata lain,

$(temukan_ke atas file1 file2)

adalah setara dengan

$(temukan_ke atas file1) $(temukan_ke atas file2)

Jika Anda ingin mencari salah satu file, gunakan "find_first_upwards".

temukan_pertama_atas file1 file2 ...
Fungsi ini berperilaku seperti "find_upwards" kecuali mengembalikan file pertama dari sembarang
file dalam daftar yang ditemukannya. Secara khusus, ia memeriksa direktori saat ini untuk
salah satu file dalam daftar, dan mengembalikan file pertama yang ada atau dapat dibuat.
Jika tidak ada file yang ada atau dapat dibangun di direktori itu, ia akan memeriksa .., kemudian
../ .., dll., hingga mencapai direktori root atau direktori yang
terletak pada sistem file yang berbeda.

pertama_tersedia file1 file2 ...
Kembalikan file pertama dalam daftar yang ada atau dapat dibangun. Ini bisa berguna untuk
mengadaptasi makefile Anda untuk bekerja di beberapa mesin atau jaringan yang berbeda, di mana
file penting mungkin terletak di tempat yang berbeda. Sebagai contoh, inilah baris dari
salah satu makefile saya:

TCL_LIB = $(tersedia_pertama \
/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 memeriksa perpustakaan Tcl di semua tempat di atas, berhenti di
pertama yang ditemukannya. Perintah tautan kemudian menyertakan $(TCL_LIB) sehingga kita mendapatkan
perpustakaan Tcl yang sesuai.

menyimpulkan_linker file1 file2 ...
Diberikan daftar file objek, buat terlebih dahulu jika belum. Kemudian temukan
apakah mereka bergantung pada sumber Fortran, C++ atau C dan mengembalikan yang sesuai
compiler (yang lebih tahu bagaimana menautkan daripada "ld").

menyimpulkan_objek file1 file2 ... belt hold
$(infer_objects objek1.o objek2.o, *.o)

Jika Anda menggunakan konvensi standar mengenai nama file header, makepp mampu
menebak file ".o" atau ".lo" mana yang perlu ditautkan dengan program Anda. Saya menggunakan ini untuk
pilih file dari direktori perpustakaan yang berisi modul yang digunakan dalam banyak hal berbeda
program. Alih-alih membuat file ".a" perpustakaan dan meminta tautan memilih
modul yang relevan, makepp dapat memilih modul yang relevan untuk Anda. Dengan cara ini, hanya
modul yang relevan dikompilasi.

Algoritme Makepp untuk menyimpulkan dependensi objek bergantung pada konvensi bahwa
implementasi semua kelas atau fungsi yang didefinisikan dalam file header "xyz.h" adalah
dikompilasi ke dalam file objek yang disebut "xyz.o" (atau "xyz.lo"). Jadi algoritma makepp untuk
menyimpulkan dependensi objek dimulai dengan satu atau beberapa objek yang kita tahu harus ada
dihubungkan ke dalam program. Itu terlihat pada file mana yang disertakan dengan "#include" di
sumber tersebut, dan mencoba untuk menemukan file objek yang sesuai untuk masing-masing include
file.

"$(infer_objects )" perlu disebutkan dalam daftar ketergantungan suatu program, seperti
ini:

prog saya: $(infer_objects main.o another_object.o, \
**/*.o /lainnya/perpustakaan/dirs/**/*.o)
$(CXX) $(masukan) -o $(keluaran) $(LIBS)

Fungsi "$(infer_objects)" membutuhkan dua argumen (dipisahkan dengan koma, seperti yang ditunjukkan).
Yang pertama adalah satu atau beberapa file objek yang diketahui diperlukan (wildcard adalah
diperbolehkan di sini). Yang kedua adalah daftar objek yang mungkin (biasanya Anda akan menggunakan a
wildcard di sini) yang dapat ditautkan jika perlu. Nilai pengembalian dari ini
fungsi adalah daftar yang berisi pertama semua objek dalam argumen pertama, dan
lalu setelah itu, semua objek tambahan yang terkandung dalam argumen kedua
yang dibutuhkan oleh objek dalam argumen pertama.

Misalnya, misalkan "main.o" berasal dari "main.cpp", yang mencakup "kelas_saya.h".
"$(infer_objects)" mencari file dengan nama "my_class.o". Jika tepat satu seperti itu
file ditemukan, itu ditambahkan ke daftar. (Jika dua file objek "my_class.o" ditemukan
di direktori yang berbeda, pesan peringatan dicetak.) "infer_objects" juga
memeriksa "my_class.cpp" untuk melihat apa yang termasuk di dalamnya, dan apa file objek tambahannya
tersirat.

mktemp
mktemp awalan
mktemp awalanXXX
mktemp /
Mengembalikan nama file sementara yang tidak dapat diprediksi, yang saat ini tidak ada. Tanpa nama
menunjuk ke file yang sama dikembalikan dua kali, bahkan dengan jalur relatif yang berbeda,
dalam satu makepp run (kecuali mungkin dengan make rekursif tradisional, atau jika Perl
kode yang berjalan dalam tindakan aturan memanggil "f_mktemp"). Di akhir makepp, jalankan semua
file yang dikembalikan oleh fungsi ini akan dihapus, jika ada (sekali lagi kecuali untuk itu
dikembalikan oleh fungsi ini dalam kode Perl yang berjalan dalam aturan).

Sejumlah huruf besar "X" di akhir argumen diganti dengan banyak itu
huruf dan angka acak. Semakin banyak, semakin kecil kemungkinannya untuk bertabrakan
dengan proses lain, jadi jika Anda memberikan awalan seperti "/tmp/abc.", kamu seharusnya sudah cukup
"X". Jika ada lebih dari satu X, karakter pertama berasal dari id proses. Jika
tidak ada, seolah-olah ada sepuluh, yang seharusnya cukup (8.4e17
kemungkinan atau 3.7e15 pada Windows). Jika tidak ada argumen, awalan default ke
"tmp." di direktori saat ini.

Perhatikan bahwa Anda tidak ingin memberikan nama seperti target aturan dan dependensi. Itu
hasilnya akan benar, tetapi akan dibuat ulang setiap kali Anda menjalankan makepp.

Juga, karena selalu berbeda, Anda harus menggunakan ini dalam tindakan aturan hanya jika Anda menggunakan
":build_check abaikan_action":

TMPFILE ;= $(mktemp) # 1 panggilan; "=" berarti 3 panggilan: 3 file
A-count B-count: :build_check abaikan_action
menghasilkan-Sebagai-dan-Bs >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o Hitungan
&grep -c /B/ $(TMPFILE) -o B-hitung

Atau Anda harus mengekspornya dan membiarkan Shell mengevaluasinya:

ekspor TMPFILE ;= $(mktemp)
A-hitungan B-hitung:
menghasilkan-Sebagai-dan-Bs >$$TMPFILE # makepp tidak melihat nilai var
fgrep -c A $$TMPFILE >A-hitungan
fgrep -c B $$TMPFILE >B-hitung

Formulir terakhir mengulangi nilai pengembalian sebelumnya, sehingga Anda dapat menggunakannya dalam aturan pola:

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

notdir nama file
Mengembalikan bagian non-direktori dari nama file, yaitu, semuanya setelah yang terakhir
slash jika ada, atau seluruh nama file sebaliknya.

hanya_dihasilkan nama file
Mengembalikan hanya nama file dalam daftar yang dihasilkan oleh makepp dan bukan sejak
dimodifikasi, sesuai dengan file info build.

Fungsi ini berguna dalam aturan target bersih (meskipun tentu saja "makeppclean" adalah
varian pilihan):

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

hanya_nontarget nama file
Mengembalikan hanya nama file dalam daftar yang bukan target aturan apa pun (baik
aturan eksplisit atau pola). Anda dapat menentukan wildcard (lihat "$(wildcard )"
fungsi untuk detail lebih lanjut tentang wildcard makepp). Ini dapat digunakan untuk menghasilkan
sasaran distribusi, misalnya:

.PHONY: distribusi

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

Dalam hal ini, "$(only_nontargets *)" mengembalikan setiap file di direktori saat ini
itu bukan target dari beberapa aturan. "$(filter_out %~, ...)" menghapus editor
backup.

Mirip dengan "only_targets" (lihat di atas), "only_nontargets" hanya tahu tentang target yang
telah didefinisikan sudah. Ini hanya masalah jika Anda menggunakannya untuk mendefinisikan variabel
dengan ":=" tugas; jika Anda menggunakannya dalam daftar ketergantungan atau di badan a
aturan, semua aturan lain sudah terlihat.

only_basi nama file
Mengembalikan hanya nama file dalam daftar yang dihasilkan oleh makepp dan bukan sejak
dimodifikasi, menurut file info build, tetapi tidak lagi menjadi target aturan apa pun.

Fungsi ini berguna untuk memastikan bahwa tidak ada ketergantungan pada file tersebut,
tanpa memaksakan pembangunan bersih dari semua target:

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

Sebenarnya, mungkin lebih baik menulis skrip yang memanggil makepp untuk menghasilkan
daftar file basi, dan kemudian minta skrip itu menghapus semua file yang terdaftar yang
saat ini tidak di bawah kendali sumber, untuk berjaga-jaga jika file yang dihasilkan menjadi sumber
mengajukan. Makepp tidak memiliki fungsi bawaan karena makepp adalah (dan mungkin
harus tetap) agnostik tentang kontrol sumber.

hanya_target nama file
Mengembalikan hanya nama file dalam daftar yang sebenarnya merupakan target dari beberapa aturan
(baik aturan eksplisit atau pola). Anda dapat menentukan wildcard (termasuk makepp's
wildcard khusus, "**") dalam nama file. (Lihat fungsi "$(wildcard )" untuk lebih lanjut
rincian. Ini dapat digunakan untuk target bersih, misalnya:

.PHONY: bersih

bersih:
&rm -f $(only_targets *)

Sekarang jika Anda mengetik "makepp clean", itu akan menghapus semua yang diketahui cara membangunnya. Tetapi
jangan buat target bersih, gunakan "makeppclean" sebagai gantinya!

Tempat lain yang mungkin berguna adalah menghindari memasukkan basi .o file di Anda
membangun. Misalnya, jika Anda membangun perpustakaan seperti ini:

mylib.a: *.o
&rm -f $(keluaran)
$(AR) cr $(keluaran) $(masukan)

dan kemudian Anda menghapus beberapa file sumber tetapi lupa untuk menghapus yang sesuai .o file,
itu .o file akan tetap ada. Ini berarti mereka masih akan dimasukkan ke dalam
perpustakaan meskipun fakta bahwa mereka tidak berguna lagi. Jika Anda memodifikasi
aturan seperti ini:

mylib.a: $(hanya_target *.o)
&rm -f $(keluaran)
$(AR) cr $(keluaran) $(masukan)

maka masalah ini tidak akan terjadi.

Perhatikan bahwa ini hanya merujuk ke file yang diketahui sebagai target at itu waktu kamu
memohon "hanya-target". Jika "only_targets" muncul di dependensi atau tindakan a
aturan, maka semua target yang mungkin akan diketahui karena dependensi dan tindakan tidak
dievaluasi sampai aturan dijalankan. Namun, jika Anda mengevaluasi, cobalah untuk mengevaluasinya
sebelumnya di makefile dengan variabel ":=" seperti ini:

SEMUA_TARGET := $(hanya_target *)

target1: ketergantungan1
tindakan

target2: ketergantungan2
tindakan

maka "only_targets" tidak akan tahu tentang aturan selanjutnya.

Demikian pula, "only_targets" tidak tahu tentang target yang dihasilkan di makefile yang
dimuat dengan make rekursif. (Tapi Anda seharusnya tidak menggunakan make rekursif; gunakan
gunakan pernyataan "load_makefile", atau pemuatan makefile implisit sebagai gantinya.)

nama_file relatif file1 file2 berkas3[, memotong]
Mengembalikan nama file tersebut relatif terhadap direktori saat ini (yang
makefile masuk). Ini juga dapat digunakan untuk membersihkan "./" yang tidak perlu dan sampah lainnya dari
jalan:

DIRI := .
SUBDIR := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/files
X := $(nama_file relatif $(FNAME))

If memotong benar (biasanya 1) nama file yang dikembalikan dijamin mengandung garis miring
dengan menambahkan "./" jika perlu, sehingga Anda dapat menggunakannya sebagai nama yang dapat dieksekusi tanpa
khawatir tentang jalur pencarian perintah yang menimpa lokasi direktori.

Jika jalur melewati direktori root, induk dari direktori home Anda atau
"$(ROOT)" dari sistem build Anda, atau pada Windows root drive (tergantung pada
lingkungan, ini juga terjadi untuk /cygdrive/c or /c), jalur absolutnya adalah
dikembalikan sebagai gantinya.

tergantung pada file1 file2 berkas3[, direktori]
Mengembalikan nama file tersebut relatif terhadap direktori yang ditentukan. Ini
biasanya berguna ketika karena alasan apa pun Anda harus menjalankan perintah dari a
direktori yang berbeda (direktori default saat ini):

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

akhiran nama...
Ekstrak akhiran setiap nama file dalam nama. Jika nama file mengandung titik,
akhiran adalah segala sesuatu yang dimulai dengan periode terakhir. Jika tidak, sufiksnya adalah
string kosong. Ini sering berarti bahwa hasilnya akan kosong ketika nama tidak,
dan jika nama berisi beberapa nama file, hasilnya mungkin berisi lebih sedikit nama file.

Sebagai contoh,

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

menghasilkan hasil ".c .c".

sementara kata
Beri tahu makepp bahwa target yang ditentukan dapat dihapus oleh aturan yang menghasilkan
mereka. Mirip dengan "palsu", kecuali makepp itu mengharapkan file asli dari nama itu
akan terpengaruh oleh aturan tersebut. Suatu aturan tidak akan dieksekusi jika hanya bersifat sementara
target sudah ketinggalan zaman.

wildcard belt hold
Mengembalikan nama yang diurutkan dari semua file yang cocok dengan pola tertentu yang ada, atau itu
file yang belum ada tetapi dapat dibangun berdasarkan aturan yang diketahui makepp
tentang pada titik ketika mengevaluasi ekspresi. Dalam poin terakhir ini berbeda
dari wildcard masukan aturan, yang berlaku bahkan untuk file yang dibuat oleh aturan yang ditemukan kemudian.

Makepp mendukung semua wildcard shell biasa ("*", "?", dan "[]"). Ia juga memiliki
wildcard "**" yang cocok dengan sejumlah direktori intervensi. (Ide ini adalah
dicuri dari zsh.) Misalnya, "**/*.c" cocok dengan semua .c file di seluruh sumber
pohon. "objects/**/*.o" cocok dengan semua .o file yang terkandung di mana saja di
subdirektori objek atau salah satu subdirektorinya atau salah satu subdirektorinya. Itu
Wildcard "**" tidak akan mengikuti tautan lunak ke direktori di tingkat mana pun, juga tidak
mencoba masuk ke direktori yang ada tetapi tidak dapat dibaca. Juga file dan
direktori yang ada tetapi tidak dapat dibaca tidak akan dikembalikan oleh "$(wildcard )".

Tali Fungsi
tambahkan awalan awalan, kata
Menambahkan string awalan ke setiap kata. Ini sebagian besar untuk merek GNU
kesesuaian; menggunakan ekspansi gaya rc, ini dapat dilakukan dengan cara yang lebih mudah dibaca
seperti ini:

MODUL := abcd
X_OLD_STYLE := $(addprefix $(OBJDIR)/, $(addsuffix .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # Bukankah lebih mudah dibaca?

tambahan akhiran, kata
Menambahkan string sufiks ke setiap kata. Ini sebagian besar untuk merek GNU
kesesuaian; menggunakan ekspansi gaya rc, ini dapat dilakukan dengan cara yang lebih mudah dibaca
seperti ini:

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

panggilan variabel[, kata-kata]...
Fungsi "panggilan" unik karena dapat digunakan untuk menganggap variabel sebagai
fungsi parameter. Anda dapat menetapkan ekspresi kompleks untuk variabel Dan gunakan
"panggil" untuk memperluas isinya ke nilai-nilai berbeda yang diparametrikan oleh kata kemudian. Di
sistem make lainnya, variabel yang digunakan terutama untuk tujuan diperluas melalui
"panggilan", disebut a makro.

Selama ekspansi makro, variabel sementara $1, $2, "..." mengacu kepada
argumen yang diberikan kepada "panggilan" selama pemanggilannya. variabel $0 akan diperluas menjadi
nama makro (mis variabel) bahwa "panggilan" sedang berkembang.

Tidak ada batasan, berapa banyak argumen yang dapat "dipanggil" dengan makro atau berapa banyak
parameter yang mungkin diharapkan makro. Jika Anda memberikan lebih banyak argumen untuk "memanggil" sebagai makro
kebutuhan, semua argumen yang berlebihan akan dibuang. Jika Anda memberikan lebih sedikit argumen daripada a
makro harapkan, semua parameter yang melebihi runtuh ke dalam string kosong.

Pertama contoh sederhana:

sisanya = $(daftar kata 2, $(kata $(1)),$(1))
daftar = ABCDE
tapi pertama := $(sisa panggilan,$(daftar))

Di sini, variabel "$(butfirst)" akan berisi daftar "BCDE".

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

sisanya = $(daftar kata 2,$(kata $(1)),${1})
peta saya = $(jika $2,$(panggil $1,$(kata pertama $2)) $(hubungi $0,$1,$(panggilan sisanya,$2)))
huruf kecil = ${makeperl lc("$1")}

UCWORDS = SEMUA KATA INI UPCASE
DCWORDS := $(panggil mymap,downcase,$(UCWORDS))

Sekarang "$(DCWORDS)" berisi "semua kata ini huruf besar". Omong-omong: itu tidak membuat
perbedaan, apakah kita mengakses argumen melalui $1, "${1}" or "$(1)" dalam makro.

Anda dapat langsung menggunakan variabel seolah-olah itu adalah fungsi, jika tidak ada
fungsi dari nama itu. Ini secara internal diubah menjadi "panggilan", jadi ini adalah
setara:

diskusi = $0 berubah menjadi $1 $2.
langsung = $(diskusi dan,argumen)
disebut = $(panggilan diskusi,an,argumen)

Mungkin tampak bisa diperdebatkan apakah "$[call]" juga harus memperluas "$[]" makro
ekspresi, atau apakah suatu fungsi harus selalu melakukan hal yang sama, tidak peduli bagaimana itu
disebut. Yang terakhir dipilih, karena dengan sintaks make normal akan menjadi
tidak mungkin memasukkan "$[1], $[2]..." ke dalam variabel (mereka tidak akan digantikan oleh apa pun,
bahkan sebelum penugasan berlangsung.) Oleh karena itu, jika Anda memiliki makro untuk mendefinisikan a
aturan, Anda ingin ekspresi seperti "$(output)" terlihat saat aturan diuraikan, jadi
anda harus melindungi mereka dari "panggilan":

tentukan myrule
$2: $1
perintah saya $$(masukan) -o $$(keluaran)
endef
$[myrule myinput, myoutput]

menyaring pola, kata
Mengembalikan semua kata dalam daftar yang cocok dengan pola. Pola mungkin hanya yang lain
kata, atau wildcard nama file (yaitu, "*", "?", dan "[az]" dikenali), atau mungkin
memiliki karakter "%", yang berarti mencocokkan string apa pun pada saat itu (sama dengan "*").

filter_out pola, kata
Mengembalikan semua kata dalam daftar yang tidak cocok dengan pola. Pola mungkin saja
kata lain, atau wildcard nama file (yaitu, "*", "?", dan "[az]" dikenali), atau
mereka mungkin memiliki karakter "%", yang berarti mencocokkan string apa pun pada saat itu (sama dengan
"*").

Sebagai contoh:

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

akan menempatkan semua .o file yang ada atau dapat dibuat, kecuali yang dimulai dengan uji_,
ke produksi lib.a.

menemukan string Temukan, in
Pengembalian menemukan, jika merupakan substring dari in.

kata pertama kata
Kembalikan kata pertama.

peta kata-kata, kode perl
membuat peta kata-kata, kode perl
Sama halnya dengan peta Perl, berlaku kode perl untuk setiap kata secara bergantian dan mengembalikan
hasil. Varian pertama adalah kode Perl biasa, sedangkan varian kedua melewati pertama
perlcode melalui ekspansi variabel Make-style. Kata-katanya diperluas di keduanya
Kasus.

Kata-kata dalam $_ dan dikembalikan kecuali Anda undef $_. Ini dimaksudkan untuk
modifikasi tidak mudah ditangani oleh "patsubst". Hanya koma pertama yang menjadi pemisah,
yang lain dianggap sebagai bagian dari kode perl.

# Ganti kata. Parens ganda, untuk mengizinkan parens dalam perlcode, atau gunakan ${}:
X = $((peta $(VALUES), s/(.+)-(.+)/$2-$1/))
# Anda dapat menggunakan ekspresi make, tetapi kemudian Anda harus menggunakan $$ untuk Perl $:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ atau $$_ = 'gagal')
# Anda dapat menghilangkan kandidat:
Y = $(peta $(VALUES), undef $_ if /no_good/)

ikut kata-kata1, kata2
Lakukan penggabungan berpasangan dari kata pertama dan kata kedua.

patsubst pola, pengganti, kata
Melakukan substitusi pada setiap kata dalam daftar kata. Karakter "%" cocok dengan semua
rangkaian. Ini paling baik diilustrasikan dengan sebuah contoh:

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

mengambil setiap file di C_SOURCES dan mengembalikan nama file objek di object_dir.
Terkadang lebih ringkas menggunakan referensi substitusi, misalnya di atas bisa
telah ditulis sebagai

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

jenis word1 word2 word3 ...
Mengurutkan kata-kata dalam urutan leksikal dan menghapus duplikat.

menelanjangi tali
Menghapus spasi putih awal dan akhir dari string dan mengganti setiap internal
urutan satu atau lebih karakter spasi dengan satu spasi. Jadi, "$(strip ab
c )" menghasilkan "abc".

subst dari, ke, teks
Melakukan penggantian tekstual pada teks teks: setiap kemunculan dari diganti
oleh untuk. Hasilnya diganti dengan pemanggilan fungsi. Sebagai contoh,

$(pengganti ee,EE,kaki di jalan)

menggantikan string "fEEt di jalan".

kata n, teks
Mengembalikan nkata dari teks. Nilai-nilai yang sah dari n mulai dari 1 di awal
atau mundur dari -1 di akhir. Jika n lebih besar dari jumlah kata dalam teks, yang
nilai kosong.

Daftar kata daftar indeks, kata
Daftar kata indeks pertama, indeks terakhir, kata
Dalam formulir pertama Anda memberikan daftar indeks (dihitung dari 1 di awal atau
mundur dari -1 di akhir) untuk memilih kata yang Anda inginkan. Dalam bentuk kedua Anda
tentukan rentang kata yang ingin dikembalikan.

kata teks
Mengembalikan jumlah kata dalam teks.

bermacam-macam Fungsi
untuk setiap var, daftar, teks
Dua argumen pertama, adalah dan daftar, diperluas sebelum hal lain dilakukan; catatan
bahwa argumen terakhir, teks, tidak diperluas pada saat yang bersamaan. Kemudian untuk setiap kata dari
nilai daftar yang diperluas, variabel yang dinamai dengan nilai var yang diperluas diatur ke
kata itu, dan teks diperluas. Agaknya teks berisi referensi ke variabel itu,
sehingga ekspansi akan berbeda setiap kali.

Contoh sederhana ini menetapkan variabel arsip ke daftar semua file di
direktori dalam daftar dirs:

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

Di sini teksnya adalah "$(wildcard $(dir)/*)". Pengulangan pertama menemukan nilai "a" untuk dir,
sehingga menghasilkan hasil yang sama dengan "$(wildcard a/*)"; pengulangan kedua menghasilkan
hasil dari "$(wildcard b/*)"; dan yang ketiga, yaitu "$(wildcard c/*)".

Contoh ini memiliki hasil yang sama (kecuali untuk pengaturan "dir") seperti contoh berikut:

file := $(karakter pengganti a/* b/* c/* d/*)

Saat teks rumit, Anda dapat meningkatkan keterbacaan dengan memberinya nama, dengan
variabel tambahan:

find_files = $(karakter pengganti $(dir)/*)
dirs := abcd
file := $(foreach dir,$(dirs),$(find_files))

Di sini kita menggunakan variabel find_files dengan cara ini. Kami menggunakan "=" biasa untuk mendefinisikan a
variabel yang berkembang secara rekursif, sehingga nilainya berisi panggilan fungsi aktual ke
dikembangkan kembali di bawah kendali foreach; variabel yang diperluas sederhana tidak akan berhasil,
karena wildcard akan dipanggil hanya sekali pada saat mendefinisikan find_files.

Catatan: Jangan bingung dengan variabel khusus "$(foreach)".

Info teks
peringatan teks
kesalahan teks
Teks keluaran mengembalikan apa-apa. Yang pertama pergi ke STDOUT, yang kedua ke STDERR,
yang ketiga juga membatalkan pemrosesan.

pra-bangun target
membuat target
Mengembalikan argumennya kata demi kata, tetapi pertama-tama buat semua file yang terdaftar. Ini berguna
ketika file tertentu diperlukan saat mengevaluasi ekspresi make. Ini biasanya terjadi
ketika Anda memiliki build di mana kumpulan file yang terlibat dihitung oleh beberapa shell
perintah. Sebagai contoh,

daftar_file :
# perintah shell untuk menghitung daftar file yang akan dimasukkan ke dalam program

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

Jika Anda memerlukan daftar di lebih dari satu aturan, akan lebih efisien menggunakan
memperluas paling banyak sekali variabel:

file_list ;= $(&cat $(daftar file_pembuatan awal))

my_program1 : ao $(daftar_file)

my_program2 : bo $(daftar_file)

Jika sebaliknya Anda hanya menentukan "$(&cat file_list)", maka makepp tidak akan memaksa
file_list menjadi yang terbaru sebelum menjalankan perintah shell. Menggunakan "$(prebuild )"
adalah cara terbaik untuk menyelesaikan masalah ini. Anda mungkin tergoda untuk mencoba hal lain, seperti
ini:

my_program : file_list $(&cat file_list)

tapi ini tidak akan berhasil karena "$(&cat file_list)" dievaluasi sebelum makepp mencoba
membangun "daftar_file".

hanya_target_palsu nama
Mengembalikan hanya nama-nama dalam daftar yang merupakan target palsu dari beberapa aturan (baik
aturan eksplisit atau pola). Anda dapat menentukan wildcard (termasuk spesial makepp
wildcard, "**") di nama file. (Lihat fungsi "$(wildcard )" untuk lebih jelasnya.
Ini dapat digunakan untuk mengelompokkan target, misalnya:

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

asal variabel
Diberi nama variabel, memberi tahu Anda dari mana nilainya berasal.

perl kode perl
pembuat kode perl
Mengevaluasi perlcode dalam satu blok dan mengembalikan hasilnya. Varian pertama adalah Perl biasa
kode, sedangkan varian kedua pertama melewati perlcode melalui variabel Make-style
ekspansi.

Perhatikan, bahwa, seperti semua fungsi, pembatas fungsi yang digunakan mungkin tidak muncul di dalam
perlcode di luar string yang dikutip tunggal atau ganda. Tapi Anda bisa menggandakannya seperti di
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 Make var dan satu Perl var
VAR = $((perl jika( ... ) { ... }))

palsu kata
Menunjukkan bahwa daftar kata-kata sebenarnya adalah target palsu, dan mengembalikan daftar
target. Ini dimaksudkan untuk digunakan seperti ini:

$(palsu semua): my_program

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

Anda juga dapat mendeklarasikan satu atau lebih target sebagai palsu dengan garis seperti ini di mana saja di
file make Anda:

.PHONY: semua bersih

mencetak teks
Menampilkan teks dan mengembalikannya. Ini sebagian besar berguna untuk debugging, ketika Anda tidak melakukannya
memahami mengapa substitusi variabel memiliki hasil seperti itu. Sebagai contoh,

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

akan mencetak hasil dari panggilan "patsubst".

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

akan mencetak argumen terakhir ke panggilan "patsubst".

tempurung shell-perintah
Mengembalikan output dari perintah shell yang diberikan, dengan baris baru diganti dengan spasi.

Perhatikan, bahwa, seperti semua fungsi, pembatas fungsi yang digunakan mungkin tidak muncul di dalam
perintah shell di luar string yang dikutip tunggal atau ganda. Tapi Anda bisa menggandakannya
seperti pada contoh kedua:

tanggal = $(tanggal shell) # lebih baik: $(perl skalar waktu lokal)
VAR = ${{shell f() { echo halo; }; F}}

xargs perintah,argumen[,akhiran[,panjang]]
Mengembalikan daftar perintah yang dipisahkan baris baru yang masing-masing dimulai dengan yang ditentukan
perintah, dan akhiri dengan elemen daftar sebanyak mungkin tanpa berlebihan
panjangnya (default 1000) karakter.

Tujuannya adalah untuk menghindari menumpahkan batas panjang perintah pada sistem Anda.
Misalnya, jika ada banyak file yang dihasilkan, maka Anda mungkin menginginkan
target bersih (yang seharusnya tidak Anda miliki, karena "makeppclean" lebih efisien) untuk
terlihat seperti ini:

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

Ini juga memiliki efek samping bahwa tidak ada perintah apa pun yang dihasilkan jika daftar
kebetulan kosong. Tetapi dalam hal ini akan lebih baik menggunakan &rm bawaan,
karena argumen untuk perintah bawaan hanya dibatasi oleh memori Perl:

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

Jika argumen ketiga ditentukan, maka itu digunakan untuk mem-postfix setiap perintah. Ini
berguna untuk menentukan redirector, misalnya (meskipun di sini lagi & echo akan membantu):

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

Beberapa dokumentasi ini dibuat berdasarkan dokumentasi GNU.

Harap dicatat bahwa jika suatu fungsi dipanggil selama inisialisasi makefile, mis
perluasan variabel ekspor, pesan kesalahan atau peringatan akan melaporkan nomor baris 0.

Gunakan makepp_functions online menggunakan layanan onworks.net