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

ໂຄງການ:

NAME

perlcall - ສົນທິສັນຍາການໂທ Perl ຈາກ C

ລາຍລະອຽດ

ຈຸດ​ປະ​ສົງ​ຂອງ​ເອ​ກະ​ສານ​ນີ້​ແມ່ນ​ເພື່ອ​ສະ​ແດງ​ໃຫ້​ທ່ານ​ກ່ຽວ​ກັບ​ວິ​ທີ​ການ​ໂທ​ຫາ subroutines Perl ໂດຍ​ກົງ​ຈາກ C​,
ie, ວິທີການຂຽນ ໂທກັບ.

ນອກເຫນືອຈາກການປຶກສາຫາລືກ່ຽວກັບການໂຕ້ຕອບ C ສະຫນອງໃຫ້ໂດຍ Perl ສໍາລັບການຂຽນ callbacks ເອກະສານ
ໃຊ້ຊຸດຕົວຢ່າງເພື່ອສະແດງໃຫ້ເຫັນວ່າການໂຕ້ຕອບທີ່ເຮັດວຽກຕົວຈິງໃນການປະຕິບັດ. ໃນ
ນອກຈາກນັ້ນ, ບາງເຕັກນິກສໍາລັບການ coding callbacks ແມ່ນກວມເອົາ.

ຕົວຢ່າງທີ່ຈໍາເປັນຕ້ອງໂທຫາກັບຄືນໄປບ່ອນປະກອບມີ

· ຕົວຈັດການຄວາມຜິດພາດ

ທ່ານໄດ້ສ້າງການໂຕ້ຕອບ XSUB ກັບ C API ຂອງແອັບພລິເຄຊັນ.

ລັກສະນະທົ່ວໄປທີ່ຂ້ອນຂ້າງຢູ່ໃນຄໍາຮ້ອງສະຫມັກແມ່ນເພື່ອໃຫ້ທ່ານສາມາດກໍານົດຫນ້າທີ່ C ທີ່
ຈະຖືກເອີ້ນທຸກຄັ້ງທີ່ສິ່ງທີ່ບໍ່ດີເກີດຂຶ້ນ. ສິ່ງທີ່ພວກເຮົາຕ້ອງການແມ່ນສາມາດ
ລະ​ບຸ​ໂປຣ​ແກຣມຍ່ອຍ Perl ທີ່​ຈະ​ຖືກ​ເອີ້ນ​ແທນ.

· ໂຄງການທີ່ຂັບເຄື່ອນໂດຍເຫດການ

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

ເຖິງແມ່ນວ່າເຕັກນິກທີ່ອະທິບາຍຢູ່ທີ່ນີ້ແມ່ນໃຊ້ໄດ້ໃນເວລາທີ່ຝັງ Perl ໃນໂຄງການ C,
ນີ້ບໍ່ແມ່ນເປົ້າໝາຍຫຼັກຂອງເອກະສານນີ້. ມີລາຍລະອຽດອື່ນໆທີ່ຈະຕ້ອງເປັນ
ພິຈາລະນາແລະສະເພາະກັບການຝັງ Perl. ສໍາລັບລາຍລະອຽດກ່ຽວກັບການຝັງ Perl ໃນ C ເບິ່ງ
perlembed.

ກ່ອນທີ່ທ່ານຈະເປີດຕົວຕົວທ່ານເອງເປັນຄັ້ງທໍາອິດເຂົ້າໄປໃນສ່ວນທີ່ເຫຼືອຂອງເອກະສານນີ້, ມັນຈະເປັນການດີ
ຄວາມຄິດທີ່ຈະໄດ້ອ່ານສອງເອກະສານຕໍ່ໄປນີ້ - perlxs ແລະ perlguts.

ການ ໂທ_ FUNCTIONS

ເຖິງແມ່ນວ່າສິ່ງນີ້ແມ່ນງ່າຍຕໍ່ການອະທິບາຍໂດຍໃຊ້ຕົວຢ່າງ, ທໍາອິດທ່ານຈໍາເປັນຕ້ອງຮູ້ຈໍານວນຫນ້ອຍຫນຶ່ງ
ຄໍານິຍາມທີ່ສໍາຄັນ.

Perl ມີຈໍານວນຫນ້າທີ່ C ທີ່ອະນຸຍາດໃຫ້ທ່ານໂທຫາ Perl subroutines. ພວກ​ເຂົາ​ແມ່ນ

I32 call_sv(SV* sv, ທຸງ I32);
I32 call_pv(char *ຊື່ຍ່ອຍ, ທຸງ I32);
I32 call_method(char *methname, ທຸງ I32);
I32 call_argv(char *subname, I32 flags, char **argv);

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

ທັງຫມົດ ໂທ_* ຟັງຊັນມີ "ທຸງ" ພາລາມິເຕີທີ່ຖືກນໍາໃຊ້ເພື່ອຜ່ານຫນ້າກາກເລັກນ້ອຍຂອງ
ທາງເລືອກໃນການ Perl. ຫນ້າກາກບິດນີ້ເຮັດວຽກຄືກັນສໍາລັບແຕ່ລະຫນ້າທີ່. ໄດ້
ການຕັ້ງຄ່າທີ່ມີຢູ່ໃນ bit mask ແມ່ນສົນທະນາໃນ "FLAG VALUES".

ແຕ່ລະຫນ້າທີ່ຈະຖືກປຶກສາຫາລືກັນໃນປັດຈຸບັນ.

call_sv
call_sv ໃຊ້ເວລາສອງຕົວກໍານົດການ. ອັນທໍາອິດ, "sv", ແມ່ນ SV*. ນີ້ອະນຸຍາດໃຫ້ທ່ານລະບຸ
Perl subroutine ທີ່ຈະຖືກເອີ້ນວ່າເປັນ C string (ເຊິ່ງທໍາອິດໄດ້ຖືກປ່ຽນ
ເຖິງ SV) ຫຼືການອ້າງອີງເຖິງລາຍການຍ່ອຍ. ພາກ​ສ່ວນ​, ການນໍາໃຊ້ call_sv, ສະແດງໃຫ້ເຫັນວິທີທີ່ທ່ານ
ສາມາດ ນຳ ໃຊ້ call_sv.

call_pv
ຫນ້າ​ທີ່​, call_pv, ແມ່ນຄ້າຍຄືກັນກັບ call_sv ຍົກເວັ້ນມັນຄາດຫວັງວ່າຕົວກໍານົດການທໍາອິດຂອງມັນ
ເປັນ C char* ເຊິ່ງກໍານົດ Perl subroutine ທີ່ທ່ານຕ້ອງການໂທຫາ, ຕົວຢ່າງ,
"call_pv("fred", 0)". ຖ້າການຍ່ອຍທີ່ເຈົ້າຕ້ອງການໂທຫາຢູ່ໃນຊຸດອື່ນ, ພຽງແຕ່
ລວມເອົາຊື່ແພັກເກັດຢູ່ໃນສະຕຣິງ, ຕົວຢ່າງ, "pkg::fred".

call_method
ຟັງຊັນ call_method ຖືກນໍາໃຊ້ເພື່ອໂທຫາວິທີການຈາກຫ້ອງຮຽນ Perl. ພາລາມິເຕີ
"methname" ກົງກັບຊື່ຂອງວິທີການທີ່ຈະເອີ້ນວ່າ. ໃຫ້ສັງເກດວ່າຫ້ອງຮຽນ
ວ່າວິທີການທີ່ເປັນຂອງແມ່ນສົ່ງຜ່ານ Perl stack ແທນທີ່ຈະຢູ່ໃນພາລາມິເຕີ
ບັນຊີລາຍຊື່. ຫ້ອງຮຽນນີ້ສາມາດເປັນຊື່ຂອງຊັ້ນຮຽນ (ສໍາລັບວິທີການຄົງທີ່) ຫຼື a
ອ້າງອີງເຖິງວັດຖຸ (ສໍາລັບວິທີການ virtual). ເບິ່ງ perlobj ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບ
ວິທີການ static ແລະ virtual ແລະ "ການນໍາໃຊ້ call_method" ສໍາລັບຕົວຢ່າງຂອງການນໍາໃຊ້
call_method.

call_argv
call_argv ເອີ້ນການກຳນົດການຍ່ອຍ Perl ໂດຍສາຍ C ທີ່ເກັບໄວ້ໃນ "ຊື່ຍ່ອຍ"
ພາລາມິເຕີ. ມັນຍັງໃຊ້ພາລາມິເຕີ "ທຸງ" ປົກກະຕິ. ຕົວກໍານົດການສຸດທ້າຍ, "argv",
ປະ​ກອບ​ດ້ວຍ​ບັນ​ຊີ​ລາຍ​ການ​ທີ່​ສິ້ນ​ສຸດ NULL ຂອງ​ສະ​ຕ​ຣິງ C ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ຜ່ານ​ເປັນ​ຕົວ​ກໍາ​ນົດ​ການ​ກັບ​
Perl subroutine. ເບິ່ງ ການນໍາໃຊ້ call_argv.

ຟັງຊັນທັງໝົດສົ່ງຄືນຈຳນວນເຕັມ. ນີ້ແມ່ນການນັບຈໍານວນລາຍການທີ່ສົ່ງຄືນໂດຍ
ປົກກະຕິຍ່ອຍ Perl. ລາຍການຕົວຈິງທີ່ສົ່ງຄືນໂດຍ subroutine ແມ່ນເກັບໄວ້ໃນ Perl
ກອງ.

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

ທຸງ VALUES

ຕົວກໍານົດການ "ທຸງ" ໃນທັງຫມົດ ໂທ_* ຟັງຊັນໜຶ່ງໃນ G_VOID, G_SCALAR, ຫຼື G_ARRAY,
ເຊິ່ງຊີ້ບອກເຖິງສະພາບການການໂທ, OR'ed ຮ່ວມກັບຫນ້າກາກເລັກນ້ອຍຂອງການປະສົມປະສານໃດໆ
ສັນຍາລັກ G_* ອື່ນໆທີ່ກໍານົດໄວ້ຂ້າງລຸ່ມນີ້.

G_VOID
ໂທຫາລາຍການຍ່ອຍ Perl ໃນບໍລິບົດທີ່ເປັນໂມຄະ.

ທຸງນີ້ມີ 2 ຜົນກະທົບ:

1. ມັນຊີ້ບອກເຖິງການກຳນົດການຍ່ອຍທີ່ເອີ້ນວ່າມັນຖືກປະຕິບັດໃນບໍລິບົດທີ່ເປັນໂມຄະ
(ຖ້າ​ຫາກ​ວ່າ​ມັນ​ປະ​ຕິ​ບັດ​ ຕ້ອງການ ຜົນໄດ້ຮັບຈະເປັນມູນຄ່າທີ່ບໍ່ໄດ້ກໍານົດ).

2. ມັນຮັບປະກັນວ່າບໍ່ມີຫຍັງຖືກສົ່ງຄືນຈາກບັນຊີຍ່ອຍ.

ຄ່າທີ່ສົ່ງຄືນໂດຍ ໂທ_* ຟັງຊັນຊີ້ບອກຈໍານວນລາຍການທີ່ຖືກສົ່ງຄືນໂດຍ
Perl subroutine - ໃນກໍລະນີນີ້ມັນຈະເປັນ 0.

G_SCALA
ໂທຫາລາຍການຍ່ອຍ Perl ໃນບໍລິບົດສະເກັດເລກ. ນີ້ແມ່ນການຕັ້ງຄ່າທຸງບໍລິບົດເລີ່ມຕົ້ນ
ສຳ ລັບທຸກສິ່ງ ໂທ_* ປະຕິບັດຫນ້າ.

ທຸງນີ້ມີ 2 ຜົນກະທົບ:

1. ມັນຊີ້ບອກເຖິງການກຳນົດການຍ່ອຍທີ່ເອີ້ນວ່າມັນຖືກປະຕິບັດໃນບໍລິບົດການສະເກັດເລກ.
(ຖ້າ​ຫາກ​ວ່າ​ມັນ​ປະ​ຕິ​ບັດ​ ຕ້ອງການ ຜົນໄດ້ຮັບຈະເປັນທີ່ບໍ່ຖືກຕ້ອງ).

2. ມັນຮັບປະກັນວ່າພຽງແຕ່ scalar ຕົວຈິງແລ້ວຖືກສົ່ງຄືນຈາກ subroutine. ໄດ້
subroutine ສາມາດ, ແນ່ນອນ, ບໍ່ສົນໃຈ ຕ້ອງການ ແລະສົ່ງຄືນລາຍຊື່ແນວໃດ. ຖ້າ​ດັ່ງ​ນັ້ນ,
ຫຼັງຈາກນັ້ນພຽງແຕ່ອົງປະກອບສຸດທ້າຍຂອງບັນຊີລາຍຊື່ຈະຖືກສົ່ງຄືນ.

ຄ່າທີ່ສົ່ງຄືນໂດຍ ໂທ_* ຟັງຊັນຊີ້ບອກຈໍານວນລາຍການທີ່ຖືກສົ່ງຄືນໂດຍ
Perl subroutine - ໃນກໍລະນີນີ້ມັນຈະເປັນ 0 ຫຼື 1.

ຖ້າ 0, ຫຼັງຈາກນັ້ນທ່ານໄດ້ລະບຸທຸງ G_DISCARD.

