makepp_rules - Dalam Talian di Awan

JADUAL:

NAMA

makepp_rules -- Cara memberitahu makepp membina sesuatu

DESCRIPTION

?: &,
-,
@, B: :build_cache,
:build_check, D: : penghantaran, E: :env, I: "ignore_error",
: termasuk, L: :peluang terakhir, M: makeperl, N: "noecho", P: : penghurai,
"perl", S: :tandatangan

Peraturan ialah perkara yang memberitahu makepp cara membina fail atau kelas fail. Makepp menyokong
sintaks peraturan yang sama seperti pelaksanaan make yang lain, serta beberapa penambahan tersendiri.

Peraturan mempunyai format umum

target_expression : dependency_expression [ : argumen pilihan]
tindakan

Senarai sasaran mungkin tidak mengandungi sebarang pembolehubah automatik (kecuali "$(foreach)"). The
senarai pergantungan mungkin mengandungi hanya pembolehubah automatik merujuk kepada sasaran (iaitu,
"$(output)", "$(outputs)", atau sinonimnya). Tindakan itu mungkin mengandungi sebarang automatik
pembolehubah.

Jika makepp memutuskan bahawa peraturan itu perlu dilaksanakan, setiap baris peraturan itu dilaksanakan
secara berurutan, dan jika ada yang mengembalikan status bukan sifar, bakinya tidak akan dilaksanakan (dan
makepp membatalkan dengan ralat melainkan anda menetapkan pilihan "-k" pada baris arahan.)
Setiap tindakan hendaklah hanya satu baris. Jika tindakan terlalu panjang untuk ditulis dengan mudah pada a
satu baris, anda boleh membahagikannya kepada beberapa baris dan meletakkan garis miring ke belakang untuk menunjukkan bahawa
beberapa baris hendaklah digabungkan menjadi satu.

Untuk membezakan tindakan daripada peraturan seterusnya, tindakan itu harus lebih diinden
daripada baris yang mengandungi sasaran dan kebergantungan. Tidak seperti pelaksanaan lain
make, makepp tidak begitu peduli berapa banyak anda mengesotnya atau sama ada anda menggunakan aksara tab
bukannya ruang. Untuk mengekalkan keserasian ke belakang dengan pembuatan tradisional, peraturan
makepp gunakan untuk memutuskan bila tindakan tamat dan peraturan seterusnya bermula agak rumit:

· Baris tindakan pertama mesti diinden lebih daripada garisan yang mengandungi sasaran.

· Jika garis diinden oleh satu aksara tab atau 8 ruang atau lebih, maka ia dianggap
garis tindakan.

· Baris kosong atau baris ulasan dengan aksara "#" di jidar kanan mengakhiri
peraturan, melainkan baris bukan kosong seterusnya diindenkan lebih daripada 8 ruang (atau lebih daripada satu
tab).

· Jika garis diindenkan sebanyak atau lebih daripada baris tindakan pertama, maka ia adalah
dianggap sebagai garis tindakan tambahan.

Terdapat beberapa item tindakan khas:

& Simbol ini hendaklah diikuti dengan nama arahan dan sebarang bilangan argumen. Shell
sintaks tidak difahami sepenuhnya di sini, hanya petikan tunggal dan berganda serta bergaris ke belakang
watak dalam, seperti sepanjang makepp. Nama arahan sama ada membawa kepada fungsi
"c_nama" untuk dipanggil dengan rentetan yang tinggal sebagai hujah. Jika fungsi sedemikian boleh
tidak dijumpai, ini sama dengan memanggil "run" dari blok "perl".

Ini membolehkan dengan cekap memanggil perintah terbina dalam, sediakan fail atau luaran.
Awalan "&" telah dipilih kerana ia adalah penyeru fungsi dalam Perl dan kerana
pada mulanya ia adalah haram di Shell.

$(ROOT)/include/%.h: %.h
&ln $(input) $(output)

noecho
@ Biasanya, setiap arahan shell dicetak semasa ia dilaksanakan. Namun, jika perkataan pertama
daripada tindakan itu ialah "noecho" (atau jika ia bermula dengan aksara "@"), maka perintah itu
tidak dicetak. Sebagai contoh,

%.o: %.cxx
noecho $(LIBTOOL) --mode=compile $(CC) -c $(input)

Ini bermakna apabila arahan libtool dilaksanakan, ia tidak dicetak. (Libtool
sendiri biasanya mencetak perintah yang diubah suai yang ia laksanakan, jadi ia berlebihan
cetak dua kali.)

abaikan_error
- Biasanya, jika arahan shell mengembalikan status bukan sifar, maka makepp akan membatalkan kerana
arahan itu gagal. Walau bagaimanapun, sesetengah program salah menetapkan status semasa keluar, atau
mungkin terdapat ralat yang sebenarnya tidak membawa maut dan tidak sepatutnya membatalkan keseluruhannya
kompilasi. Anda boleh menyebabkan makepp mengabaikan status pemulangan dengan menyatakan
"ignore_error" sebagai perkataan pertama baris arahan (atau "-" sebagai aksara pertama).
Sebagai contoh,

