makepp_extending - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

makepp_extending -- ວິທີການຂະຫຍາຍ makepp ໂດຍໃຊ້ Perl

ລາຍລະອຽດ

Makepp ພາຍໃນແມ່ນມີຄວາມຍືດຫຍຸ່ນພຽງພໍເພື່ອໃຫ້ໂດຍການຂຽນລະຫັດ Perl ເລັກນ້ອຍ, ທ່ານສາມາດເຮັດໄດ້
ເພີ່ມຟັງຊັນ ຫຼືປະຕິບັດການອື່ນໆຈໍານວນຫນຶ່ງ.

ໂດຍ​ທົ່ວ​ໄປ ອ່ືນ on ລາຍລັກອັກສອນ Perl ລະຫັດ to ການເຮັດວຽກ ກັບ ແຕ່ງໜ້າ
ແຕ່ລະ makefile ອາໄສຢູ່ໃນຊຸດຂອງຕົນເອງ. ດັ່ງນັ້ນຄໍານິຍາມໃນຫນຶ່ງ makefile ບໍ່ມີຜົນກະທົບ
ຄໍານິຍາມໃນ makefile ອື່ນ. ຊຸດຟັງຊັນທົ່ວໄປລວມທັງມາດຕະຖານທັງໝົດ
ຟັງຊັນການຫມູນໃຊ້ຕົວຫນັງສືຖືກນໍາເຂົ້າເຂົ້າໄປໃນຊຸດໃນເວລາທີ່ມັນຖືກສ້າງຂຶ້ນ.

ຕົວແປ Makefile ຖືກເກັບໄວ້ເປັນ Perl scalars ໃນຊຸດນັ້ນ. (ມີຂໍ້ຍົກເວັ້ນ
ນີ້: ຕົວແປອັດຕະໂນມັດແລະຄ່າເລີ່ມຕົ້ນຂອງຕົວແປເຊັ່ນ CC ແມ່ນຕົວຈິງແລ້ວ
ປະຕິບັດເປັນຫນ້າທີ່ທີ່ບໍ່ມີການໂຕ້ຖຽງ. ເປົ້າຫມາຍສະເພາະ vars, ເສັ້ນຄໍາສັ່ງ vars ແລະ
vars ສະພາບແວດລ້ອມແມ່ນບໍ່ເຫັນດ້ວຍວິທີນີ້.) ດັ່ງນັ້ນລະຫັດ Perl ໃດໆທີ່ທ່ານຂຽນມີການເຂົ້າເຖິງທັງຫມົດ
makefile ຕົວແປ. ຕົວແປທົ່ວໂລກຖືກເກັບໄວ້ໃນຊຸດ "Mpp::global". ເບິ່ງ
ຕົວແປ Makefile ສໍາລັບລາຍລະອຽດ.

ແຕ່ລະຄໍາຖະແຫຼງການ (ifperl / ifmakeperl, perl / makeperl, sub / makeub), the
ຫນ້າທີ່ (perl / makeperl, ແຜນທີ່ / makemap) ແລະການປະຕິບັດກົດລະບຽບ (perl / makeperl) ສໍາລັບ
ການຂຽນລະຫັດ Perl ໂດຍກົງໃນ makefile ມາໃນສອງລົດຊາດ. ທໍາອິດແມ່ນແທ້ໆ
Perl ປົກກະຕິ, ຊຶ່ງຫມາຍຄວາມວ່າທ່ານຕ້ອງໃຊ້ຄໍານໍາຫນ້າ "f_" ດັ່ງທີ່ໄດ້ອະທິບາຍໄວ້ໃນພາກຕໍ່ໄປ, ຖ້າ
ທ່ານຕ້ອງການໂທຫາຫນ້າທີ່ makepp. ຕົວແປທີສອງທໍາອິດຜ່ານຄໍາຖະແຫຼງການ
ການຂະຫຍາຍຕົວແປແບບເຮັດໃຫ້ຮູບແບບ, ຊຶ່ງຫມາຍຄວາມວ່າທ່ານຕ້ອງສອງເທົ່າ "$" ທີ່ທ່ານຕ້ອງການ Perl ເບິ່ງ.

ການຈັດການສິ້ນສຸດແມ່ນພິເສດເພາະວ່າຂໍ້ມູນຂະຫນາດໃຫຍ່ຂອງ makepp (ຂຶ້ນກັບລະບົບການກໍ່ສ້າງຂອງທ່ານ).
ໂຄງສ້າງຈະໃຊ້ເວລາຫຼາຍວິນາທີເພື່ອເກັບຂີ້ເຫຍື້ອດ້ວຍການອອກຕາມປົກກະຕິ. ດັ່ງນັ້ນພວກເຮົາເຮັດ a
brute force ອອກ. ໃນຂະບວນການຕົ້ນຕໍທ່ານຍັງສາມາດມີ "END" ຕັນແຕ່ຖ້າທ່ານມີ
ການຈັດການໄຟລ໌ທົ່ວໂລກພວກເຂົາອາດຈະບໍ່ໄດ້ຮັບການ flushed. ແຕ່ທ່ານຄວນໃຊ້ lexical ທີ່ທັນສະໄຫມ
filehandles, ເຊິ່ງປິດຢ່າງຖືກຕ້ອງໃນເວລາທີ່ອອກໄປນອກຂອບເຂດ.

ໃນລະຫັດ Perl ດໍາເນີນການໂດຍກົງເປັນການປະຕິບັດກົດລະບຽບຫຼືຜ່ານຄໍາສັ່ງທີ່ທ່ານກໍານົດ, ມັນແມ່ນ
ກົງກັນຂ້າມ. ບລັອກ "END" ຈະບໍ່ຖືກດໍາເນີນການ, ແຕ່ຕົວຈັດການໄຟລ໌ທົ່ວໂລກໄດ້ຮັບການ flushed ສໍາລັບທ່ານ. ໄດ້
"ການທໍາລາຍ" ຂອງວັດຖຸທົ່ວໂລກຈະບໍ່ຖືກດໍາເນີນການ.