ຖ້າ 1, ຫຼັງຈາກນັ້ນລາຍການທີ່ສົ່ງຄືນຕົວຈິງໂດຍ Perl subroutine ຈະຖືກເກັບໄວ້ໃນ Perl
stack - ພາກ ກັບມາ a ສະເກລາ ສະແດງວິທີການເຂົ້າເຖິງຄ່ານີ້ຢູ່ໃນ stack.
ຈື່ໄວ້ວ່າບໍ່ວ່າຈະເປັນລາຍການຍ່ອຍຂອງ Perl ເທົ່າໃດ, ມີພຽງແຕ່ອັນສຸດທ້າຍເທົ່ານັ້ນ
ຈະສາມາດເຂົ້າເຖິງໄດ້ຈາກ stack - ຄິດວ່າກໍລະນີທີ່ມີພຽງແຕ່ຫນຶ່ງມູນຄ່າຖືກສົ່ງຄືນເປັນ
ເປັນບັນຊີລາຍຊື່ທີ່ມີພຽງແຕ່ອົງປະກອບຫນຶ່ງ. ລາຍການອື່ນໆທີ່ຖືກສົ່ງຄືນຈະບໍ່ມີໂດຍ
ການຄວບຄຸມເວລາກັບຄືນມາຈາກ ໂທ_* ຫນ້າທີ່. ພາກ ກັບມາ a ບັນຊີລາຍຊື່ in a
ຜິວ ໜັງ context ສະແດງໃຫ້ເຫັນຕົວຢ່າງຂອງພຶດຕິກໍານີ້.

G_ARRAY
ໂທຫາລາຍການຍ່ອຍ Perl ໃນບໍລິບົດລາຍການ.

ເຊັ່ນດຽວກັນກັບ G_SCALAR, ທຸງນີ້ມີ 2 ຜົນກະທົບ:

1. ມັນຊີ້ບອກເຖິງການກຳນົດການຍ່ອຍທີ່ເອີ້ນວ່າມັນກໍາລັງດໍາເນີນການຢູ່ໃນບໍລິບົດລາຍການ
(ຖ້າ​ຫາກ​ວ່າ​ມັນ​ປະ​ຕິ​ບັດ​ ຕ້ອງການ ຜົນໄດ້ຮັບຈະເປັນຄວາມຈິງ).

2. ມັນ​ເຮັດ​ໃຫ້​ແນ່​ໃຈວ່​າ​ລາຍ​ການ​ທັງ​ຫມົດ​ກັບ​ຄືນ​ມາ​ຈາກ subroutine ຈະ​ສາ​ມາດ​ເຂົ້າ​ເຖິງ​ໃນ​ເວ​ລາ​ທີ່
ການຄວບຄຸມກັບຄືນຈາກ ໂທ_* function

ຄ່າທີ່ສົ່ງຄືນໂດຍ ໂທ_* ຟັງຊັນຊີ້ບອກຈໍານວນລາຍການທີ່ຖືກສົ່ງຄືນໂດຍ
ປົກກະຕິຍ່ອຍ Perl.

ຖ້າ 0, ຫຼັງຈາກນັ້ນທ່ານໄດ້ລະບຸທຸງ G_DISCARD.

ຖ້າບໍ່ແມ່ນ 0, ມັນຈະເປັນຕົວເລກຂອງຈໍານວນລາຍການທີ່ສົ່ງຄືນໂດຍ subroutine. ເຫຼົ່ານີ້
ລາຍການຈະຖືກເກັບໄວ້ໃນ stack Perl. ພາກ ກັບມາ a ບັນຊີລາຍຊື່ of ຄ່າ ໃຫ້
ຕົວຢ່າງຂອງການໃຊ້ທຸງ G_ARRAY ແລະກົນໄກຂອງການເຂົ້າເຖິງລາຍການທີ່ສົ່ງຄືນຈາກ
stack Perl.

G_DISCARD
ໂດຍຄ່າເລີ່ມຕົ້ນ, the ໂທ_* ຟັງຊັນຈັດວາງລາຍການທີ່ສົ່ງຄືນມາຈາກ routine ຍ່ອຍ Perl
stack ໄດ້. ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ບໍ່​ມີ​ຄວາມ​ສົນ​ໃຈ​ໃນ​ລາຍ​ການ​ເຫຼົ່າ​ນີ້​, ຫຼັງ​ຈາກ​ນັ້ນ​ການ​ຕັ້ງ​ທຸງ​ນີ້​ຈະ​ເຮັດ​ໃຫ້​
Perl ກໍາຈັດພວກມັນໂດຍອັດຕະໂນມັດສໍາລັບທ່ານ. ໃຫ້ສັງເກດວ່າມັນຍັງສາມາດຊີ້ບອກ a
ບໍລິບົດຂອງໂປຣເຈັກຍ່ອຍ Perl ໂດຍໃຊ້ G_SCALAR ຫຼື G_ARRAY.

ຖ້າທ່ານບໍ່ຕັ້ງທຸງນີ້ແລ້ວມັນແມ່ນ ຫຼາຍ ສິ່ງສໍາຄັນທີ່ທ່ານເຮັດໃຫ້ແນ່ໃຈວ່າໃດກໍ່ຕາມ
ຊົ່ວຄາວ (ເຊັ່ນ, ພາລາມິເຕີທີ່ສົ່ງໄປຫາ routine ຍ່ອຍ Perl ແລະຄ່າທີ່ສົ່ງຄືນມາຈາກ
subroutine ) ແມ່ນ disposed ຂອງ ຕົວ ທ່ານ ເອງ . ພາກ ກັບມາ a ສະເກລາ ໃຫ້ລາຍລະອຽດຂອງວິທີການ
ເພື່ອກໍາຈັດການຊົ່ວຄາວເຫຼົ່ານີ້ຢ່າງຈະແຈ້ງແລະພາກສ່ວນ ການນໍາໃຊ້ Perl to ມີ of
ຊົ່ວຄາວ ສົນທະນາກ່ຽວກັບສະຖານະການສະເພາະທີ່ທ່ານສາມາດບໍ່ສົນໃຈບັນຫາແລະປ່ອຍໃຫ້
Perl ຈັດການກັບມັນສໍາລັບທ່ານ.

G_NOARGS
ທຸກຄັ້ງທີ່ routine ຍ່ອຍ Perl ຖືກເອີ້ນໃຊ້ຫນຶ່ງຂອງ ໂທ_* ຫນ້າທີ່, ມັນແມ່ນສົມມຸດຕິຖານໂດຍ
ຄ່າເລີ່ມຕົ້ນທີ່ພາລາມິເຕີຈະຖືກສົ່ງກັບ routine ຍ່ອຍ. ຖ້າທ່ານບໍ່ໄດ້ຜ່ານໃດໆ
ພາລາມິເຕີກັບ Perl subroutine, ທ່ານສາມາດປະຫຍັດເວລາເລັກນ້ອຍໂດຍການຕັ້ງຄ່າທຸງນີ້. ມັນ
ມີຜົນກະທົບຂອງການບໍ່ສ້າງ @_ array ສໍາລັບ Perl subroutine.

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

ໃນ​ຄວາມ​ເປັນ​ຈິງ, ສິ່ງ​ທີ່​ສາ​ມາດ​ເກີດ​ຂຶ້ນ​ແມ່ນ​ວ່າ subroutine Perl ທີ່​ທ່ານ​ໄດ້​ເອີ້ນ​ວ່າ​ສາ​ມາດ​ເຂົ້າ​ເຖິງ @_
array ຈາກ routine ຍ່ອຍ Perl ທີ່ຜ່ານມາ. ນີ້ຈະເກີດຂຶ້ນໃນເວລາທີ່ລະຫັດທີ່ກໍາລັງປະຕິບັດ
ໄດ້ ໂທ_* ຟັງຊັນຕົວຂອງມັນເອງໄດ້ຖືກເອີ້ນຈາກການເຮັດວຽກຍ່ອຍ Perl ອື່ນ. ລະຫັດຂ້າງລຸ່ມນີ້
ສະແດງໃຫ້ເຫັນນີ້

ຍ່ອຍ fred
{ ພິມ "@_\n" }

sub joe
{ &fred }

&jo(1,2,3);

ນີ້ຈະພິມ

+1 2 3

ສິ່ງທີ່ເກີດຂຶ້ນແມ່ນວ່າ "fred" ເຂົ້າເຖິງ @_ array ເຊິ່ງເປັນຂອງ "joe".

G_EVAL
ມັນເປັນໄປໄດ້ສໍາລັບ subroutine Perl ທີ່ທ່ານກໍາລັງໂທຫາເພື່ອຢຸດການຜິດປົກກະຕິ, ຕົວຢ່າງ, ໂດຍ.
ໂທຫາ ໄດ້ ຢ່າງຈະແຈ້ງ ຫຼືບໍ່ມີຢູ່ແລ້ວ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ເມື່ອທັງສອງອັນນີ້
ເຫດການເກີດຂື້ນ, ຂະບວນການຈະຢຸດຕິທັນທີ. ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະໃສ່ກັບດັກປະເພດນີ້
ເຫດການ, ລະບຸທຸງ G_EVAL. ມັນຈະເຮັດໃຫ້ເປັນ ການປະເມີນ { } ປະມານການໂທແບບປົກກະຕິ.

ເມື່ອໃດກໍ່ຕາມການຄວບຄຸມກັບຄືນມາຈາກ ໂທ_* ຫນ້າທີ່ທ່ານຈໍາເປັນຕ້ອງກວດເບິ່ງຕົວແປ $@ ຕາມທີ່ທ່ານ
ຈະຢູ່ໃນສະຄິບ Perl ປົກກະຕິ.

ຄ່າກັບຄືນຈາກ ໂທ_* ການທໍາງານແມ່ນຂຶ້ນກັບສິ່ງທີ່ທຸງອື່ນໆໄດ້
ລະບຸ ແລະວ່າມີຂໍ້ຜິດພາດເກີດຂຶ້ນຫຼືບໍ່. ນີ້ແມ່ນທຸກກໍລະນີທີ່ແຕກຕ່າງກັນທີ່ສາມາດເຮັດໄດ້
ເກີດ:

·ຖ້າຫາກວ່າ ໂທ_* function ກັບຄືນມາຕາມປົກກະຕິ, ຫຼັງຈາກນັ້ນຄ່າທີ່ສົ່ງຄືນແມ່ນຕາມທີ່ລະບຸໄວ້ໃນ
ພາກສ່ວນທີ່ຜ່ານມາ.

· ຖ້າ G_DISCARD ຖືກລະບຸ, ຄ່າກັບຄືນຈະເປັນ 0 ສະເໝີ.

· ຖ້າ G_ARRAY ຖືກລະບຸ ແລະ ມີຂໍ້ຜິດພາດເກີດຂຶ້ນ, ຄ່າກັບຄືນຈະເປັນ 0 ສະເໝີ.

· ຖ້າ G_SCALAR ຖືກລະບຸ ແລະ ມີຂໍ້ຜິດພາດເກີດຂຶ້ນ, ຄ່າກັບຄືນຈະເປັນ 1 ແລະ
ມູນຄ່າຢູ່ເທິງສຸດຂອງ stack ຈະເປັນ undef. ນີ້ຫມາຍຄວາມວ່າຖ້າທ່ານມີແລ້ວ
ກວດພົບຂໍ້ຜິດພາດໂດຍການກວດສອບ $@ ແລະທ່ານຕ້ອງການໃຫ້ໂຄງການສືບຕໍ່, ທ່ານຕ້ອງ
ຈືຂໍ້ມູນການທີ່ຈະປາກົດ undef ຈາກ stack ໄດ້.

ເບິ່ງ ການນໍາໃຊ້ G_EVAL ສໍາລັບລາຍລະອຽດກ່ຽວກັບການນໍາໃຊ້ G_EVAL.

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

ສະຖານະການນີ້ສ່ວນຫຼາຍແມ່ນໃຊ້ໄດ້ກັບລະຫັດທີ່ຫມາຍເຖິງການໂທຫາຈາກພາຍໃນ
ຕົວທຳລາຍ, ໂທກັບຄືນແບບບໍ່ກົງກັນ, ແລະຕົວຈັດການສັນຍານ. ໃນສະຖານະການດັ່ງກ່າວ, ບ່ອນທີ່
ລະຫັດທີ່ຖືກເອີ້ນມີຄວາມສໍາພັນຫນ້ອຍກັບສະພາບການເຄື່ອນໄຫວອ້ອມຂ້າງ, ໂຄງການຕົ້ນຕໍ
ຕ້ອງໄດ້ຮັບການ insulated ຈາກຄວາມຜິດພາດໃນລະຫັດທີ່ເອີ້ນວ່າ, ເຖິງແມ່ນວ່າພວກເຂົາບໍ່ສາມາດຈັດການໄດ້
ຢ່າງສະຫຼາດ. ມັນອາດຈະເປັນປະໂຫຍດທີ່ຈະເຮັດສິ່ງນີ້ດ້ວຍລະຫັດ "__DIE__" ຫຼື "__WARN__"
hooks, ແລະຫນ້າທີ່ "tie".

ທຸງ G_KEEPERR ແມ່ນຫມາຍຄວາມວ່າຈະຖືກນໍາໃຊ້ຮ່ວມກັບ G_EVAL ໃນ ໂທ_* ຫນ້າທີ່
ຖືກນໍາໃຊ້ເພື່ອປະຕິບັດລະຫັດດັ່ງກ່າວ, ຫຼືກັບ "eval_sv". ທຸງນີ້ບໍ່ມີຜົນຕໍ່
"call_*" ຟັງຊັນເມື່ອ G_EVAL ບໍ່ໄດ້ໃຊ້.

ເມື່ອ G_KEEPERR ຖືກໃຊ້, ຂໍ້ຜິດພາດໃດໆໃນລະຫັດທີ່ຖືກເອີ້ນຈະຢຸດການໂທຕາມປົກກະຕິ, ແລະ
ຄວາມ​ຜິດ​ພາດ​ຈະ​ບໍ່​ແຜ່​ຂະ​ຫຍາຍ​ນອກ​ເຫນືອ​ການ​ໂທ (ຕາມ​ປົກ​ກະ​ຕິ​ສໍາ​ລັບ G_EVAL​)​, ແຕ່​ວ່າ​ມັນ​ຈະ​ບໍ່​ໄປ​
ເຂົ້າໄປໃນ $@. ແທນທີ່ຈະ, ຄວາມຜິດພາດຈະຖືກປ່ຽນເປັນຄໍາເຕືອນ, ແທນທີ່ດ້ວຍສະຕຣິງ
"\t (ຢູ່ໃນການທໍາຄວາມສະອາດ)". ນີ້ສາມາດຖືກປິດໃຊ້ງານໄດ້ໂດຍໃຊ້ "ບໍ່ມີຄໍາເຕືອນ 'misc'". ຖ້າບໍ່ມີຂໍ້ຜິດພາດ,
$@ ຈະບໍ່ຖືກລຶບລ້າງ.

