makepp_extending - Online di Cloud

PROGRAM:

NAMA

makepp_extending -- Cara memperpanjang makepp menggunakan Perl

DESKRIPSI

Makepp secara internal cukup fleksibel sehingga dengan menulis sedikit kode Perl, Anda dapat
menambahkan fungsi atau melakukan sejumlah operasi lainnya.

Umum catatan on penulisan Perl kode untuk kerja dengan makepp
Setiap makefile hidup dalam paketnya sendiri. Jadi definisi dalam satu makefile tidak mempengaruhi
definisi di makefile lain. Satu set fungsi umum termasuk semua standar
fungsi manipulasi tekstual diimpor ke dalam paket saat dibuat.

Variabel Makefile disimpan sebagai skalar Perl dalam paket itu. (Ada pengecualian untuk
ini: variabel otomatis dan nilai default variabel seperti CC sebenarnya
diimplementasikan sebagai fungsi tanpa argumen. Targetkan vars tertentu, vars baris perintah, dan
var lingkungan tidak terlihat seperti ini.) Jadi setiap kode Perl yang Anda tulis memiliki akses ke semua
variabel makefile. Variabel global disimpan dalam paket "Mpp::global". Lihat
Variabel Makefile untuk detailnya.

Setiap pernyataan (ifperl / ifmakeperl, perl / makeperl, sub / makesub), the
fungsi (perl / makeperl, peta / makemap) dan tindakan aturan (perl / makeperl) untuk
menulis kode Perl langsung di makefile datang dalam dua rasa. Yang pertama benar-benar
Perl normal, artinya Anda harus menggunakan awalan "f_" seperti yang dijelaskan di bagian selanjutnya, jika
Anda ingin memanggil fungsi makepp. Varian kedua pertama melewati pernyataan melalui
Ekspansi variabel make-style, artinya Anda harus menggandakan "$" yang Anda ingin Perl lihat.

Penanganan akhir sangat istimewa karena data makepp yang sangat besar (tergantung pada sistem build Anda)
struktur akan membutuhkan beberapa detik untuk mengumpulkan sampah dengan jalan keluar yang normal. Jadi kami melakukan
keluar paksa. Dalam proses utama Anda masih dapat memiliki blok "AKHIR" tetapi jika Anda memilikinya
menangani file global mereka mungkin tidak memerah. Tetapi Anda harus menggunakan leksikal modern
filehandles, yang ditutup dengan benar saat keluar dari ruang lingkup.

Dalam kode Perl, jalankan langsung sebagai tindakan aturan atau melalui perintah yang Anda tetapkan, itu adalah
di depan. Blok "AKHIR" tidak akan dijalankan, tetapi pegangan file global akan dihapus untuk Anda. NS
"HANCURKAN" objek global tidak akan pernah dijalankan.

Menambahkan yang baru tekstual fungsi
Anda dapat menambahkan fungsi baru ke repertoar makepp hanya dengan mendefinisikan subrutin Perl dari
nama yang sama tetapi dengan awalan "f_". Sebagai contoh:

sub f_fungsiku {
$argumen saya = &arg; # Sebutkan argumennya.
saya( undef, $mkfile, $mkfile_line ) = @_; # Sebutkan argumennya.

... lakukan sesuatu di sini

kembalikan $return_value;
}

XYZ := $(myfunc my func argument)

Jika fungsi Anda tidak membutuhkan argumen, tidak ada yang bisa dilakukan. Jika fungsi Anda membutuhkan satu
argumen, seperti pada contoh di atas, gunakan pengakses sederhana &arg untuk mendapatkannya. Jika kamu
mengharapkan lebih banyak argumen, Anda memerlukan "args" pengakses yang lebih kompleks yang dijelaskan di bawah ini.

Pengakses ini memproses tiga parameter yang sama yang harus diteruskan ke "f_" apa pun
fungsi, yaitu argumen fungsi, objek makefile dan deskriptor baris untuk
pesan. Oleh karena itu Anda dapat menggunakan bentuk efisien &arg dalam kasus pertama.