ເພີ່ມຕື່ມ ໃຫມ່ ບົດເລື່ອງ ຫນ້າທີ່
ທ່ານສາມາດເພີ່ມຟັງຊັນໃຫມ່ໃຫ້ກັບ repertoire ຂອງ makepp ໂດຍພຽງແຕ່ກໍານົດ Perl subroutine ຂອງ
ຊື່ດຽວກັນແຕ່ມີຄໍານໍາຫນ້າຂອງ "f_". ຍົກ​ຕົວ​ຢ່າງ:

ຍ່ອຍ f_myfunc {
$argument ຂອງຂ້ອຍ = &arg; # ຕັ້ງຊື່ການໂຕ້ຖຽງ.
ຂອງຂ້ອຍ( undef, $mkfile, $mkfile_line ) = @_; # ຊື່ການໂຕ້ຖຽງ.

... ເຮັດບາງສິ່ງບາງຢ່າງທີ່ນີ້

ກັບຄືນ $return_value;
}

XYZ := $(myfunc my func arguments)

ຖ້າຫນ້າທີ່ຂອງເຈົ້າບໍ່ມີຂໍ້ໂຕ້ແຍ້ງ, ບໍ່ມີຫຍັງທີ່ຈະເຮັດ. ຖ້າຫນ້າທີ່ຂອງເຈົ້າໃຊ້ເວລາຫນຶ່ງ
argument, ເຊັ່ນດຽວກັບຕົວຢ່າງຂ້າງເທິງ, ໃຊ້ accessor & arg ງ່າຍໆເພື່ອໃຫ້ໄດ້ມັນ. ຖ້າ​ເຈົ້າ
ຄາດຫວັງວ່າການໂຕ້ຖຽງຫຼາຍ, ທ່ານຕ້ອງການຕົວເຊື່ອມຕໍ່ທີ່ສັບສົນຫຼາຍ "args" ທີ່ອະທິບາຍຂ້າງລຸ່ມນີ້.

ຕົວເຊື່ອມຕໍ່ເຫຼົ່ານີ້ປະມວນຜົນສາມຕົວກໍານົດການດຽວກັນທີ່ຄວນຈະຖືກສົ່ງໄປຫາ "f_" ໃດໆ.
function, ຄືການໂຕ້ຖຽງຟັງຊັນ, ວັດຖຸ makefile ແລະຕົວອະທິບາຍເສັ້ນສໍາລັບ
ຂໍ້ຄວາມ. ດັ່ງນັ້ນທ່ານສາມາດນໍາໃຊ້ຮູບແບບ & arg ທີ່ມີປະສິດທິພາບໃນກໍລະນີທໍາອິດ.