ໃຫ້ສັງເກດວ່າທຸງ G_KEEPERR ບໍ່ໄດ້ແຜ່ຂະຫຍາຍໄປສູ່ evaals ພາຍໃນ; ສິ່ງເຫຼົ່ານີ້ອາດຈະຍັງຕັ້ງ $@.

ທຸງ G_KEEPERR ຖືກນໍາສະເຫນີໃນ Perl ຮຸ່ນ 5.002.

ເບິ່ງ ການນໍາໃຊ້ G_KEEPERR ສໍາລັບຕົວຢ່າງຂອງສະຖານະການທີ່ຮັບປະກັນການນໍາໃຊ້ທຸງນີ້.

ການ ກຳ ນົດ ໄດ້ Context
ດັ່ງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ, ທ່ານສາມາດກໍານົດສະພາບການຂອງ subroutine ທີ່ກໍາລັງປະຕິບັດໃນປະຈຸບັນຢູ່ໃນ
Perl ກັບ ຕ້ອງການ. ການທົດສອບທຽບເທົ່າສາມາດເຮັດໄດ້ໃນ C ໂດຍໃຊ້ມະຫາພາກ "GIMME_V",
ເຊິ່ງໃຫ້ຜົນຕອບແທນ "G_ARRAY" ຖ້າທ່ານຖືກເອີ້ນໃນບໍລິບົດລາຍການ, "G_SCALAR" ຖ້າຢູ່ໃນ
context scalar, ຫຼື "G_VOID" ຖ້າຢູ່ໃນບໍລິບົດທີ່ເປັນໂມຄະ (ເຊັ່ນ, ຄ່າກັບຄືນຈະບໍ່ເປັນ.
ໃຊ້). ຮຸ່ນເກົ່າຂອງມະຫາພາກນີ້ເອີ້ນວ່າ "GIMME"; ໃນບໍລິບົດທີ່ບໍ່ມີປະໂຫຍດມັນກັບຄືນມາ
"G_SCALAR" ແທນ "G_VOID". ຕົວຢ່າງຂອງການໃຊ້ "GIMME_V" macro ແມ່ນສະແດງຢູ່ໃນ
ສ່ວນ ການນໍາໃຊ້ GIMME_V.

ຕົວຢ່າງ

ພຽງ​ພໍ​ຂອງ​ຄໍາ​ນິ​ຍາມ​ເວົ້າ​! ຂໍ​ໃຫ້​ມີ​ບາງ​ຕົວ​ຢ່າງ​.

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

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

No ພາລາມິເຕີ, ບໍ່ມີຫຍັງ ກັບມາແລ້ວ
ຕົວຢ່າງເລັກນ້ອຍອັນທໍາອິດນີ້ຈະໂທຫາການຍ່ອຍ Perl, PrintUID, ເພື່ອພິມອອກ UID ຂອງ
ຂະບວນການ.

ຍ່ອຍ PrintUID
{
ພິມ "UID ແມ່ນ $<\n";
}

ແລະນີ້ແມ່ນຟັງຊັນ C ເພື່ອໂທຫາມັນ

void static
call_PrintUID()
{
dSP;

PUSHMARK(SP);
call_pv("PrintUID", G_DISCARD|G_NOARGS);
}

ງ່າຍດາຍ, eh?

ບາງຈຸດທີ່ຄວນສັງເກດກ່ຽວກັບຕົວຢ່າງນີ້:

1. ບໍ່ສົນໃຈ "dSP" ແລະ "PUSHMARK(SP)" ສໍາລັບຕອນນີ້. ພວກເຂົາເຈົ້າຈະໄດ້ຮັບການປຶກສາຫາລືໃນຕົວຢ່າງຕໍ່ໄປ.

2. ພວກເຮົາບໍ່ໄດ້ຜ່ານຕົວກໍານົດການໃດໆ PrintUID ດັ່ງນັ້ນ G_NOARGS ສາມາດຖືກກໍານົດ.

3. ພວກເຮົາບໍ່ສົນໃຈຫຍັງກັບຄືນມາຈາກ PrintUID, ດັ່ງນັ້ນ G_DISCARD ຖືກລະບຸ.
ເຖິງແມ່ນວ່າຖ້າຫາກວ່າ PrintUID ຖືກປ່ຽນເພື່ອສົ່ງຄືນຄ່າບາງຢ່າງ, ໂດຍລະບຸ G_DISCARD ຈະ
ຫມາຍ ຄວາມ ວ່າ ພວກ ເຂົາ ເຈົ້າ ຈະ ໄດ້ ຮັບ ການ wiped ໂດຍ ການ ຄວບ ຄຸມ ທີ່ ໃຊ້ ເວ ລາ ກັບ ຄືນ ມາ ຈາກ call_pv.

ປີ 4. ດັ່ງ call_pv ກໍາລັງຖືກນໍາໃຊ້, Perl subroutine ຖືກກໍານົດເປັນ C string. ໃນ​ນີ້
ກໍ​ລະ​ນີ​ທີ່​ຊື່ subroutine ໄດ້ 'hard-wired' ເຂົ້າ​ໄປ​ໃນ​ລະ​ຫັດ​.

5. ເນື່ອງຈາກວ່າພວກເຮົາກໍານົດ G_DISCARD, ມັນບໍ່ຈໍາເປັນຕ້ອງກວດເບິ່ງມູນຄ່າທີ່ສົ່ງຄືນຈາກ
call_pv. ມັນຈະເປັນ 0 ສະເໝີ.

Passing ຕົວກໍານົດການ
ຕອນນີ້ໃຫ້ເຮົາສ້າງຕົວຢ່າງທີ່ສັບສົນກວ່າເລັກນ້ອຍ. ເວລານີ້ພວກເຮົາຕ້ອງການໂທຫາ Perl
subroutine, "LeftString", ເຊິ່ງຈະໃຊ້ເວລາ 2 ຕົວກໍານົດການ - a string ($s) ແລະ integer ($n).
ລາຍການຍ່ອຍຈະພິມຕົວອັກສອນ $n ທຳອິດຂອງສະຕຣິງ.

ດັ່ງນັ້ນ routine ຍ່ອຍ Perl ຈະມີລັກສະນະນີ້:

ຍ່ອຍ LeftString
{
my($s, $n) = @_;
ພິມຍ່ອຍ ($s, 0, $n), "\n";
}

ຟັງຊັນ C ຕ້ອງການໂທຫາ ເສັ້ນຊ້າຍ ຈະ​ເບິ່ງ​ຄື​ນີ້​:

void static
call_LeftString(a, b)
char * a ;
int b;
{
dSP;

ENTER;
SAVETMPS;

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(a, 0)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK;

call_pv("LeftString", G_DISCARD);

FREETMPS;
ອອກຈາກ;
}

ນີ້ແມ່ນບັນທຶກສອງສາມຢ່າງກ່ຽວກັບຟັງຊັນ C call_LeftString.

1. ພາຣາມິເຕີຖືກສົ່ງຕໍ່ໄປຫາ routine ຍ່ອຍ Perl ໂດຍໃຊ້ Perl stack. ນີ້​ແມ່ນ
ຈຸດປະສົງຂອງລະຫັດເລີ່ມຕົ້ນດ້ວຍເສັ້ນ "dSP" ແລະສິ້ນສຸດດ້ວຍເສັ້ນ "PUTBACK".
"dSP" ປະກາດສໍາເນົາທ້ອງຖິ່ນຂອງຕົວຊີ້ stack. ສໍາເນົາທ້ອງຖິ່ນນີ້ຄວນ ສະເຫມີໄປ
ເຂົ້າເຖິງເປັນ "SP".

2. ຖ້າເຈົ້າຈະເອົາອັນໃດອັນໜຶ່ງໃສ່ໃສ່ Perl stack, ເຈົ້າຕ້ອງຮູ້ວ່າຈະໃສ່ບ່ອນໃດ
ມັນ. ນີ້ແມ່ນຈຸດປະສົງຂອງມະຫາພາກ "dSP"--ມັນປະກາດ ແລະເລີ່ມຕົ້ນ a ທ້ອງຖິ່ນ ຄັດລອກ
ຂອງຕົວຊີ້ Perl stack.

ມະຫາພາກອື່ນໆທັງໝົດທີ່ຈະໃຊ້ໃນຕົວຢ່າງນີ້ຕ້ອງການໃຫ້ທ່ານໃຊ້ອັນນີ້
ມະຫາພາກ.

ຂໍ້ຍົກເວັ້ນຂອງກົດລະບຽບນີ້ແມ່ນຖ້າຫາກວ່າທ່ານກໍາລັງໂທຫາ subroutine Perl ໂດຍກົງຈາກ an
ຟັງຊັນ XSUB. ໃນກໍລະນີນີ້ມັນບໍ່ຈໍາເປັນຕ້ອງໃຊ້ "dSP" macro ຢ່າງຊັດເຈນ - ມັນ
ຈະຖືກປະກາດໃຫ້ທ່ານໂດຍອັດຕະໂນມັດ.

3. ຕົວກໍານົດການໃດໆທີ່ຈະ pushed ໃສ່ stack ຄວນຖືກຍຶດໂດຍ "PUSHMARK" ແລະ.
"PUTBACK" ມະຫາພາກ. ຈຸດປະສົງຂອງທັງສອງມະຫາພາກ, ໃນສະພາບການນີ້, ແມ່ນເພື່ອນັບ
ຈໍານວນຂອງຕົວກໍານົດການທີ່ທ່ານກໍາລັງຊຸກຍູ້ອັດຕະໂນມັດ. ຫຼັງຈາກນັ້ນ, ທຸກຄັ້ງທີ່ Perl ກໍາລັງສ້າງ
array @_ ສໍາລັບ routine ຍ່ອຍ, ມັນຮູ້ວ່າມັນໃຫຍ່ປານໃດ.

ມະຫາພາກ "PUSHMARK" ບອກ Perl ໃຫ້ບັນທຶກຈິດໃຈຂອງຕົວຊີ້ stack ໃນປັດຈຸບັນ.
ເຖິງແມ່ນວ່າທ່ານຈະບໍ່ໄດ້ຜ່ານຕົວກໍານົດການໃດໆ (ເຊັ່ນຕົວຢ່າງທີ່ສະແດງຢູ່ໃນພາກ No
ພາລາມິເຕີ, ບໍ່ມີຫຍັງ ກັບມາແລ້ວ) ທ່ານຍັງຕ້ອງໂທຫາ "PUSHMARK" macro ກ່ອນທີ່ທ່ານຈະສາມາດ
ໂທຫາໃດໆຂອງ ໂທ_* functions--Perl ຍັງຕ້ອງການຮູ້ວ່າບໍ່ມີ
ຕົວກໍານົດການ.

ມະຫາພາກ "PUTBACK" ກໍານົດການສໍາເນົາທົ່ວໂລກຂອງຕົວຊີ້ stack ຄືກັນກັບຂອງພວກເຮົາ
ສຳເນົາທ້ອງຖິ່ນ. ຖ້າພວກເຮົາບໍ່ໄດ້ເຮັດສິ່ງນີ້, call_pv ຈະບໍ່ຮູ້ວ່າສອງຕົວກໍານົດການທີ່ພວກເຮົາ
pushed were-- ຈົ່ງຈື່ໄວ້ວ່າມາຮອດປັດຈຸບັນການຫມູນໃຊ້ຕົວຊີ້ stack ທັງໝົດທີ່ພວກເຮົາໄດ້ເຮັດແລ້ວ
ແມ່ນ​ກັບ​ສໍາ​ເນົາ​ທ້ອງ​ຖິ່ນ​ຂອງ​ພວກ​ເຮົາ​, ບໍ່ ສໍາເນົາທົ່ວໂລກ.

4. ຕໍ່ໄປ, ພວກເຮົາມາ XPUSHs. ນີ້ແມ່ນບ່ອນທີ່ຕົວກໍານົດການຕົວຈິງໄດ້ຮັບການ pushed ໃສ່
stack. ໃນ​ກໍ​ລະ​ນີ​ນີ້​ພວກ​ເຮົາ​ກໍາ​ລັງ​ຊຸກ​ດັນ​ໃຫ້​ສະ​ຕ​ຣິງ​ແລະ​ຈໍາ​ນວນ​ເຕັມ​.

ເບິ່ງ "XSUBs ແລະ Argument Stack" ໃນ perlguts ສໍາລັບລາຍລະອຽດກ່ຽວກັບວິທີການ Macros XPUSH
ເຮັດວຽກ.

5. ເນື່ອງຈາກວ່າພວກເຮົາສ້າງຄຸນຄ່າຊົ່ວຄາວ (ໂດຍວິທີການ sv_2mortal() ໂທ) ພວກເຮົາຈະຕ້ອງ
ເຮັດ​ໃຫ້​ກະ​ທັດ​ຮັດ​ເຖິງ stack Perl ແລະ​ກໍາ​ຈັດ​ຂອງ SVs ມະ​ຕະ​.

ນີ້ແມ່ນຈຸດປະສົງຂອງ

ENTER;
SAVETMPS;

ໃນຕອນເລີ່ມຕົ້ນຂອງຫນ້າທີ່, ແລະ

FREETMPS;
ອອກຈາກ;