Aksesor &arg menangani hal berikut untuk Anda: Jika argumen sudah ada
diperluas (misalnya untuk menemukan nama fungsi di "$(my$(function) arg)" arg adalah
diteruskan sebagai string dan baru saja kembali. Jika argumen masih membutuhkan ekspansi, ini adalah
kasus biasa, itu bukan referensi ke string. Aksesor &arg memperluasnya untuk Anda,
yang membutuhkan objek makefile sebagai parameter ke-2.

Jika Anda mengharapkan lebih banyak argumen, mungkin dalam jumlah variabel, pekerjaan dilakukan oleh "args".
Accessor ini mengambil 3 parameter yang sama dengan arg, ditambah parameter tambahan:

max: jumlah argumen (default 2): berikan ~0 (maxint) untuk tanpa akhir
min: jumlah argumen (default 0 jika maks adalah ~0, jika tidak sama dengan maks)
only_comma: jangan makan spasi di sekitar koma, biasa untuk non-nama file

Maksimal maksimal, tetapi setidaknya koma minimal yang ada sebelum ekspansi digunakan untuk membagi
argumen. Beberapa contoh dari fungsi bawaan makepp:

my( $prefix, $text ) = args $_[0], $_[1], $_[2], 2, 2, 1; # tambahkan awalan
untuk $cond saya ( args $_[0], undef, $_[2], ~0 ) ... # dan, atau
saya @args= args $_[0], $_[1], $_[2], ~0, 1, 1; # panggilan
my( $filters, $words ) = args $_[0], $_[1], $_[2]; # Saring

Fungsi harus mengembalikan string skalar (bukan array) yang kemudian dimasukkan ke dalam
teks pada saat itu.

Jika fungsi Anda menemukan kesalahan, itu harus mati menggunakan pernyataan mati Perl yang biasa.
Ini akan terjebak oleh makepp dan pesan kesalahan yang menampilkan nama file dan baris
jumlah ekspresi yang menyebabkan kesalahan akan dicetak.

Pada dasarnya tidak ada batasan tentang apa yang dapat dilakukan oleh fungsi tersebut; Anda dapat mengakses file, jalankan
perintah shell, dll.

Saat ini, ekspresi yang muncul dalam dependensi dan dalam tindakan aturan diperluas
sekali saat ekspresi yang muncul di target diperluas dua kali, jadi berhati-hatilah jika
fungsi memiliki efek samping dan hadir dalam ekspresi untuk target.

Perhatikan bahwa lingkungan (khususnya, cwd) di mana fungsi mengevaluasi akan
belum tentu cocok dengan lingkungan di mana aturan dari Makefile di mana
fungsi dievaluasi dijalankan. Jika ini masalah bagi Anda, maka fungsi Anda
mungkin harus terlihat seperti ini:

sub f_foo {
...
chdir $makefile->{CWD};

... dll.
}

Puting fungsi ke a Perl modul
Jika Anda memasukkan fungsi ke dalam file yang disertakan, Anda akan memiliki satu salinan per Makeppfile yang
menggunakannya. Untuk menghindarinya, Anda dapat menulisnya sebagai modul Perl biasa dengan "Eksportir"
antarmuka, dan gunakan itu. Ini akan memuat lebih cepat dan menghemat memori:

perl { gunakan mymodule }
perl {
gunakan saya::modul; # put : pada baris baru jadi ini tidak diuraikan sebagai aturan
}

Jika Anda memerlukan salah satu fungsi yang biasanya tersedia di Makefile (seperti "f_"
fungsi, "arg" atau "args"), Anda harus memasukkan baris ini ke dalam modul Anda:

gunakan Mpp::Subs;

Kekurangannya adalah modul akan berada dalam paket yang berbeda dari fungsi secara langsung
muncul di makefile. Jadi, Anda harus memasukkan semuanya sebagai parameter, atau konstruksi
nama dengan fungsi "pemanggil" Perl.

panggilan luar Perl script
Jika Anda memanggil skrip Perl eksternal melalui "sistem", atau sebagai tindakan aturan, makepp akan membayar
proses baru (kecuali itu adalah tindakan aturan terakhir) dan jalankan juru bahasa Perl baru.
Tidak ada yang salah dengan itu, kecuali ada cara yang lebih efisien:

&Command argumen...
Ini bisa menjadi tindakan aturan. Ini akan memanggil fungsi Command dengan awalan "c_", dan
berikan sisanya (gaya makepp yang dikutip secara opsional -- tidak persis sama dengan
Shell) argumen. Jika fungsi seperti itu tidak dapat ditemukan, ini akan meneruskan semua string ke
"Lari".

sub c_mycmd { @args saya = @_; ... }

$(panggilan palsucmd):
&mycmd 'arg with space' arg2 "arg3" # memanggil c_mycmd

%.keluar masuk
&myscript -o $(output) $(input) # memanggil myscript eksternal

Anda dapat menulis perintah Anda dalam kerangka kerja bawaan, memungkinkan Anda untuk menggunakan
opsi standar yang sama seperti yang mereka miliki, dan penanganan I/O yang mereka berikan.

Operator blok "Mpp::Cmds::frame" diikuti oleh daftar opsi huruf tunggal dari
builtin (maksimal "qw(fi I ​​o O rs)"). Bahkan jika Anda menentukan pilihan Anda sendiri
mengesampingkan salah satunya, Anda masih memberikan satu huruf dari opsi standar.

Setiap opsi sendiri ditentukan sebagai "[qw(n nama), \$ref, argumen, sub]". Dua pertama
elemen adalah nama pendek dan panjang, diikuti oleh referensi variabel dan opsional oleh
boolean untuk apakah akan mengambil argumen. Tanpa arg, variabelnya adalah
bertambah setiap kali opsi diberikan, jika tidak, nilai opsi disimpan di dalamnya.

sub c_my_ocmd { # Kasus keluaran tipikal
lokal @ARGV = @_;
Mpp::Cmds::bingkai {

... cetak sesuatu di sini dengan @ARGV, dengan opsi yang sudah dihapus secara otomatis

} 'f', qw(o O);
}

sub c_my_icmd { # Kasus input tipikal dengan 2 opsi
lokal @ARGV = @_;
saya( $pendek, $panjang );
Mpp::Cmds::bingkai {

... lakukan sesuatu di sini dengan <>

} qw(i I rs), # s hanya menentukan --separator, bukan -s
[qw(s short), \$short], # Tidak ada opsi arg -> $short == 1
[qw(l long), \$long, 1, sub { warn "mendapat arg $long"}];
}

Inilah perintah sederhana yang hanya menampilkan karakter pertama dari setiap input
record (setara dengan "&sed '$$_ = "\u\L$$_"'"):

sub c_uc {
lokal @ARGV = @_;
Mpp::Cmds::bingkai {
print "\u\L$_" while <>;
} 'f', qw(i I o O rs);
}

Di dalam blok yang ditangani oleh bingkai, Anda dapat memiliki blok bersarang untuk melakukan kritis
operasi, seperti membuka file lain.

Mpp::Cmds::perform { ... } 'pesan';

Ini akan menampilkan pesan dengan "--verbose" (yang diterima setiap perintah) jika
perintah berhasil dijalankan. Tetapi jika blok tersebut bernilai salah, blok itu mati dengan
pesan yang dinegasikan.

menjalankan naskah argumen...
Ini adalah fungsi Perl normal yang dapat Anda gunakan dalam konteks Perl apa pun dalam makefile Anda.
Ini mirip dengan bentuk sistem multi-argumen, tetapi menjalankan skrip Perl di dalamnya
proses saat ini. Untuk pernyataan makepp, fungsi perl atau fungsi Anda sendiri
itulah proses yang menjalankan makepp. Tetapi untuk aturan yang merupakan kinerja subproses
dia. Skrip diurai sebanyak yang dipanggil, tetapi Anda dapat menempatkan yang asli
bekerja menjadi lib, seperti halnya pod2html. Lib ini kemudian dapat digunakan di tingkat atas, jadi
bahwa itu sudah ada:

perl { use mylib } # di-fork ke semua aturan yang tidak perlu di-reparse

%.keluar masuk
makeperl { jalankan qw'myscript -o $(output) $(input)' }

Jika skrip memanggil "keluar", menutup deskriptor file standar atau bergantung pada sistem
untuk membersihkan setelahnya (membuka file, memori ...), ini bisa menjadi masalah dengan "jalankan". Jika
Anda memanggil "jalankan" di dalam pernyataan atau fungsi perl, makepp bisa terganggu atau
pembersihan hanya terjadi di akhir makepp.

Jika Anda memiliki salah satu masalah yang disebutkan di atas, jalankan skrip secara eksternal, yaitu dari
baris perintah sebagai gantinya. Dalam aturan, pembersihan tidak terlalu menjadi masalah, terutama tidak
sebagai tindakan terakhir dari suatu aturan, karena subproses aturan akan keluar setelahnya,
kecuali di Windows.

Writing Tujuan sendiri tanda tangan metode
Terkadang Anda ingin makepp menghitung metode tanda tangan menggunakan teknik yang berbeda. Untuk
contoh, misalkan Anda memiliki biner yang bergantung pada pustaka bersama. Biasanya, jika Anda
ubah perpustakaan bersama, Anda tidak perlu menautkan kembali executable yang bergantung padanya karena
penautan dilakukan pada saat run time. (Namun, ada kemungkinan bahwa menautkan kembali executable
mungkin diperlukan, itulah sebabnya saya tidak menjadikan ini sebagai default.) Apa yang Anda inginkan makepp
lakukan adalah memiliki tanda tangan yang sama untuk perpustakaan bersama meskipun itu berubah.

Hal ini dapat dicapai dengan beberapa cara. Cara termudah adalah membuat sendiri yang baru
metode tanda tangan (sebut saja "shared_object"). Anda akan menggunakan metode tanda tangan ini
hanya pada aturan yang menautkan biner, seperti ini:

program saya : *.o lib1/lib1.so lib2/lib2.so
: tanda tangan shared_object
$(CC) $(masukan) -o $(keluaran)

Sekarang kita harus membuat metode tanda tangan.

Semua metode tanda tangan harus kelas mereka sendiri, dan kelas harus berisi beberapa khusus
item (lihat Mpp/Signature.pm dalam distribusi untuk detailnya). Nama kelas harus
diawali dengan "Mpp::Signature::", jadi dalam hal ini kelas kita harus dipanggil
"Mpp::Tanda tangan::shared_object". Kita harus membuat file bernama objek_bersama.pm dan taruh
itu menjadi Mpp::Tanda tangan direktori di suatu tempat di Perl include path; tempat termudah
mungkin di Mpp/Tanda Tangan direktori di instalasi makepp (mis.,
/usr/local/share/makepp/Mpp/Signature atau di mana pun Anda menginstalnya).

Untuk detail yang tepat tentang apa yang harus dilakukan di kelas ini, Anda harus melihat dengan cermat
file Mpp/Tanda Tangan.pm dan mungkin juga Mpp/Tanda Tangan/exact_match.pm di makepp
distribusi. Namun dalam kasus kami, yang ingin kami lakukan hanyalah membuat perubahan kecil pada sebuah
mekanisme tanda tangan yang ada; jika file tersebut adalah perpustakaan bersama, kami ingin memiliki konstanta
tanda tangan, sedangkan jika file adalah hal lain, kami ingin mengandalkan makepp's normal
mekanisme tanda tangan. Cara terbaik untuk melakukan ini adalah dengan mewarisi dari
"Mpp::Signature::c_compilation_md5", yang merupakan metode tanda tangan yang biasanya dipilih
ketika makepp mengenali perintah tautan.

Jadi filenya Mpp/Tanda Tangan/shared_object.pm mungkin berisi hal-hal berikut:

gunakan ketat;
paket Mpp::Tanda tangan::shared_object;
gunakan Mpp::Tanda tangan::c_compilation_md5;
@ISA kami = qw(Mpp::Tanda tangan::c_compilation_md5); # Tunjukkan warisan.
$shared_object kami = memberkati \@ISA; # Sepotong keajaiban yang membantu makepp menemukan
# subrutin untuk metode ini. Semua
# metode tanda tangan harus memiliki salah satunya.
# Nilai tidak digunakan, sembarang objek.
# Sekarang inilah metode yang dipanggil ketika kita membutuhkan tanda tangan dari
# target atau ketergantungan apa pun yang mengaktifkan metode tanda tangan ini:
tanda tangan tambahan {
my ($self, # Ini akan sama dengan $shared_object.
$finfo) = @_; # Struktur khusus yang berisi segalanya
# makepp tahu tentang file ini. Lihat
# Mpp/File.pm untuk detailnya.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # Apakah nama file diakhiri dengan .so atau .sa?
kembalikan $finfo->file_exists ? 'ada' : '';
# Selalu kembalikan tanda tangan yang sama jika file
# ada. Dalam hal ini, tanda tangan adalah
# string "ada".
}

Mpp::Tanda tangan::c_compilation_md5::tanda tangan;
# Jika file tidak berakhiran .so atau .sa,
# delegasikan ke metode tanda tangan makepp yang biasa.
}

