makepp_rules - Online di Cloud

PROGRAM:

NAMA

makepp_rules -- Bagaimana cara memberitahu makepp untuk membuat sesuatu

DESKRIPSI

?: &,
-,
@, B: : build_cache,
: build_periksa, D: :menugaskan, E: :env, I: "abaikan_kesalahan",
:termasuk, L: :kesempatan terakhir, M: pembuat, N: "noecho", P: : pengurai,
"perl", S: :tanda tangan

Aturan adalah apa yang memberi tahu makepp cara membuat file atau kelas file. Makepp mendukung
sintaks aturan yang sama dengan implementasi make lainnya, ditambah beberapa tambahannya sendiri.

Aturan memiliki format umum

target_expression : dependency_expression [ : argumen opsional]
tindakan

Daftar target tidak boleh berisi variabel otomatis apa pun (kecuali "$(foreach)"). NS
daftar ketergantungan mungkin hanya berisi variabel otomatis yang merujuk ke target (yaitu,
"$(keluaran)", "$(keluaran)", atau sinonimnya). Tindakan mungkin berisi otomatis
variabel.

Jika makepp memutuskan bahwa aturan perlu dieksekusi, setiap baris aturan dieksekusi
berurutan, dan jika ada yang mengembalikan status bukan nol, sisanya tidak dieksekusi (dan
makepp dibatalkan dengan kesalahan kecuali Anda menentukan opsi "-k" pada baris perintah.)
Setiap tindakan harus hanya satu baris. Jika suatu tindakan terlalu panjang untuk ditulis dengan nyaman di a
satu baris, Anda dapat membaginya menjadi beberapa baris dan memberikan garis miring terbalik untuk menunjukkan bahwa
beberapa baris harus digabungkan menjadi satu.

Untuk membedakan tindakan dari aturan berikutnya, tindakan harus lebih menjorok
daripada baris yang berisi target dan dependensi. Tidak seperti implementasi lain dari
make, makepp tidak terlalu peduli seberapa banyak Anda membuat indentasi atau apakah Anda menggunakan karakter tab
daripada spasi. Untuk menjaga kompatibilitas ke belakang dengan merek tradisional, aturannya
makepp digunakan untuk memutuskan kapan tindakan berakhir dan aturan berikutnya dimulai agak rumit:

· Garis aksi pertama harus menjorok lebih dari garis yang berisi target.

· Jika garis diindentasi oleh satu karakter tab atau 8 spasi atau lebih, maka itu dianggap
sebuah garis aksi.

· Baris kosong atau baris komentar dengan karakter "#" di margin kanan mengakhiri
aturan, kecuali baris tidak kosong berikutnya menjorok lebih dari 8 spasi (atau lebih dari satu)
tab).

· Jika sebuah garis menjorok sebanyak atau lebih dari garis tindakan pertama, maka itu adalah
dianggap sebagai garis tindakan tambahan.

Ada beberapa item tindakan khusus:

& Simbol ini harus diikuti dengan nama perintah dan sejumlah argumen. Kerang
sintaks tidak dipahami sepenuhnya di sini, hanya tanda kutip tunggal dan ganda dan garis miring terbalik
karakter di dalamnya, seperti di seluruh makepp. Nama perintah mengarah ke suatu fungsi
"C_nama" untuk dipanggil dengan string yang tersisa sebagai argumen. Jika fungsi seperti itu dapat
tidak ditemukan, ini identik dengan memanggil "run" dari blok "Perl".

Ini memungkinkan pemanggilan perintah internal, makefile-provided, atau eksternal secara efisien.
Awalan "&" telah dipilih karena merupakan pemanggil fungsi di Perl, dan karena
pada awalnya itu ilegal di Shell.

$(ROOT)/termasuk/%.h: %.h
&ln $(masukan) $(keluaran)

tidak ada gema
@ Biasanya, setiap perintah shell dicetak saat dijalankan. Namun, jika kata pertama
tindakannya adalah "noecho" (atau jika dimulai dengan karakter "@"), maka perintahnya
tidak dicetak. Sebagai contoh,

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

Ini berarti bahwa ketika perintah libtool dijalankan, itu tidak dicetak. (Libtool
sendiri biasanya mencetak perintah yang dimodifikasi yang dijalankannya, jadi itu berlebihan untuk
cetak dua kali.)

abaikan_kesalahan
- Biasanya, jika perintah shell mengembalikan status bukan nol, maka makepp dibatalkan karena
perintah gagal. Namun, beberapa program salah mengatur status saat keluar, atau
mungkin ada kesalahan yang sebenarnya tidak fatal dan tidak harus membatalkan keseluruhan
kompilasi. Anda dapat menyebabkan makepp mengabaikan status pengembalian dengan menentukan
"ignore_error" sebagai kata pertama dari baris perintah (atau "-" sebagai karakter pertama).
Sebagai contoh,