ໃນຕອນທ້າຍ. ຄູ່ "ENTER"/"SAVETMPS" ສ້າງຂອບເຂດສໍາລັບການຊົ່ວຄາວທີ່ພວກເຮົາ
ສ້າງ. ນີ້ຫມາຍຄວາມວ່າການຊົ່ວຄາວທີ່ພວກເຮົາໄດ້ຮັບການກໍາຈັດຈະຈໍາກັດພຽງແຕ່ສິ່ງທີ່
ຖືກສ້າງຂື້ນຫຼັງຈາກການໂທເຫຼົ່ານີ້.

ຄູ່ "FREETMPS"/"LEAVE" ຈະກໍາຈັດຄ່າໃດໆທີ່ສົ່ງຄືນໂດຍ Perl
subroutine (ເບິ່ງຕົວຢ່າງຕໍ່ໄປ), ບວກກັບມັນຍັງຈະ dump SVs ຕາຍທີ່ພວກເຮົາໄດ້ສ້າງ.
ການມີ "ENTER"/"SAVETMPS" ໃນຕອນຕົ້ນຂອງລະຫັດເຮັດໃຫ້ແນ່ໃຈວ່າບໍ່ມີອັນອື່ນ
ມະນຸດຖືກທໍາລາຍ.

ຄິດວ່າ macro ເຫຼົ່ານີ້ເຮັດວຽກເລັກນ້ອຍເຊັ່ນ "{" ແລະ "}" ໃນ Perl ເພື່ອຈໍາກັດຂອບເຂດຂອງ
ຕົວແປທ້ອງຖິ່ນ.

ເບິ່ງພາກ ການນໍາໃຊ້ Perl to ຖິ້ມ of ຊົ່ວຄາວ ສໍາລັບລາຍລະອຽດຂອງທາງເລືອກໃນການ
ການນໍາໃຊ້ macro ເຫຼົ່ານີ້.

6. ສຸດທ້າຍ, ເສັ້ນຊ້າຍ ດຽວນີ້ສາມາດໂທຜ່ານທາງ call_pv ຫນ້າທີ່. ທຸງດຽວ
ລະບຸເວລານີ້ແມ່ນ G_DISCARD. ເນື່ອງຈາກວ່າພວກເຮົາກໍາລັງຜ່ານ 2 ຕົວກໍານົດການກັບ Perl
subroutine ເວລານີ້, ພວກເຮົາບໍ່ໄດ້ລະບຸ G_NOARGS.

ກັບມາ a ສະເກລາ
ໃນປັດຈຸບັນສໍາລັບຕົວຢ່າງຂອງການຈັດການກັບລາຍການທີ່ສົ່ງຄືນມາຈາກການຍ່ອຍ Perl.

ນີ້ແມ່ນ routine ຍ່ອຍ Perl, Adder, ທີ່ໃຊ້ເວລາ 2 ຕົວກໍານົດການຈໍານວນເຕັມແລະພຽງແຕ່ກັບຄືນຂອງເຂົາເຈົ້າ
ຜົນລວມ.

ຍ່ອຍ Adder
{
my($a, $b) = @_;
$a + $b;
}

ເນື່ອງຈາກວ່າພວກເຮົາມີຄວາມເປັນຫ່ວງໃນປັດຈຸບັນກັບມູນຄ່າກັບຄືນຈາກ Adder, ການທໍາງານຂອງ C ຕ້ອງການ
ໂທຫາມັນໃນປັດຈຸບັນແມ່ນສັບສົນຫຼາຍ.

void static
call_Adder(a, b)
int a;
int b;
{
dSP;
int ນັບ;

ENTER;
SAVETMPS;

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK;

count = call_pv("Adder", G_SCALAR);

SPAGAIN;

ຖ້າ (ນັບ != 1)
croak("ບັນຫາໃຫຍ່\n");

printf ("ຜົນລວມຂອງ %d ແລະ %d ແມ່ນ %d\n", a, b, POPi);

PUTBACK;
FREETMPS;
ອອກຈາກ;
}

ຈຸດທີ່ຄວນສັງເກດເວລານີ້ແມ່ນ

1. ທຸງດຽວທີ່ລະບຸເວລານີ້ແມ່ນ G_SCALAR. ນັ້ນຫມາຍຄວາມວ່າ @_ array ຈະເປັນ
ສ້າງແລະມູນຄ່າທີ່ສົ່ງຄືນໂດຍ Adder ຈະຍັງຄົງຢູ່ຫຼັງຈາກການໂທຫາ
call_pv.

2. ຈຸດປະສົງຂອງມະຫາພາກ "SPAGAIN" ແມ່ນເພື່ອໂຫຼດຫນ້າຈໍຄືນສໍາເນົາທ້ອງຖິ່ນຂອງຕົວຊີ້ stack.
ນີ້ແມ່ນມີຄວາມຈໍາເປັນເພາະວ່າມັນເປັນໄປໄດ້ວ່າຫນ່ວຍຄວາມຈໍາທີ່ຖືກຈັດສັນໃຫ້ກັບ Perl stack
ໄດ້​ຖືກ​ຈັດ​ສັນ​ໃນ​ໄລ​ຍະ​ call_pv ໂທຫາ.

ຖ້າທ່ານກໍາລັງໃຊ້ຕົວຊີ້ Perl stack ໃນລະຫັດຂອງທ່ານ, ທ່ານຕ້ອງໂຫຼດຫນ້າຈໍຄືນສະເຫມີ
ສໍາເນົາທ້ອງຖິ່ນໂດຍໃຊ້ SPAGAIN ທຸກຄັ້ງທີ່ທ່ານໃຊ້ ໂທ_* ຫນ້າທີ່ຫຼືໃດໆ
ການທໍາງານພາຍໃນ Perl ອື່ນໆ.

3. ເຖິງແມ່ນວ່າມີພຽງແຕ່ມູນຄ່າດຽວທີ່ຄາດວ່າຈະກັບຄືນມາຈາກ Adder, ມັນຍັງດີ
ການປະຕິບັດການກວດສອບລະຫັດກັບຄືນຈາກ call_pv ຢ່າງໃດກໍ່ຕາມ.

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

4. ມະຫາພາກ "POPi" ຖືກນໍາໃຊ້ຢູ່ທີ່ນີ້ເພື່ອປ໊ອບຄ່າກັບຄືນຈາກ stack. ໃນ​ກໍ​ລະ​ນີ​ນີ້
ພວກເຮົາຕ້ອງການຈໍານວນເຕັມ, ດັ່ງນັ້ນ "POPi" ຖືກນໍາໃຊ້.

ນີ້ແມ່ນບັນຊີລາຍຊື່ເຕັມຂອງ POP macro ທີ່ມີຢູ່, ພ້ອມກັບປະເພດທີ່ພວກເຂົາສົ່ງຄືນ.

POPs SV
ຕົວຊີ້ POPp
POPn ສອງເທົ່າ
ຈຳນວນເຕັມ POPi
POPL ຍາວ

5. ສຸດທ້າຍ "PUTBACK" ຖືກນໍາໃຊ້ເພື່ອອອກຈາກ Perl stack ຢູ່ໃນສະພາບທີ່ສອດຄ່ອງກ່ອນ
ອອກຈາກຟັງຊັນ. ນີ້ແມ່ນມີຄວາມຈໍາເປັນເພາະວ່າໃນເວລາທີ່ພວກເຮົາ popped ມູນຄ່າກັບຄືນຈາກ
stack ກັບ "POPi" ມັນປັບປຸງພຽງແຕ່ສໍາເນົາທ້ອງຖິ່ນຂອງພວກເຮົາຂອງຕົວຊີ້ stack. ຈືຂໍ້ມູນການ,
"PUTBACK" ກໍານົດຕົວຊີ້ stack ທົ່ວໂລກໃຫ້ຄືກັນກັບສໍາເນົາທ້ອງຖິ່ນຂອງພວກເຮົາ.

ກັບມາ a ບັນ​ຊີ​ລາຍ​ຊື່ of ມູນຄ່າ
ຕອນນີ້, ໃຫ້ຂະຫຍາຍຕົວຢ່າງທີ່ຜ່ານມາເພື່ອສົ່ງຄືນທັງຜົນລວມຂອງພາລາມິເຕີແລະ
ຄວາມແຕກຕ່າງ.

ນີ້ແມ່ນລາຍການຍ່ອຍ Perl

ຍ່ອຍ AddSubtract
{
my($a, $b) = @_;
($a+$b, $a-$b);
}

ແລະນີ້ແມ່ນຟັງຊັນ C

void static
call_AddSubtract(a, b)
int a;
int b;
{
dSP;
int ນັບ;

ENTER;
SAVETMPS;

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK;

count = call_pv("AddSubtract", G_ARRAY);

SPAGAIN;

ຖ້າ (ນັບ != 2)
croak("ບັນຫາໃຫຍ່\n");

printf("%d - %d = %d\n", a, b, POPi);
printf("%d + %d = %d\n", a, b, POPi);

PUTBACK;
FREETMPS;
ອອກຈາກ;
}

If call_AddSubtract ເອີ້ນວ່າແບບນີ້

call_AddSubtract(7, 4);

ຫຼັງຈາກນັ້ນ, ນີ້ແມ່ນຜົນຜະລິດ

7-4 = 3
7 + 4 = 11

ອ່ືນ

1. ພວກເຮົາຕ້ອງການບໍລິບົດລາຍການ, ດັ່ງນັ້ນ G_ARRAY ຖືກນໍາໃຊ້.

2. ບໍ່ແປກໃຈວ່າ "POPi" ຖືກໃຊ້ສອງເທື່ອໃນເທື່ອນີ້ ເພາະວ່າພວກເຮົາກຳລັງດຶງເອົາ 2 ຄ່າ.
ຈາກ stack ໄດ້. ສິ່ງທີ່ສໍາຄັນທີ່ຄວນສັງເກດແມ່ນວ່າເມື່ອໃຊ້ "POP*" macros ພວກເຂົາ
ອອກມາຈາກ stack ໃນ ຍ້ອນກັບ order

ກັບມາ a ບັນ​ຊີ​ລາຍ​ຊື່ in a ສະເກລາ Context
ເວົ້າວ່າ routine ຍ່ອຍ Perl ໃນພາກກ່ອນຫນ້າຖືກເອີ້ນໃນສະພາບການ, ແບບນີ້

void static
call_AddSubScalar(a, b)
int a;
int b;
{
dSP;
int ນັບ;
int i;

ENTER;
SAVETMPS;

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK;

count = call_pv("AddSubtract", G_SCALAR);

SPAGAIN;

printf("ລາຍການທີ່ສົ່ງຄືນ = %d\n", ນັບ);

ສໍາລັບ (i = 1; i <= ນັບ; ++i)
printf("ຄ່າ %d = %d\n", i, POPi);

PUTBACK;
FREETMPS;
ອອກຈາກ;
}

ການ​ດັດ​ແກ້​ອື່ນໆ​ທີ່​ເຮັດ​ແມ່ນ​ວ່າ​ call_AddSubScalar ຈະພິມຈໍານວນລາຍການ
ກັບຄືນຈາກ Perl subroutine ແລະມູນຄ່າຂອງພວກເຂົາ (ສໍາລັບຄວາມງ່າຍດາຍມັນສົມມຸດວ່າພວກເຂົາແມ່ນ
ຈຳນວນເຕັມ). ດັ່ງນັ້ນຖ້າ call_AddSubScalar ຖືກເອີ້ນວ່າ

call_AddSubScalar(7, 4);

ຫຼັງຈາກນັ້ນ, ຜົນຜະລິດຈະເປັນ

ລາຍການທີ່ສົ່ງຄືນ = 1
ມູນຄ່າ 1 = 3

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

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

ປົກກະຕິຍ່ອຍ Perl, Inc, ຂ້າງລຸ່ມນີ້ໃຊ້ເວລາ 2 ຕົວກໍານົດການແລະການເພີ່ມຂຶ້ນແຕ່ລະຄົນໂດຍກົງ.

ຍ່ອຍ Inc
{
++ $_[0];
++ $_[1];
}

ແລະນີ້ແມ່ນຟັງຊັນ C ເພື່ອໂທຫາມັນ.

void static
call_Inc(a, b)
int a;
int b;
{
dSP;
int ນັບ;
SV * sva;
SV * svb;

ENTER;
SAVETMPS;

sva = sv_2mortal(newSViv(a));
svb = sv_2mortal(newSViv(b));

PUSHMARK(SP);
XPUSHs(sva);
XPUSHs(svb);
PUTBACK;

count = call_pv("Inc", G_DISCARD);

ຖ້າ (ນັບ != 0)
croak ("call_Inc: ຄາດການ 0 ຄ່າຈາກ 'Inc', ໄດ້ %d\n",
ນັບ);

printf("%d + 1 = %d\n", a, SvIV(sva));
printf("%d + 1 = %d\n", b, SvIV(svb));

FREETMPS;
ອອກຈາກ;
}

ເພື່ອໃຫ້ສາມາດເຂົ້າເຖິງສອງຕົວກໍານົດການທີ່ຖືກ pushed ໃສ່ stack ຫຼັງຈາກພວກເຂົາກັບຄືນມາ
ຈາກ call_pv ມັນເປັນສິ່ງຈໍາເປັນທີ່ຈະເຮັດໃຫ້ບັນທຶກທີ່ຢູ່ຂອງເຂົາເຈົ້າ - ດັ່ງນັ້ນທັງສອງຕົວແປ
"sva" ແລະ "svb".

ເຫດຜົນນີ້ແມ່ນມີຄວາມຈໍາເປັນແມ່ນວ່າພື້ນທີ່ຂອງ stack Perl ທີ່ຖືໃຫ້ເຂົາເຈົ້າຫຼາຍ
ອາດຈະຖືກຂຽນທັບໂດຍສິ່ງອື່ນໂດຍການຄວບຄຸມເວລາກັບຄືນມາ call_pv.