$(pengedaran palsu):
ignore_error rm -r my_program-$(VERSION) # Buang sampah sebelumnya.
&mkdir my_program-$(VERSION)
&cp $(FILES) my_program-$(VERSION)
tar cf my_program-$(VERSION).tar my_program-$(VERSION)

Perintah ini membuat direktori, menyalin sekumpulan fail ke dalamnya, dan kemudian meletakkan
semuanya ke dalam fail tar untuk diedarkan. Adalah idea yang baik untuk membersihkannya
kandungan direktori sebelumnya, jika terdapat apa-apa di sana sebelum ini, dan itu
apa yang baris pertama lakukan. "rm" mungkin gagal, tetapi status pengembaliannya diabaikan.

perl
makeperl
Ini pada asasnya sama dengan pernyataan perl, tetapi ia dilakukan setiap kali apabila
menjalankan peraturan, bukan semasa membaca makefile. Varian pertama ialah Perl biasa
kod, manakala varian kedua terlebih dahulu menghantar pernyataan melalui pembolehubah gaya Make
pengembangan.

Untuk dua kemungkinan meletakkan pendakap badan, lihat penjelasan di
"perl_perlcode" dalam makepp_statements. Perhatikan bahawa varian ketiga dijelaskan di sana
tidak bermakna di sini, kerana semua baris tindakan mesti diinden. Anda mesti memberi isyarat
kegagalan dalam pernyataan Perl, dengan memanggil "mati".

Per peraturan kenyataan Perl sedang dinilai dalam subproses biasa, kecuali pada
Windows. Ini bermakna mereka hanya mempunyai akses membaca kepada mana-mana pembolehubah makefile. Ia juga
proses yang melaksanakan tindakan bukan Perl. Jadi memanggil exec atau exit akan mengelirukan
makepp. Tetapi ini mungkin berubah pada masa hadapan. Untuk cara yang cekap untuk memanggil Perl
skrip, lihat item sebelumnya "&" atau "run".

$(versi palsu):
noecho perl {{ # $(sasaran) & $(VERSION) daripada Perl:
cetak "Ini ialah ".f_target()." $VERSION\n";
}}
echo Anda boleh mencampurkannya dengan arahan Shell
-makeperl { print "Ini ialah $(sasaran) $(VERSION)\n" }

Terdapat beberapa jenis peraturan yang berbeza, setiap satu dengan tujuan yang berbeza.

Eksplisit peraturan
sasaran1 sasaran2: kebergantungan1 kebergantungan2 ...
tindakan yang perlu dilakukan

Sintaks ini menentukan bahawa untuk membuat sama ada target1 or target2, semua fail
pergantungan1, pergantungan2, dsb., mesti sudah dibuat. Maka tindakan yang diberikan ialah
dilaksanakan oleh cangkerang untuk membuat sasaran.

Peraturan eksplisit pertama dalam fail ialah sasaran lalai, dan dibuat jika anda tidak menyatakannya
sebarang sasaran pada baris arahan.

Tidak seperti program make tradisional, makepp biasanya mengandaikan bahawa satu permintaan tindakan itu
membuat semua sasaran (melainkan tiada kebergantungan). Sebagai contoh, satu doa
daripada yacc mencipta kedua-dua fail output untuk peraturan ini:

y.tab.c y.tab.h : parser.y
$(YACC) -d parser.y

Ambil perhatian bahawa pelaksanaan lain make tidak mempunyai konsep satu arahan
menghasilkan berbilang fail output, dan apabila anda menentukan berbilang sasaran, mereka akan melakukannya
laksanakan peraturan sekali setiap sasaran. Makepp akan kembali kepada tingkah laku ini jika ia kelihatan seperti
ini adalah makefile gaya lama. Khususnya, ia akan melaksanakan peraturan sekali bagi setiap sasaran,
bukannya hanya sekali secara keseluruhan, jika semua yang berikut adalah benar:

· Tindakan peraturan menyebut pembolehubah automatik $@. (Sinonim "$(output)" atau
"$(target)" jangan cetuskan tingkah laku ini.)

· Tindakan peraturan tidak menyebut pembolehubah automatik "$(outputs)" (atau sinonimnya
"$(sasaran)").

· Ini bukan peraturan corak, dan tiada klausa foreach.

Sebagai contoh,

semua pemasangan ujian:
untuk subdir dalam $(SUBDIRS); buat cd $$subdir && $(BUAT) $@; cd ..; selesai

ialah simpulan bahasa biasa dalam makefiles, dan makepp menyokongnya. (Perhatikan bahawa anda tidak boleh menggunakan
buat rekursif dalam mana-mana fail make baharu yang anda tulis--gunakan pernyataan "load_makefile", atau
sebaliknya memuatkan makefile tersirat.)