File ini diberikan sebagai contoh dalam distribusi makepp, dengan beberapa tambahan
komentar.

Kebetulan, mengapa kita tidak menjadikan ini sebagai default? Nah, ada kalanya berubah
perpustakaan bersama akan memerlukan penautan ulang program Anda. Jika Anda pernah mengubah salah satu dari
simbol yang didefinisikan oleh perpustakaan bersama, atau simbol yang bergantung pada perpustakaan lain
karena, tautan ulang terkadang diperlukan.

Misalkan, misalnya, perpustakaan bersama memanggil beberapa subrutin yang program Anda
menyediakan. Misalnya, Anda mengubah perpustakaan bersama sehingga sekarang memanggil eksternal
subrutin "xyz()". Kecuali Anda menggunakan opsi "-E" atau "--export-dynamic" ke tautan
(untuk GNU binutils; linker lain memiliki nama opsi yang berbeda), simbol "xyz()" mungkin tidak
dapat diakses oleh run-time linker bahkan jika itu ada di program Anda.

Lebih buruk lagi, misalkan Anda mendefinisikan "xyz()" di perpustakaan lain (sebut saja libxyz), seperti ini:

program_saya: main.o lib1/lib1.so xyz/libxyz.a

Karena "libxyz" adalah .a file dan bukan .begitu file, maka "xyz()" tidak dapat ditarik
benar dari libxyz.a kecuali Anda menautkan ulang biner Anda.

