makepp_extending - Dalam talian di Awan

JADUAL:

NAMA

makepp_extending -- Cara memanjangkan makepp menggunakan Perl

DESCRIPTION

Makepp secara dalaman cukup fleksibel supaya dengan menulis sedikit kod Perl, anda boleh
menambah fungsi atau melakukan beberapa operasi lain.

Umum nota on bertulis Perl kod kepada bekerja bersama makepp
Setiap makefile hidup dalam pakejnya sendiri. Oleh itu takrifan dalam satu makefile tidak menjejaskan
definisi dalam makefile lain. Satu set fungsi biasa termasuk semua standard
fungsi manipulasi teks diimport ke dalam pakej apabila ia dicipta.

Pembolehubah Makefile disimpan sebagai skalar Perl dalam pakej itu. (Terdapat pengecualian untuk
ini: pembolehubah automatik dan nilai lalai pembolehubah seperti CC sebenarnya
dilaksanakan sebagai fungsi tanpa hujah. Sasarkan vars khusus, vars baris arahan dan
vars persekitaran tidak dilihat dengan cara ini.) Oleh itu, mana-mana kod Perl yang anda tulis mempunyai akses kepada semua
pembolehubah makefile. Pembolehubah global disimpan dalam pakej "Mpp::global". Lihat
Pembolehubah Makefile untuk butiran.

Setiap pernyataan (ifperl / ifmakeperl, perl / makeperl, sub / makesub),
fungsi (perl / makeperl, peta / makemap) dan tindakan peraturan (perl / makeperl) untuk
menulis kod Perl terus dalam makefile datang dalam dua perisa. Yang pertama adalah mutlak
Perl biasa, bermakna anda perlu menggunakan awalan "f_" seperti yang dijelaskan dalam bahagian seterusnya, jika
anda mahu memanggil fungsi makepp. Varian kedua mula-mula melepasi kenyataan
Pengembangan pembolehubah gaya buat, bermakna anda perlu menggandakan "$" yang anda mahu Perl lihat.

Pengendalian akhir adalah istimewa kerana data makepp yang besar (bergantung pada sistem binaan anda).
struktur akan mengambil masa beberapa saat untuk mengutip sampah dengan jalan keluar biasa. Jadi kita lakukan a
keluar dengan kekerasan. Dalam proses utama anda masih boleh mempunyai blok "END" tetapi jika anda ada
pemegang fail global mereka mungkin tidak akan disiram. Tetapi anda harus menggunakan leksikal moden
pemegang fail, yang ditutup dengan betul apabila keluar dari skop.

Dalam kod Perl dijalankan secara langsung sebagai tindakan peraturan atau melalui arahan yang anda tentukan, ia adalah
bertentangan. Blok "TAMAT" tidak akan dijalankan, tetapi pemegang fail global akan disiram untuk anda. The
"DESTROY" objek global tidak akan dijalankan.

Menambah baru tekstual fungsi
Anda boleh menambah fungsi baharu pada himpunan makepp dengan hanya mentakrifkan subrutin Perl bagi
nama yang sama tetapi dengan awalan "f_". Sebagai contoh:

sub f_myfunc {
$argumen saya = &arg; # Namakan hujah.
my( undef, $mkfile, $mkfile_line ) = @_; # Namakan hujah.

... buat sesuatu di sini

pulangkan $return_value;
}

XYZ := $(myfunc my func arguments)

Jika fungsi anda tidak mengambil hujah, tiada apa yang perlu dilakukan. Jika fungsi anda mengambil satu
hujah, seperti dalam contoh di atas, gunakan accessor &arg mudah untuk mendapatkannya. Jika awak
mengharapkan lebih banyak hujah, anda memerlukan aksesor yang lebih kompleks "args" yang diterangkan di bawah.

Aksesori ini memproses tiga parameter yang sama yang harus dihantar ke mana-mana "f_"
fungsi, iaitu argumen fungsi, objek makefile dan deskriptor baris untuk
mesej. Oleh itu anda boleh menggunakan borang &arg yang cekap dalam kes pertama.