ຕົວເຊື່ອມຕໍ່ & arg ເບິ່ງແຍງສິ່ງຕໍ່ໄປນີ້ສໍາລັບທ່ານ: ຖ້າການໂຕ້ຖຽງແມ່ນແລ້ວ
ຂະຫຍາຍ (ເຊັ່ນ: ຊອກຫາຊື່ຂອງຟັງຊັນໃນ "$(my$(function) arg)" arg ແມ່ນ
ຜ່ານໄປເປັນສະຕຣິງ ແລະພຽງແຕ່ກັບຄືນມາ. ຖ້າການໂຕ້ຖຽງຍັງຕ້ອງການການຂະຫຍາຍຕົວ, ນີ້ແມ່ນ
ກໍລະນີປົກກະຕິ, ມັນເປັນການອ້າງອີງເຖິງສະຕຣິງ. ເຄື່ອງມື & arg ຂະຫຍາຍມັນສໍາລັບທ່ານ,
ເຊິ່ງມັນຕ້ອງການວັດຖຸ makefile ເປັນພາລາມິເຕີທີ 2 ຂອງມັນ.

ຖ້າທ່ານຄາດຫວັງວ່າການໂຕ້ຖຽງຫຼາຍ, ອາດຈະເປັນຕົວເລກທີ່ປ່ຽນແປງ, ວຽກງານແມ່ນປະຕິບັດໂດຍ "args".
ຕົວເຊື່ອມຕໍ່ນີ້ໃຊ້ 3 ຕົວກໍານົດການດຽວກັນກັບ arg, ບວກກັບພາລາມິເຕີເພີ່ມເຕີມ:

ສູງສຸດ: ຈຳນວນຂອງ args (ຄ່າເລີ່ມຕົ້ນ 2): ໃຫ້ ~0 (maxint) ສໍາລັບການບໍ່ສິ້ນສຸດ
ຕ່ຳສຸດ: ຈຳນວນຂອງ args (ຄ່າເລີ່ມຕົ້ນ 0 ຖ້າສູງສຸດແມ່ນ ~0, ອັນອື່ນຄືກັນກັບຄ່າສູງສຸດ)
only_comma: ຫ້າມກິນພື້ນທີ່ອ້ອມເຄື່ອງໝາຍຈຸດ, ປົກກະຕິສຳລັບຊື່ທີ່ບໍ່ແມ່ນຊື່ໄຟລ໌

ສູງສຸດທີ່ເຄຍ, ແຕ່ຢ່າງໜ້ອຍມີເຄື່ອງໝາຍຈຸດສູງສຸດກ່ອນການຂະຫຍາຍແມ່ນໃຊ້ເພື່ອແຍກ
ການໂຕ້ຖຽງ. ບາງຕົວຢ່າງຈາກຟັງຊັນ buildin ຂອງ makepp:

my($prefix, $text) = args $_[0], $_[1], $_[2], 2, 2, 1; # ຄຳນຳໜ້າ
ສໍາລັບ $cond ຂອງຂ້ອຍ ( args $_[0], undef, $_[2], ~0 ) ... # ແລະ, ຫຼື
my @args= args $_[0], $_[1], $_[2], ~0, 1, 1; # ໂທ
my( $filters, $words ) = args $_[0], $_[1], $_[2]; # ຕົວກອງ

ຟັງຊັນຄວນສົ່ງຄືນ scalar string (ບໍ່ແມ່ນ array) ເຊິ່ງຫຼັງຈາກນັ້ນຖືກໃສ່ເຂົ້າໄປໃນ
ຂໍ້ຄວາມຢູ່ໃນຈຸດນັ້ນ.

ຖ້າຟັງຊັນຂອງທ່ານພົບຂໍ້ຜິດພາດ, ມັນຄວນຈະຕາຍໂດຍໃຊ້ຄໍາຖະແຫຼງການ Perl die ປົກກະຕິ.
ນີ້ຈະຖືກດັກໂດຍ makepp ແລະຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດທີ່ສະແດງຊື່ໄຟລ໌ແລະສາຍ
ຈໍານວນການສະແດງອອກທີ່ເຮັດໃຫ້ເກີດຄວາມຜິດພາດຈະຖືກພິມອອກ.

ມັນເປັນສິ່ງຈໍາເປັນທີ່ບໍ່ມີຂອບເຂດຈໍາກັດກ່ຽວກັບສິ່ງທີ່ຫນ້າທີ່ສາມາດເຮັດໄດ້; ທ່ານສາມາດເຂົ້າເຖິງໄຟລ໌, ດໍາເນີນການ
ຄໍາສັ່ງ shell, ແລະອື່ນໆ.

ໃນປັດຈຸບັນ, ການສະແດງອອກທີ່ປາກົດຢູ່ໃນຄວາມເພິ່ງພາອາໄສແລະການປະຕິບັດກົດລະບຽບໄດ້ຖືກຂະຫຍາຍອອກ
ຫນຶ່ງຄັ້ງໃນຂະນະທີ່ການສະແດງອອກທີ່ປາກົດຢູ່ໃນເປົ້າຫມາຍແມ່ນຂະຫຍາຍສອງຄັ້ງ, ດັ່ງນັ້ນຈົ່ງລະມັດລະວັງຖ້າເຈົ້າ
ຟັງຊັນມີຜົນຂ້າງຄຽງແລະມີຢູ່ໃນການສະແດງອອກສໍາລັບເປົ້າຫມາຍໃດຫນຶ່ງ.

ໃຫ້ສັງເກດວ່າສະພາບແວດລ້ອມ (ໂດຍສະເພາະ, cwd) ໃນຫນ້າທີ່ປະເມີນຈະ
ບໍ່ຈໍາເປັນຕ້ອງກົງກັບສະພາບແວດລ້ອມທີ່ກົດລະບຽບຈາກ Makefile ທີ່
ຟັງຊັນຖືກປະເມີນຖືກປະຕິບັດ. ຖ້ານີ້ແມ່ນບັນຫາສໍາລັບທ່ານ, ຫຼັງຈາກນັ້ນຫນ້າທີ່ຂອງທ່ານ
ອາດ​ຈະ​ເບິ່ງ​ບາງ​ສິ່ງ​ບາງ​ຢ່າງ​ເຊັ່ນ​ນີ້​:

ຍ່ອຍ f_foo {
...
chdir $makefile->{CWD};

... ເປັນຕົ້ນ.
}

ການວາງ ຫນ້າທີ່ ເຂົ້າໄປໃນ a Perl ໂມດູນ
ຖ້າທ່ານເອົາຫນ້າທີ່ເຂົ້າໄປໃນໄຟລ໌ລວມ, ທ່ານຈະມີຫນຶ່ງສໍາເນົາຕໍ່ Makeppfile ເຊິ່ງ
ໃຊ້ມັນ. ເພື່ອຫຼີກເວັ້ນການນັ້ນ, ທ່ານສາມາດຂຽນພວກມັນເປັນໂມດູນ Perl ປົກກະຕິທີ່ມີ "ຜູ້ສົ່ງອອກ"
ການໂຕ້ຕອບ, ແລະນໍາໃຊ້ມັນ. ນີ້ຈະເປັນການໂຫຼດໄວຂຶ້ນ ແລະປະຫຍັດໜ່ວຍຄວາມຈຳ:

perl {ໃຊ້ mymodule }
perl {
ໃຊ້::ໂມດູນຂອງຂ້ອຍ; # ໃສ່ : ໃນແຖວໃຫມ່ດັ່ງນັ້ນນີ້ບໍ່ໄດ້ຖືກວິເຄາະຕາມກົດລະບຽບ
}

ຖ້າທ່ານຕ້ອງການຟັງຊັນຕ່າງໆຕາມປົກກະຕິທີ່ມີຢູ່ໃນ Makefile (ເຊັ່ນ "f_"
functions, "arg" ຫຼື "args"), ທ່ານຕ້ອງໃສ່ເສັ້ນນີ້ເຂົ້າໄປໃນໂມດູນຂອງທ່ານ:

ໃຊ້ Mpp::Subs;

ຂໍ້ເສຍແມ່ນວ່າໂມດູນຈະຢູ່ໃນຊຸດທີ່ແຕກຕ່າງກັນກ່ວາຟັງຊັນໂດຍກົງ
ປະກົດຢູ່ໃນ makefile. ດັ່ງນັ້ນທ່ານຈໍາເປັນຕ້ອງຜ່ານທຸກສິ່ງທຸກຢ່າງເປັນຕົວກໍານົດການ, ຫຼືການກໍ່ສ້າງ
ຊື່ທີ່ມີຫນ້າທີ່ "ຜູ້ໂທ" ຂອງ Perl.

ການໂທ ພາຍນອກ Perl scripts
ຖ້າທ່ານໂທຫາສະຄິບ Perl ພາຍນອກຜ່ານ "ລະບົບ", ຫຼືເປັນການປະຕິບັດກົດລະບຽບ, makepp ຈະແຍກ a
ຂະບວນການໃຫມ່ (ເວັ້ນເສຍແຕ່ວ່າມັນເປັນການປະຕິບັດກົດລະບຽບສຸດທ້າຍ) ແລະປິດການແປພາສາ perl ຍີ່ຫໍ້ໃຫມ່.
ບໍ່ມີຫຍັງຜິດປົກກະຕິກັບສິ່ງນັ້ນ, ຍົກເວັ້ນວ່າມີວິທີທີ່ມີປະສິດທິພາບກວ່າ:

&ຄໍາສັ່ງ ການໂຕ້ຖຽງ...
ນີ້ສາມາດເປັນການປະຕິບັດກົດລະບຽບ. ມັນຈະໂທຫາຫນ້າທີ່ ຄໍາສັ່ງ ດ້ວຍຄຳນຳໜ້າ "c_", ແລະ
ຜ່ານມັນທີ່ຍັງເຫຼືອ (ທາງເລືອກທີ່ອ້າງເຖິງແບບ makepp - ບໍ່ຄືກັນກັບ
Shell) ການໂຕ້ຖຽງ. ຖ້າບໍ່ພົບຟັງຊັນດັ່ງກ່າວ, ນີ້ຈະຜ່ານສາຍທັງໝົດໄປຫາ
"ແລ່ນ".

sub c_mycmd { ຂອງຂ້ອຍ @args = @_; ... }

$(phony callcmd):
&mycmd 'arg with space' arg2 "arg3" # ໂທຫາ c_mycmd

%.ອອກ: %.in
&myscript -o $(output) $(input) # ໂທຫາ myscript ພາຍນອກ

ທ່ານສາມາດຂຽນຄໍາສັ່ງຂອງທ່ານພາຍໃນກອບຂອງ buildins, ໃຫ້ທ່ານໃຊ້
ທາງເລືອກມາດຕະຖານດຽວກັນທີ່ເຂົາເຈົ້າມີ, ແລະການຈັດການ I/O ເຂົາເຈົ້າໃຫ້.

ຕົວປະຕິບັດການຕັນ "Mpp::Cmds::frame" ແມ່ນຕິດຕາມດ້ວຍບັນຊີລາຍຊື່ທາງເລືອກຕົວອັກສອນດຽວຂອງ
buildins (ສູງສຸດແມ່ນ "qw(fi I ​​o O rs)"). ເຖິງແມ່ນວ່າທ່ານກໍານົດທາງເລືອກຂອງທ່ານເອງ
overriding ຫນຶ່ງໃນເຫຼົ່ານີ້, ທ່ານຍັງໃຫ້ຕົວອັກສອນດຽວຂອງທາງເລືອກມາດຕະຖານ.

ແຕ່ລະທາງເລືອກຂອງຕົນເອງຖືກລະບຸເປັນ "[qw(n name), \$ref, ອາກ, ຍ່ອຍ]". ສອງອັນ ທຳ ອິດ
ອົງປະກອບແມ່ນຊື່ສັ້ນແລະຍາວ, ຕິດຕາມມາດ້ວຍການອ້າງອີງຕົວແປແລະທາງເລືອກໂດຍ
boolean ສໍາລັບວ່າຈະເອົາການໂຕ້ຖຽງ. ໂດຍບໍ່ມີການ arg, ຕົວແປແມ່ນ
ເພີ່ມຂຶ້ນໃນແຕ່ລະຄັ້ງທີ່ທາງເລືອກແມ່ນໃຫ້, ຖ້າບໍ່ດັ່ງນັ້ນມູນຄ່າທາງເລືອກຈະຖືກເກັບໄວ້ໃນມັນ.

sub c_my_ocmd { # ກໍລະນີຜົນຜະລິດປົກກະຕິ
ທ້ອງຖິ່ນ @ARGV = @_;
Mpp::Cmds::frame {

... ພິມບາງສິ່ງບາງຢ່າງທີ່ນີ້ດ້ວຍ @ARGV, ທີ່ມີຕົວເລືອກອອກແລ້ວອັດຕະໂນມັດ

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

sub c_my_icmd { # ກໍລະນີປ້ອນຂໍ້ມູນແບບປົກກະຕິມີ 2 ທາງເລືອກ
ທ້ອງຖິ່ນ @ARGV = @_;
ຂອງຂ້ອຍ($ສັ້ນ, $ຍາວ);
Mpp::Cmds::frame {

... ເຮັດອັນນີ້ກັບ <>

} qw(i I rs), # s ລະບຸພຽງແຕ່ --separator, ບໍ່ແມ່ນ -s
[qw(s short), \$short], # ບໍ່ມີທາງເລືອກ arg -> $short == 1
[qw(l long), \$long, 1, sub { warn "got arg $long"}];
}

ນີ້ແມ່ນຄໍາສັ່ງທີ່ງ່າຍດາຍທີ່ upcases ພຽງແຕ່ລັກສະນະທໍາອິດຂອງແຕ່ລະ input
ບັນທຶກ (ເທົ່າກັບ "&sed '$$_ = "\u\L$$_"'"):

ຍ່ອຍ c_uc {
ທ້ອງຖິ່ນ @ARGV = @_;
Mpp::Cmds::frame {
ພິມ "\u\L$_" ໃນຂະນະທີ່ <>;
} 'f', qw(i I o O rs);
}

ພາຍໃນທ່ອນໄມ້ທີ່ຖືກຈັດການໂດຍກອບ, ທ່ານສາມາດມີທ່ອນໄມ້ທີ່ມີຮັງສໍາລັບການປະຕິບັດທີ່ສໍາຄັນ
ການ​ດໍາ​ເນີນ​ງານ​ເຊັ່ນ​: ການ​ເປີດ​ໄຟລ​໌​ອື່ນໆ​.

Mpp::Cmds::perform {... } 'ຂໍ້ຄວາມ';

ນີ້ຈະອອກຂໍ້ຄວາມດ້ວຍ "--verbose" (ທີ່ທຸກຄໍາສັ່ງຍອມຮັບ) iff the
ຄໍາສັ່ງຖືກດໍາເນີນການສົບຜົນສໍາເລັດ. ແຕ່ຖ້າຫາກວ່າຕັນປະເມີນວ່າບໍ່ຖືກຕ້ອງ, ມັນຕາຍດ້ວຍ
ຂໍ້ຄວາມປະຕິເສດ.

ແລ່ນ script ການໂຕ້ຖຽງ...
ນີ້ແມ່ນຫນ້າທີ່ Perl ປົກກະຕິທີ່ທ່ານສາມາດນໍາໃຊ້ໃນສະພາບການ Perl ໃດໆພາຍໃນ makefile ຂອງທ່ານ.
ມັນຄ້າຍຄືກັນກັບຮູບແບບການໂຕ້ຖຽງຫຼາຍຂອງລະບົບ, ແຕ່ມັນແລ່ນສະຄິບ Perl ພາຍໃນ
ຂະ​ບວນ​ການ​ໃນ​ປັດ​ຈຸ​ບັນ​. ສໍາລັບຄໍາຖະແຫຼງການ makepp, ຫນ້າທີ່ perl ຫຼືຫນ້າທີ່ຂອງທ່ານເອງ
ນັ້ນແມ່ນຂະບວນການແລ່ນ makepp. ແຕ່ສໍາລັບກົດລະບຽບທີ່ເປັນຂະບວນການຍ່ອຍປະຕິບັດ
ມັນ. ສະຄຣິບໄດ້ຖືກວິເຄາະຫຼາຍເທື່ອເທົ່າທີ່ມັນຖືກເອີ້ນວ່າ, ແຕ່ເຈົ້າສາມາດໃສ່ຕົວຈິງໄດ້
ເຮັດວຽກຢູ່ໃນ lib, ດັ່ງທີ່ pod2html ເຮັດ. lib ນີ້ສາມາດຖືກນໍາໃຊ້ໃນລະດັບສູງສຸດ, ດັ່ງນັ້ນ
ວ່າ​ມັນ​ມີ​ຢູ່​ແລ້ວ​:

perl { ໃຊ້ mylib } # ຖືກແຍກອອກເປັນກົດເກນທັງໝົດທີ່ບໍ່ຈໍາເປັນຕ້ອງແປຄືນ

%.ອອກ: %.in
makeperl { ແລ່ນ qw'myscript -o $(output) $(input)' }

ຖ້າສະຄິບເອີ້ນວ່າ "ອອກ", ປິດຕົວອະທິບາຍໄຟລ໌ມາດຕະຖານຫຼືອີງໃສ່ລະບົບ
ເພື່ອເຮັດຄວາມສະອາດຫຼັງຈາກມັນ (ເປີດໄຟລ໌, ຫນ່ວຍຄວາມຈໍາ ...), ນີ້ສາມາດເປັນບັນຫາກັບ "ແລ່ນ". ຖ້າ
ທ່ານເອີ້ນວ່າ "ແລ່ນ" ພາຍໃນຄໍາຖະແຫຼງການຫຼືຫນ້າທີ່ perl, makepp ສາມາດຖືກລົບກວນຫຼື
ການເຮັດຄວາມສະອາດພຽງແຕ່ເກີດຂຶ້ນໃນຕອນທ້າຍຂອງ makepp.

ຖ້າທ່ານມີບັນຫາຫນຶ່ງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ, ດໍາເນີນການ script ພາຍນອກ, ເຊັ່ນ: ຈາກ
ເສັ້ນຄໍາສັ່ງແທນ. ພາຍໃນກົດລະບຽບການທໍາຄວາມສະອາດແມ່ນມີບັນຫາຫນ້ອຍ, ໂດຍສະເພາະບໍ່ແມ່ນ
ເປັນການປະຕິບັດສຸດທ້າຍຂອງກົດລະບຽບ, ເນື່ອງຈາກວ່າຂະບວນການຍ່ອຍຂອງກົດລະບຽບຈະອອກໄປຫຼັງຈາກນັ້ນຢ່າງໃດກໍ່ຕາມ,
ຍົກເວັ້ນໃນ Windows.

ລາຍລັກອັກສອນ ຂອງ​ທ່ານ ຂອງຕົນເອງ ລາຍເຊັນ ວິທີການ
ບາງຄັ້ງທ່ານຕ້ອງການ makepp ຄິດໄລ່ວິທີການລາຍເຊັນໂດຍໃຊ້ເຕັກນິກທີ່ແຕກຕ່າງກັນ. ສໍາລັບ
ຕົວຢ່າງ, ສົມມຸດວ່າທ່ານມີຖານສອງທີ່ຂຶ້ນກັບຫ້ອງສະຫມຸດທີ່ໃຊ້ຮ່ວມກັນ. ປົກກະຕິ, ຖ້າທ່ານ
ການ​ປ່ຽນ​ແປງ​ຫ້ອງ​ສະ​ຫມຸດ​ທີ່​ແບ່ງ​ປັນ​, ທ່ານ​ບໍ່​ຈໍາ​ເປັນ​ຕ້ອງ relink ການ​ປະ​ຕິ​ບັດ​ທີ່​ຂຶ້ນ​ກັບ​ມັນ​ເພາະ​ວ່າ​
ການເຊື່ອມໂຍງແມ່ນເຮັດໃນເວລາແລ່ນ. (ຢ່າງໃດກໍ່ຕາມ, ມັນເປັນໄປໄດ້ວ່າ relinking executable
ອາດຈະມີຄວາມຈໍາເປັນ, ຊຶ່ງເປັນເຫດຜົນທີ່ຂ້ອຍບໍ່ໄດ້ເຮັດໃຫ້ນີ້ເປັນຄ່າເລີ່ມຕົ້ນ.) ສິ່ງທີ່ທ່ານຕ້ອງການ makepp
ທີ່ຕ້ອງເຮັດຄືການມີລາຍເຊັນດຽວກັນສໍາລັບຫ້ອງສະຫມຸດທີ່ໃຊ້ຮ່ວມກັນເຖິງແມ່ນວ່າມັນຈະປ່ຽນແປງ.

ນີ້ສາມາດເຮັດໄດ້ໃນຫຼາຍວິທີ. ວິທີທີ່ງ່າຍທີ່ສຸດແມ່ນການສ້າງໃຫມ່ຂອງທ່ານເອງ
ວິທີການລາຍເຊັນ (ໃຫ້ເອີ້ນວ່າ "shared_object"). ເຈົ້າຈະໃຊ້ວິທີລາຍເຊັນນີ້
ພຽງແຕ່ກ່ຽວກັບກົດລະບຽບທີ່ເຊື່ອມຕໍ່ binaries, ເຊັ່ນນີ້:

myprogram : *.o lib1/lib1.so lib2/lib2.so
: ລາຍເຊັນ shared_object
$(CC) $(inputs) -o $(output)

ໃນປັດຈຸບັນພວກເຮົາຕ້ອງສ້າງວິທີການລາຍເຊັນ.

ວິທີການລາຍເຊັນທັງໝົດຕ້ອງເປັນຊັ້ນຮຽນຂອງຕົນເອງ, ແລະຫ້ອງຮຽນຕ້ອງມີບາງອັນພິເສດ
ລາຍການ (ເບິ່ງ Mpp/Signature.pm ໃນການແຈກຢາຍສໍາລັບລາຍລະອຽດ). ຊື່ຂອງຫ້ອງຮຽນຕ້ອງເປັນ
ຄໍານໍາຫນ້າດ້ວຍ "Mpp::Signature::", ດັ່ງນັ້ນໃນກໍລະນີນີ້ຫ້ອງຮຽນຂອງພວກເຮົາຄວນຈະຖືກເອີ້ນ
"Mpp::ລາຍເຊັນ::shared_object". ພວກເຮົາຕ້ອງສ້າງໄຟລ໌ທີ່ເອີ້ນວ່າ shared_object.pm ແລະໃສ່
ມັນເຂົ້າໄປໃນ Mpp::ລາຍເຊັນ directory somewhere ໃນ Perl ປະກອບມີເສັ້ນທາງ; ສະ​ຖານ​ທີ່​ທີ່​ງ່າຍ​ທີ່​ສຸດ​
ອາດຈະຢູ່ໃນ Mpp/ລາຍເຊັນ ໄດເລກະທໍລີໃນການຕິດຕັ້ງ makepp (ເຊັ່ນ:
/usr/local/share/makepp/Mpp/ລາຍເຊັນ ຫຼືບ່ອນໃດກໍຕາມທີ່ທ່ານຕິດຕັ້ງມັນ).

ສໍາລັບລາຍລະອຽດທີ່ຊັດເຈນກ່ຽວກັບສິ່ງທີ່ຕ້ອງເຂົ້າໄປໃນຫ້ອງຮຽນນີ້, ທ່ານຄວນເບິ່ງຢ່າງລະອຽດ
ເອກະສານທີ່ Mpp/ລາຍເຊັນ.pm ແລະອາດຈະເປັນຄືກັນ Mpp/Signature/exact_match.pm ໃນ makepp ໄດ້
ການ​ແຜ່​ກະ​ຈາຍ​. ແຕ່ໃນກໍລະນີຂອງພວກເຮົາ, ທັງຫມົດທີ່ພວກເຮົາຕ້ອງການທີ່ຈະເຮັດແມ່ນເພື່ອເຮັດໃຫ້ການປ່ຽນແປງຂະຫນາດນ້ອຍຫຼາຍເປັນ
ກົນໄກການລົງລາຍເຊັນທີ່ມີຢູ່ແລ້ວ; ຖ້າໄຟລ໌ເປັນຫ້ອງສະຫມຸດທີ່ໃຊ້ຮ່ວມກັນ, ພວກເຮົາຕ້ອງການຄົງທີ່
ລາຍເຊັນ, ໃນຂະນະທີ່ໄຟລ໌ແມ່ນສິ່ງອື່ນ, ພວກເຮົາຕ້ອງການທີ່ຈະອີງໃສ່ການປົກກະຕິຂອງ makepp
ກົນ​ໄກ​ລາຍ​ເຊັນ​. ວິທີທີ່ດີທີ່ສຸດທີ່ຈະເຮັດຄືການສືບທອດຈາກ
"Mpp::Signature::c_compilation_md5", ເຊິ່ງເປັນວິທີການລາຍເຊັນທີ່ມັກຈະຖືກເລືອກ.
ເມື່ອ makepp ຮັບຮູ້ຄໍາສັ່ງເຊື່ອມຕໍ່.

ດັ່ງນັ້ນໄຟລ໌ Mpp/Signature/shared_object.pm ອາດ​ຈະ​ປະ​ກອບ​ດ້ວຍ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​:

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
package Mpp::ລາຍເຊັນ::shared_object;
ໃຊ້ Mpp::ລາຍເຊັນ::c_compilation_md5;
@ISA ຂອງພວກເຮົາ = qw(Mpp::ລາຍເຊັນ::c_compilation_md5); # ບົ່ງບອກເຖິງການສືບທອດ.
$shared_object ຂອງພວກເຮົາ = ອວຍພອນ \@ISA; # ຊິ້ນສ່ວນຂອງ magic ທີ່ຊ່ວຍໃຫ້ makepp ຊອກຫາ
# ໂປຣເຈັກຍ່ອຍສຳລັບວິທີນີ້. ທັງໝົດ
# ວິທີການລາຍເຊັນຕ້ອງມີອັນໃດອັນໜຶ່ງອັນນີ້.
# ຄຸນຄ່າບໍ່ໄດ້ໃຊ້, ພຽງແຕ່ວັດຖຸໃດໆ.
# ໃນປັດຈຸບັນນີ້ແມ່ນວິທີການທີ່ຈະໄດ້ຮັບການເອີ້ນໃນເວລາທີ່ພວກເຮົາຕ້ອງການລາຍເຊັນຂອງ
# ເປົ້າໝາຍ ຫຼືການເພິ່ງພາອາໄສທີ່ວິທີການລາຍເຊັນນີ້ແມ່ນມີການເຄື່ອນໄຫວ:
ລາຍເຊັນຍ່ອຍ {
ຂອງຂ້ອຍ ($self, # ອັນນີ້ຈະຄືກັນກັບ $shared_object.
$finfo) = @_; # ໂຄງສ້າງພິເສດທີ່ປະກອບດ້ວຍທຸກສິ່ງທຸກຢ່າງ
# makepp ຮູ້ກ່ຽວກັບໄຟລ໌ນີ້. ເບິ່ງ
# Mpp/File.pm ສໍາລັບລາຍລະອຽດ.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # ຊື່ໄຟລ໌ລົງທ້າຍດ້ວຍ .so ຫຼື .sa?
ກັບຄືນ $finfo->file_exists ? 'ມີຢູ່': '';
# ສະເຫມີສົ່ງຄືນລາຍເຊັນດຽວກັນຖ້າໄຟລ໌
# ມີຢູ່. ໃນກໍລະນີນີ້, ລາຍເຊັນແມ່ນ
# string "ມີຢູ່".
}

Mpp::ລາຍເຊັນ::c_compilation_md5::ລາຍເຊັນ;
# ຖ້າໄຟລ໌ບໍ່ສິ້ນສຸດດ້ວຍ .so ຫຼື .sa,
# ມອບໝາຍໃຫ້ວິທີການລາຍເຊັນປົກກະຕິຂອງ makepp.
}

ໄຟລ໌ນີ້ໄດ້ຖືກສະຫນອງໃຫ້ເປັນຕົວຢ່າງໃນການແຈກຢາຍ makepp, ມີບາງສ່ວນເພີ່ມເຕີມ
ຄໍາເຫັນ

ບັງເອີນ, ເປັນຫຍັງພວກເຮົາຈຶ່ງບໍ່ເຮັດໃຫ້ອັນນີ້ເປັນຄ່າເລີ່ມຕົ້ນ? ດີ, ມີເວລາປ່ຽນ a
ຫ້ອງສະໝຸດທີ່ແບ່ງປັນຈະຕ້ອງມີການເຊື່ອມໂຍງໂປຼແກຼມຂອງທ່ານຄືນໃໝ່. ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ເຄີຍ​ມີ​ການ​ປ່ຽນ​ແປງ​ທັງ​ຫມົດ​
ສັນ​ຍາ​ລັກ​ທີ່​ຫ້ອງ​ສະ​ຫມຸດ​ແບ່ງ​ປັນ​ກໍາ​ນົດ​, ຫຼື​ສັນ​ຍາ​ລັກ​ທີ່​ມັນ​ຂຶ້ນ​ກັບ​ຫ້ອງ​ສະ​ຫມຸດ​ອື່ນໆ​
ສໍາລັບ, relink ບາງຄັ້ງອາດຈະມີຄວາມຈໍາເປັນ.

ຕົວຢ່າງ, ສົມມຸດວ່າຫ້ອງສະຫມຸດທີ່ແບ່ງປັນໄດ້ຮຽກຮ້ອງບາງໂຄງການຍ່ອຍທີ່ໂຄງການຂອງເຈົ້າ
ສະຫນອງ. ຕົວຢ່າງ, ສົມມຸດວ່າເຈົ້າປ່ຽນຫ້ອງສະຫມຸດທີ່ໃຊ້ຮ່ວມກັນ, ດັ່ງນັ້ນຕອນນີ້ມັນໂທຫາພາຍນອກ
subroutine "xyz()". ເວັ້ນເສຍແຕ່ວ່າທ່ານໃຊ້ຕົວເລືອກ "-E" ຫຼື "--export-dynamic" ກັບຕົວເຊື່ອມຕໍ່
(ສໍາລັບ GNU binutils; ຕົວເຊື່ອມຕໍ່ອື່ນໆມີຊື່ທາງເລືອກທີ່ແຕກຕ່າງກັນ), ສັນຍາລັກ "xyz()" ອາດຈະບໍ່
ສາມາດເຂົ້າເຖິງຕົວເຊື່ອມຕໍ່ເວລາແລ່ນໄດ້ເຖິງແມ່ນວ່າມັນມີຢູ່ໃນໂປຼແກຼມຂອງເຈົ້າ.

ຮ້າຍແຮງກວ່າເກົ່າ, ສົມມຸດວ່າເຈົ້າກໍານົດ "xyz()" ໃນຫ້ອງສະຫມຸດອື່ນ (ໂທຫາມັນ ລີບຊີ), ດັ່ງ​ນີ້​:

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

ນັບຕັ້ງແຕ່ "libxyz" ເປັນ .a ໄຟລ໌ແລະບໍ່ແມ່ນ a ດັ່ງນັ້ນ, ໄຟລ໌, ຫຼັງຈາກນັ້ນ "xyz()" ອາດຈະບໍ່ຖືກດຶງເຂົ້າ
ຖືກຕ້ອງຈາກ libxyz.a ເວັ້ນເສຍແຕ່ວ່າທ່ານ relink binary ຂອງທ່ານ.

Mpp::ວິທີການລາຍເຊັນຍັງຄວບຄຸມບໍ່ພຽງແຕ່ສະຕຣິງທີ່ໃຊ້ເພື່ອກໍານົດວ່າ a
ໄຟລ໌ມີການປ່ຽນແປງ, ແຕ່ algorithm ທີ່ຖືກນໍາໃຊ້ເພື່ອປຽບທຽບສະຕຣິງ. ສໍາລັບຕົວຢ່າງ, ໄດ້
ວິທີການລາຍເຊັນ "target_newer" ໃນການແຈກຢາຍ makepp ພຽງແຕ່ຮຽກຮ້ອງໃຫ້
ເປົ້າໝາຍແມ່ນໃໝ່ກວ່າການເພິ່ງພາອາໄສ, ໃນຂະນະທີ່ວິທີການລາຍເຊັນ "exact_match" (ແລະ
ທຸກສິ່ງທຸກຢ່າງທີ່ຂຶ້ນກັບມັນ, ເຊັ່ນ "md5" ແລະ "c_compilation_md5") ຮຽກຮ້ອງໃຫ້
ໄຟລ໌ມີລາຍເຊັນດຽວກັນກັບການສ້າງຫຼ້າສຸດ.

ນີ້ແມ່ນບາງວິທີລາຍເຊັນອື່ນໆທີ່ອາດຈະເປັນປະໂຫຍດ, ເພື່ອຊ່ວຍໃຫ້ທ່ານຮັບຮູ້
ຄວາມເປັນໄປໄດ້. ຖ້າຈຸດປະສົງທົ່ວໄປພຽງພໍ, ບາງສ່ວນຂອງເຫຼົ່ານີ້ໃນທີ່ສຸດອາດຈະເປັນ
ລວມ​ເຂົ້າ​ໄປ​ໃນ makepp​:

· ວິທີການລາຍເຊັນສຳລັບຫ້ອງສະໝຸດທີ່ໃຊ້ຮ່ວມກັນທີ່ສົ່ງຄືນ checksum ຂອງທັງໝົດທີ່ສົ່ງອອກແລ້ວ
ສັນຍາລັກ, ແລະສັນຍາລັກທັງຫມົດທີ່ມັນຕ້ອງການຈາກຫ້ອງສະຫມຸດອື່ນໆ. ນີ້​ແກ້​ໄຂ​ໄດ້​
ບັນຫາກັບຕົວຢ່າງຂ້າງເທິງ, ແລະຮັບປະກັນການເຊື່ອມຕໍ່ທີ່ຖືກຕ້ອງພາຍໃຕ້ສະຖານະການທັງຫມົດ.
ໄດ້ມີການພະຍາຍາມທົດລອງເພື່ອເຮັດສິ່ງນີ້ໃນການແຈກຢາຍ makepp (ເບິ່ງ
Mpp/Signature/shared_object.pm), ແຕ່ມັນຈະເຮັດວຽກກັບ GNU binutils ແລະ ELF ເທົ່ານັ້ນ
ຫ້ອງສະຫມຸດໃນປັດຈຸບັນ.

· ວິທີການລາຍເຊັນທີ່ບໍ່ສົນໃຈການປະທັບຕາວັນທີທີ່ຂຽນໄວ້ໃນໄຟລ໌. ຕົວຢ່າງ, ຖ້າເຈົ້າ
ສ້າງກ .c ໄຟລ໌ອັດຕະໂນມັດໂດຍໃຊ້ບາງໂຄງການທີ່ຮຽກຮ້ອງໃຫ້ໃສ່ສາຍ
ໃນ​ແບບ​ນີ້​:

static char * date_stamp = "ສ້າງອັດຕະໂນມັດໃນວັນທີ 01 ເມສາ 2004 ໂດຍບໍ່ມີໃຜ";

ເຈົ້າສາມາດຂຽນວິທີການລາຍເຊັນທີ່ບໍ່ສົນໃຈການປ່ຽນແປງຂອງສະແຕມວັນທີໂດຍສະເພາະ.
ດັ່ງນັ້ນ, ຖ້າສະແຕມວັນທີແມ່ນສິ່ງດຽວທີ່ມີການປ່ຽນແປງ, makepp ຈະບໍ່ສ້າງໃຫມ່.

· ວິທີການລາຍເຊັນທີ່ຄິດໄລ່ລາຍເຊັນໃນແບບປົກກະຕິ, ແຕ່ບໍ່ສົນໃຈ
ການເອື່ອຍອີງສະຖາປັດຕະຍະກໍາໃນເວລາທີ່ຕັດສິນໃຈວ່າຈະສ້າງໃຫມ່. ນີ້ອາດຈະເປັນປະໂຫຍດສໍາລັບ
ໄຟລ໌ທີ່ເປັນເອກະລາດສະຖາປັດຕະຍະກໍາຢ່າງແທ້ຈິງ; ໃນປັດຈຸບັນຖ້າຫາກວ່າທ່ານກໍ່ສ້າງໃນສະຖາປັດຕະຫນຶ່ງ,
makepp ຈະຍືນຍັນໃນການກໍ່ສ້າງຄືນໃຫມ່ເຖິງແມ່ນວ່າໄຟລ໌ສະຖາປັດຕະຍະກໍາ - ເອກະລາດໃນເວລາທີ່ທ່ານປ່ຽນ
ກັບສະຖາປັດຕະຍະກໍາທີ່ແຕກຕ່າງກັນ.

· ວິທີການລາຍເຊັນທີ່ຮູ້ວິທີການບໍ່ສົນໃຈຄໍາເຫັນໃນໄຟລ໌ຢາງ, ເປັນ
"c_compilation_md5" ວິທີການຮູ້ວິທີການບໍ່ສົນໃຈຄໍາເຫັນໃນໄຟລ໌ C.

· ວິທີການລາຍເຊັນສໍາລັບການສະກັດເອກະສານອັດຕະໂນມັດທີ່ checksums ພຽງແຕ່
ຄວາມຄິດເຫັນທີ່ຜູ້ສະກັດເອກະສານຕ້ອງການແລະບໍ່ສົນໃຈການປ່ຽນແປງອື່ນໆຕໍ່ກັບແຫຼ່ງ
ຍື່ນ.

ຍັງບໍ່ແລ້ວ
ເອກະສານນີ້ຍັງບໍ່ແລ້ວເທື່ອ. ມັນຄວນຈະກວມເອົາວິທີການຂຽນເຄື່ອງສະແກນຂອງທ່ານເອງສໍາລັບ
ລວມມີໄຟລ໌ ແລະສິ່ງຕ່າງໆເຊັ່ນນັ້ນ.

ໃຊ້ makepp_extending ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net