Mpp::Metode tanda tangan juga mengontrol tidak hanya string yang digunakan untuk menentukan apakah a
file telah berubah, tetapi algoritma yang digunakan untuk membandingkan string. Misalnya,
metode tanda tangan "target_newer" dalam distribusi makepp hanya mengharuskan
target lebih baru daripada dependensi, sedangkan metode tanda tangan "exact_match" (dan
segala sesuatu yang bergantung padanya, seperti "md5" dan "c_compilation_md5") mengharuskan
file memiliki tanda tangan yang sama seperti pada build terakhir.

Berikut adalah beberapa jenis metode tanda tangan lain yang mungkin berguna, untuk membantu Anda menyadari
kemungkinan-kemungkinan. Jika tujuan umum cukup, beberapa di antaranya pada akhirnya mungkin
dimasukkan ke dalam makepp:

· Metode tanda tangan untuk pustaka bersama yang mengembalikan checksum dari semua yang diekspor
simbol, dan juga semua simbol yang dibutuhkan dari perpustakaan lain. Ini memecahkan
masalah dengan contoh di atas, dan menjamin tautan yang benar dalam semua keadaan.
Upaya eksperimental telah dilakukan untuk melakukan ini dalam distribusi makepp (lihat
Mpp/Tanda Tangan/shared_object.pm), tetapi hanya akan bekerja dengan GNU binutils dan ELF
perpustakaan pada saat ini.