Aksesor &arg menguruskan perkara berikut untuk anda: Jika hujah-hujah itu sudah pun
dikembangkan (cth untuk mencari nama fungsi dalam "$(my$(function) arg)" arg ialah
berlalu sebagai rentetan dan baru kembali. Jika hujah masih memerlukan pengembangan, ini adalah
kes biasa, ia sebaliknya merujuk kepada rentetan. Aksesor &arg mengembangkannya untuk anda,
yang mana ia memerlukan objek makefile sebagai parameter ke-2nya.

Jika anda menjangkakan lebih banyak hujah, mungkin dalam nombor berubah-ubah, kerja itu dilakukan oleh "args".
Aksesori ini mengambil 3 parameter yang sama seperti arg, serta parameter tambahan:

max: bilangan args (lalai 2): berikan ~0 (maxint) untuk tidak berkesudahan
min: bilangan args (lalai 0 jika maks ialah ~0, jika tidak sama dengan maks)
only_comma: jangan makan ruang di sekeliling koma, biasa untuk bukan nama fail

Paling banyak maks, tetapi sekurang-kurangnya koma min hadir sebelum pengembangan digunakan untuk membelah
hujah. Beberapa contoh daripada fungsi terbina dalam makepp:

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

Fungsi harus mengembalikan rentetan skalar (bukan tatasusunan) yang kemudiannya dimasukkan ke dalam
teks pada ketika itu.

Jika fungsi anda menghadapi ralat, ia harus mati menggunakan pernyataan Perl die yang biasa.
Ini akan terperangkap oleh makepp dan mesej ralat yang memaparkan nama fail dan baris
nombor ungkapan yang menyebabkan ralat akan dicetak.

Pada asasnya tiada had pada fungsi yang boleh dilakukan; anda boleh mengakses fail, jalankan
arahan shell, dsb.

Pada masa ini, ungkapan yang muncul dalam kebergantungan dan dalam tindakan peraturan dikembangkan
sekali manakala ungkapan yang muncul dalam sasaran dikembangkan dua kali, jadi berhati-hati jika anda
fungsi mempunyai kesan sampingan dan terdapat dalam ungkapan untuk sasaran.

Ambil perhatian bahawa persekitaran (khususnya, cwd) di mana fungsi menilai akan
tidak semestinya sepadan dengan persekitaran di mana peraturan dari Makefile di mana
fungsi telah dinilai dilaksanakan. Jika ini adalah masalah untuk anda, maka fungsi anda
mungkin sepatutnya kelihatan seperti ini:

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

... dan lain-lain.
}

Meletakkan fungsi ke dalam a Perl modul
Jika anda meletakkan fungsi ke dalam fail termasuk, anda akan mempunyai satu salinan setiap Makeppfile yang
menggunakannya. Untuk mengelakkannya, anda boleh menulisnya sebagai modul Perl biasa dengan "Pengeksport"
antara muka, dan gunakan itu. Ini akan memuatkan lebih cepat dan menjimatkan memori:

perl { gunakan mymodule }
perl {
gunakan my::modul; # put : pada baris baharu supaya ini tidak dihuraikan sebagai peraturan
}

Jika anda memerlukan mana-mana fungsi yang biasanya tersedia dalam Makefile (seperti "f_"
functions, "arg" atau "args"), anda mesti meletakkan baris ini ke dalam modul anda:

gunakan Mpp::Subs;

Kelemahannya ialah modul akan berada dalam pakej yang berbeza daripada fungsi secara langsung
muncul dalam makefile. Jadi anda perlu lulus dalam segala-galanya sebagai parameter, atau membina
nama dengan fungsi "pemanggil" Perl.

Memanggil luar Perl skrip
Jika anda memanggil skrip Perl luaran melalui "sistem", atau sebagai tindakan peraturan, makepp akan memotong a
proses baharu (melainkan tindakan peraturan terakhir) dan aktifkan penterjemah perl yang serba baharu.
Tidak ada yang salah dengan itu, kecuali terdapat cara yang lebih cekap:

&arahan hujah...
Ini boleh menjadi tindakan peraturan. Ia akan memanggil fungsi arahan dengan awalan "c_", dan
berikan baki (gaya makepp yang dipetik secara pilihan -- tidak sama persis dengan
Shell) hujah. Jika fungsi sedemikian tidak ditemui, ini menghantar semua rentetan ke
"lari".

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

$(callcmd palsu):
&mycmd 'arg dengan ruang' arg2 "arg3" # memanggil c_mycmd

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

Anda boleh menulis arahan anda dalam rangka kerja binaan, membolehkan anda menggunakannya
pilihan standard yang sama seperti yang mereka ada, dan pengendalian I/O yang mereka berikan.