Jika anda ingin peraturan yang sama dilaksanakan sekali untuk setiap sasaran (cth, kerana sasaran
mempunyai arahan yang serupa), lebih baik menggunakan sama ada peraturan corak (lihat di bawah) atau a
klausa "foreach". Sebagai contoh, jika dengan program buat tradisional anda akan menulis:

abcd:
buat_sesuatu untuk membina $@ > $@

dalam makepp, anda mungkin mahu menulisnya seperti ini:

$(foreach) : : foreach abcd
lakukan_sesuatu untuk membina $(output) > $(output)

Phony sasaran

A palsu sasaran adalah sasaran yang tidak akan pernah wujud dalam sistem fail; ia hanya a
cara mendapatkan makepp untuk membina beberapa sasaran dan mungkin melaksanakan beberapa arahan tambahan.

Sasaran palsu biasa ialah "semua", yang biasanya digunakan untuk menyebabkan semua yang boleh
dibina untuk dibina, seperti ini:

semua: prog1 prog2 subdir/prog3 subdir2/libmine.a
@&echo "Selesai!"

Jika anda menaip "makepp all", atau jika anda meletakkan semua sebagai sasaran eksplisit pertama dalam fail make anda
(yang tipikal) dan hanya taip "makepp", maka ia akan menyebabkan semua kebergantungan menjadi
dibina, maka ia akan mencetak "Semua selesai!". Pada ketika ini, makepp akan mencari fail tersebut ./semua
dan akan mendapati bahawa ia tidak wujud. Ia akan mengeluh dengan kuat.

Untuk memastikan makepp tidak mengharapkan fail ./semua untuk keluar, anda perlu memberitahunya bahawa ia adalah a
sasaran palsu. Hanya letakkan baris seperti berikut dalam makefile anda (tiada bezanya
di mana):

.FONI: semua

Alternatif setara yang kadangkala lebih mudah ialah menggunakan "$(phony )"
fungsi, seperti ini:

$(palsu semua): prog1 prog2 subdir/prog3 subdir2/libmine.a

Sasaran palsu dalam satu fail buatan boleh merujuk kepada sasaran palsu dalam fail buatan yang lain. Ini adalah
sering dilakukan dengan sasaran "bersih", seperti ini:

# Makefile peringkat atas:
# banyak peraturan dan perkara di sini
# ....
$(phony clean): subdir1/clean subdir2/clean
&rm -fm my_program

Kemudian dalam subdirektori, makefiles mungkin berbunyi seperti ini:

# Makefile dalam subdirektori
# ...
$(palsu bersih):
&rm -fm $(wildcard *.o *.a)

Tetapi pada masa kini anda akan menggunakan arahan "makeppclean", bukannya sasaran yang bersih.

Kad Liar

Adalah selamat untuk menentukan kad bebas dalam senarai kebergantungan. Kad bebas sepadan dengan bukan sahaja fail
yang wujud, tetapi fail yang boleh dibuat berdasarkan peraturan dalam makefile. Sebagai contoh,
untuk membina perpustakaan daripada semua fail .o dalam direktori, anda boleh menulis ini:

libmine.a: *.o
&rm -f $(output)
ar cr $(output) $(inputs)

Ini akan berfungsi walaupun tiada satu pun daripada fail ".o" telah dibuat, kerana makepp's
kad bebas sepadan dengan fail yang belum wujud tetapi boleh dibina. Ini malah akan meningkat
fail yang peraturannya ditemui kemudian (dalam makefile yang sama, atau yang belum dibaca). Di dalam ini
titik terakhir ia berbeza daripada fungsi "wildcard", yang terhad kepada peraturan yang diketahui,
kerana ia mesti mengembalikan hasilnya apabila ia dikembangkan.

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 telah dicuri
daripada zsh.) Contohnya, "**/*.c" sepadan dengan semua .c fail dalam keseluruhan pokok sumber.
"objek/**/*.o" sepadan dengan semua .o fail yang terkandung di mana-mana dalam subdirektori objek
atau mana-mana subdirektorinya atau mana-mana subdirektorinya. Kad bebas "**" tidak akan
ikuti pautan lembut ke direktori di mana-mana peringkat. Ia juga tidak akan mengembalikan sasaran palsu.

Kad bebas Makepp akan mengabaikan fail atau direktori yang wujud tetapi tidak boleh dibaca. Selepas
semua, fail sedemikian tidak boleh digunakan dalam proses binaan. Meletakkan fail tidak boleh dibaca dalam a
direktori amat berguna untuk menghalang import automatik fail yang diberikan daripada a
repositori.

Penegasan awal adalah bahawa ini adalah selamat. Ini adalah dalam erti kata bahawa ia berfungsi sama ada
fail sudah wujud, atau perlu dibina terlebih dahulu. Walau bagaimanapun ia adalah tidak selamat dalam pengertian
bahawa ia masih akan sepadan dengan fail yang dibina oleh makepp, tetapi tidak lagi mempunyai peraturan (cth
anda membuang .c fail, tetapi .o fail masih ada.) Untuk mengelakkan ini, gunakan
Pilihan "--rm-basi".