$(distribusi palsu):
abaikan_error rm -r my_program-$(VERSION) # Singkirkan sampah sebelumnya.
&mkdir my_program-$(VERSION)
&cp $(FILES) my_program-$(VERSION)
tar cf program_saya-$(VERSION).tar program_saya-$(VERSION)

Perintah ini membuat direktori, menyalin banyak file ke dalamnya, dan kemudian menempatkan
semuanya menjadi file tar untuk didistribusikan. Ada baiknya untuk membersihkannya
isi direktori sebelumnya, jika ada sesuatu di sana sebelumnya, dan itu
apa yang dilakukan baris pertama. "rm" mungkin gagal, tetapi status pengembaliannya diabaikan.

perl
pembuat
Ini pada dasarnya sama dengan pernyataan perl, tetapi ini dilakukan setiap saat ketika
menjalankan aturan, bukan saat membaca makefile. Varian pertama adalah Perl biasa
kode, sedangkan varian kedua pertama melewati pernyataan melalui variabel Make-style
ekspansi.

Untuk dua kemungkinan memasang penyangga badan, simak penjelasannya di
"perl_perlcode" di makepp_statements. Perhatikan bahwa varian ketiga dijelaskan di sana
tidak masuk akal di sini, karena semua garis tindakan harus menjorok. Anda harus memberi isyarat
kegagalan dalam pernyataan Perl, dengan memanggil "mati".

Per aturan, pernyataan Perl saat ini dievaluasi dalam subproses umum, kecuali pada
jendela. Itu berarti mereka hanya memiliki akses baca ke variabel makefile apa pun. Itu juga
proses yang mengeksekusi tindakan non-Perl. Jadi memanggil exec atau exit akan membingungkan
makepp. Tapi ini bisa berubah di masa depan. Untuk cara yang efisien untuk menelepon Perl
skrip, lihat item sebelumnya "&" atau "jalankan".

$(versi palsu):
noecho Perl {{ # $(target) & $(VERSION) dari Perl:
print "Ini adalah ".f_target()." $VERSION\n";
}}
echo Anda dapat mencampur ini dengan perintah Shell
-makeperl { print "Ini adalah $(target) $(VERSION)\n" }

Ada beberapa jenis aturan, masing-masing dengan tujuan yang berbeda.

Eksplisit Peraturan
target1 target2: ketergantungan1 ketergantungan2 ...
tindakan yang akan dilakukan

Sintaks ini menentukan bahwa untuk membuat target1 or target2, semua file
ketergantungan1, ketergantungan2, dll., pasti sudah dibuat. Maka tindakan yang diberikan adalah
dieksekusi oleh shell untuk membuat target.

Aturan eksplisit pertama dalam file adalah target default, dan dibuat jika Anda tidak menentukan
target apa pun di baris perintah.

Tidak seperti program make tradisional, makepp biasanya mengasumsikan bahwa satu pemanggilan aksi
membuat semua target (kecuali tidak ada dependensi). Misalnya, satu doa
dari yacc membuat kedua file keluaran untuk aturan ini:

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

Perhatikan bahwa implementasi lain dari make tidak memiliki konsep perintah tunggal
menghasilkan beberapa file keluaran, dan ketika Anda menentukan beberapa target mereka akan
mengeksekusi aturan sekali per target. Makepp akan kembali ke perilaku ini jika terlihat seperti
ini adalah makefile gaya lama. Secara khusus, itu akan menjalankan aturan sekali per target,
alih-alih hanya sekali secara keseluruhan, jika semua hal berikut ini benar:

· Tindakan aturan menyebutkan variabel otomatis $@. (Sinonim "$(keluaran)" atau
"$(target)" tidak memicu perilaku ini.)

· Tindakan aturan tidak menyebutkan variabel otomatis "$(outputs)" (atau sinonimnya
"$(target)").

· Ini bukan aturan pola, dan tidak ada klausa foreach.

Sebagai contoh,

semua tes instal:
untuk subdir di $(SUBDIRS); lakukan cd $$subdir && $(BUAT) $@; cd..; selesai

adalah idiom umum di makefile, dan makepp mendukungnya. (Perhatikan bahwa Anda tidak boleh menggunakan
make rekursif di setiap makefile baru yang Anda tulis--gunakan pernyataan "load_makefile", atau
pemuatan makefile implisit sebagai gantinya.)