Pengendali blok "Mpp::Cmds::frame" diikuti dengan senarai pilihan huruf tunggal
binaan (maksimum "qw(fi I ​​o O rs)"). Walaupun anda menentukan pilihan anda sendiri
mengatasi salah satu daripada ini, anda masih memberikan satu huruf pilihan standard.

Setiap pilihan sendiri ditentukan sebagai "[qw(n name), \$ref, arg, sub]". Dua yang pertama
elemen ialah nama pendek dan panjang, diikuti dengan rujukan pembolehubah dan secara pilihan oleh
boolean untuk sama ada untuk mengambil hujah. Tanpa arg, pembolehubah ialah
bertambah setiap kali pilihan diberikan, jika tidak nilai pilihan disimpan di dalamnya.

sub c_my_ocmd { # Kes keluaran biasa
tempatan @ARGV = @_;
Mpp::Cmds::frame {

... cetak sesuatu di sini dengan @ARGV, dengan pilihan yang telah dialih keluar secara automatik

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

sub c_my_icmd { # Kes input biasa dengan 2 pilihan
tempatan @ARGV = @_;
my( $pendek, $panjang);
Mpp::Cmds::frame {

... lakukan sesuatu di sini dengan <>

} qw(i I rs), # s menyatakan hanya --separator, bukan -s
[qw(s short), \$short], # Tiada pilihan arg -> $short == 1
[qw(l panjang), \$panjang, 1, sub { amaran "dapat arg $panjang"}];
}

Di sini datang arahan mudah yang hanya menaikkan huruf pertama bagi setiap input
rekod (bersamaan dengan "&sed '$$_ = "\u\L$$_"'"):

sub c_uc {
tempatan @ARGV = @_;
Mpp::Cmds::frame {
cetak "\u\L$_" sambil <>;
} 'f', qw(i I o O rs);
}

Dalam blok yang dikendalikan oleh bingkai, anda boleh mempunyai blok bersarang untuk melakukan kritikal
operasi, seperti membuka fail lain.

Mpp::Cmds::melakukan { ... } 'mesej';

Ini akan mengeluarkan mesej dengan "--verbose" (yang setiap arahan diterima) jika
arahan berjaya dijalankan. Tetapi jika blok itu dinilai sebagai palsu, ia mati dengan
mesej yang dinafikan.

menjalankan skrip hujah...
Ini ialah fungsi Perl biasa yang anda boleh gunakan dalam mana-mana konteks Perl dalam fail make anda.
Ia serupa dengan bentuk sistem berbilang argumen, tetapi ia menjalankan skrip Perl di dalamnya
proses semasa. Untuk pernyataan makepp, fungsi perl atau fungsi anda sendiri
itu adalah proses menjalankan makepp. Tetapi untuk peraturan yang merupakan prestasi subproses
ia. Skrip akan dihuraikan seberapa banyak kali ia dipanggil, tetapi anda boleh meletakkan yang sebenar
bekerja ke dalam lib, seperti yang dilakukan oleh pod2html. Lib ini kemudiannya boleh digunakan di peringkat teratas, jadi
bahawa ia sudah ada:

perl { use mylib } # mendapat bercabang kepada semua peraturan yang tidak perlu mengulanginya

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

Jika skrip memanggil "keluar", menutup deskriptor fail standard atau bergantung pada sistem
untuk membersihkan selepas itu (buka fail, memori...), ini boleh menjadi masalah dengan "run". Jika
anda memanggil "run" dalam penyata atau fungsi perl, makepp boleh terganggu atau
pembersihan hanya berlaku pada akhir makepp.

Jika anda mempunyai satu masalah yang disebutkan di atas, jalankan skrip secara luaran, iaitu dari
baris arahan sebaliknya. Dalam peraturan pembersihan adalah kurang masalah, terutamanya tidak
sebagai tindakan terakhir peraturan, kerana subproses peraturan akan keluar selepas itu,
kecuali pada Windows.

Penulisan Matlamat sendiri tanda tangan kaedah
Kadangkala anda mahu makepp mengira kaedah tandatangan menggunakan teknik yang berbeza. Untuk
contoh, katakan anda mempunyai binari yang bergantung pada perpustakaan kongsi. Biasanya, jika anda
tukar perpustakaan kongsi, anda tidak perlu memautkan semula boleh laku yang bergantung padanya kerana
pemautan dilakukan pada masa larian. (Walau bagaimanapun, adalah mungkin bahawa memautkan semula executable
mungkin perlu, itulah sebabnya saya tidak menjadikan ini sebagai lalai.) Apa yang anda mahu makepp
yang perlu dilakukan ialah mempunyai tandatangan yang sama untuk perpustakaan kongsi walaupun ia berubah.

Ini boleh dicapai dalam beberapa cara. Cara paling mudah ialah mencipta baharu anda sendiri
kaedah tandatangan (mari namakannya "objek_kongsi"). Anda akan menggunakan kaedah tandatangan ini
hanya pada peraturan yang menghubungkan binari, seperti ini:

myprogram : *.o lib1/lib1.so lib2/lib2.so
: tandatangan shared_object
$(CC) $(input) -o $(output)

Sekarang kita perlu mencipta kaedah tandatangan.

Semua kaedah tandatangan mestilah kelas mereka sendiri, dan kelas mesti mengandungi beberapa khas
item (lihat Mpp/Signature.pm dalam pengedaran untuk butiran). Nama kelas mestilah
diawali dengan "Mpp::Tandatangan::", jadi dalam kes ini kelas kita harus dipanggil
"Mpp::Tandatangan::shared_object". Kita perlu mencipta fail bernama shared_object.pm dan meletakkan
ia menjadi a Mpp::Tandatangan direktori di suatu tempat dalam Perl termasuk laluan; tempat paling senang
mungkin dalam Mpp/Tandatangan direktori dalam pemasangan makepp (cth,
/usr/local/share/makepp/Mpp/Tandatangan atau di mana sahaja anda memasangnya).

Untuk mendapatkan butiran yang tepat tentang perkara yang perlu dilakukan dalam kelas ini, anda harus menyemak dengan teliti
fail Mpp/Tandatangan.pm dan mungkin juga Mpp/Tandatangan/exact_match.pm dalam makepp
pengedaran. Tetapi dalam kes kita, semua yang kita mahu lakukan ialah membuat perubahan yang sangat kecil kepada a
mekanisme tandatangan sedia ada; jika fail itu adalah perpustakaan kongsi, kami mahu mempunyai pemalar
tandatangan, sedangkan jika fail itu adalah apa-apa lagi, kami mahu bergantung pada normal makepp
mekanisme tandatangan. Cara terbaik untuk melakukan ini adalah dengan mewarisi
"Mpp::Signature::c_compilation_md5", iaitu kaedah tandatangan yang biasanya dipilih
apabila makepp mengenali arahan pautan.

Jadi fail Mpp/Tandatangan/shared_object.pm mungkin mengandungi perkara berikut:

gunakan ketat;
pakej Mpp::Tandatangan::objek_kongsi;
gunakan Mpp::Tandatangan::c_compilation_md5;
kami @ISA = qw(Mpp::Tandatangan::c_compilation_md5); # Tunjukkan warisan.
$shared_object = memberkati \@ISA; # Sekeping sihir yang membantu makepp mencari
# subrutin untuk kaedah ini. Semua
# kaedah tandatangan mesti mempunyai salah satu daripada ini.
# Nilai tidak digunakan, hanya sebarang objek.
# Sekarang inilah kaedah yang akan dipanggil apabila kita memerlukan tandatangan
# sebarang sasaran atau pergantungan yang kaedah tandatangan ini aktif:
sub tandatangan {
my ($self, # Ini akan sama dengan $shared_object.
$finfo) = @_; # Struktur khas yang mengandungi segala-galanya
# makepp tahu tentang fail ini. Lihat
# Mpp/File.pm untuk butiran.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # Adakah nama fail berakhir dengan .so atau .sa?
kembalikan $finfo->file_exists ? 'wujud' : '';
# Sentiasa kembalikan tandatangan yang sama jika fail
# wujud. Dalam kes ini, tandatangan adalah
# rentetan "wujud".
}

Mpp::Tandatangan::c_compilation_md5::signature;
# Jika fail tidak berakhir dengan .so atau .sa,
# mewakilkan kepada kaedah tandatangan biasa makepp.
}

Fail ini disediakan sebagai contoh dalam pengedaran makepp, dengan beberapa tambahan
komen.

Secara kebetulan, mengapa kita tidak menjadikan ini sebagai lalai? Nah, ada kalanya menukar a
perpustakaan kongsi akan memerlukan pemautan semula program anda. Jika anda pernah menukar sama ada
simbol yang ditakrifkan oleh perpustakaan kongsi, atau simbol yang bergantung pada perpustakaan lain
kerana, pautan semula kadangkala diperlukan.

Katakan, sebagai contoh, perpustakaan kongsi menggunakan beberapa subrutin yang program anda
menyediakan. Contohnya, katakan anda menukar pustaka kongsi supaya ia kini memanggil luaran
subrutin "xyz()". Melainkan anda menggunakan pilihan "-E" atau "--eksport-dinamik" kepada pemaut
(untuk binutil GNU; penyambung lain mempunyai nama pilihan yang berbeza), simbol "xyz()" mungkin tidak
boleh diakses oleh pemaut masa jalan walaupun ia wujud dalam program anda.

Lebih teruk lagi, katakan anda mentakrifkan "xyz()" dalam perpustakaan lain (panggilnya libxyz), seperti ini:

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

Oleh kerana "libxyz" ialah a .a fail dan bukan a .so fail, maka "xyz()" mungkin tidak boleh ditarik masuk
betul dari libxyz.a melainkan anda memautkan semula binari anda.

Mpp::Kaedah tandatangan juga mengawal bukan sahaja rentetan yang digunakan untuk menentukan sama ada a
fail telah berubah, tetapi algoritma yang digunakan untuk membandingkan rentetan. Sebagai contoh, yang
kaedah tandatangan "target_newer" dalam pengedaran makepp hanya memerlukan bahawa
sasaran lebih baharu daripada kebergantungan, manakala kaedah tandatangan "exact_match" (dan
semua yang bergantung padanya, seperti "md5" dan "c_compilation_md5") memerlukan
fail mempunyai tandatangan yang sama seperti pada binaan terakhir.

Berikut ialah beberapa jenis kaedah tandatangan lain yang mungkin berguna, untuk membantu anda sedar
kemungkinan. Jika tujuan umum cukup, sebahagian daripada ini mungkin akhirnya
dimasukkan ke dalam makepp:

· Kaedah tandatangan untuk perpustakaan kongsi yang mengembalikan jumlah semak semua yang dieksport
simbol, dan juga semua simbol yang diperlukan daripada perpustakaan lain. Ini menyelesaikan
masalah dengan contoh di atas, dan menjamin pautan yang betul dalam semua keadaan.
Percubaan percubaan telah dibuat untuk melakukan ini dalam pengedaran makepp (lihat
Mpp/Tandatangan/shared_object.pm), tetapi ia hanya akan berfungsi dengan GNU binutils dan ELF
perpustakaan pada masa ini.

· Kaedah tandatangan yang mengabaikan cap tarikh yang ditulis ke dalam fail. Cth, jika anda
menjana a .c fail secara automatik menggunakan beberapa program yang berkeras untuk meletakkan rentetan
seperti ini:

static char * date_stamp = "Dijana secara automatik pada 01 Apr 2004 oleh tiada siapa";

anda boleh menulis kaedah tandatangan yang secara khusus mengabaikan perubahan dalam setem tarikh.
Oleh itu, jika setem tarikh adalah satu-satunya perkara yang telah berubah, makepp tidak akan membina semula.

· Kaedah tandatangan yang mengira tandatangan dengan cara biasa, tetapi mengabaikannya
pergantungan seni bina apabila membuat keputusan sama ada untuk membina semula. Ini boleh berguna untuk
fail yang benar-benar bebas seni bina; pada masa ini jika anda membina satu seni bina,
makepp akan berkeras untuk membina semula walaupun fail bebas seni bina apabila anda bertukar
kepada seni bina yang berbeza.

· Kaedah tandatangan yang mengetahui cara mengabaikan komen dalam fail lateks, sebagai
Kaedah "c_compilation_md5" tahu bagaimana untuk mengabaikan komen dalam fail C.

· Kaedah tandatangan untuk pengekstrakan dokumentasi automatik yang menjumlahkan semak hanya kepada
mengulas bahawa pengekstrak dokumentasi memerlukan dan mengabaikan perubahan lain pada sumber
fail.

Belum selesai
Dokumen ini belum selesai. Ia sepatutnya merangkumi cara menulis pengimbas anda sendiri
sertakan fail dan perkara seperti itu.

Gunakan makepp_extending dalam talian menggunakan perkhidmatan onworks.net