ການນໍາໃຊ້ G_EVAL
ຕອນນີ້ຕົວຢ່າງທີ່ໃຊ້ G_EVAL. ຂ້າງລຸ່ມນີ້ແມ່ນຊຸດຍ່ອຍ Perl ທີ່ຄິດໄລ່ຄວາມແຕກຕ່າງຂອງ
2 ຕົວກໍານົດການຂອງມັນ. ຖ້າອັນນີ້ຈະເຮັດໃຫ້ຜົນໄດ້ຮັບທາງລົບ, ບັນຊີຍ່ອຍຈະໂທຫາ ໄດ້.

ລົບ
{
ຂອງຂ້ອຍ ($a, $b) = @_;

die "ຄວາມຕາຍສາມາດຕາຍໄດ້\n" ຖ້າ $a < $b;

$a - $b;
}

ແລະບາງ C ໂທຫາມັນ

void static
call_Subtract(a, b)
int a;
int b;
{
dSP;
int ນັບ;

ENTER;
SAVETMPS;

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK;

count = call_pv("Subtract", G_EVAL|G_SCALAR);

SPAGAIN;

/* ກວດ​ສອບ​ການ​ກວດ​ສອບ​ກ່ອນ​ທີ່​ຈະ */
ຖ້າ (SvTRUE(ERRSV))
{
printf ("ໂອ້ຍ - %s\n", SvPV_nolen(ERRSV));
POPs;
}
ອື່ນ
{
ຖ້າ (ນັບ != 1)
croak("call_Subtract: ຕ້ອງການ 1 ຄ່າຈາກ 'Subtract', ໄດ້ %d\n",
ນັບ);

printf("%d - %d = %d\n", a, b, POPi);
}

PUTBACK;
FREETMPS;
ອອກຈາກ;
}

If call_Subtract ເອີ້ນວ່າດັ່ງນັ້ນ

call_Subtract(4, 5)

ຕໍ່ໄປນີ້ຈະຖືກພິມອອກ

ໂອ້ຍ - ຄວາມຕາຍສາມາດຕາຍໄດ້

ອ່ືນ

1. ພວກເຮົາຕ້ອງການທີ່ຈະສາມາດຈັບໄດ້ ໄດ້ ດັ່ງນັ້ນພວກເຮົາໄດ້ໃຊ້ທຸງ G_EVAL. ບໍ່ໄດ້ລະບຸ
ທຸງນີ້ຫມາຍຄວາມວ່າໂຄງການຈະຢຸດຕິທັນທີຢູ່ທີ່ ໄດ້
ຄໍາ​ຖະ​ແຫຼງ​ການ​ໃນ subroutine ໄດ້​ ການຫັກລົບ.

2. ລະຫັດ

ຖ້າ (SvTRUE(ERRSV))
{
printf ("ໂອ້ຍ - %s\n", SvPV_nolen(ERRSV));
POPs;
}

ແມ່ນທຽບເທົ່າໂດຍກົງຂອງ Perl ນີ້

ພິມ "ໂອ້ຍ - $@\n" ຖ້າ $@;

"PL_errgv" ແມ່ນ perl ທົ່ວໂລກຂອງປະເພດ "GV *" ທີ່ຊີ້ໃຫ້ເຫັນເຖິງການເຂົ້າຕາຕະລາງສັນຍາລັກ
ມີ​ຄວາມ​ຜິດ​ພາດ​. "ERRSV" ດັ່ງນັ້ນຈຶ່ງຫມາຍເຖິງ C ທຽບເທົ່າກັບ $@.

3. ໃຫ້ສັງເກດວ່າ stack ແມ່ນ popped ໂດຍໃຊ້ "POPs" ໃນບລັອກບ່ອນທີ່ "SvTRUE(ERRSV)" ແມ່ນ.
ຄວາມຈິງ. ນີ້ແມ່ນມີຄວາມຈໍາເປັນເພາະວ່າທຸກຄັ້ງ a ໂທ_* ຫນ້າ​ທີ່​ຮຽກ​ຮ້ອງ​ໃຫ້​ມີ​
G_EVAL|G_SCALAR ຕອບຂໍ້ຜິດພາດ, ເທິງສຸດຂອງ stack ຖືຄ່າ undefທີ່ຢູ່ ເນື່ອງຈາກວ່າ
ພວກ​ເຮົາ​ຕ້ອງ​ການ​ໃຫ້​ໂຄງ​ການ​ທີ່​ຈະ​ສືບ​ຕໍ່​ຫຼັງ​ຈາກ​ການ​ກວດ​ພົບ​ຄວາມ​ຜິດ​ພາດ​ນີ້​, ມັນ​ເປັນ​ສິ່ງ​ຈໍາ​ເປັນ​ທີ່​
stack ໄດ້ tidied ເຖິງ ໂດຍ ການ ລົບ undef.

ການນໍາໃຊ້ G_KEEPERR
ພິຈາລະນາຕົວຢ່າງທີ່ແປກປະຫລາດນີ້, ບ່ອນທີ່ພວກເຮົາໄດ້ໃຊ້ສະບັບ XS ຂອງ
call_Subtract ຕົວຢ່າງຂ້າງເທິງພາຍໃນ destructor:

package foo;
ຍ່ອຍໃໝ່ { ອວຍພອນ {}, $_[0] }
ລົບ {
my($a,$b) = @_;
die "ຄວາມຕາຍສາມາດຕາຍໄດ້" ຖ້າ $a< $b;
$a - $b;
}
sub DESTROY { call_Subtract(5, 4); }
sub foo { die "foo dies"; }

package main;
{
ຂອງຂ້ອຍ $foo = Foo->ໃໝ່;
eval { $foo->foo };
}
ພິມ "Saw: $@" ຖ້າ $@; # ຄວນຈະເປັນ, ແຕ່ບໍ່ແມ່ນ

ຕົວຢ່າງນີ້ຈະບໍ່ຮັບຮູ້ວ່າມີຂໍ້ຜິດພາດເກີດຂຶ້ນພາຍໃນ "eval {}". ນີ້ແມ່ນ
ເປັນຫຍັງ: ລະຫັດ call_Subtract ໄດ້ຖືກປະຕິບັດໃນຂະນະທີ່ perl ກໍາລັງທໍາຄວາມສະອາດຊົ່ວຄາວໃນເວລາທີ່
ອອກຈາກບລັອກວົງເລັບພາຍນອກ, ແລະເນື່ອງຈາກວ່າ call_Subtract ຖືກປະຕິບັດດ້ວຍ call_pv
ໂດຍໃຊ້ທຸງ G_EVAL, ມັນຣີເຊັດ $@ ທັນທີ. ນີ້ເຮັດໃຫ້ຄວາມລົ້ມເຫຼວຂອງ outermost ໄດ້
ການທົດສອບສໍາລັບ $@, ແລະດັ່ງນັ້ນຄວາມລົ້ມເຫຼວຂອງກັບດັກຄວາມຜິດພາດ.

ການຕໍ່ທ້າຍທຸງ G_KEEPERR, ດັ່ງນັ້ນ call_pv ໂທໃນ call_Subtract ອ່ານ:

count = call_pv("Subtract", G_EVAL|G_SCALAR|G_KEEPERR);

ຈະຮັກສາຄວາມຜິດພາດແລະຟື້ນຟູການຈັດການຄວາມຜິດພາດທີ່ເຊື່ອຖືໄດ້.

ການນໍາໃຊ້ call_sv
ໃນຕົວຢ່າງທີ່ຜ່ານມາທັງຫມົດຂ້ອຍມີ 'ສາຍໄຟແຂງ' ຊື່ຂອງ Perl subroutine ທີ່ຈະເປັນ
ເອີ້ນວ່າຈາກ C. ສ່ວນຫຼາຍແມ່ນ, ມັນສະດວກກວ່າທີ່ຈະສາມາດລະບຸໄດ້
ຊື່ຂອງ routine ຍ່ອຍ Perl ຈາກພາຍໃນ Perl script.

ພິຈາລະນາລະຫັດ Perl ຂ້າງລຸ່ມນີ້

ຍ່ອຍ fred
{
ພິມ "ສະບາຍດີ\n";
}

CallSubPV("fred");

ນີ້ແມ່ນຕົວຢ່າງຂອງ XSUB ເຊິ່ງກໍານົດ ໂທSubPV.

void
CallSubPV(ຊື່)
char * ຊື່
ລະຫັດ:
PUSHMARK(SP);
call_pv(ຊື່, G_DISCARD|G_NOARGS);

ນັ້ນແມ່ນດີເທົ່າທີ່ມັນໄປ. ສິ່ງທີ່ເປັນ, Perl subroutine ສາມາດຖືກກໍານົດເປັນພຽງແຕ່
ແນວໃດກໍ່ຕາມ, Perl ອະນຸຍາດໃຫ້ອ້າງອີງເຖິງ routines ແລະ subroutines ທີ່ບໍ່ເປີດເຜີຍຊື່. ນີ້
ແມ່ນບ່ອນທີ່ call_sv ແມ່ນເປັນປະໂຫຍດ.

ລະຫັດຂ້າງລຸ່ມນີ້ສໍາລັບ CallSubSV ແມ່ນຄືກັນກັບ ໂທSubPV ຍົກເວັ້ນວ່າ "ຊື່" ພາລາມິເຕີແມ່ນ
ໃນປັດຈຸບັນກໍານົດເປັນ SV* ແລະພວກເຮົາໃຊ້ call_sv ແທນ​ທີ່ call_pv.

void
CallSubSV(ຊື່)
SV * ຊື່
ລະຫັດ:
PUSHMARK(SP);
call_sv(ຊື່, G_DISCARD|G_NOARGS);

ເນື່ອງຈາກວ່າພວກເຮົາກໍາລັງໃຊ້ SV ເພື່ອໂທຫາ Fred ຕໍ່ໄປນີ້ສາມາດໃຊ້ໄດ້ທັງຫມົດ:

CallSubSV("fred");
CallSubSV(\&fred);
$ref = \&fred;
CallSubSV($ref);
CallSubSV(ຍ່ອຍ {ພິມ "ສະບາຍດີຢູ່ທີ່ນັ້ນ\n" } );

ຂະນະທີ່ທ່ານສາມາດເບິ່ງ, call_sv ເຮັດໃຫ້ທ່ານມີຄວາມຍືດຫຍຸ່ນຫຼາຍກວ່າເກົ່າໃນວິທີທີ່ທ່ານສາມາດລະບຸ Perl ໄດ້
ປະຈຳຍ່ອຍ.

ທ່ານຄວນສັງເກດວ່າ, ຖ້າມັນຈໍາເປັນຕ້ອງເກັບຮັກສາ SV ("ຊື່" ໃນຕົວຢ່າງຂ້າງເທິງ).
ເຊິ່ງກົງກັບ routine ຍ່ອຍ Perl ເພື່ອໃຫ້ມັນສາມາດຖືກນໍາໃຊ້ຕໍ່ມາໃນໂຄງການ, ມັນ
ບໍ່ພຽງພໍພຽງແຕ່ເກັບຮັກສາສໍາເນົາຕົວຊີ້ໄປຫາ SV. ເວົ້າວ່າລະຫັດຂ້າງເທິງເຄີຍເປັນຄື
ນີ້:

static SV * RememberSub;

void
SaveSub1(ຊື່)
SV * ຊື່
ລະຫັດ:
RememberSub = ຊື່;

void
CallSavedSub1()
ລະຫັດ:
PUSHMARK(SP);
call_sv(rememberSub, G_DISCARD|G_NOARGS);

ເຫດຜົນນີ້ແມ່ນຜິດພາດແມ່ນວ່າ, ເມື່ອເວລາທີ່ທ່ານມາໃຊ້ຕົວຊີ້ "rememberSub" ໃນ
"CallSavedSub1", ມັນອາດຈະຫຼືອາດຈະບໍ່ຍັງຫມາຍເຖິງການຍ່ອຍ Perl ທີ່ຖືກບັນທຶກໄວ້ໃນ
"SaveSub1". ນີ້ແມ່ນຄວາມຈິງໂດຍສະເພາະສໍາລັບກໍລະນີເຫຼົ່ານີ້:

SaveSub1(\&fred);
CallSavedSub1();

SaveSub1( ຍ່ອຍ {ພິມ "ສະບາຍດີຢູ່ທີ່ນັ້ນ\n" } );
CallSavedSub1();

ເມື່ອແຕ່ລະຄໍາຖະແຫຼງການ "SaveSub1" ຂ້າງເທິງໄດ້ຖືກປະຕິບັດ, SV*s ທີ່
ທີ່ສອດຄ້ອງກັນກັບພາລາມິເຕີຈະບໍ່ມີຕໍ່ໄປອີກແລ້ວ. ຄາດວ່າຈະມີຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດຈາກ Perl of
ແບບຟອມ

ບໍ່​ສາ​ມາດ​ນໍາ​ໃຊ້​ຄ່າ​ທີ່​ບໍ່​ໄດ້​ກໍາ​ນົດ​ເປັນ​ການ​ອ້າງ​ອີງ​ລະ​ບົບ​ຍ່ອຍ​ທີ່ ...

ສໍາລັບແຕ່ລະສາຍ "CallSavedSub1".

ເຊັ່ນດຽວກັນ, ມີລະຫັດນີ້

$ref = \&fred;
SaveSub1($ref);
$ref = 47;
CallSavedSub1();

ທ່ານສາມາດຄາດຫວັງວ່າຫນຶ່ງໃນຂໍ້ຄວາມເຫຼົ່ານີ້ (ທີ່ທ່ານໄດ້ຮັບຕົວຈິງແມ່ນຂຶ້ນກັບສະບັບ
ຂອງ Perl ທີ່​ທ່ານ​ກໍາ​ລັງ​ໃຊ້​)

ບໍ່ແມ່ນການອ້າງອີງ CODE ຢູ່...
routine ຍ່ອຍທີ່ບໍ່ໄດ້ກໍານົດ &main::47 ເອີ້ນວ່າ ...