Jika Anda ingin aturan yang sama dijalankan sekali untuk setiap target (misalnya, karena target
memiliki perintah serupa), lebih baik menggunakan aturan pola (lihat di bawah) atau a
klausa "foreach". Misalnya, jika dengan program make tradisional Anda akan menulis:

abcd:
lakukan_sesuatu untuk membangun $@ > $@

di makepp, Anda mungkin ingin menulisnya seperti ini:

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

Palsu target

A palsu target adalah target yang tidak akan pernah benar-benar ada di sistem file; itu hanya
cara membuat makepp membangun beberapa target dan mungkin menjalankan beberapa perintah tambahan.

Target palsu yang khas adalah "semua", yang biasanya digunakan untuk menyebabkan segala sesuatu yang bisa terjadi
dibangun untuk dibangun, seperti ini:

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

Jika Anda mengetik "makepp all", atau jika Anda menempatkan semua sebagai target eksplisit pertama di makefile Anda
(yang khas) dan cukup ketik "makepp", maka itu akan menyebabkan semua dependensi menjadi
dibangun, maka akan mencetak "Semua selesai!". Pada titik ini, makepp akan mencari file ./semua
dan akan menemukan bahwa itu tidak ada. Ini akan mengeluh keras.

Agar makepp tidak mengharapkan file ./semua untuk keluar, Anda harus mengatakan bahwa itu adalah
sasaran palsu. Letakkan saja baris seperti berikut di makefile Anda (tidak ada bedanya
di mana):

.PHONY: semua

Alternatif yang setara yang terkadang lebih nyaman adalah dengan menggunakan "$(phony )"
fungsi, seperti ini:

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

Target palsu dalam satu makefile dapat merujuk ke target palsu di makefile lain. Ini adalah
sering dilakukan dengan target "bersih", seperti ini:

# Makefile tingkat atas:
# banyak aturan dan hal-hal di sini
# ....
$(bersih palsu): subdir1/bersih subdir2/bersih
&rm -fm my_program

Kemudian di subdirektori, makefile mungkin terbaca seperti ini:

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

Tetapi saat ini Anda akan menggunakan perintah "makeppclean", alih-alih target bersih.

Kartu liar

Aman untuk menentukan wildcard dalam daftar ketergantungan. Wildcard tidak hanya cocok dengan file
yang ada, tetapi file yang dapat dibuat diberikan aturan di makefile. Sebagai contoh,
untuk membangun perpustakaan dari semua file .o dalam direktori, Anda dapat menulis ini:

libmine.a: *.o
&rm -f $(keluaran)
ar cr $(keluaran) $(masukan)

Ini akan berfungsi bahkan jika tidak ada file ".o" yang telah dibuat, karena makepp's
wildcard cocok dengan file yang belum ada tetapi dapat dibuat. Ini bahkan akan mengambil
file yang aturannya ditemukan kemudian (dalam makefile yang sama, atau yang belum dibaca). Di dalam
poin terakhir ini berbeda dari fungsi "wildcard", yang terbatas pada aturan yang diketahui,
karena harus mengembalikan hasilnya ketika diperluas.

Makepp mendukung semua wildcard shell biasa ("*", "?", dan "[]"). Ia juga memiliki
wildcard "**" yang cocok dengan sejumlah direktori intervensi. (Ide ini dicuri
dari zsh.) Misalnya, "**/*.c" cocok dengan semua .c file di seluruh pohon sumber.
"objects/**/*.o" cocok dengan semua .o file yang terdapat di mana saja di subdirektori objek
atau salah satu subdirektorinya atau salah satu subdirektorinya. Wildcard "**" tidak akan
ikuti tautan lunak ke direktori di tingkat mana pun. Itu juga tidak akan pernah mengembalikan target palsu.

Wildcard Makepp akan mengabaikan file atau direktori yang ada tetapi tidak dapat dibaca. Setelah
semua, file seperti itu tidak dapat digunakan dalam proses pembuatan. Menempatkan file yang tidak dapat dibaca di a
direktori terutama berguna untuk menghambat impor otomatis file yang diberikan dari a
gudang.

Pernyataan awal adalah bahwa ini aman. Ini dalam arti berfungsi apakah
file sudah ada, atau perlu dibangun terlebih dahulu. Namun itu tidak aman dalam arti
bahwa itu masih akan cocok dengan file yang dibuat oleh makepp, tetapi tidak lagi memiliki aturan (mis
kamu menghapus .c file, tapi .o file masih ada.) Untuk mencegah hal ini, gunakan
opsi "--rm-basi".

pola aturan
Aturan pola adalah aturan yang diterapkan berdasarkan beberapa pola tekstual. Ini digunakan untuk
menerapkan aturan yang sama ke seluruh kelas file. Sintaksnya sama dengan GNU make's
aturan pola:

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

