ນີ້ແມ່ນຄໍາສັ່ງ makepp_extending ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
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