ຕົວແປ $ref ອາດຈະໄດ້ອ້າງອີງເຖິງ subroutine "fred" ທຸກຄັ້ງທີ່ໂທຫາ
"SaveSub1" ຖືກສ້າງຂື້ນແຕ່ເມື່ອ "CallSavedSub1" ຖືກເອີ້ນວ່າມັນປະຈຸບັນຖືຕົວເລກ.
47. ເນື່ອງຈາກວ່າພວກເຮົາບັນທຶກພຽງແຕ່ຕົວຊີ້ໄປຫາ SV ຕົ້ນສະບັບໃນ "SaveSub1", ການປ່ຽນແປງໃດໆຕໍ່ກັບ $ref.
ຈະຖືກຕິດຕາມໂດຍຕົວຊີ້ "rememberSub". ນີ້ຫມາຍຄວາມວ່າທຸກຄັ້ງ "CallSavedSub1"
ຖືກເອີ້ນ, ມັນຈະພະຍາຍາມປະຕິບັດລະຫັດທີ່ອ້າງອີງໂດຍ SV*
"rememberSub". ໃນກໍລະນີນີ້, ເຖິງແມ່ນວ່າມັນຫມາຍເຖິງຈໍານວນເຕັມ 47, ດັ່ງນັ້ນຄາດວ່າ Perl ຈະ
ຈົ່ມດັງໆ.

ບັນຫາທີ່ຄ້າຍຄືກັນແຕ່ລະອຽດກວ່າແມ່ນສະແດງດ້ວຍລະຫັດນີ້:

$ref = \&fred;
SaveSub1($ref);
$ref = \&joe;
CallSavedSub1();

ເວລານີ້ທຸກຄັ້ງທີ່ "CallSavedSub1" ຖືກເອີ້ນວ່າມັນຈະດໍາເນີນການ Perl subroutine "joe"
(ສົມມຸດວ່າມັນມີຢູ່) ແທນທີ່ຈະເປັນ "fred" ຕາມການຮ້ອງຂໍໃນເບື້ອງຕົ້ນໃນການໂທຫາ
"SaveSub1".

ເພື່ອແກ້ໄຂບັນຫາເຫຼົ່ານີ້, ມັນຈໍາເປັນຕ້ອງໄດ້ສໍາເນົາສະບັບເຕັມຂອງ SV. ລະຫັດ
ຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນ "SaveSub2" ດັດແກ້ເພື່ອເຮັດແນວນັ້ນ.

static SV * keepSub = (SV*)NULL;

void
SaveSub2(ຊື່)
SV * ຊື່
ລະຫັດ:
/* ເອົາສຳເນົາຂອງການໂທກັບ */
ຖ້າ (keepSub == (SV*)NULL)
/* ຄັ້ງທຳອິດ, ສະນັ້ນສ້າງ SV ໃໝ່ */
keepSub = newSVsv(ຊື່);
ອື່ນ
/* ເຄີຍຢູ່ນີ້ກ່ອນ, ສະນັ້ນຂຽນທັບ */
SvSetSV(keepSub, ຊື່);

void
CallSavedSub2()
ລະຫັດ:
PUSHMARK(SP);
call_sv(keepSub, G_DISCARD|G_NOARGS);

ເພື່ອຫຼີກເວັ້ນການສ້າງ SV ໃຫມ່ທຸກຄັ້ງ "SaveSub2" ຖືກເອີ້ນ, ຟັງຊັນທໍາອິດກວດເບິ່ງ
ເບິ່ງວ່າມັນໄດ້ຖືກເອີ້ນກ່ອນ. ຖ້າບໍ່, ຫຼັງຈາກນັ້ນ, ພື້ນທີ່ສໍາລັບ SV ໃຫມ່ແມ່ນຈັດສັນແລະ
ການອ້າງອິງເຖິງ Perl subroutine "ຊື່" ຖືກຄັດລອກໄປຫາຕົວແປ "keepSub" ໃນຫນຶ່ງ.
ການດໍາເນີນງານໂດຍໃຊ້ "newSVsv". ຫຼັງຈາກນັ້ນ, ທຸກຄັ້ງທີ່ "SaveSub2" ຖືກເອີ້ນ, SV ທີ່ມີຢູ່ແລ້ວ,
"keepSub", ຖືກຂຽນທັບດ້ວຍຄ່າໃຫມ່ໂດຍໃຊ້ "SvSetSV".

ການນໍາໃຊ້ call_argv
ນີ້ແມ່ນລາຍການຍ່ອຍ Perl ທີ່ພິມພາລາມິເຕີໃດກໍ່ຕາມທີ່ຖືກສົ່ງໄປຫາມັນ.

ລາຍຊື່ພິມຍ່ອຍ
{
my(@list) = @_;

foreach (@list) { ພິມ "$_\n" }
}

ແລະນີ້ແມ່ນຕົວຢ່າງຂອງ call_argv ເຊິ່ງຈະໂທຫາ ລາຍຊື່ພິມ.

static char * words[] = {"alpha", "beta", "gamma", "delta", NULL};

void static
call_PrintList()
{
dSP;

call_argv("PrintList", G_DISCARD, ຄໍາ);
}

ໃຫ້ສັງເກດວ່າມັນບໍ່ຈໍາເປັນທີ່ຈະໂທຫາ "PUSHMARK" ໃນກໍລະນີນີ້. ນີ້​ແມ່ນ​ຍ້ອນ​ວ່າ
call_argv ຈະເຮັດແນວໃດມັນສໍາລັບທ່ານ.

ການນໍາໃຊ້ call_method
ພິຈາລະນາລະຫັດ Perl ຕໍ່ໄປນີ້:

{
package ລະເບີດຝັງດິນ;

ຍ່ອຍໃຫມ່
{
my($type) = shift;
ອວຍພອນ [@_]
}

ການສະແດງຍ່ອຍ
{
ຂອງຂ້ອຍ ($self, $index) = @_;
ພິມ "$index: $$self[$index]\n";
}

sub PrintID
{
my($class) = @_;
ພິມ "ນີ້ແມ່ນ Class $class version 1.0\n";
}
}

ມັນປະຕິບັດພຽງແຕ່ຫ້ອງຮຽນທີ່ງ່າຍດາຍຫຼາຍໃນການຄຸ້ມຄອງ array. ນອກຈາກຜູ້ກໍ່ສ້າງ,
"ໃຫມ່", ມັນປະກາດວິທີການ, ຫນຶ່ງ static ແລະຫນຶ່ງ virtual. ວິທີການຄົງທີ່, "PrintID",
ພິມອອກພຽງແຕ່ຊື່ຊັ້ນຮຽນແລະຕົວເລກສະບັບ. ວິທີການ virtual, "ສະແດງ",
ພິມອອກອົງປະກອບດຽວຂອງອາເຣ. ນີ້ແມ່ນຕົວຢ່າງ All-Perl ຂອງການໃຊ້ມັນ.

$a = mine->new('ສີແດງ', 'ສີຂຽວ', 'ສີຟ້າ');
$a->ການສະແດງ(1)
mine->PrintID;

ຈະພິມ

1: ສີຂຽວ
ນີ້ແມ່ນ Class Mine ລຸ້ນ 1.0

ການໂທຫາວິທີການ Perl ຈາກ C ແມ່ນກົງໄປກົງມາ. ສິ່ງຕໍ່ໄປນີ້ແມ່ນຕ້ອງການ:

· ການອ້າງອີງເຖິງວັດຖຸສໍາລັບວິທີການ virtual ຫຼືຊື່ຂອງຫ້ອງຮຽນສໍາລັບ static
ວິທີການ

·ຊື່ຂອງວິທີການ

· ຕົວກໍານົດການອື່ນໆສະເພາະກັບວິທີການ

ນີ້ແມ່ນ XSUB ງ່າຍໆທີ່ສະແດງໃຫ້ເຫັນເຖິງກົນໄກການໂທຫາທັງ "PrintID" ແລະ
ວິທີການ "ສະແດງ" ຈາກ C.

void
call_Method(ອ້າງອີງ, ວິທີການ, ດັດຊະນີ)
SV * ອ້າງອີງ
char * ວິທີການ
ດັດຊະນີ int
ລະຫັດ:
PUSHMARK(SP);
XPUSHs(ອ້າງອີງ);
XPUSHs(sv_2mortal(newSViv(index)));
PUTBACK;

call_method(ວິທີການ, G_DISCARD);

void
call_PrintID(ຊັ້ນ, ວິທີການ)
char * ຫ້ອງຮຽນ
char * ວິທີການ
ລະຫັດ:
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(ຊັ້ນ, 0)));
PUTBACK;

call_method(ວິທີການ, G_DISCARD);

ດັ່ງນັ້ນວິທີການ "PrintID" ແລະ "ການສະແດງ" ສາມາດຖືກເອີ້ນເຊັ່ນນີ້:

$a = mine->new('ສີແດງ', 'ສີຂຽວ', 'ສີຟ້າ');
call_Method($a, 'ສະແດງ', 1);
call_PrintID('Mine', 'PrintID');

ສິ່ງດຽວທີ່ຄວນສັງເກດແມ່ນວ່າ, ໃນທັງວິທີການ static ແລະ virtual, ຊື່ວິທີການແມ່ນ
ບໍ່ຜ່ານ stack - ມັນຖືກນໍາໃຊ້ເປັນພາລາມິເຕີທໍາອິດທີ່ຈະ call_method.

ການນໍາໃຊ້ GIMME_V
ນີ້ແມ່ນ XSUB ເລັກນ້ອຍທີ່ພິມບໍລິບົດທີ່ມັນກໍາລັງປະຕິບັດຢູ່.

void
PrintContext()
ລະຫັດ:
I32 gimme = GIMME_V;
ຖ້າ (gimme == G_VOID)
printf ("ເນື້ອໃນເປັນໂມຄະ\n");
ອື່ນຖ້າ (gimme == G_SCALAR)
printf ("ເນື້ອໃນແມ່ນ Scalar\n");
ອື່ນ
printf ("ບໍລິບົດແມ່ນ Array\n");

ແລະນີ້ແມ່ນ Perl ບາງຢ່າງທີ່ຈະທົດສອບມັນ.

PrintContext;
$a = PrintContext;
@a = PrintContext;

ຜົນໄດ້ຮັບຈາກນັ້ນຈະເປັນ

ບໍລິບົດແມ່ນ Void
ບໍລິບົດແມ່ນ Scalar
ບໍລິບົດແມ່ນ Array

ການນໍາໃຊ້ Perl to ຖິ້ມ of ຊົ່ວຄາວ
ໃນຕົວຢ່າງທີ່ໃຫ້ມາເຖິງປະຈຸບັນ, ຊົ່ວຄາວທີ່ສ້າງຂຶ້ນໃນການໂທກັບຄືນ (ie, ພາລາມິເຕີ
ຜ່ານ stack ໄດ້ ໂທ_* function ຫຼືຄ່າສົ່ງຄືນຜ່ານ stack) ໄດ້
ປົດປ່ອຍໂດຍຫນຶ່ງໃນວິທີການເຫຼົ່ານີ້:

· ການລະບຸທຸງ G_DISCARD ກັບ ໂທ_*

· ການໃຊ້ການຈັບຄູ່ "ENTER"/"SAVETMPS"--"FREETMPS"/"LEAVE" ຢ່າງຊັດເຈນ

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

ENTER;
SAVETMPS;
...
FREETMPS;
ອອກຈາກ;

ລໍາດັບໃນການເອີ້ນຄືນ (ແລະບໍ່ແມ່ນ, ແນ່ນອນ, ການລະບຸທຸງ G_DISCARD).

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

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

ໃນຕົວຢ່າງທໍາອິດ, ຕົວຈັດການຄວາມຜິດພາດ, ການໄຫຼເຂົ້າຂອງການຄວບຄຸມສາມາດເປັນດັ່ງຕໍ່ໄປນີ້. ເຈົ້າ​ມີ
ສ້າງການໂຕ້ຕອບກັບຫ້ອງສະຫມຸດພາຍນອກ. ການຄວບຄຸມສາມາດບັນລຸຫ້ອງສະຫມຸດພາຍນອກເຊັ່ນ
ນີ້

perl --> XSUB --> ຫ້ອງສະໝຸດພາຍນອກ

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

perl --> XSUB --> ຫ້ອງສະໝຸດພາຍນອກ
...
ຄວາມ​ຜິດ​ພາດ​ເກີດ​ຂຶ້ນ​
...
ຫ້ອງສະໝຸດພາຍນອກ --> call_* --> perl
|
perl <-- XSUB <-- ຫ້ອງສະໝຸດພາຍນອກ <-- call_* <----+

ຫຼັງ​ຈາກ​ການ​ປຸງ​ແຕ່ງ​ຄວາມ​ຜິດ​ພາດ​ການ​ນໍາ​ໃຊ້​ ໂທ_* ສໍາເລັດແລ້ວ, ການຄວບຄຸມ reverts ກັບຄືນໄປບ່ອນ Perl ຫຼາຍ
ຫຼືຫນ້ອຍລົງທັນທີ.

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

ໃນຕົວຢ່າງທີສອງ, ໂຄງການຂັບເຄື່ອນເຫດການ, ການໄຫຼເຂົ້າຂອງການຄວບຄຸມຈະເປັນແບບນີ້

perl --> XSUB --> ຕົວຈັດການເຫດການ
...
ຕົວຈັດການເຫດການ --> call_* --> perl
|
ຕົວຈັດການເຫດການ <-- call_* <----+
...
ຕົວຈັດການເຫດການ --> call_* --> perl
|
ຕົວຈັດການເຫດການ <-- call_* <----+
...
ຕົວຈັດການເຫດການ --> call_* --> perl
|
ຕົວຈັດການເຫດການ <-- call_* <----+