corak peraturan
Peraturan corak ialah peraturan yang digunakan berdasarkan beberapa corak teks. Ini sudah biasa
gunakan peraturan yang sama pada keseluruhan kelas fail. Sintaks adalah sama dengan GNU make's
peraturan corak:

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

Ini mengatakan bahawa mana-mana fail dalam direktori semasa yang sepadan dengan "*.c" boleh ditukar menjadi
fail .o yang sepadan menggunakan arahan yang diberikan.

Ambil perhatian bahawa beberapa kebergantungan corak mungkin dibekalkan. Sebagai contoh, jika anda xyz.o fail
bergantung pada yang sepadan xyz.cpp fail, dan juga pada fail yang dipanggil moc_xyz.cflags yang
mengandungi pilihan pengkompil, ini boleh dinyatakan dengan:

%.o: %.cpp %.cflags
$(CXX) `cat $(stem).cflags` -c $(inputs) -o $(output)

Anda juga mungkin mempunyai beberapa sasaran corak. Sebagai contoh,

%.tab.h %.tab.c : %.y
yacc -d $(input)
&mv y.tab.h $(stem).tab.h
&mv y.tab.c $(stem).tab.c

Biasanya, peraturan corak hanya mencari fail dalam direktori semasa. Anda boleh memaksa
mereka untuk mencari dalam direktori semasa dan semua direktori di bawahnya dengan menetapkan

makepp_percent_subdirs := 1

sebelum peraturan corak pertama dalam makefile anda atau pada baris arahan sebagai contoh.

Terdapat perbezaan yang jelas antara "%" dan kad bebas "*", walaupun kedua-duanya sepadan dengan mana-mana
rentetan: Kad bebas mengembalikan senarai fail yang digunakan sepenuhnya pada ketika itu. Jadi
ini bergantung kepada semua .o fail boleh dibina di sini:

prog: *.o
$(LD) $(LDFLAGS) $(input) -o $(output)

Ini tidak boleh dicapai dengan menggantikan "*" dengan "%", kerana yang terakhir adalah untuk satu demi satu
pemadanan input kepada output, menghasilkan secara dalaman satu peraturan untuk setiap batang yang dipadankan.

statik pola peraturan
Peraturan corak statik ialah peraturan corak yang digunakan hanya pada set fail terhad:

$(MODUL_KHAS).o : %.o : %.cpp
$(CXX) -c $(input) -o $(output)

Ini mengatakan bahawa peraturan corak hanya digunakan pada fail dalam "$(SPECIAL_MODULES).o".

Ini kebanyakannya untuk keserasian dengan GNU make; setiap peraturan (lihat di bawah) adalah lebih
cara yang berkuasa untuk melakukan perkara yang sama.

Untuk setiap peraturan
Sintaks peraturan corak di atas cukup kuat untuk menyokong hampir semua binaan, tetapi
kadang-kadang perlu melakukan sesuatu yang lebih rumit. Makepp menyediakan lebih
sintaks berkuasa: klausa ":foreach" untuk peraturan.

target_expression : dependency_expression : untuk setiap senarai fail
tindakan

Jenis peraturan foreach yang paling mudah hanyalah peraturan corak yang aplikasinya dihadkan
kepada senarai fail tertentu. Sebagai contoh, katakan anda mempunyai peraturan corak yang memberitahu
makepp bagaimana untuk menyusun semua .c fail. Walau bagaimanapun, anda mempunyai senarai .c fail untuk anda
mahu melakukan sesuatu yang berbeza. Anda boleh melakukan sesuatu seperti ini:

# Berikut ialah peraturan yang terpakai untuk semua perkara:
%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

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

Penggunaan peraturan foreach yang lebih berkuasa mengambil kesempatan daripada fakta bahawa pembolehubah
"$(foreach)" ditetapkan pula kepada setiap fail yang sepadan dengan senarai fail dan sasaran dan
ungkapan kebergantungan dinilai. Senarai fail mungkin mengandungi kad bebas, dan ini
padankan walaupun fail yang belum wujud lagi tetapi boleh dibina (lihat "Wildcards" dalam
makepp_rules).

Ini adalah sintaks yang sukar digunakan tetapi ia sangat fleksibel, kerana pembolehubah "$(foreach)"
boleh muncul dalam apa jua cara dalam ungkapan. Pertama, ambil perhatian bahawa peraturan corak sebenarnya adalah a
kes khas untuk setiap peraturan; peraturan corak

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

betul-betul bersamaan dengan:

$(patsubst %.c, %.o, $(foreach)): $(foreach) : foreach *.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

(Malah, ia ditukar kepada kira-kira itu secara dalaman.)

Sebagai contoh cara anda menggunakan klausa ":foreach" di mana peraturan corak tidak
mencukupi, andaikan anda mempunyai beberapa .c fail yang dibina menggunakan beberapa jenis prapemproses
yang mengambil sebagai fail input dengan a .k sambungan. Anda mahu menyusunnya .c fail dengan a
set pilihan kompilasi yang berbeza daripada biasa .c fail yang merupakan sumber biasa
fail. Anda boleh melakukan sesuatu seperti ini:

# Peraturan untuk fail .c biasa:
%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

# Peraturan untuk membuat fail .c daripada fail .k:
%.c : %.k
$(prapemproses) $(input) > $(output)

# Peraturan binaan khas untuk fail .c yang dibuat daripada fail .k:
$(foreach:%.k=%.o) : $(foreach:%.c=%.k): foreach *.k
$(CC) $(SPECIAL_CFLAGS) -c $(input) -o $(output)

(Ini menggunakan sintaks rujukan penggantian yang lebih ringkas daripada memanggil
"patsubst" secara eksplisit.)

Ambil perhatian bahawa jika semua yang anda mahu lakukan ialah menukar nilai pembolehubah ("CFLAGS" dalam ini
kes) kadangkala lebih mudah untuk menggunakan pembolehubah khusus sasaran.

Warisan akhiran peraturan
Untuk keserasian ke belakang, makepp menyokong peraturan akhiran gaya lama.

.akhiran1.akhiran2:
tindakan

adalah bersamaan dengan

%.akhiran2: %.akhiran1
tindakan

tetapi lebih sukar untuk diingati. (Sufiks yang manakah didahulukan?) Biasanya, peraturan akan muncul
dalam makefile lama seperti ini:

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

yang betul-betul setara dengan

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

Berkonflik peraturan
Apabila terdapat lebih daripada satu cara untuk membuat fail, makepp menggunakan prosedur mudah untuk
tentukan peraturan yang hendak digunakan.

· Ia adalah ralat untuk mempunyai peraturan eksplisit yang bercanggah untuk membina fail.

· Peraturan corak dan peraturan foreach dengan kad bebas tidak sekali-kali mengatasi peraturan eksplisit. Justeru
peraturan eksplisit boleh digunakan untuk menentukan pengecualian untuk peraturan corak. (Perhatikan bahawa semata-mata
menggunakan klausa ":foreach" tidak menjadikan sesuatu peraturan corak. Ia mesti mempunyai a
kad bebas (seperti "*" atau "?") sebagai sebahagian daripada nama fail dalam klausa ":foreach". Jika ia adalah
hanya senarai fail eksplisit, ia dianggap sebagai peraturan eksplisit untuk setiap fail tersebut
fail.)

· Apabila peraturan corak bercanggah datang daripada fail make yang berbeza, peraturan daripada "lebih dekat"
makefiles mengatasi peraturan daripada makefiles "lebih jauh". "Lebih dekat" bermaksud bahawa fail make
terletak lebih dekat dengan sasaran dalam hierarki direktori (iaitu, nama fail
sasaran relatif kepada direktori makefile dijalankan adalah lebih pendek). Jika ini
tidak membezakan makefiles, maka peraturan dari makefile yang dimuatkan
terkini digunakan.

Ini bermakna anda boleh menentukan peraturan corak yang digunakan untuk semua fail dalam anda
keseluruhan pepohon direktori hanya dalam makefile peringkat atas, tetapi kemudian anda boleh mengatasinya
makefile peringkat rendah. Sebagai contoh, makefile peringkat atas anda boleh mengandungi:

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

dan anda boleh mempunyai fail make dalam salah satu subdirektori yang mengatakan:

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

· Peraturan corak yang mempunyai rantaian inferens yang lebih pendek diutamakan berbanding corak lain
peraturan. Sebagai contoh, jika anda mempunyai peraturan berikut (berdasarkan contoh daripada
kernel Linux):

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

%.o: %.s
$(AS) $(input) -o $(output)

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

Jika kita perlu membina "xyz.o", kita boleh membina fail ".s" perantaraan dan kemudian
jalankan itu melalui pemasang menggunakan dua peraturan pertama, atau kita boleh pergi terus ke a
Fail ".o" menggunakan peraturan terakhir. Peraturan terakhir lebih disukai kerana terdapat lebih sedikit
langkah dalam rantaian inferens (satu bukannya dua).

· Peraturan corak kemudian dalam makefile mengatasi peraturan corak yang lebih awal. (Ini adalah
ke belakang daripada GNU make.) Ini bermakna anda harus meletakkan peraturan anda yang lebih umum
lebih awal, dan peraturan anda yang lebih khusus kemudian. Sebagai contoh,

%.o: %.c # Peraturan kompilasi am.
tindakan

special_%.o: special_%.c # Peraturan khas untuk fail dengan a
tindakan yang berbeza # awalan "special_".

peraturan pilihan
Kadangkala adalah perlu untuk membekalkan pilihan tambahan untuk mengubah suai cara makepp melaksanakan
peraturan. Pilihan ini ditentukan sebagai ": nilai nama pilihan", sama ada pada baris yang mengandungi
kebergantungan, atau pada baris seterusnya.