Ini mengatakan bahwa file apa pun di direktori saat ini yang cocok dengan "*.c" dapat dikonversi menjadi
file .o yang sesuai menggunakan perintah yang diberikan.

Perhatikan bahwa beberapa dependensi pola mungkin diberikan. Misalnya, jika Anda xyz.o fillet
tergantung pada yang sesuai xyz.cpp file, dan juga pada file bernama moc_xyz.cflags yang
berisi opsi kompiler, ini dapat dinyatakan dengan:

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

Anda mungkin juga memiliki beberapa target pola. Sebagai contoh,

%.tab.h %.tab.c : %.y
yacc -d $(masukan)
&mv y.tab.h $(batang).tab.h
&mv y.tab.c $(batang).tab.c

Biasanya, aturan pola hanya mencari file di direktori saat ini. Anda bisa memaksa
mereka untuk mencari di direktori saat ini dan semua direktori di bawahnya dengan menyetel

makepp_percent_subdirs := 1

sebelum aturan pola pertama di makefile Anda atau di baris perintah misalnya.

Ada perbedaan yang jelas antara "%" dan wildcard "*", meskipun keduanya cocok
string: Wildcard mengembalikan daftar file yang benar-benar digunakan pada saat itu. Jadi
ini tergantung semua .o file yang dapat dibangun di sini:

program: *.o
$(LD) $(LDFLAGS) $(masukan) -o $(keluaran)

Ini tidak dapat dicapai dengan mengganti "*" dengan "%", karena yang terakhir adalah untuk satu-per-satu
pencocokan input ke output, menghasilkan secara internal satu aturan untuk setiap batang yang cocok.

Statis belt hold aturan
Aturan pola statis adalah aturan pola yang diterapkan hanya pada kumpulan file terbatas:

$(SPECIAL_MODULES).o : %.o : %.cpp
$(CXX) -c $(masukan) -o $(keluaran)

Ini mengatakan bahwa aturan pola hanya berlaku untuk file di "$(SPECIAL_MODULES).o".

Ini sebagian besar untuk kompatibilitas dengan GNU make; aturan foreach (lihat di bawah) lebih banyak
cara ampuh untuk melakukan hal yang sama.

Untuk setiap aturan
Sintaks aturan pola di atas cukup kuat untuk mendukung hampir semua build, tetapi
kadang-kadang perlu melakukan sesuatu yang lebih rumit. Makepp menyediakan lebih banyak
sintaks yang kuat: klausa ":foreach" untuk aturan.

target_expression : dependency_expression : untuk setiap daftar file
tindakan

Jenis aturan foreach yang paling sederhana hanyalah aturan pola yang penerapannya dibatasi
ke daftar file tertentu. Misalnya, Anda memiliki aturan pola yang memberi tahu
makepp cara mengkompilasi semua .c file. Namun, Anda memiliki daftar .c file yang Anda
ingin melakukan sesuatu yang berbeda. Anda dapat melakukan sesuatu seperti ini:

# Inilah aturan yang berlaku untuk semuanya:
%.o : %.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

%.o : %.c : untuk setiap $(SPECIAL_MODULES)
$(CC) $(SPECIAL_CFLAGS) -c $(masukan) -o $(keluaran)

Penggunaan aturan foreach yang lebih kuat mengambil keuntungan dari fakta bahwa variabel
"$(foreach)" diatur secara bergantian ke setiap file yang cocok dengan daftar file dan target dan
ekspresi ketergantungan dievaluasi. Daftar file mungkin berisi wildcard, dan ini:
mencocokkan bahkan file yang belum ada tetapi dapat dibuat (lihat "Wildcard" di
makepp_rules).

Ini adalah sintaks yang berat tetapi sangat fleksibel, karena variabel "$(foreach)"
dapat muncul dengan cara apapun dalam ekspresi. Pertama, perhatikan bahwa aturan pola sebenarnya adalah
kasus khusus dari aturan foreach; aturan pola

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

persis sama dengan:

$(patsubst %.c, %.o, $(foreach)) : $(foreach) : foreach *.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

(Faktanya, ini dikonversi menjadi kira-kira secara internal.)

Sebagai contoh bagaimana Anda akan menggunakan klausa ":foreach" di mana aturan pola tidak
cukup, misalkan Anda punya beberapa .c file yang dibangun menggunakan semacam preprocessor
yang mengambil sebagai file input dengan a .k perpanjangan. Anda ingin mengkompilasinya .c file dengan
kumpulan opsi kompilasi yang berbeda dari biasanya .c file yang merupakan sumber biasa
file. Anda dapat melakukan sesuatu seperti ini:

# Aturan untuk file .c biasa:
%.o : %.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

# Aturan untuk membuat file .c dari file .k:
%.c : %.k
$(praprosesor) $(masukan) > $(keluaran)

# Aturan pembuatan khusus untuk file .c yang dibuat dari file .k:
$(foreach:%.k=%.o) : $(foreach:%.c=%.k) : foreach *.k
$(CC) $(SPECIAL_CFLAGS) -c $(masukan) -o $(keluaran)

(Ini menggunakan sintaks referensi substitusi yang sedikit lebih ringkas daripada memanggil
"patsubst" secara eksplisit.)

Perhatikan bahwa jika semua yang ingin Anda lakukan adalah mengubah nilai variabel ("CFLAGS" dalam ini
case) terkadang lebih nyaman menggunakan variabel target-spesifik.

Warisan akhiran aturan
Untuk kompatibilitas mundur, makepp mendukung aturan sufiks gaya lama.

.suffix1.suffix2:
tindakan

adalah setara dengan

%.suffix2: %.suffix1
tindakan

tapi lebih sulit untuk diingat. (Sufiks mana yang lebih dulu?) Biasanya, aturan akan muncul
dalam makefile lama seperti ini:

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

yang persis sama dengan

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

Berbenturan aturan
Ketika ada lebih dari satu cara untuk membuat file, makepp menggunakan prosedur sederhana untuk
menentukan aturan mana yang akan digunakan.

· Merupakan kesalahan untuk memiliki aturan eksplisit yang bertentangan untuk membangun file.

· Aturan pola dan aturan foreach dengan wildcard tidak pernah mengesampingkan aturan eksplisit. Dengan demikian
aturan eksplisit dapat digunakan untuk menentukan pengecualian untuk aturan pola. (Perhatikan bahwa hanya
menggunakan klausa ":foreach" tidak membuat sesuatu menjadi aturan pola. Itu harus memiliki
wildcard (seperti "*" atau "?") sebagai bagian dari nama file dalam klausa ":foreach". Jika memang
hanya daftar file eksplisit, itu diperlakukan sebagai aturan eksplisit untuk masing-masing file itu
file.)

· Ketika aturan pola yang bertentangan berasal dari makefile yang berbeda, aturan dari "lebih dekat"
makefiles mengesampingkan aturan dari makefiles "lebih jauh". "Lebih dekat" berarti makefile
terletak lebih dekat ke target dalam hierarki direktori (yaitu, nama file dari
target relatif terhadap direktori tempat makefile dijalankan lebih pendek). Jika ini
tidak membedakan makefile, maka aturan dari makefile yang dimuat
terbaru digunakan.

Ini berarti Anda dapat menentukan aturan pola yang berlaku untuk semua file di . Anda
seluruh pohon direktori hanya dalam makefile tingkat atas, tetapi kemudian Anda dapat menimpanya di
makefile tingkat yang lebih rendah. Misalnya, makefile tingkat atas Anda dapat berisi:

%.o : %.c : depan **/*.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

dan Anda dapat memiliki makefile di salah satu subdirektori yang mengatakan:

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

· Aturan pola yang memiliki rantai inferensi yang lebih pendek lebih disukai daripada pola lainnya
aturan. Misalnya, jika Anda memiliki aturan berikut (berdasarkan contoh dari
Kernel Linux):

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

%.o: %.s
$(AS) $(masukan) -o $(keluaran)

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

Jika kita perlu membangun "xyz.o", kita bisa membuat file ".s" perantara dan kemudian
jalankan itu melalui assembler menggunakan dua aturan pertama, atau kita bisa langsung ke a
File ".o" menggunakan aturan terakhir. Aturan terakhir lebih disukai karena lebih sedikit
langkah-langkah dalam rantai inferensi (satu bukannya dua).

· Aturan pola nanti di makefile mengesampingkan aturan pola yang sebelumnya. (Ini adalah
mundur dari GNU make.) Ini berarti Anda harus meletakkan aturan yang lebih umum
sebelumnya, dan aturan Anda yang lebih spesifik nanti. Sebagai contoh,

%.o: %.c # Aturan kompilasi umum.
tindakan

special_%.o: special_%.c # Aturan khusus untuk file dengan
tindakan berbeda # awalan "khusus_".

Aturan Pilihan
Terkadang perlu memberikan opsi tambahan untuk memodifikasi cara makepp mengeksekusi
aturan. Opsi ini ditentukan sebagai ": nilai nama opsi", baik pada baris yang berisi
dependensi, atau pada baris berikutnya.

Menyediakan opsi pada jalur terpisah memungkinkan Anda untuk menggunakan yang sama
makefile dengan makepp dan make tradisional. Sebagai contoh,

target: dependensi
: tanda tangan target_newer
tindakan

akan bekerja dengan baik dengan merek Unix tradisional, karena menginterpretasikan baris ": signature"
sebagai perintah shell, dan perintah yang dimulai dengan titik dua tidak melakukan apa-apa.

: build_cache /path/ke/build/cache
target: dependensi
: build_cache /put/cache/files/over/there
tindakan

Menentukan jalur ke cache build yang akan digunakan untuk file yang dihasilkan oleh aturan ini. Ini
mengesampingkan efek dari pernyataan "build_cache" atau perintah "--build-cache"
opsi baris, jika ada, untuk aturan ini. Lihat makepp_build_cache untuk detail tentang build
cache.

Jika Anda menentukan "tidak ada" alih-alih jalur, Anda menonaktifkan cache build untuk ini
aturan tertentu. Ini berguna untuk menghindari pemborosan ruang disk pada file yang Anda
tahu tidak berguna untuk di-cache, baik karena Anda sangat yakin mereka tidak akan pernah
digunakan kembali atau karena dibuat dengan sangat cepat sehingga tidak layak untuk di-cache.

: build_check build_check_method
target: dependensi
: build_check target_baru
tindakan

Ini memberitahu makepp algoritma apa yang digunakan untuk memutuskan apakah target perlu dibangun kembali.
Lihat makepp_build_check untuk detail selengkapnya. Ini mengesampingkan efek dari
pernyataan "build_check" atau opsi baris perintah "--build-check-method", jika ada, untuk
aturan ini.

: env VARIABEL ...
Tambahkan ketergantungan pada nilai variabel lingkungan bernama. Jika salah satu dari mereka
berbeda dari build sebelumnya, maka target dianggap ketinggalan zaman, jika
build_check metode begitu mendikte. (Semua metode pemeriksaan build bawaan kecuali untuk
target_newer menghormati ini.)

VARIABEL dapat berbentuk "nama file dalam PATH_VARIABLE" (dalam tanda kutip), dalam hal ini:
target dianggap kedaluwarsa jika direktori pertama dari titik dua dibatasi
nilai PATH_VARIABLE di mana nama file ada berbeda dari build terakhir.
Ini dapat digunakan untuk menghindari membangun kembali target ketika PATH_VARIABLE berubah dalam
cara yang tidak relevan.

:menugaskan Command ...
Lampirkan setiap tindakan shell (tetapi bukan tindakan Perl atau perintah Perl) dalam "sh -c '...'"
dan awali dengan perintah, tetapi asumsikan bahwa target tidak bergantung pada perintah.
Ini berguna jika Anda ingin mengirim tindakan ke sistem antrian pekerjaan, tetapi hasilnya adalah
diasumsikan independen dari parameter antrian, serta apakah antrian
sistem digunakan sama sekali.

:termasuk file_atau_pola
Aturan bervariasi tergantung pada kompiler:

%.o : %.c
: sertakan %.d : tanda tangan C
gcc -MD -c ...

%.o : %.c
: include %.u : signature C # IBM menggunakan akhiran yang berbeda
xlc -M -c ...

sub dependify { # Ubah obrolan Microsoft menjadi format yang berguna
s/\$/\$\$/g;
s/(Catatan: termasuk file: *)?(.+?)\r?\n/$1 ? "'$2' " : "'".f_output()."': "/e;
}
%.o : %.c
: sertakan %.d : tanda tangan C
cl -showIncludes -c ... >$(stem).d
&sed &bergantung -o +<$(batang).d

Beberapa kompiler (icc Intel seperti gcc di atas, atau xlc IBM) dapat menghasilkan ketergantungan
file dengan cepat. Artinya, saat mereka mengkompilasi, mereka menulis makefile yang makepp bisa
termasuk. Kelebihan scanner makepp adalah dijamin 100%
benar, di mana kita mungkin hanya datang dekat.

Opsi ini memanfaatkannya dengan cara khusus: Jika file tidak ada, mis
biasanya pada build pertama, pemindaian normal terjadi. Tetapi jika file itu ada, tidak
pemindaian terjadi (itulah sebabnya kami menetapkan tanda tangan pintar di atas -- bukan pemindaian yang jatuh
kembali ke default bodoh dari cap waktu dan ukuran). Alih-alih itu termasuk file, sebelumnya
menjalankan aturan. Setelah berhasil menjalankan aturan, ia melupakan apa pun itu
baca pertama kali, mengingat file tersebut mungkin sudah kedaluwarsa. Sebaliknya itu berbunyi
file lagi, jika berubah, karena memiliki info build terbaru.

PERINGATAN: Ini pada dasarnya tidak dapat diandalkan. File dependensi diproduksi oleh yang sangat
aturan yang menjadi ketergantungannya. Di sisi lain, kompiler tahu tentang semua
itu adalah sub-include internal, yang biasanya diabaikan oleh makepp. Ini adalah keandalan
keuntungan hanya untuk kasus di mana tambalan kompiler hanya memperbaiki sub-penyertaan. NS
harga adalah bahwa makepp akhirnya melihat lebih banyak file, yang membutuhkan waktu.

Ada masalah saat Anda menghapus pernyataan "#include" dan file yang sesuai:
Itu masih akan disebutkan dalam file ketergantungan dari terakhir kali, ketika itu
diperlukan. Dalam kasus seperti itu, Anda harus mengedit file dependensi untuk menghapus dependensi
yang tidak lagi dapat dipenuhi.

Fitur ini tidak dapat digunakan dengan cache build karena mengambil file dari sana
membutuhkan mengetahui segala sesuatu tentang file. Tetapi file ketergantungan tergantung pada itu
file yang dipelajari makepp dengan membacanya. Ketergantungan melingkar seperti itu tidak normal
mungkin dalam sistem build yang andal. Ini adalah pengecualian karena setelah membangun kembali
dan membaca ulang file dependensi semuanya benar lagi.

Jika Anda membangun di repositori Anda, makepp akan mengambil file dependensi dari
Repositori pertama yang berisi satu. Ini tidak seperti file lain, di mana dibutuhkan yang pertama
dengan tanda tangan yang diharapkan. Ini lebih baik daripada untuk membangun cache, di mana karena kekurangan
tanda tangan, bahkan tidak dapat menemukan file.

:kesempatan terakhir
Aktifkan aturan terbuka, seperti

%.foo foo%.bar: :peluang_terakhir
&echo $@ -o $@
&cp $(keluaran)

Karena aturan seperti ini pada dasarnya dapat menghasilkan jumlah target yang tidak terbatas,
target aturan ini tidak akan cocok dengan fungsi $(wildcard) atau aturan pola kecuali
sesuatu yang lain telah menerapkan aturan dengan merujuk target secara khusus.
Selanjutnya, jika "--rm-stale" ditentukan, maka target yang tersisa dari sebelumnya
makepp run akan tampak basi jika satu-satunya cara untuk membuatnya adalah melalui aturan last_chance
yang belum diterapkan untuk target, yang merupakan perilaku yang diinginkan karena
build akan gagal lebih konsisten ketika salah mengandalkan wildcard untuk
mencocokkan target dari lari sebelumnya.

Opsi ": last_chance" dimaksudkan untuk menarik perhatian pada perilaku khusus dari
aturan sehubungan dengan pencocokan wildcard.

: pengurai pengurai
Ini memberitahu makepp bagaimana mengurai perintah untuk mendeteksi (termasuk) file. Biasanya,
makepp menebak bagaimana melakukan ini berdasarkan kata-kata dalam perintah itu sendiri (lihat
makepp_scanning untuk detailnya). Namun, jika makepp salah menebak, Anda mungkin ingin
secara eksplisit menunjukkan parser, seperti ini:

%.o: %.abc
: parser c_kompilasi
aksi disini

Ini menyebabkan makepp melakukan penguraian dan pemindaian yang sama seperti yang dilakukan untuk C/C++
membangun perintah, meskipun tidak mengenali tindakan sebagai kompilasi C.

Parser default tergantung pada perintah. Jika Anda tidak menentukan opsi ":parser",
kemudian kata pertama dari setiap perintah diperiksa. Misalnya untuk kompilasi atau tautan
perintah, makepp akan menggunakan parser "c_compilation"; atau jika perintahnya terlihat seperti
Varian GNU, "gcc_compilation". Jika tidak ada pengurai yang ditemukan, ia menggunakan pengurai "tidak ada". Untuk
lebih detail tentang ini, atau jika Anda ingin menulis parser Anda sendiri atau mengubah makepp's
parser default, lihat makepp_scanning.

Perhatikan bahwa ini berlaku untuk setiap perintah dalam aturan, yang mungkin bukan yang Anda inginkan:

%.o: %.c : parser c-kompilasi
@echo 'Membangun $(keluaran)'
@lucu_cc...

Ini juga akan menafsirkan "gema" sebagai kompiler dan menyimpulkan argumennya 'Bangunan
mymodule.o' sebagai dependensi implisit. Hal ini akan menimbulkan keluhan bahwa
tidak tahu bagaimana membangun file seperti itu. Dalam hal ini Anda akan lebih baik dengan
"daftar_parser". Di sana Anda menemukan penjelasan caranya pengurai dapat diberikan sebagai
nama kelas atau sebagai nama fungsi.

:tanda tangan metode_tanda tangan
target: dependensi
: tanda tangan md5
tindakan

Ini memberitahu makepp algoritma apa yang digunakan untuk menentukan apakah dependensi telah berubah.
Lihat makepp_signatures untuk lebih jelasnya. Metode tanda tangan yang disertakan dengan
distribusi makepp adalah "plain", "md5", "C" atau "c_compilation_md5", dan
"berbagi_objek". Ini mengesampingkan metode tanda tangan apa pun yang ditentukan dengan "-m" atau
Opsi baris perintah "--signature-method", atau dengan pernyataan "signature".

Khusus karakter
Makepp dapat mendukung nama file yang memiliki karakter khusus di dalamnya seperti titik dua atau spasi.
Misalkan, misalnya, Anda ingin membuat file bernama "a:thing" dari file "b:thing".
Anda tidak dapat menulis aturan dengan cara ini:

a:thing : b:thing # Ini adalah kesalahan sintaks
&cat $(masukan) -o $(keluaran)

karena makepp tidak akan tahu titik dua mana yang memisahkan target dari dependensi dan mana yang
bagian dari nama file. Sebagai gantinya, cukup sertakan nama dalam tanda kutip, seperti ini:

"a:benda" : "b:benda"
&cat $(masukan) -o $(keluaran)

Sekarang aturannya tidak ambigu.

Sintaks kutipan Makepp sangat mirip dengan shell. Anda dapat, misalnya, menggunakan single
tanda kutip alih-alih tanda kutip ganda, atau Anda dapat menghindari karakter khusus dengan garis miring terbalik:

a\:benda : 'b:benda'
&cat $(masukan) -o $(keluaran)

Misalkan, misalnya, nama file Anda adalah "'"!;\$". Sekarang mengapa Anda menginginkan nama file seperti itu?
Saya tidak tahu, tetapi berikut adalah beberapa cara Anda dapat menentukannya ke makepp (dan shell):

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

Perhatikan kapan makepp strip mengutip dan kapan shell melakukannya. Makepp melihat
kutipan hanya dalam kasus berikut:

· dalam keluarga ujian "ifeq"

· sebelum dan sesudah aturan titik dua

· dalam perintah makepp bawaan

· dalam fungsi yang berkaitan dengan file

Tidak seperti shell, makepp tidak memperluas tanda kutip saat menugaskannya ke variabel. Dengan demikian
aturan berikut identik:

FILE = 'nama dengan spasi'
x := $(print $(FILE)) # hanya untuk memeriksa bahwa kutipan masih ada
$(FILE): # tanda kutip di sekitar satu file yang dihapus oleh makepp
&echo hello -o$(FILE) # tanda kutip di sekitar satu file yang dihapus oleh makepp
echo there >>$(FILE) # kutipan di sekitar satu file yang dilucuti oleh Shell
'nama dengan spasi':
&echo hello -o'name dengan spasi'
echo there >>'$(output)' # tanda kutip dihilangkan di atas, tambahkan lagi

Perhatikan bahwa (tidak seperti Shell) variabel yang dimulai dengan "$" diperluas bahkan di dalam single
kutipan. Tanda dolar tidak dapat dilindungi oleh tanda kutip atau garis miring terbalik. Untuk mendapatkan literal
tanda dolar, gunakan tanda dolar ganda, misalnya,

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

Secara umum, Anda harus dapat menangani hampir semua karakter khusus dengan mengutipnya
dalam beberapa cara. Ini termasuk spasi, karakter kontrol, dll. Namun, perlu diketahui bahwa di
sekarang, pengupasan komentar makepp agak sederhana, dan karakter "#" apa pun
didahului oleh spasi akan ditafsirkan sebagai komentar tidak peduli bagaimana kutipannya.

Ketika nama target atau dependensi dimasukkan ke dalam variabel otomatis seperti "$(output)", maka
tanda kutip dan garis miring terbalik apa pun dilucuti. Ini berarti bahwa jika Anda ingin mereferensikan
nama file dalam tindakan, Anda mungkin harus mengutipnya lagi, seperti ini:

"nama file dengan spasi":
echo "Konten khusus" > "$@"

Jika Anda tidak menempatkan tanda kutip di sekitar $@, maka shell akan melihat perintah

echo "Konten khusus"> nama file dengan spasi

yang menulis string "Nama file konten khusus dengan spasi" ke file bernama a.
Ini mungkin bukan yang Anda inginkan.

Gunakan makepp_rules online menggunakan layanan onworks.net