ໃນກໍລະນີນີ້, ການໄຫຼຂອງການຄວບຄຸມສາມາດປະກອບດ້ວຍພຽງແຕ່ລໍາດັບຊ້ໍາຊ້ອນ

ຕົວຈັດການເຫດການ --> call_* --> perl

ສໍາລັບການປະຕິບັດໄລຍະເວລາທີ່ສົມບູນຂອງໂຄງການ. ນີ້ຫມາຍຄວາມວ່າການຄວບຄຸມອາດຈະ ບໍ່ເຄີຍ
ກັບຄືນໄປຫາຂອບເຂດອ້ອມຂ້າງໃນ Perl ຢູ່ເບື້ອງຊ້າຍທີ່ສຸດ.

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

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

ແຜນຍຸດທະສາດ ສໍາລັບການ ເກັບຮັກສາໄວ້ ໂທ Context ຂໍ້ມູນຂ່າວສານ
ອາດຈະເປັນຫນຶ່ງໃນບັນຫາ trickiest ທີ່ຈະເອົາຊະນະໃນເວລາທີ່ການອອກແບບການໂຕ້ຕອບການໂທກັບຄືນໄປບ່ອນ
ສາມາດຊອກຫາວິທີການເກັບຮັກສາແຜນທີ່ລະຫວ່າງຟັງຊັນ C callback ແລະ Perl
ທຽບເທົ່າ.

ເພື່ອຊ່ວຍໃຫ້ເຂົ້າໃຈວ່າເປັນຫຍັງອັນນີ້ອາດຈະເປັນບັນຫາທີ່ແທ້ຈິງທໍາອິດໃຫ້ພິຈາລະນາວິທີການໂທຫາກັບຄືນໄປບ່ອນ
ໃນ​ສະ​ພາບ​ແວດ​ລ້ອມ C ທັງ​ຫມົດ​. ໂດຍປົກກະຕິ C API ຈະໃຫ້ຟັງຊັນເພື່ອລົງທະບຽນ a
ໂທ​ກັບ. ນີ້ຈະຄາດຫວັງວ່າຕົວຊີ້ໄປຫາຫນ້າທີ່ເປັນຫນຶ່ງໃນຕົວກໍານົດການຂອງມັນ. ຂ້າງລຸ່ມນີ້ແມ່ນ a
ໂທຫາຫນ້າທີ່ສົມມຸດຕິຖານ "register_fatal" ເຊິ່ງລົງທະບຽນຟັງຊັນ C ທີ່ຈະໄດ້ຮັບ
ເອີ້ນວ່າເມື່ອມີຄວາມຜິດພາດຮ້າຍແຮງເກີດຂຶ້ນ.

register_fatal(cb1);

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

void static
cb1()
{
printf ("ຄວາມຜິດພາດຮ້າຍແຮງ\n");
ການທ່ອງທ່ຽວ(1)
}

ຕອນນີ້ປ່ຽນອັນນັ້ນໄປເອີ້ນເປັນລາຍການຍ່ອຍ Perl ແທນ

static SV * callback = (SV*)NULL;

void static
cb1()
{
dSP;

PUSHMARK(SP);

/* ໂທ​ຫາ Perl sub ເພື່ອ​ປຸງ​ແຕ່ງ​ການ​ໂທ​ກັບ */
call_sv(callback, G_DISCARD);
}

void
register_fatal(fn)
SV * fn
ລະຫັດ:
/* ຈືຂໍ້ມູນການຍ່ອຍ Perl */
ຖ້າ (ໂທກັບ == (SV*)NULL)
callback = newSVsv(fn);
ອື່ນ
SvSetSV(ໂທກັບ, fn);

/* ລົງ​ທະ​ບຽນ​ການ​ໂທ​ກັບ​ຫ້ອງ​ສະ​ຫມຸດ​ພາຍ​ນອກ */
register_fatal(cb1);

ບ່ອນທີ່ Perl ທຽບເທົ່າກັບ "register_fatal" ແລະການເອີ້ນຄືນທີ່ມັນລົງທະບຽນ, "pcb1", ອາດຈະ.
ເບິ່ງແບບນີ້

#ລົງທະບຽນຍ່ອຍ pcb1
register_fatal(\&pcb1);

ຍ່ອຍ pcb1
{
ຕາຍ "ຂ້ອຍກຳລັງຈະຕາຍ...\n";
}

ການສ້າງແຜນທີ່ລະຫວ່າງ C callback ແລະ Perl ທຽບເທົ່າຖືກເກັບໄວ້ທົ່ວໂລກ
ຕົວແປ "ໂທກັບ".

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

ເວົ້າຕົວຢ່າງວ່າທ່ານຕ້ອງການໂຕ້ຕອບກັບຫ້ອງສະຫມຸດທີ່ອະນຸຍາດໃຫ້ໄຟລ໌ asynchronous i/o. ໃນ
ກໍລະນີນີ້ທ່ານອາດຈະສາມາດລົງທະບຽນການໂທຫາກັບຄືນໄປບ່ອນທຸກຄັ້ງທີ່ດໍາເນີນການອ່ານສໍາເລັດ.
ເພື່ອເປັນປະໂຫຍດທີ່ພວກເຮົາຕ້ອງການທີ່ຈະສາມາດໂທຫາ subroutines Perl ແຍກຕ່າງຫາກສໍາລັບແຕ່ລະໄຟລ໌ທີ່
ຖືກເປີດ. ດັ່ງທີ່ມັນຢືນຢູ່, ຕົວຢ່າງຕົວຈັດການຄວາມຜິດພາດຂ້າງເທິງຈະບໍ່ພຽງພໍຍ້ອນວ່າມັນ
ອະ​ນຸ​ຍາດ​ໃຫ້​ມີ​ພຽງ​ແຕ່ callback ດຽວ​ທີ່​ຈະ​ກໍາ​ນົດ​ໄດ້​ທຸກ​ເວ​ລາ​. ສິ່ງທີ່ພວກເຮົາຕ້ອງການແມ່ນວິທີການ
ການເກັບຮັກສາແຜນທີ່ລະຫວ່າງໄຟລ໌ທີ່ເປີດແລະ Perl subroutine ທີ່ພວກເຮົາຕ້ອງການທີ່ຈະເອີ້ນວ່າ
ສໍາລັບໄຟລ໌ນັ້ນ.

ເວົ້າວ່າຫ້ອງສະຫມຸດ i/o ມີຟັງຊັນ "asynch_read" ເຊິ່ງເຊື່ອມໂຍງກັບຟັງຊັນ C
"ProcessRead" ກັບຕົວຈັດການໄຟລ໌ "fh"-- ນີ້ສົມມຸດວ່າມັນໄດ້ສະຫນອງການປົກກະຕິບາງຢ່າງ.
ເພື່ອ​ເປີດ​ໄຟລ​໌​ແລະ​ສະ​ນັ້ນ​ໄດ້​ຮັບ​ການ​ຈັບ​ໄຟລ​໌​.

asynch_read(fh, ProcessRead)

ນີ້​ອາດ​ຈະ​ຄາດ​ວ່າ​ຈະ C ProcessRead ຫນ້າທີ່ຂອງແບບຟອມນີ້

void
ProcessRead(fh, buffer)
int fh;
char * buffer;
{
...
}

ເພື່ອສະຫນອງການໂຕ້ຕອບ Perl ໃຫ້ກັບຫ້ອງສະຫມຸດນີ້, ພວກເຮົາຈໍາເປັນຕ້ອງສາມາດສ້າງແຜນທີ່ລະຫວ່າງ "fh" ໄດ້.
ພາລາມິເຕີແລະ perl subroutine ທີ່ພວກເຮົາຕ້ອງການເອີ້ນວ່າ. A hash ເປັນກົນໄກທີ່ສະດວກສໍາລັບ
ການເກັບຮັກສາແຜນທີ່ນີ້. ລະຫັດຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນເຖິງການປະຕິບັດທີ່ເປັນໄປໄດ້

static HV * Mapping = (HV*)NULL;

void
asynch_read(fh, callback)
int fh
SV * ໂທກັບ
ລະຫັດ:
/* ຖ້າ hash ບໍ່ມີຢູ່ແລ້ວ, ສ້າງມັນ */
ຖ້າ (ແຜນທີ່ == (HV*)NULL)
ແຜນທີ່ = newHV();

/* ບັນທຶກ fh -> callback mapping */
hv_store(mapping, (char*)&fh, sizeof(fh), newSVsv(callback), 0);

/* ລົງ​ທະ​ບຽນ​ກັບ C Library */
asynch_read(fh, asynch_read_if);

ແລະ "asynch_read_if" ສາມາດມີລັກສະນະນີ້

void static
asynch_read_if(fh, buffer)
int fh;
char * buffer;
{
dSP;
SV** sv;

/* ຮັບ​ການ​ໂທ​ກັບ​ຄືນ​ທີ່​ກ່ຽວ​ຂ້ອງ​ກັບ fh */
sv = hv_fetch(ແຜນທີ່, (char*)&fh , sizeof(fh), FALSE);
ຖ້າ (sv == (SV**)NULL)
croak("ຄວາມຜິດພາດພາຍໃນ...\n");

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(fh)));
XPUSHs(sv_2mortal(newSVpv(buffer, 0)));
PUTBACK;

/* ໂທ​ຫາ Perl sub */
call_sv(*sv, G_DISCARD);
}

ເພື່ອຄວາມສົມບູນ, ນີ້ແມ່ນ "asynch_close". ນີ້ສະແດງໃຫ້ເຫັນວິທີການເອົາລາຍການອອກຈາກ
hash "ແຜນທີ່".

void
asynch_close(fh)
int fh
ລະຫັດ:
/* ເອົາ​ການ​ເຂົ້າ​ຈາກ hash */
(void) hv_delete(Mapping, (char*)&fh, sizeof(fh), G_DISCARD);

/* ດຽວນີ້ໂທຫາ asynch_close ທີ່ແທ້ຈິງ */
asynch_close(fh);

ດັ່ງນັ້ນການໂຕ້ຕອບ Perl ຈະເບິ່ງຄືວ່ານີ້

ໂທ​ກັບ​ຍ່ອຍ 1
{
my($handle, $buffer) = @_;
}

# ລົງທະບຽນການໂທຄືນ Perl
asynch_read($fh, \&callback1);

asynch_close($fh);

ການ​ສ້າງ​ແຜນ​ທີ່​ລະ​ຫວ່າງ C callback ແລະ Perl ຖືກ​ເກັບ​ຮັກ​ສາ​ໄວ້​ໃນ hash ທົ່ວ​ໂລກ "ການ​ສ້າງ​ແຜນ​ທີ່​" ນີ້​
ເວລາ. ການນໍາໃຊ້ hash ມີປະໂຫຍດທີ່ແຕກຕ່າງກັນທີ່ມັນອະນຸຍາດໃຫ້ຈໍານວນບໍ່ຈໍາກັດ
ໂທກັບຄືນທີ່ຈະລົງທະບຽນ.

ຈະເປັນແນວໃດຖ້າການໂຕ້ຕອບທີ່ສະຫນອງໂດຍ C callback ບໍ່ມີພາລາມິເຕີທີ່ອະນຸຍາດໃຫ້
ໄຟລ໌ຈັດການກັບ Perl subroutine mapping? ເວົ້າໃນແພັກເກັດ i/o asynchronous, the
ຟັງຊັນ callback ໄດ້ຮັບພຽງແຕ່ "buffer" ພາລາມິເຕີເຊັ່ນນີ້

void
ProcessRead(buffer)
char * buffer;
{
...
}

ຖ້າບໍ່ມີຕົວຈັດການໄຟລ໌ແມ່ນບໍ່ມີວິທີທາງກົງໄປກົງມາໃນແຜນທີ່ຈາກ C callback ກັບ the
Perl subroutine.

ໃນ​ກໍ​ລະ​ນີ​ນີ້​ວິ​ທີ​ທີ່​ເປັນ​ໄປ​ໄດ້​ປະ​ມານ​ບັນ​ຫາ​ນີ້​ແມ່ນ​ການ​ກໍາ​ນົດ​ໄວ້​ລ່ວງ​ຫນ້າ​ຊຸດ​ຂອງ C ຫນ້າ​ທີ່​ເປັນ​
ປະຕິບັດເປັນການໂຕ້ຕອບກັບ Perl, ດັ່ງນັ້ນ

#ກຳນົດ MAX_CB 3
#define NULL_HANDLE -1
typedef void (*FnMap)();

ໂຄງສ້າງແຜນທີ່ {
ຟັງຊັນ FnMap;
SV * PerlSub;
int Handle;
};

static void fn1();
static void fn2();
static void fn3();

static struct MapStruct Map [MAX_CB] =
{
{ fn1, NULL, NULL_HANDLE },
{ fn2, NULL, NULL_HANDLE },
{ fn3, NULL, NULL_HANDLE }
};

void static
Pcb(ດັດຊະນີ, buffer)
int ດັດຊະນີ;
char * buffer;
{
dSP;

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(buffer, 0)));
PUTBACK;

/* ໂທ​ຫາ Perl sub */
call_sv(ແຜນທີ່[index].PerlSub, G_DISCARD);
}

void static
fn1(buffer)
char * buffer;
{
Pcb(0, buffer);
}

void static
fn2(buffer)
char * buffer;
{
Pcb(1, buffer);
}

void static
fn3(buffer)
char * buffer;
{
Pcb(2, buffer);
}

void
array_asynch_read(fh, callback)
int fh
SV * ໂທກັບ
ລະຫັດ:
int ດັດຊະນີ;
int null_index = MAX_CB;

/* ຊອກ​ຫາ​ຕົວ​ຈັບ​ດຽວ​ກັນ​ຫຼື​ການ​ເຂົ້າ​ເປົ່າ */
ສໍາລັບ (index = 0; index < MAX_CB; ++index)
{
ຖ້າ (ແຜນທີ່[index]. ຈັດການ == fh)
ທໍາລາຍ;

ຖ້າ (ແຜນທີ່[index].ຈັດການ == NULL_HANDLE)
null_index = ດັດຊະນີ;
}