Membekalkan pilihan pada baris yang berasingan mungkin membolehkan anda menggunakan yang sama
makefile dengan makepp dan buatan tradisional. Sebagai contoh,

sasaran : tanggungan
: tandatangan target_newer
tindakan

akan berfungsi dengan baik dengan buatan Unix tradisional, kerana ia mentafsir baris ": tandatangan".
sebagai arahan shell, dan arahan yang bermula dengan titik bertindih tidak melakukan apa-apa.

:build_cache /path/to/build/cache
sasaran : tanggungan
: build_cache /put/cache/files/over/there
tindakan

Menentukan laluan ke cache binaan untuk digunakan untuk fail yang dihasilkan oleh peraturan ini. ini
mengatasi kesan pernyataan "build_cache" atau arahan "--build-cache".
pilihan baris, jika ada, untuk peraturan ini. Lihat makepp_build_cache untuk mendapatkan butiran tentang binaan
tembolok.

Jika anda menentukan "tiada" dan bukannya laluan, anda melumpuhkan cache binaan untuk ini
peraturan tertentu. Ini berguna untuk mengelakkan pembaziran ruang cakera pada fail yang anda
tahu tidak berguna untuk cache, sama ada kerana anda pasti ia tidak akan berguna
digunakan semula atau kerana ia dibina dengan pantas sehingga tidak berbaloi untuk menyimpannya dalam cache.

:build_check bina_kaedah_semak
sasaran : tanggungan
: build_check target_newer
tindakan

Ini memberitahu makepp algoritma apa yang hendak digunakan untuk memutuskan sama ada sasaran perlu dibina semula.
Lihat makepp_build_check untuk mendapatkan butiran lanjut. Ini mengatasi kesan daripada
pernyataan "build_check" atau pilihan baris arahan "--build-check-method", jika ada, untuk
peraturan ini.

:env BERBAGAI ...
Tambah kebergantungan pada nilai pembolehubah persekitaran yang dinamakan. Jika ada di antara mereka
berbeza daripada binaan sebelumnya, maka sasaran dianggap ketinggalan zaman, jika
kaedah build_check jadi menentukan. (Semua kaedah semakan binaan terbina dalam kecuali untuk
target_newer hormati ini.)

VARIABLE mungkin dalam bentuk "nama fail dalam PATH_VARIABLE" (dalam petikan), dalam hal ini
sasaran dianggap lapuk jika direktori pertama daripada dipisahkan bertindih
nilai PATH_VARIABLE di mana nama fail wujud adalah berbeza daripada binaan terakhir.
Ini boleh digunakan untuk mengelakkan membina semula sasaran apabila PATH_VARIABLE berubah dalam
cara yang tidak relevan.

: penghantaran arahan ...
Lampirkan setiap tindakan shell (tetapi bukan tindakan Perl atau perintah Perl) dalam "sh -c '...'"
dan awalannya dengan arahan, tetapi anggap bahawa sasaran tidak bergantung pada arahan.
Ini berguna jika anda ingin menghantar tindakan ke sistem giliran kerja, tetapi hasilnya adalah
diandaikan bebas daripada parameter baris gilir, serta sama ada baris gilir
sistem digunakan sama sekali.

: termasuk fail_atau_corak
Peraturan berbeza-beza bergantung pada pengkompil:

%.o : %.c
: sertakan %.d : tandatangan C
gcc -MD -c ...

%.o : %.c
: sertakan %.u : tandatangan C # IBM menggunakan akhiran yang berbeza
xlc -M -c ...

sub dependify { # Tukar perbualan Microsoft kepada format yang berguna
s/\$/\$\$/g;
s/(Nota: termasuk fail: *)?(.+?)\r?\n/$1 ? "'$2' " : "'".f_output()."': "/e;
}
%.o : %.c
: sertakan %.d : tandatangan C
cl -showTermasuk -c ... >$(stem).d
&sed &bergantung -o +<$(batang).d

Sesetengah penyusun (icc Intel sama seperti gcc di atas, atau xlc IBM) boleh menghasilkan pergantungan
fail dengan cepat. Iaitu, semasa mereka menyusun, mereka menulis fail make yang boleh dibuat oleh makepp
termasuk. Kelebihan berbanding pengimbas makepp ialah ia dijamin 100%
betul, di mana kita mungkin hanya mendekati.

Pilihan ini memanfaatkannya dengan cara yang istimewa: Jika fail tidak ada, iaitu
biasanya pada binaan pertama, pengimbasan biasa berlaku. Tetapi jika fail itu ada, tidak
pengimbasan berlaku (itulah sebabnya kami menentukan tandatangan pintar di atas -- bukan pengimbasan jatuh
kembali ke lalai bodoh cap masa dan saiz). Sebaliknya ia termasuk fail, sebelum
melaksanakan peraturan. Selepas berjaya melaksanakan peraturan, ia melupakan apa sahaja
baca kali pertama, memandangkan fail itu mungkin sudah lapuk. Sebaliknya ia berbunyi
fail sekali lagi, jika ia berubah, kerana mempunyai maklumat binaan yang terkini.