· Metode tanda tangan yang mengabaikan cap tanggal yang ditulis ke dalam file. Misalnya, jika Anda
menghasilkan a .c file secara otomatis menggunakan beberapa program yang bersikeras menempatkan string
dalam seperti ini:

static char * date_stamp = "Dihasilkan secara otomatis pada 01 Apr 2004 oleh siapa pun";

Anda dapat menulis metode tanda tangan yang secara khusus mengabaikan perubahan pada cap tanggal.
Jadi jika cap tanggal adalah satu-satunya hal yang berubah, makepp tidak akan dibangun kembali.

· Metode tanda tangan yang menghitung tanda tangan dengan cara biasa, tetapi mengabaikan
ketergantungan arsitektur ketika memutuskan apakah akan membangun kembali. Ini bisa berguna untuk
file yang benar-benar tidak bergantung pada arsitektur; saat ini jika Anda membangun satu arsitektur,
makepp akan bersikeras untuk membangun kembali bahkan file yang tidak bergantung pada arsitektur saat Anda beralih
ke arsitektur yang berbeda.

· Metode tanda tangan yang tahu cara mengabaikan komentar di file lateks, sebagai
Metode "c_compilation_md5" mengetahui cara mengabaikan komentar di file C.

· Metode tanda tangan untuk ekstraksi dokumentasi otomatis yang checksum hanya untuk
komentar yang dibutuhkan oleh pengekstrak dokumentasi dan mengabaikan perubahan lain pada sumbernya
file.

Belum selesai
Dokumen ini belum selesai. Itu harus mencakup cara menulis pemindai Anda sendiri untuk
termasuk file dan hal-hal seperti itu.

Gunakan makepp_extending online menggunakan layanan onworks.net