ຖ້າ (ດັດຊະນີ == MAX_CB && null_index == MAX_CB)
croak ("ການລົງທະບຽນຟັງຊັນໂທກັບຫຼາຍເກີນໄປ\n");

ຖ້າ (ດັດຊະນີ == MAX_CB)
index = null_index;

/* ບັນ​ທຶກ​ໄຟລ​໌ handle */
ແຜນທີ່[index].Handle = fh;

/* ຈືຂໍ້ມູນການຍ່ອຍ Perl */
ຖ້າ (ແຜນທີ່[index].PerlSub == (SV*)NULL)
ແຜນທີ່[index].PerlSub = newSVsv(callback);
ອື່ນ
SvSetSV(ແຜນທີ່[index].PerlSub, callback);

asynch_read(fh, ແຜນທີ່[index].Function);

void
array_asynch_close(fh)
int fh
ລະຫັດ:
int ດັດຊະນີ;

/* ຊອກຫາຕົວຈັບໄຟລ໌ */
ສໍາລັບ (index = 0; index < MAX_CB; ++ index)
ຖ້າ (ແຜນທີ່[index]. ຈັດການ == fh)
ທໍາລາຍ;

ຖ້າ (ດັດຊະນີ == MAX_CB)
croak ("ບໍ່ສາມາດປິດ fh %d\n", fh);

ແຜນທີ່[index].ຈັດການ = NULL_HANDLE;
SvREFCNT_dec(ແຜນທີ່[index].PerlSub);
ແຜນທີ່[index].PerlSub = (SV*)NULL;

asynch_close(fh);

ໃນກໍລະນີນີ້, ຫນ້າທີ່ "fn1", "fn2", ແລະ "fn3" ຖືກນໍາໃຊ້ເພື່ອຈື່ຈໍາ Perl.
subroutine ທີ່ຈະເອີ້ນວ່າ. ແຕ່ລະຫນ້າທີ່ຖືດັດສະນີສາຍແຂງແຍກຕ່າງຫາກເຊິ່ງເປັນ
ໃຊ້ໃນຟັງຊັນ "Pcb" ເພື່ອເຂົ້າຫາ "ແຜນທີ່" array ແລະຕົວຈິງແລ້ວໂທຫາ Perl
ປະຈຳຍ່ອຍ.

ມີບາງຂໍ້ເສຍທີ່ຊັດເຈນກັບເຕັກນິກນີ້.

ກ່ອນອື່ນ ໝົດ, ລະຫັດແມ່ນສັບສົນຫຼາຍກ່ວາຕົວຢ່າງກ່ອນ ໜ້າ ນີ້.

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

ເພື່ອສະຫຼຸບ, ນີ້ແມ່ນວິທີການທີ່ເປັນໄປໄດ້ຈໍານວນຫນຶ່ງສໍາລັບທ່ານທີ່ຈະພິຈາລະນາສໍາລັບການເກັບຮັກສາ
ແຜນທີ່ລະຫວ່າງ C ແລະ Perl callback

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

2. ສ້າງລໍາດັບຂອງ callbacks - hard wired limit
ຖ້າຫາກວ່າມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະບອກຈາກຕົວກໍານົດການທີ່ຜ່ານກັບຄືນໄປບ່ອນ C callback ແມ່ນຫຍັງ
ສະພາບການແມ່ນ, ຫຼັງຈາກນັ້ນທ່ານອາດຈະຕ້ອງສ້າງລໍາດັບຂອງການໂຕ້ຕອບ C callback
ຟັງຊັນ, ແລະເກັບຕົວຊີ້ໄປຫາແຕ່ລະອັນໃນອາເຣ.

3. ໃຊ້ຕົວກໍານົດການເພື່ອແຜນທີ່ກັບການໂທກັບຄືນໄປບ່ອນ Perl
A hash ເປັນກົນໄກທີ່ເຫມາະສົມທີ່ຈະເກັບຮັກສາແຜນທີ່ລະຫວ່າງ C ແລະ Perl.

ທາງເລືອກ Stack ການຈັດການ
ເຖິງແມ່ນວ່າຂ້ອຍໄດ້ໃຊ້ພຽງແຕ່ "POP*" macros ເພື່ອເຂົ້າເຖິງຄ່າທີ່ສົ່ງຄືນມາຈາກ Perl
subroutines, ມັນເປັນໄປໄດ້ທີ່ຈະ bypass macro ເຫຼົ່ານີ້ແລະອ່ານ stack ໂດຍໃຊ້ "ST"
macro (ເບິ່ງ perlxs ສໍາລັບລາຍລະອຽດເຕັມຂອງ "ST" macro).

ສ່ວນໃຫຍ່ຂອງເວລາ macro "POP*" ຄວນຈະພຽງພໍ; ບັນຫາຕົ້ນຕໍກັບພວກເຂົາແມ່ນວ່າ
ພວກມັນບັງຄັບໃຫ້ທ່ານປະມວນຜົນຄ່າທີ່ສົ່ງມາຕາມລຳດັບ. ນີ້ອາດຈະບໍ່ແມ່ນຫຼາຍທີ່ສຸດ
ວິທີທີ່ເຫມາະສົມໃນການປຸງແຕ່ງຄຸນຄ່າໃນບາງກໍລະນີ. ສິ່ງທີ່ພວກເຮົາຕ້ອງການແມ່ນເພື່ອສາມາດເຂົ້າເຖິງໄດ້
stack ໃນຄໍາສັ່ງສຸ່ມ. ມະຫາພາກ "ST" ທີ່ໃຊ້ໃນເວລາທີ່ຂຽນລະຫັດ XSUB ແມ່ນເຫມາະສົມສໍາລັບສິ່ງນີ້
ຈຸດປະສົງ.

ລະຫັດຂ້າງລຸ່ມນີ້ແມ່ນຕົວຢ່າງທີ່ໃຫ້ຢູ່ໃນພາກ ກັບມາ a ບັນ​ຊີ​ລາຍ​ຊື່ of ມູນຄ່າ recoded ເປັນ
ໃຊ້ "ST" ແທນ "POP*".

void static
call_AddSubtract2(a, b)
int a;
int b;
{
dSP;
I32 ຕັດທອນລາຍຈ່າຍ;
int ນັບ;

ENTER;
SAVETMPS;

PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK;

count = call_pv("AddSubtract", G_ARRAY);

SPAGAIN;
SP -= ນັບ;
ax = (SP - PL_stack_base) + 1;

ຖ້າ (ນັບ != 2)
croak("ບັນຫາໃຫຍ່\n");

printf("%d + %d = %d\n", a, b, SvIV(ST(0));
printf("%d - %d = %d\n", a, b, SvIV(ST(1));

PUTBACK;
FREETMPS;
ອອກຈາກ;
}

ອ່ືນ

1. ສັງເກດເຫັນວ່າມັນຈໍາເປັນຕ້ອງກໍານົດຕົວແປ "ຂວານ". ນີ້ແມ່ນຍ້ອນວ່າ "ST"
ມະຫາພາກຄາດວ່າມັນມີຢູ່. ຖ້າພວກເຮົາຢູ່ໃນ XSUB ມັນບໍ່ຈໍາເປັນທີ່ຈະກໍານົດ
"ຂວານ" ຍ້ອນວ່າມັນຖືກກໍານົດໄວ້ແລ້ວສໍາລັບພວກເຮົາ.

2. ລະຫັດ

SPAGAIN;
SP -= ນັບ;
ax = (SP - PL_stack_base) + 1;

ຕັ້ງ stack ຂຶ້ນເພື່ອໃຫ້ພວກເຮົາສາມາດໃຊ້ "ST" macro.

3. ບໍ່ເຫມືອນກັບລະຫັດຕົ້ນສະບັບຂອງຕົວຢ່າງນີ້, ຄ່າທີ່ສົ່ງຄືນບໍ່ໄດ້ເຂົ້າເຖິງ
ຄໍາສັ່ງປີ້ນກັບກັນ. ດັ່ງນັ້ນ ST(0) ຫມາຍເຖິງຄ່າທໍາອິດທີ່ສົ່ງຄືນໂດຍ Perl subroutine
ແລະ "ST(count-1)" ຫມາຍເຖິງອັນສຸດທ້າຍ.

ການສ້າງ ແລະ ການໂທ an Anonymous ເສັ້ນທາງຍ່ອຍ in C
ດັ່ງທີ່ພວກເຮົາໄດ້ສະແດງແລ້ວ, "call_sv" ສາມາດຖືກໃຊ້ເພື່ອເອີ້ນກິດຈະວັດຍ່ອຍທີ່ບໍ່ເປີດເຜີຍຊື່. ແນວໃດກໍ່ຕາມ,
ຕົວຢ່າງຂອງພວກເຮົາສະແດງໃຫ້ເຫັນສະຄິບ Perl ທີ່ເອີ້ນ XSUB ເພື່ອປະຕິບັດການນີ້. ໃຫ້ເຮົາເບິ່ງ
ມັນສາມາດເຮັດໄດ້ແນວໃດພາຍໃນລະຫັດ C ຂອງພວກເຮົາ:

...

SV *cvrv = eval_pv("sub { ພິມ 'ທ່ານຈະບໍ່ພົບຂ້ອຍ cluttering namespace ໃດ!' }", TRUE);

...

call_sv(cvrv, G_VOID|G_NOARGS);

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

ແສງສະຫວ່າງ ການໂທກັບ

ບາງຄັ້ງເຈົ້າຕ້ອງເອີ້ນກິດຈະວັດຍ່ອຍດຽວກັນຊ້ຳໆ. ນີ້ມັກຈະເກີດຂຶ້ນກັບ a
ຟັງຊັນທີ່ປະຕິບັດໃນບັນຊີລາຍຊື່ຂອງຄ່າ, ເຊັ່ນ Perl's built-in ຄັດ (). ທ່ານສາມາດຜ່ານ a
ຟັງຊັນປຽບທຽບກັບ ຄັດ (), ເຊິ່ງຫຼັງຈາກນັ້ນຈະຖືກເອີ້ນສໍາລັບທຸກໆຄູ່ຂອງມູນຄ່າທີ່
ຈໍາເປັນຕ້ອງໄດ້ປຽບທຽບ. ໄດ້ ທຳອິດ() ແລະ ຫຼຸດ() ຟັງຊັນຈາກລາຍການ::Util ປະຕິບັດຕາມຄ້າຍຄືກັນ
ຮູບແບບ.

ໃນ​ກໍ​ລະ​ນີ​ນີ້​ມັນ​ເປັນ​ໄປ​ໄດ້​ທີ່​ຈະ​ເລັ່ງ​ການ​ປົກ​ກະ​ຕິ (ມັກ​ຈະ​ຂ້ອນ​ຂ້າງ​ຫຼາຍ​) ໂດຍ​ການ​ນໍາ​ໃຊ້​
API callback ນ້ຳໜັກເບົາ. ແນວຄວາມຄິດແມ່ນວ່າສະພາບການໂທຫາພຽງແຕ່ຕ້ອງການ
ສ້າງແລະທໍາລາຍຄັ້ງດຽວ, ແລະຍ່ອຍສາມາດເອີ້ນວ່າ arbitrarily ຫຼາຍຄັ້ງໃນລະຫວ່າງ.

ມັນເປັນເລື່ອງປົກກະຕິທີ່ຈະຜ່ານພາລາມິເຕີໂດຍໃຊ້ຕົວແປທົ່ວໂລກ (ໂດຍປົກກະຕິ $_ ສໍາລັບພາລາມິເຕີດຽວ, ຫຼື
$a ແລະ $b ສໍາລັບສອງພາລາມິເຕີ) ແທນທີ່ຈະຜ່ານ @_. (ມັນເປັນໄປໄດ້ທີ່ຈະໃຊ້ກົນໄກ @_
ຖ້າທ່ານຮູ້ວ່າທ່ານກໍາລັງເຮັດຫຍັງ, ເຖິງແມ່ນວ່າບໍ່ມີ API ທີ່ສະຫນັບສະຫນູນສໍາລັບມັນ. ມັນຍັງ
ໂດຍປົກກະຕິແມ່ນຊ້າລົງ.)

ຮູບແບບຂອງການໂທມະຫາພາກເປັນແບບນີ້:

dMULTICALL; /* ປະກາດຕົວແປທ້ອງຖິ່ນ */
I32 gimme = G_SCALAR; /* ບໍລິບົດຂອງການໂທ: G_SCALAR,
* G_ARRAY, ຫຼື G_VOID */

PUSH_MULTICALL(cv); /* ຕັ້ງຄ່າບໍລິບົດສໍາລັບການໂທຫາ cv,
ແລະກໍານົດ vars ທ້ອງຖິ່ນທີ່ເຫມາະສົມ */

/* ວົງ */ {
/* ກໍານົດຄ່າຂອງຕົວແປພາລາມິເຕີຂອງທ່ານ */
MULTICALL; /* ໂທ​ອອກ​ຕົວ​ຈິງ */
} /* ສິ້ນສຸດຂອງ loop */

POP_MULTICALL; /* ທຳລາຍບໍລິບົດການເອີ້ນ */

ສໍາ​ລັບ​ຕົວ​ຢ່າງ​ສີ​ມັງ​ບາງ​, ເບິ່ງ​ການ​ປະ​ຕິ​ບັດ​ຂອງ​ ທຳອິດ() ແລະ ຫຼຸດ() ຫນ້າທີ່
ຂອງບັນຊີລາຍຊື່::Util 1.18. ຢູ່ທີ່ນັ້ນທ່ານຍັງຈະພົບເຫັນໄຟລ໌ header ທີ່ເຮັດຕາມ multicall API
ໃນສະບັບເກົ່າຂອງ perl.

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