AMARAN: Ini sememangnya tidak boleh dipercayai. Fail pergantungan akan dihasilkan oleh very
peraturan yang menjadi pergantungan. Sebaliknya, penyusun tahu tentang semua
ia adalah sub-termasuk dalaman, yang makepp biasanya abaikan. Ini adalah kebolehpercayaan
kelebihan hanya untuk kes di mana patch pengkompil membetulkan hanya sub-termasuk. The
harga adalah bahawa makepp akhirnya melihat lebih banyak fail, yang mengambil masa.

Terdapat tangkapan apabila anda mengalih keluar pernyataan "#include". and fail yang sepadan:
Ia masih akan disebut dalam fail dependensi dari kali terakhir, apabila ia adalah
diperlukan. Dalam kes sedemikian, anda mesti mengedit fail kebergantungan untuk membuang kebergantungan
yang tidak dapat dipenuhi lagi.

Ciri ini tidak boleh digunakan dengan cache binaan kerana mengambil fail dari sana
memerlukan mengetahui segala-galanya tentang fail. Tetapi fail pergantungan bergantung pada mereka
fail makepp belajar tentang dengan membacanya. Kebergantungan bulat sebegini bukanlah kebiasaannya
mungkin dalam sistem binaan yang boleh dipercayai. Ini adalah pengecualian kerana selepas membina semula
dan membaca semula fail kebergantungan semuanya betul lagi.

Jika anda membina dalam repositori anda, makepp akan mengambil fail kebergantungan daripada fail
Repositori pertama yang mengandungi satu. Ini tidak seperti fail lain, di mana ia mengambil masa yang pertama
dengan tandatangan yang diharapkan. Ini adalah lebih baik daripada untuk membina cache, di mana untuk kekurangan
tandatangan, ia tidak dapat mencari fail itu.

:peluang terakhir
Dayakan peraturan terbuka, seperti

%.foo foo%.bar: :last_chance
&gema $@ -o $@
&cp $(output)

Oleh kerana peraturan seperti ini boleh menjana bilangan sasaran yang pada dasarnya tidak terhingga,
sasaran peraturan ini tidak akan sepadan dengan fungsi $(wildcard) atau peraturan corak melainkan
sesuatu yang lain telah pun menerapkan peraturan dengan merujuk sasaran secara khusus.
Tambahan pula, jika "--rm-stale" ditentukan, maka sasaran yang tinggal daripada sasaran sebelumnya
makepp run akan kelihatan basi jika satu-satunya cara untuk membinanya adalah melalui peraturan last_chance
yang masih belum digunakan untuk sasaran, yang merupakan tingkah laku yang wajar kerana
binaan akan gagal dengan lebih konsisten apabila ia tersilap bergantung pada kad bebas untuk
padankan sasaran dari larian sebelumnya.

Pilihan ":last_chance" bertujuan untuk menarik perhatian kepada tingkah laku istimewa
peraturan berkenaan dengan kad bebas yang sepadan.

: penghurai parser
Ini memberitahu makepp cara menghuraikan arahan untuk mengesan (termasuk) fail. Biasanya,
makepp meneka cara melakukan ini berdasarkan perkataan dalam arahan itu sendiri (lihat
makepp_scanning untuk butiran). Namun, jika makepp tersalah teka, anda mungkin mahu
secara eksplisit menunjukkan penghurai, seperti ini:

%.o: %.abc
: parser c_compilation
tindakan di sini

Ini menyebabkan makepp melakukan penghuraian dan pengimbasan yang sama seperti yang dilakukannya untuk C/C++
bina arahan, walaupun ia tidak mengiktiraf tindakan sebagai kompilasi C.

Penghurai lalai bergantung pada arahan. Jika anda tidak menentukan pilihan ":parser",
kemudian perkataan pertama setiap perintah diperiksa. Contohnya untuk kompilasi atau pautan
arahan, makepp akan menggunakan parser "c_compilation"; atau jika arahan itu kelihatan seperti
Varian GNU, "gcc_compilation". Jika tiada penghurai ditemui, ia menggunakan penghurai "tiada". Untuk
butiran lanjut tentang ini, atau jika anda ingin menulis penghurai anda sendiri atau menukar makepp
penghurai lalai, lihat makepp_scanning.

Ambil perhatian bahawa ini digunakan untuk setiap perintah dalam peraturan, yang mungkin bukan yang anda mahukan:

%.o: %.c : parser c-compilation
@echo 'Membina $(output)'
@funny_cc ...

Ini juga akan mentafsirkan "gema" sebagai penyusun dan menyimpulkan hujahnya 'Building
mymodule.o' sebagai kebergantungan tersirat. Ini akan membawa kepada aduan bahawa ia
tidak tahu bagaimana untuk membina fail sedemikian. Dalam kes ini, anda lebih baik melakukannya
"register_parser". Di sana anda dapati penjelasan bagaimana parser boleh diberikan sama ada sebagai a
nama kelas atau sebagai nama fungsi.

:tandatangan kaedah_tandatangan
sasaran : tanggungan
: tandatangan md5
tindakan

Ini memberitahu makepp algoritma apa yang hendak digunakan untuk menentukan sama ada kebergantungan telah berubah.
Lihat makepp_signatures untuk butiran lanjut. Kaedah tandatangan yang disertakan dengan
pengedaran makepp adalah "plain", "md5", "C" atau "c_compilation_md5", dan
"objek_kongsi". Ini mengatasi mana-mana kaedah tandatangan yang ditentukan dengan "-m" atau
Pilihan baris arahan "--signature-method", atau dengan pernyataan "tandatangan".

khas aksara
Makepp boleh menyokong nama fail yang mempunyai aksara khas di dalamnya seperti titik bertindih atau ruang.
Katakan, sebagai contoh, anda ingin mencipta fail yang dipanggil "a:thing" daripada fail "b:thing".
Anda tidak boleh menulis peraturan dengan cara ini:

a:thing : b:thing # Ini ialah ralat sintaks
&cat $(input) -o $(output)

kerana makepp tidak akan mengetahui titik bertindih yang memisahkan sasaran daripada kebergantungan dan yang mana
sebahagian daripada nama fail. Sebaliknya, hanya sertakan nama dalam petikan, seperti ini:

"a:thing" : "b:thing"
&cat $(input) -o $(output)

Sekarang peraturan itu tidak jelas.

Sintaks petikan Makepp agak serupa dengan shell. Anda boleh, sebagai contoh, menggunakan single
petikan dan bukannya petikan berganda, atau anda boleh melarikan diri daripada aksara khas dengan garis miring ke belakang:

a\:thing : 'b:thing'
&cat $(input) -o $(output)

Katakan, sebagai contoh, nama fail anda ialah "'"!;\$". Sekarang mengapa anda mahukan nama fail sedemikian
Saya tidak tahu, tetapi berikut adalah beberapa cara anda boleh menentukannya untuk makepp (dan shell):

\''"!;\$$'
"'\"!;\\$$"

Beri perhatian tentang bila makepp menjalurkan petikan dan apabila cangkerang melakukannya. Makepp memandang
sebut harga hanya dalam kes berikut:

· dalam keluarga ujian "ifeq".

· sebelum dan selepas kolon peraturan

· dalam arahan terbina makepp

· dalam fungsi yang berkaitan dengan fail

Tidak seperti shell, makepp tidak mengembangkan petikan semasa menugaskannya kepada pembolehubah. Justeru
peraturan berikut adalah sama:

FILE = 'nama dengan ruang'
x := $(print $(FILE)) # hanya untuk menyemak bahawa petikan masih ada
$(FILE): # petikan di sekitar fail tunggal yang dilucutkan oleh makepp
&echo hello -o$(FILE) # petikan di sekitar fail tunggal yang dilucutkan oleh makepp
bergema di sana >>$(FILE) # petikan di sekitar fail tunggal yang dilucutkan oleh Shell
'nama dengan ruang':
&echo hello -o'name with spaces'
bergema di sana >>'$(output)' # petikan telah dilucutkan di atas, tambahkannya semula

Ambil perhatian bahawa (tidak seperti Shell) pembolehubah yang bermula dengan "$" dikembangkan walaupun di dalam tunggal
petikan. Tanda dolar tidak boleh dilindungi oleh sebut harga atau garis miring ke belakang. Untuk mendapatkan literal
tanda dolar, gunakan tanda dolar berganda, cth,

$(palsu semua):
@&echo Ini ialah tanda dolar: $$
@untuk val dalam abcd; lakukan echo $$val; selesai

Secara amnya, anda sepatutnya dapat menangani hampir semua watak istimewa dengan memetiknya
dalam sesuatu cara. Ini termasuk ruang, aksara kawalan, dsb. Walau bagaimanapun, ambil perhatian bahawa di
Sekarang, pelucutan komen makepp agak ringkas, dan sebarang aksara "#".
didahului oleh ruang kosong akan ditafsirkan sebagai ulasan tidak kira bagaimana ia dipetik.

Apabila nama sasaran atau kebergantungan dimasukkan ke dalam pembolehubah automatik seperti "$(output)", maka
petikan dan sebarang garis miring terbalik dilucutkan. Ini bermakna jika anda ingin merujuk kepada
nama fail dalam tindakan, anda mungkin perlu memetiknya sekali lagi, seperti ini:

"nama fail dengan ruang":
echo "Kandungan khas" > "$@"

Jika anda tidak meletakkan petikan di sekitar $@, maka shell akan melihat arahan

echo "Kandungan khas" > nama fail dengan ruang

yang menulis rentetan "Nama fail kandungan khas dengan ruang" pada fail yang dipanggil a.
Ini mungkin bukan yang anda mahukan.

Gunakan makepp_rules dalam talian menggunakan perkhidmatan onworks.net