ຄາດຫວັງວ່າແມ່ນໂຄງການທີ່ເວົ້າເຖິງໂຄງການທີ່ມີການໂຕ້ຕອບອື່ນໆຕາມ script. ຄາດຫວັງວ່າຈະຮູ້ສິ່ງທີ່ສາມາດຄາດຫວັງຈາກໂຄງການແລະສິ່ງຕອບແທນທີ່ຖືກຕ້ອງ. ພາສາທີ່ແປພາສາໃຫ້ໂຄງສ້າງການຄວບຄຸມທີ່ແຕກຕ່າງກັນແລະລະດັບສູງເພື່ອຊີ້ນໍາກ່ອງໂຕ້ຕອບ. ນອກຈາກນັ້ນ, ຜູ້ໃຊ້ສາມາດຄວບຄຸມແລະໂຕ້ຕອບໂດຍກົງໃນເວລາທີ່ຕ້ອງການ, ຫຼັງຈາກນັ້ນກັບຄືນມາຄວບຄຸມກັບສະຄິບ.
Expectk ແມ່ນປະສົມຂອງ Expect ແລະ Tk. ມັນປະຕິບັດຕາມຄວາມຫວັງແລະຄວາມຫວັງຂອງ Tk. ຄາດວ່າຍັງສາມາດນໍາໃຊ້ໂດຍກົງໃນ C ຫຼື C ++ ໂດຍບໍ່ຕ້ອງ Tcl.
ຊື່ "ຄາດຫວັງ" ມາຈາກຄວາມຄິດຂອງການສົ່ງ / ຄາດວ່າລໍາດັບທີ່ນິຍົມໂດຍ uucp, kermit ແລະໂຄງການຄວບຄຸມໂມເດັມອື່ນໆ. ຢ່າງໃດກໍຕາມບໍ່ເຫມືອນກັບ uucp, Expect ແມ່ນທົ່ວໄປເພື່ອໃຫ້ມັນສາມາດດໍາເນີນການເປັນຄໍາສັ່ງລະດັບຜູ້ໃຊ້ທີ່ມີໂຄງການແລະວຽກງານໃດຫນຶ່ງທີ່ຢູ່ໃນໃຈ. ຄາດວ່າຈະສາມາດສົນທະນາກັບໂຄງການຕ່າງໆໃນເວລາດຽວກັນ.
ສິ່ງທີ່ຄາດວ່າຈະສາມາດເຮັດໄດ້
ຕົວຢ່າງ, ຕໍ່ໄປນີ້ແມ່ນສິ່ງທີ່ຄາດວ່າຈະສາມາດເຮັດໄດ້:
- ເຮັດໃຫ້ຄອມພິວເຕີຂອງທ່ານໂທຫາທ່ານກັບຄືນໄປບ່ອນ, ດັ່ງນັ້ນທ່ານສາມາດເຂົ້າໃຊ້ໄດ້ໂດຍບໍ່ຕ້ອງຈ່າຍຄ່າໂທ.
- ເລີ່ມຕົ້ນເກມແລະຖ້າການຕັ້ງຄ່າທີ່ດີທີ່ສຸດບໍ່ປາກົດ, ເລີ່ມການເຮັດວຽກມັນອີກຄັ້ງແລະອີກຄັ້ງ) ຈົນກວ່າມັນຈະເຮັດ, ແລະຫຼັງຈາກນັ້ນເອົາມືຄວບຄຸມໄປຫາທ່ານ.
- ດໍາເນີນການ fsck , ແລະຕອບຄໍາຖາມຂອງຕົນ, ຕອບ "yes" ຫຼື "no" ຫຼືໃຫ້ການຄວບຄຸມກັບທ່ານ, ອີງຕາມເງື່ອນໄຂທີ່ກໍານົດໄວ້ກ່ອນ.
- ເຊື່ອມຕໍ່ເຄືອຂ່າຍອື່ນແລະລວບລວມຈົດຫມາຍຂອງທ່ານໂດຍອັດຕະໂນມັດເພື່ອໃຫ້ມັນປາກົດວ່າມັນຖືກສົ່ງໄປຫາລະບົບທ້ອງຖິ່ນຂອງທ່ານ.
- ຕົວປ່ຽນແປງສະພາບແວດລ້ອມທີ່ມີປະສິດທິພາບ, ໄດເລກະທໍລີປະຈຸບັນ, ຫຼືຂໍ້ມູນໃດໆທີ່ຜ່ານ rlogin, telnet, tip, su , ຫຼື chgrp
ມີຫລາຍເຫດຜົນວ່າເປັນຫຍັງ ຫອຍ ບໍ່ສາມາດປະຕິບັດຫນ້າວຽກເຫຼົ່ານີ້ໄດ້. ທັງຫມົດແມ່ນມີຄວາມຄາດຫວັງ.
ໂດຍທົ່ວໄປ, ຄາດຫວັງວ່າມັນຈະເປັນປະໂຫຍດສໍາລັບການດໍາເນີນໂຄງການທີ່ຕ້ອງການການພົວພັນລະຫວ່າງໂຄງການກັບຜູ້ໃຊ້. ສິ່ງທີ່ຈໍາເປັນທັງຫມົດແມ່ນວ່າການໂຕ້ຕອບສາມາດຖືກກໍານົດໂດຍໂຄງການ. ຄາດວ່າຍັງສາມາດໃຫ້ການຄວບຄຸມກັບຜູ້ໃຊ້ໂດຍບໍ່ຕ້ອງຢຸດການຄວບຄຸມໂຄງການ. ເຊັ່ນດຽວກັນ, ຜູ້ໃຊ້ສາມາດສົ່ງຄືນການຄວບຄຸມໄປສະຄິບໄດ້ທຸກເວລາ.
ການນໍາໃຊ້
ຄາດວ່າຈະອ່ານ cmdfile ສໍາລັບບັນຊີລາຍຊື່ຂອງຄໍາສັ່ງທີ່ຈະປະຕິບັດ. ຄາດວ່າອາດຈະຖືກເອີ້ນໂດຍກົງກ່ຽວກັບລະບົບທີ່ສະຫນັບສະຫນູນ #! ຫມາຍໂດຍການຫມາຍອັກສອນເປັນຕົວປະຕິບັດແລະເຮັດໃຫ້ເສັ້ນທໍາອິດໃນສະຄິບ:
#! / usr / local / bin / expect-fແນ່ນອນ, ເສັ້ນທາງຕ້ອງໄດ້ອະທິບາຍຢ່າງຖືກຕ້ອງທີ່ຄາດຫວັງວ່າຊີວິດ. / usr / local / bin ແມ່ນພຽງແຕ່ເປັນຕົວຢ່າງ.
ທຸງ -c prefaces ຄໍາສັ່ງທີ່ຈະຖືກປະຕິບັດກ່ອນທີ່ຈະຢູ່ໃນສະຄິບ. ຄໍາສັ່ງດັ່ງກ່າວຄວນຈະຖືກກ່າວເຖິງເພື່ອປ້ອງກັນບໍ່ໃຫ້ຖືກແຍກອອກຈາກແກະ. ຕົວເລືອກນີ້ອາດຈະໃຊ້ຫຼາຍຄັ້ງ. ຄໍາສັ່ງຫຼາຍອາດຈະຖືກປະຕິບັດດ້ວຍ single -c ໂດຍແຍກຂໍ້ມູນໃຫ້ພວກເຂົາດ້ວຍ semicolons. ຄໍາສັ່ງຖືກປະຕິບັດຕາມຄໍາສັ່ງທີ່ພວກເຂົາປາກົດ. ເມື່ອໃຊ້ Expectk, ຕົວເລືອກນີ້ຖືກກໍານົດເປັນ - ຄໍາສັ່ງ.
ທຸງ -d ຊ່ວຍໃຫ້ຜົນການວິນິດໄສຈໍານວນຫນຶ່ງ, ເຊິ່ງລາຍງານຕົ້ນຕໍກິດຈະກໍາພາຍໃນຂອງຄໍາສັ່ງເຊັ່ນຄາດວ່າແລະປະຕິບັດ. ທຸງນີ້ມີຜົນກະທົບດຽວກັນກັບ "exp_internal 1" ໃນຕອນເລີ່ມຕົ້ນຂອງສະຄາດຄາດຄະເນ, ບວກກັບສະບັບຂອງ Expect ຖືກພິມ.
ທົງ -D ຊ່ວຍໃຫ້ມີການແກ້ໄຂການໂຕ້ຕອບແບບໂຕ້ຕອບ. ມູນຄ່າຈໍານວນເຕັມຄວນປະຕິບັດຕາມ. ຕົວແກ້ໄຂຈະຄວບຄຸມກ່ອນການດໍາເນີນງານ Tcl ຕໍ່ໄປຖ້າຫາກວ່າຄ່າທີ່ບໍ່ແມ່ນສູນຫຼືຖ້າກົດ C ຖືກກົດປຸ່ມກົດຫລືປຸ່ມຄໍາສັ່ງ debugger ທີ່ເຫມາະສົມຈະປາກົດໃນ script. ເມື່ອໃຊ້ Expectk, ຕົວເລືອກນີ້ຖືກລະບຸໄວ້ເປັນ - ການ ແກ້ໄຂ.
ທົງ -f ໄດ້ preferences ໄຟລ໌ທີ່ຈະອ່ານຄໍາສັ່ງ. ທຸງຊາດຕົວມັນເອງເປັນທາງເລືອກຍ້ອນມັນມີປະໂຫຍດພຽງແຕ່ໃຊ້ເວລາໃນການໃຊ້ #! ຫມາຍເຫດ, ດັ່ງນັ້ນການໂຕ້ຖຽງອື່ນໆອາດຈະຖືກສະຫນອງໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງ. ເມື່ອໃຊ້ Expectk, ຕົວເລືອກນີ້ຖືກກໍານົດເປັນໄຟ.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ໄຟລ໌ຄໍາສັ່ງແມ່ນເຂົ້າໄປໃນ ຫນ່ວຍຄວາມຈໍາ ແລະປະຕິບັດທັງຫມົດ. ມັນມັກຈະເປັນຄວາມຕ້ອງການທີ່ຈະອ່ານໄຟລ໌ຫນຶ່ງເສັ້ນໃນເວລາດຽວກັນ. ໃນຄໍາສັ່ງເພື່ອບັງຄັບໃຊ້ໄຟລ໌ທີ່ມັກຈະໄດ້ຮັບການຈັດການກັບວິທີນີ້, ໃຫ້ໃຊ້ b-flag. ເມື່ອໃຊ້ Expectk, ຕົວເລືອກນີ້ຖືກລະບຸໄວ້ເປັນ -buffer.
ຖ້າສະຕິງ "-" ຖືກສະຫນອງໃຫ້ເປັນຊື່ໄຟລ໌, ການນໍາເຂົ້າມາດຕະຖານຖືກອ່ານແທນ. ໃຊ້ "./-" ເພື່ອອ່ານຈາກໄຟລ໌ທີ່ມີຊື່ວ່າ "-".
flag -i ເຮັດໃຫ້ຄາດວ່າຈະໂຕ້ຕອບແບບສໍາລັບຄໍາສັ່ງແທນທີ່ຈະອ່ານມັນຈາກໄຟລ໌. Prompting ຖືກຍົກເລີກຜ່ານຄໍາສັ່ງການອອກຫລືຕາມ EOF. flag -i ແມ່ນການຄາດຄະເນຖ້າບໍ່ມີໄຟລ໌ຄໍາສັ່ງຫຼື -c ຖືກນໍາໃຊ້. ເມື່ອນໍາໃຊ້ Expectk, ຕົວເລືອກນີ້ຖືກລະບຸວ່າເປັນການໂຕ້ຕອບ.
- ອາດຈະຖືກນໍາໃຊ້ເພື່ອກໍານົດໃນຕອນທ້າຍຂອງທາງເລືອກ. ນີ້ແມ່ນມີຜົນປະໂຫຍດຖ້າທ່ານຕ້ອງການໂຕ້ແຍ້ງທາງເລືອກທີ່ຄ້າຍຄືກັນກັບ script ຂອງທ່ານໂດຍບໍ່ມີການແປຄວາມຫມາຍໂດຍຄາດຫວັງ. ນີ້ສາມາດນໍາໃຊ້ໄດ້ຢ່າງຖືກຕ້ອງໃນ #! ເສັ້ນເພື່ອປ້ອງກັນການຕີຄວາມຫມາຍໃດໆທີ່ແຕກຕ່າງກັນໂດຍຄາດຫວັງ. ຕົວຢ່າງດັ່ງຕໍ່ໄປນີ້ຈະອອກຈາກການໂຕ້ຖຽງຕົ້ນສະບັບລວມທັງຊື່ script ໃນ argv ຕົວແປ.
#! / usr / local / bin / expect -ໃຫ້ສັງເກດວ່າຜົນປະ ໂຫຍດຂອງ getopt (3) ແລະ execve (2) ປົກກະຕິຄວນຈະຖືກສັງເກດໃນເວລາທີ່ມີການໂຕ້ຖຽງກັບ #! line
ໄຟລ໌ $ exp_library / expect.rc ແມ່ນມາໂດຍອັດຕະໂນມັດຖ້າຫາກວ່າມີຢູ່, ເວັ້ນເສຍແຕ່ວ່າການນໍາໃຊ້ທົງ N ແມ່ນຖືກນໍາໃຊ້. (ເມື່ອໃຊ້ Expectk, ຕົວເລືອກນີ້ຖືກລະບຸໄວ້ເປັນ -NORC.) ທັນທີຫຼັງຈາກນີ້, ໄຟລ໌ ~ / .expectrc ແມ່ນແຫຼ່ງທີ່ມາໂດຍອັດຕະໂນມັດ, ເວັ້ນເສຍແຕ່ວ່າຕົວນໍາ -n ຖືກນໍາໃຊ້. ຖ້າ DOTDIR ຕົວປ່ຽນແປງສະພາບແວດລ້ອມຖືກກໍານົດ, ມັນຈະຖືກຖືວ່າເປັນໄດເລກະທໍລີແລະ .expectrc ແມ່ນຖືກອ່ານຈາກນັ້ນ. ເມື່ອໃຊ້ Expectk, ຕົວເລືອກນີ້ຖືກກໍານົດເປັນ -norc. ການຊອກຫານີ້ເກີດຂື້ນພຽງແຕ່ຫຼັງຈາກການປະຕິບັດໃດໆ - c ທົງ.
- v ເຫດຜົນຄາດວ່າຈະພິມຈໍານວນເວີຊັນຂອງມັນແລະອອກ. ທົງທີ່ສອດຄ້ອງກັນໃນ Expectk, ເຊິ່ງໃຊ້ຊື່ທຸງຍາວ, ແມ່ນ -version.
args ທາງເລືອກແມ່ນການກໍ່ສ້າງເຂົ້າໃນບັນຊີລາຍຊື່ແລະເກັບຮັກສາໄວ້ໃນຕົວປ່ຽນແປງຊື່ argv ແລະ. argc ແມ່ນເລີ່ມຕົ້ນກັບຄວາມຍາວຂອງ argv.
Argv0 ຖືກກໍານົດໃຫ້ເປັນຊື່ຂອງ script ຫຼື binary ຖ້າບໍ່ມີ script ຖືກໃຊ້. ຕົວຢ່າງ, ການພິມຕໍ່ໄປນີ້ພິມຊື່ຂອງສະຄິບແລະສາມໂຕ້ຖຽງທໍາອິດ:
send_user "$ argv0 [lrange $ argv 0 2] \ n"ຄໍາສັ່ງ
ຄາດວ່າຈະໃຊ້ພາສາຄໍາສັ່ງເຄື່ອງມື. Tcl ໃຫ້ການຄວບຄຸມການໄຫລວຽນ (ຖ້າ, ສໍາລັບ, ການພັກຜ່ອນ), ການປະເມີນຜົນການສະແດງອອກແລະລັກສະນະອື່ນໆອີກເຊັ່ນ: ການກໍານົດວິທີການ recursionand. ຄໍາສັ່ງທີ່ໃຊ້ຢູ່ນີ້ແຕ່ບໍ່ຖືກກໍານົດ (set, if, exec) ແມ່ນຄໍາສັ່ງ Tcl. ຄາດວ່າຈະສະຫນັບສະຫນູນຄໍາສັ່ງເພີ່ມເຕີມ. ເວັ້ນເສຍແຕ່ໄດ້ລະບຸໄວ້ຖ້າບໍ່ດັ່ງນັ້ນ, ຄໍາສັ່ງຈະສົ່ງຄືນສະຕິງຫວ່າງ.
ຄໍາສັ່ງຖືກລະບຸໄວ້ໃນຕົວອັກສອນເພື່ອໃຫ້ພວກເຂົາສາມາດຕັ້ງຢູ່ຢ່າງໄວວາ. ຢ່າງໃດກໍຕາມ, ຜູ້ໃຊ້ໃຫມ່ອາດພົບວ່າມັນງ່າຍທີ່ຈະເລີ່ມຕົ້ນໂດຍການອ່ານຄໍາອະທິບາຍຂອງການຜະລິດ, ການສົ່ງ, ການຄາດຫວັງແລະການໂຕ້ຕອບໃນຄໍາສັ່ງນັ້ນ.
ປິດ [-slave] [-onexec 0 | 1] [-i spawn_id]ປິດການເຊື່ອມຕໍ່ກັບ ຂະບວນການ ປະຈຸບັນ. ໂປລແກລມການໂຕ້ຕອບສ່ວນໃຫຍ່ຈະກວດຫາ EOF ໃນ stdin ແລະອອກຈາກພວກເຂົາ; ດັ່ງນັ້ນຈຶ່ງມີ ຄວາມ ພຽງພໍທີ່ຈະຂ້າ ຂະບວນການ ເຊັ່ນກັນ. ທຸງ -i ປະກາດ ຂະບວນການ ທີ່ຈະປິດທີ່ສອດຄ້ອງກັບຊື່ spawn_id.
ທັງສອງຄາດຫວັງແລະໂຕ້ຕອບຈະກວດພົບໃນເວລາທີ່ ຂະບວນການ ໃນປະຈຸບັນອອກຈາກແລະ implicitly ເຮັດຢ່າງໃກ້ຊິດ, ແຕ່ຖ້າຫາກວ່າທ່ານຂ້າ ຂະບວນການ ໂດຍ, ເວົ້າວ່າ, "exec ຄ່າ $ pid", ທ່ານຈໍາເປັນຕ້ອງໂທຢ່າງຊັດເຈນ .
ທົງ -onexec ກໍານົດວ່າ idle ປາຈະຖືກປິດໃນຂະບວນການທີ່ ສ້າງຂື້ນ ໃຫມ່ໃດໆຫຼືຖ້າ ຂະບວນການ ນີ້ແມ່ນ overlayed. ເມື່ອຕ້ອງການໃຫ້ id open, ໃຊ້ຄ່າ 0. ມູນຄ່າ integer ທີ່ບໍ່ແມ່ນສູນຈະບັງຄັບໃຫ້ໄຂ່ປິດໃນຂະບວນການໃຫມ່.
ທຸງຊາດສະຫງ່າຜ່າເຜີຍໃຫ້ຜູກພັນທີ່ກ່ຽວຂ້ອງກັບການຜະລິດນ້ໍານົມ. ໃນເວລາທີ່ການເຊື່ອມຕໍ່ໄດ້ຖືກປິດ, ສໍາລອງແມ່ນປິດໂດຍອັດຕະໂນມັດຖ້າມັນຍັງເປີດ.
ບໍ່ວ່າຈະເປັນການເຊື່ອມຕໍ່ໄດ້ຖືກປິດຢ່າງຊັດເຈນຫຼືຢ່າງຊັດເຈນ, ທ່ານຄວນໂທຫາລໍຖ້າເພື່ອລ້າງຊ່ອງໃສ່ ຂະບວນການ ເຄີເນນທີ່ສອດຄ້ອງກັນ. ຄໍາສັ່ງປິດບໍ່ເອີ້ນການລໍຖ້າເນື່ອງຈາກບໍ່ມີການຮັບປະກັນວ່າປິດ ການ ເຊື່ອມຕໍ່ ຂະບວນ ການຈະເຮັດໃຫ້ມັນອອກ.
debug [[-now] 0 | 1]ຄວບຄຸມຕົວແກ້ໄຂ Tcl ຊ່ວຍໃຫ້ທ່ານສາມາດກ້າວອອກຈາກຄໍາເວົ້າແລະຕັ້ງຈຸດຕັດ.
ມີການໂຕ້ຖຽງບໍ່ມີ, 1 ຈະຖືກສົ່ງຄືນຖ້າຫາກວ່າ debugger ບໍ່ໄດ້ເຮັດວຽກ, ຖ້າບໍ່ດັ່ງນັ້ນ 0 ຖືກສົ່ງຄືນ.
ມີການໂຕ້ຖຽງ 1, debugger ໄດ້ຖືກເລີ່ມຕົ້ນ. ມີການໂຕ້ຖຽງ 0, ຕົວແກ້ໄຂແມ່ນຖືກຢຸດ. ຖ້າການໂຕ້ຖຽງ 1 ແມ່ນ preceded by -now flag, debugger ຈະຖືກເລີ່ມຕົ້ນທັນທີ. ຖ້າບໍ່ດັ່ງນັ້ນ, debugger ຈະຖືກເລີ່ມຕົ້ນດ້ວຍຄໍາສັ່ງ Tcl ຕໍ່ໄປ.
ຄໍາສັ່ງ debug ບໍ່ປ່ຽນແປງກັບດັກໃດໆ. ປຽບທຽບນີ້ເພື່ອເລີ່ມຕົ້ນຄາດຫວັງກັບທຸງ -D.
ຄໍາສັ່ງປິດການເຊື່ອມຕໍ່ disconnects process forked ຈາກ terminal . ມັນຍັງສືບຕໍ່ແລ່ນຢູ່ໃນພື້ນຫລັງ. ຂະບວນການດັ່ງກ່າວແມ່ນໄດ້ມອບໃຫ້ກຸ່ມຂະບວນການຂອງຕົນເອງ. ມາດຕະຖານ I / O ຖືກສົ່ງກັບ / dev / null .
fragment ດັ່ງຕໍ່ໄປນີ້ໃຊ້ການເຊື່ອມຕໍ່ເພື່ອສືບຕໍ່ການແລ່ນ script ໃນພື້ນຫລັງ.
ຖ້າ {[fork]! = 0} ອອກຈາກການເຊື່ອມຕໍ່. ທີ່ຢູ່ ທີ່ຢູ່ສະຄິບຕໍ່ໄປນີ້ຈະອ່ານລະຫັດຜ່ານແລະຫຼັງຈາກນັ້ນດໍາເນີນໂຄງການທຸກໆຊົ່ວໂມງທີ່ຕ້ອງການລະຫັດຜ່ານແຕ່ລະຄັ້ງທີ່ມັນຖືກໃຊ້. script ໃຫ້ລະຫັດຜ່ານດັ່ງນັ້ນທ່ານພຽງແຕ່ຕ້ອງພິມມັນຄັ້ງດຽວ.
send_user "password? \" expect_user -re "(*) \ n" for {} 1 {} {if {[fork]! = 0} {sleep 3600 continue} disconnect spawn priv_prog expect Password: send "$ expect_out ( 1, string) \ r " ທີ່ຢູ່ ທີ່ຢູ່ ອອກຈາກ}ຄວາມສາມາດໃນການນໍາໃຊ້ການເຊື່ອມຕໍ່ໃນໄລຍະຫ່າງໄກສອກຫຼີກຄຸນສົມບັດຂະບວນການໄຄເອັນ (&) ແມ່ນວ່າ Expect ສາມາດບັນທຶກພາລາມິເຕີທີ່ຢູ່ປາຍຍອດກ່ອນທີ່ຈະປິດການເຊື່ອມຕໍ່ແລະຫຼັງຈາກນັ້ນນໍາໃຊ້ໃຫ້ກັບ ptys ໃຫມ່. ກັບ &, ຄາດວ່າຈະບໍ່ມີໂອກາດທີ່ຈະອ່ານຕົວກໍານົດຂອງເທີມິນັນຍ້ອນວ່າປາຍທາງຖືກປິດແລ້ວໂດຍເວລາທີ່ຄາດວ່າຈະໄດ້ຮັບການຄວບຄຸມ.
ອອກຈາກ [-opts] [status]ເຮັດໃຫ້ຄາດວ່າຈະອອກຈາກຫຼືຖ້າບໍ່ດັ່ງນັ້ນຈະກະກຽມເພື່ອເຮັດແນວນັ້ນ.
ທົງດ່ຽວ - ດຽວກັນເຮັດໃຫ້ການໂຕ້ຖຽງຕໍ່ໄປໃຊ້ເປັນ handler ຕົວທ່ອງເວັບ. ໂດຍບໍ່ມີການໂຕ້ຖຽງ, ຕົວຈັດການການທ່ອງທ່ຽວປະຈຸບັນຖືກສົ່ງກັບຄືນ.
ການ ໂຄສະ ນາທີ່ບໍ່ມີຜົນກະທົບເຮັດໃຫ້ ຄາດວ່າ ຈະກຽມພ້ອມທີ່ຈະອອກແຕ່ຢຸດການຄວບຄຸມທີ່ແທ້ຈິງກັບລະບົບປະຕິບັດການ. ຜູ້ຈັດການການທ່ອງທ່ຽວທີ່ຖືກກໍານົດໂດຍຜູ້ໃຊ້ໄດ້ຖືກດໍາເນີນການເຊັ່ນດຽວກັນກັບຕົວຈັດການພາຍໃນຂອງ Expect ເອງ. ບໍ່ຕ້ອງລໍຖ້າຄໍາສັ່ງເພີ່ມເຕີມ. ນີ້ແມ່ນມີຜົນປະໂຫຍດຖ້າທ່ານກໍາລັງເຮັດວຽກຄາດຫວັງກັບການຂະຫຍາຍ Tcl ອື່ນໆ. ຜູ້ແປພາສາໃນປະຈຸບັນ (ແລະປ່ອງຢ້ຽມຕົ້ນຕໍຖ້າຫາກວ່າຢູ່ໃນສະພາບແວດລ້ອມ Tk) ຍັງຄົງຢູ່ເພື່ອວ່າການຂະຫຍາຍ Tcl ອື່ນໆສາມາດເຮັດຄວາມສະອາດໄດ້. ຖ້າການຄາດຄະເນຂອງການ ທ່ອງທ່ຽວ ຖືກເອີ້ນອີກເທື່ອຫນຶ່ງ (ເຖິງແມ່ນວ່ານີ້ອາດຈະເກີດຂື້ນ), ຜູ້ຈັດການບໍ່ໄດ້ກັບຄືນມາ.
ເມື່ອອອກຈາກຫນື່ງ, ທຸກເຊື່ອມຕໍ່ກັບຂະບວນການທີ່ຜະລິດໄດ້ຖືກປິດ. ການປິດຈະຖືກກວດພົບວ່າເປັນ EOF ໂດຍຂະບວນການທີ່ຜະລິດ. ການອອກເດີນທາງ ຈະບໍ່ມີການກະທໍາອື່ນໃດນອກເຫນືອຈາກຂັ້ນຕອນປົກກະຕິຂອງ _exit (2). ດັ່ງນັ້ນ, ຂະບວນການທີ່ເກີດຂື້ນທີ່ບໍ່ກວດສອບ EOF ອາດຈະສືບຕໍ່ດໍາເນີນການ. (ເງື່ອນໄຂຕ່າງໆແມ່ນມີຄວາມສໍາຄັນໃນການກໍານົດຕົວຢ່າງວ່າສັນຍານທີ່ເກີດຂື້ນຈະຖືກສົ່ງໄປແຕ່ວ່າມັນແມ່ນລະບົບທີ່ກ່ຽວຂ້ອງ, ຕາມປົກກະຕິພາຍໃຕ້ການເປີດ (3).) ຂະບວນການທີ່ຈະສືບຕໍ່ດໍາເນີນການຈະໄດ້ຮັບການສືບທອດໂດຍ init.
ສະຖານະ (ຫລື 0 ຖ້າບໍ່ລະບຸ) ຖືກສົ່ງຄືນເປັນສະຖານະການອອກຂອງ Expect . exit ແມ່ນປະຕິບັດໂດຍກົງຖ້າຫາກວ່າສິ້ນສຸດຂອງ script ໄດ້ຖືກບັນລຸ.
exp_continue [-continue_timer]
ຄໍາສັ່ງ exp_continue ອະນຸຍາດໃຫ້ ຄາດວ່າ ຕົວເອງຈະສືບຕໍ່ດໍາເນີນການແທນທີ່ຈະກັບຄືນຕາມປົກກະຕິ. ໂດຍຄ່າເລີ່ມຕົ້ນ exp_continue ປັບຄ່າເວລາຫມົດເວລາ. ທົງ -continue_timer ປ້ອງກັນບໍ່ໃຫ້ຈັບເວລາຈາກການເລີ່ມຕົ້ນໃຫມ່. (ເບິ່ງຄວາມ ຄາດຫວັງ ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.)
exp_internal [-f file] value
ເຮັດໃຫ້ຄໍາສັ່ງເພີ່ມເຕີມທີ່ຈະສົ່ງຂໍ້ມູນການວິນິດໄສພາຍໃນທີ່ ຄາດຫວັງ ກັບ stderr ຖ້າ ຄ່າ ແມ່ນບໍ່ສູນ. ຂໍ້ມູນການວິນິດໄສນີ້ລວມເຖິງທຸກຕົວອັກສອນທີ່ໄດ້ຮັບແລະທຸກໆຄວາມພະຍາຍາມທີ່ຈະປະຕິບັດກັບຜົນຜະລິດໃນປະຈຸບັນຕໍ່ກັບຮູບແບບຕ່າງໆ.
ຖ້າ ໄຟລ໌ ທາງເລືອກທີ່ຖືກສະຫນອງ, ທັງຫມົດຜົນຜະລິດປົກກະຕິແລະ debugging ແມ່ນລາຍລັກອັກສອນກັບໄຟລ໌ນັ້ນ (ບໍ່ວ່າຈະເປັນມູນຄ່າຂອງ ມູນຄ່າ ). ທຸກໄຟລ໌ຜົນການວິນິດໄສທີ່ຜ່ານມາຖືກປິດ.
ທຸງ -info ເຮັດໃຫ້ exp_internal ກັບຄືນລາຍລະອຽດຂອງການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນຂໍ້ມູນຫຼ້າສຸດທີ່ໃຫ້.
exp_open [args] [-i spawn_id]
ຜົນຕອບແທນຂອງລະຫັດ Tcl ທີ່ສອດຄ້ອງກັນກັບເອກະສານສະເພາະຂອງຕົ້ນກໍາເນີດ. ຕົວລະບຸຊື່ໄຟລ໌ດັ່ງກ່າວສາມາດນໍາໃຊ້ໄດ້ຖ້າມັນຖືກເປີດໂດຍຄໍາສັ່ງ ເປີດ ຂອງ Tcl. (ບໍ່ຕ້ອງໃຊ້ id ນ້ໍາຈືດເລີຍ. ການ ລໍຖ້າ ບໍ່ຄວນປະຕິບັດ.
ທຸງ ທ່ອນເລີ້ມ ອອກຈາກໃບຢັ້ງຢືນການເປີດຕົວສໍາລັບການເຂົ້າເຖິງຜ່ານຄໍາສັ່ງຄາດຫມາຍ. ການ ລໍຖ້າ ຕ້ອງໄດ້ຮັບການປະຕິບັດຢູ່ໃນຈໍານວນການຜະລິດ.
exp_pid [-i spawn_id]
ສົ່ງຄືນ id ຂະບວນການທີ່ສອດຄ້ອງກັບຂະບວນການທີ່ກໍາລັງເກີດຂື້ນ. ຖ້າມີ flag -i ຖືກນໍາໃຊ້, pid ກັບຄືນໄປບ່ອນເທົ່າກັບ id ຂອງ id.
exp_send
ເປັນນາມແຝງສໍາລັບການ ສົ່ງ .
exp_send_error
ເປັນນາມແຝງສໍາລັບ send_error .
exp_send_log
ເປັນ alias ສໍາລັບ send_log .
exp_send_tty
ເປັນນາມແຝງສໍາລັບ send_tty .
exp_send_user
ເປັນນາມແຝງສໍາລັບ send_user .
exp_version [[-exit] version]
ແມ່ນເປັນປະໂຫຍດສໍາລັບການຮັບປະກັນວ່າ script ແມ່ນເຫມາະສົມກັບສະບັບປະຈຸບັນຂອງ Expect.
ມີການໂຕ້ຖຽງບໍ່ມີ, ສະບັບປະຈຸບັນຂອງ Expect ຈະ ຖືກສົ່ງຄືນ. ສະບັບນີ້ອາດຈະໄດ້ຮັບການເຂົ້າລະຫັດໃນສະຄິບຂອງທ່ານ. ຖ້າທ່ານຮູ້ວ່າທ່ານບໍ່ໄດ້ໃຊ້ຄຸນສົມບັດຂອງຮຸ່ນທີ່ຜ່ານມາ, ທ່ານສາມາດລະບຸສະບັບກ່ອນຫນ້ານີ້.
ຮຸ່ນປະກອບດ້ວຍສາມຈໍານວນແຍກດ້ວຍຈຸດ. ຫນ້າທໍາອິດແມ່ນຈໍານວນທີ່ສໍາຄັນ. ຫນັງສືທີ່ຂຽນສໍາລັບສະບັບຂອງ ຄາດຫວັງວ່າ ມີຈໍານວນທີ່ສໍາຄັນທີ່ແຕກຕ່າງກັນເກືອບແນ່ນອນຈະບໍ່ເຮັດວຽກ. exp_version ສົ່ງຄືນຂໍ້ຜິດພາດຖ້າຈໍານວນທີ່ສໍາຄັນບໍ່ກົງກັນ.
ອັນທີສອງແມ່ນຈໍານວນຫນ້ອຍ. Scripts ທີ່ຂຽນສໍາລັບສະບັບທີ່ມີຈໍານວນຫນ້ອຍທີ່ຫນ້ອຍກວ່າເວີຊັນໃນປະຈຸບັນອາດຈະຂຶ້ນກັບຄຸນນະສົມບັດໃຫມ່ແລະອາດຈະບໍ່ສາມາດດໍາເນີນການໄດ້. exp_version ສົ່ງຄືນຂໍ້ຜິດພາດຖ້າຫມາຍເລກທີ່ສໍາຄັນເທົ່ານັ້ນ, ແຕ່ຈໍານວນນ້ອຍໆຂອງອັກສອນແມ່ນສູງກວ່າທີ່ ຄາດວ່າຈະ ກໍາລັງລໍຖ້າ.
ສາມແມ່ນຈໍານວນທີ່ບໍ່ມີສ່ວນຮ່ວມໃນການປຽບທຽບຮຸ່ນ. ຢ່າງໃດກໍ່ຕາມ, ມັນໄດ້ຖືກເພີ່ມຂຶ້ນເມື່ອການ ຄາດຄະເນ ການແຈກຢາຍຂອງຊອບແວຈະມີການປ່ຽນແປງໃນທາງໃດກໍ່ຕາມ, ເຊັ່ນ: ໂດຍການເອກະສານເພີ່ມເຕີມຫຼືການເພີ່ມປະສິດທິພາບ. ມັນຖືກປັບກັບ 0 ເມື່ອມີແຕ່ລະຮຸ່ນໃຫມ່ຫນ້ອຍ.
ມີທົງທຸລະກິດ, ຄາດຫວັງວ່າຈະ ພິມຂໍ້ຜິດພາດແລະອອກຖ້າສະບັບບໍ່ມີວັນທີ.
ຄາດຫວັງວ່າ [[-opts] pat1 body1] ... [-opts] patn [bodyn]
ລໍຖ້າຈົນກ່ວາຫນຶ່ງໃນຮູບແບບທີ່ກົງກັນກັບຜົນຜະລິດຂອງຂະບວນການທີ່ເກີດ, ໄລຍະເວລາທີ່ກໍານົດໄວ້ໄດ້ຖືກຜ່ານໄປ, ຫຼືສິ້ນສຸດຂອງໄຟແມ່ນເຫັນໄດ້. ຖ້າຮ່າງກາຍສຸດທ້າຍແມ່ນເປົ່າ, ມັນອາດຈະຖືກຍົກເລີກ.
ຮູບແບບຈາກຄໍາສັ່ງ expect_before ທີ່ສຸດແມ່ນຖືກນໍາໃຊ້ຢ່າງສົມບູນກ່ອນຮູບແບບອື່ນໆ. ຮູບແບບຈາກຄໍາສັ່ງ ຄາດຫວັງ ຫຼ້າສຸດ ຄາດ ວ່າຈະຖືກນໍາໃຊ້ຢ່າງສົມບູນຫຼັງຈາກຮູບແບບອື່ນໆ.
ຖ້າການໂຕ້ຖຽງກັບຄໍາສັ່ງ ຄາດຫມາຍ ທັງຫມົດຕ້ອງການຫຼາຍກວ່າຫນຶ່ງເສັ້ນ, ການໂຕ້ຖຽງທັງຫມົດອາດຈະຖືກ "ຂື້ນ" ເປັນຫນຶ່ງເພື່ອຫຼີກເວັ້ນການສິ້ນສຸດໃນແຕ່ລະເສັ້ນໂດຍມີຮົ້ວຕານ. ໃນກໍລະນີນີ້, ການທົດແທນ Tcl ປົກກະຕິຈະເກີດຂຶ້ນເຖິງແມ່ນວ່າຈະມີການຂັດຂວາງ.
ຖ້າຮູບແບບແມ່ນ eof ຄໍາທີ່ໃຊ້, ຮ່າງກາຍທີ່ສອດຄ້ອງກັນຈະຖືກປະຕິບັດເມື່ອທ້າຍຂອງໄຟລ໌. ຖ້າຮູບແບບເປັນ ເວລາ ສໍາຄັນ, ຮ່າງກາຍທີ່ສອດຄ້ອງກັນຈະຖືກປະຕິບັດຕາມເວລາຫມົດເວລາ. ຖ້າບໍ່ມີຄໍາທີ່ໃຊ້ເວລາທີ່ໃຊ້ເວລາ, ການປະຕິບັດ null implicit ແມ່ນປະຕິບັດຕາມເວລາຫມົດ. ໄລຍະເວລາຫມົດເວລາຂອງຄ່າທໍານຽມແມ່ນ 10 ວິນາທີແຕ່ອາດຈະຖືກກໍານົດ, ເຊັ່ນວ່າ 30, ໂດຍຄໍາສັ່ງ "set timeout 30". ໄລຍະເວລາອັນເປັນນິດສາມາດກໍາຫນົດໂດຍຄ່າ -1. ຖ້າຮູບແບບເປັນ ຄ່າເລີ່ມຕົ້ນຂອງ ຄໍາທີ່ໃຊ້ໄດ້, ຮ່າງກາຍທີ່ສອດຄ້ອງກັນຈະຖືກປະຕິບັດຕາມເວລາຫມົດເວລາຫລືສິ້ນສຸດຂອງແຟ້ມ.
ຖ້າຮູບແບບກົງກັນ, ຫຼັງຈາກນັ້ນຮ່າງກາຍທີ່ສອດຄ້ອງກັນຈະຖືກປະຕິບັດ. ຄາດຫວັງວ່າ ຜົນໄດ້ຮັບຂອງຮ່າງກາຍ (ຫຼືສາຍໄຟທີ່ບໍ່ມີເປືອກຖ້າບໍ່ມີຮູບແບບ). ໃນກໍລະນີທີ່ມີຮູບແບບທີ່ແຕກຕ່າງກັນ, ຫນຶ່ງທີ່ປາກົດຢູ່ຄັ້ງທໍາອິດແມ່ນໃຊ້ເພື່ອເລືອກຮ່າງກາຍ.
ໃນເວລາທີ່ແຕ່ລະຜົນຜະລິດໃຫມ່ມາເຖິງ, ມັນຈະຖືກປຽບທຽບກັບແຕ່ລະຮູບແບບຕາມລໍາດັບທີ່ພວກມັນຖືກລະບຸ. ດັ່ງນັ້ນ, ທ່ານອາດຈະທົດສອບສໍາລັບການບໍ່ມີການແຂ່ງຂັນໂດຍການເຮັດໃຫ້ຮູບແບບສຸດທ້າຍບາງສິ່ງບາງຢ່າງທີ່ຮັບປະກັນຈະປາກົດ, ເຊັ່ນ: ຄໍາແນະນໍາ. ໃນສະຖານະການທີ່ບໍ່ມີຄໍາເຕືອນ, ທ່ານຕ້ອງໃຊ້ ເວລາຫມົດເວລາ (ຄືກັນກັບວ່າທ່ານຈະໂຕ້ຕອບດ້ວຍຕົນເອງ).
ຮູບແບບຕ່າງໆໄດ້ຖືກກໍານົດໄວ້ໃນສາມວິທີ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ຮູບແບບຈະຖືກລະບຸໄວ້ກັບຄໍາສັ່ງຄໍາສັ່ງຂອງລໍາດັບຂອງ Tcl. (ຮູບແບບດັ່ງກ່າວແມ່ນຄ້າຍຄືກັນກັບ ການ ສະແດງອອກແບບປົກກະຕິ C-shell ໂດຍປົກກະຕິເອີ້ນວ່າຮູບແບບ "glob"). ທຸງຊາດ -gl ສາມາດຖືກນໍາໃຊ້ເພື່ອປົກປ້ອງຮູບແບບຕ່າງໆທີ່ອາດຈະກົງກັບຄວາມ ຄາດຫວັງຂອງ ທຸງຊາດ. ຮູບແບບເລີ່ມຕົ້ນດ້ວຍ "-" ຄວນໄດ້ຮັບການປົກປ້ອງດ້ວຍວິທີນີ້. (ທຸກສາຍທີ່ເລີ່ມຕົ້ນດ້ວຍ "-" ຈະຖືກຈອງໄວ້ສໍາລັບຕົວເລືອກໃນອະນາຄົດ.)
ຕົວຢ່າງເຊັ່ນ fragment ດັ່ງຕໍ່ໄປນີ້ສໍາລັບການເຂົ້າສູ່ລະບົບທີ່ປະສົບຜົນສໍາເລັດ. (ຫມາຍເຫດ abort ຖືກຖືວ່າເປັນຂັ້ນຕອນທີ່ຖືກກໍານົດໄວ້ໃນບ່ອນອື່ນໃນ script).
ຄາດວ່າ {busy {puts busy \ n exp_continue} ລົ້ມເຫລວຍົກເລີກ "ລະຫັດຜ່ານທີ່ບໍ່ຖືກຕ້ອງ" ການຍົກເລີກສິ້ນສຸດການເຊື່ອມຕໍ່ທີ່ເຊື່ອມຕໍ່ໄປແລ້ວ}ວົງຢືມແມ່ນມີຄວາມຈໍາເປັນໃນຮູບແບບທີສີ່ເນື່ອງຈາກມັນມີຊ່ອງ, ເຊິ່ງຈະແຍກຮູບແບບຈາກການປະຕິບັດ. ຮູບແບບທີ່ມີການປະຕິບັດດຽວກັນ (ເຊັ່ນ: ທີ 3 ແລະທີ 4) ຕ້ອງຮຽກການປະຕິບັດອີກເທື່ອຫນຶ່ງ. ນີ້ສາມາດຫລີກລ່ຽງໄດ້ໂດຍໃຊ້ຮູບແບບແບບ regexp-style (ເບິ່ງຂ້າງລຸ່ມນີ້). ຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການສ້າງຮູບແບບແບບທົ່ວໂລກສາມາດພົບໄດ້ໃນຄູ່ມື Tcl.
ຮູບແບບແບບ Regexp ແບບປະຕິບັດຕາມຄໍາສັບທີ່ຖືກກໍານົດໂດຍ Regexp ຂອງ Tcl (ສັ້ນສໍາລັບຄໍາສັ່ງ "ການສະແດງອອກເປັນປົກກະຕິ"). ຮູບແບບ regexp ຖືກນໍາສະເຫນີດ້ວຍທົງຊາດ -re . ຕົວຢ່າງທີ່ຜ່ານມາສາມາດຖືກຂຽນຄືນໂດຍໃຊ້ regexp ເປັນ:
ຄາດວ່າ {busy {puts busy \ n exp_continue} -re "ລົ້ມເຫລວລະຫັດຜ່ານທີ່ບໍ່ຖືກຕ້ອງ" abort timeout abort connected}ທັງສອງປະເພດຂອງຮູບແບບແມ່ນ "unanchored". ນີ້ຫມາຍຄວາມວ່າຮູບແບບບໍ່ຈໍາເປັນຕ້ອງສອດຄ່ອງກັບລະບົບຕ່ອງໂສ້ທັງຫມົດ, ແຕ່ສາມາດເລີ່ມຕົ້ນແລະສິ້ນສຸດຄໍາທີ່ຢູ່ໃນສະຕວັດ (ເວັ້ນເສຍແຕ່ວ່າທຸກສິ່ງທຸກຢ່າງກົງກັນ). ໃຊ້ ^ ເພື່ອໃຫ້ກົງກັບຈຸດເລີ່ມຕົ້ນຂອງສະຕິງ, ແລະ $ ເພື່ອໃຫ້ກົງກັບຈຸດສິ້ນສຸດ. ໃຫ້ສັງເກດວ່າຖ້າທ່ານບໍ່ລໍຖ້າທ້າຍຊ່ອຍແນ່, ຄໍາຕອບຂອງທ່ານກໍ່ສາມາດສິ້ນສຸດລົງຢູ່ເຄິ່ງກາງຂອງຊ່ອຍແນ່ຍ້ອນວ່າພວກເຂົາຖືກຄັດເລືອກຈາກຂະບວນການທີ່ຜະລິດ. ໃນຂະນະທີ່ຍັງຜະລິດຜົນໄດ້ຮັບທີ່ຖືກຕ້ອງ, ຜົນຜະລິດສາມາດເບິ່ງບໍ່ທໍາມະດາ. ດັ່ງນັ້ນ, ການໃຊ້ $ ແມ່ນສະຫນັບສະຫນູນຖ້າທ່ານສາມາດອະທິບາຍລັກສະນະທີ່ຢູ່ໃນຕອນທ້າຍຂອງຊ່ອຍແນ່.
ໃຫ້ສັງເກດວ່າໃນບັນນາທິການຈໍານວນຫຼາຍ, ^ ແລະ $ ກົງກັບຈຸດເລີ່ມຕົ້ນແລະສິ້ນສຸດຂອງເສັ້ນຕາມລໍາດັບ. ຢ່າງໃດກໍຕາມ, ເນື່ອງຈາກວ່າຄາດວ່າຈະບໍ່ສອດຄ່ອງກັບເສັ້ນ, ລັກສະນະເຫຼົ່ານີ້ກົງກັບຈຸດເລີ່ມຕົ້ນແລະສິ້ນສຸດຂອງຂໍ້ມູນ (ກົງກັນຂ້າມກັບສາຍ) ໃນປະຈຸບັນທີ່ຄາດວ່າຈະມີຄວາມສົມບູນແບບ. (ນອກຈາກນີ້, ເບິ່ງບັນທຶກຂ້າງລຸ່ມນີ້ກ່ຽວກັບ "ການຍ່ອຍລະບົບ.")
ທົງ -ex ໄດ້ ເຮັດໃຫ້ຮູບແບບທີ່ຖືກຈັບເປັນສາຍ "ທີ່ແນ່ນອນ". ບໍ່ມີການຕີຄວາມຂອງ *, ^, etc ແມ່ນເຮັດ (ເຖິງແມ່ນວ່າສົນທິສັນຍາ Tcl ປົກກະຕິຕ້ອງຍັງສັງເກດເຫັນ). ຮູບແບບທີ່ຖືກຕ້ອງແມ່ນຖືກປະຕິເສດສະເຫມີໄປ.
ທົງ -nocase ເຮັດໃຫ້ອັກຂະລະຕົວອັກສອນຂອງຜົນຜະລິດທີ່ຈະປຽບທຽບເທົ່າທີ່ເປັນຕົວອັກສອນຕົວນ້ອຍ. ຮູບແບບບໍ່ໄດ້ຮັບຜົນກະທົບ.
ໃນຂະນະທີ່ການອ່ານຜົນຜະລິດ, ຫຼາຍກວ່າ 2000 bytes ສາມາດບັງຄັບ byte ກ່ອນຫນ້ານີ້ຈະຖືກ "ລືມ". ນີ້ອາດຈະມີການປ່ຽນແປງກັບ function_max function. (ໃຫ້ສັງເກດວ່າຄ່າຂະຫນາດໃຫຍ່ເກີນໄປສາມາດຫຼຸດລົງຕົວ matcher ຮູບແບບ.) ຖ້າ patlist ແມ່ນ full_buffer , ຮ່າງກາຍທີ່ສອດຄ້ອງກັນຈະຖືກປະຕິບັດຖ້າຫາກວ່າ match_max bytes ໄດ້ຮັບແລະບໍ່ມີຮູບແບບອື່ນໆທີ່ກົງກັນ. ບໍ່ວ່າຈະໃຊ້ຄໍາຫລັກ full_buffer ຫຼືບໍ່ໃຊ້, ລັກສະນະທີ່ລືມຖືກຂຽນໄວ້ໃນ expect_out (buffer).
ຖ້າ patlist ແມ່ນຄໍາຫລັກ null , ແລະ nulls ຖືກອະນຸຍາດ (ຜ່ານຄໍາສັ່ງ remove_nulls ), ຮ່າງກາຍທີ່ສອດຄ້ອງກັນຈະຖືກປະຕິບັດຖ້າ ASCII 0 ດຽວເທົ່ານັ້ນ. ມັນບໍ່ສາມາດຫາ 0 bytes ຜ່ານຮູບແບບ glob ຫຼື regexp.
ເມື່ອທຽບກັບຮູບແບບ (ຫຼື eof ຫຼື full_buffer), ທຸກຜົນຜະລິດທີ່ເທົ່າທຽມກັນແລະກ່ອນທີ່ບໍ່ມີມາກ່ອນຈະຖືກບັນທຶກໄວ້ໃນ variable expect_out (buffer) . ເຖິງ 9 ຄໍາວ່າ substring regexp ຖືກບັນທຶກໃນຕົວແປ expect_out (1, string) ຜ່ານ expect_out (9, string) . ຖ້າຕົວນໍາຫນ້າຖືກນໍາໃຊ້ກ່ອນຮູບແບບ, ດັດຊະນີເລີ່ມຕົ້ນແລະສິ້ນສຸດ (ໃນຮູບແບບທີ່ເຫມາະສົມສໍາລັບ lrange ) ຂອງ 10 strings ຖືກເກັບໄວ້ໃນຕົວ ຄາດຫມາຍ expect_out (X, start) ແລະ expect_out (X, end) ທີ່ X ເປັນ ເລກ, ກົງກັບຕໍາແຫນ່ງ substring ໃນ buffer. 0 ຫມາຍເຖິງສາຍທີ່ສອດຄ້ອງກັບຮູບແບບທັງຫມົດແລະຖືກສ້າງສໍາລັບຮູບແບບທົ່ວໂລກເຊັ່ນດຽວກັນກັບຮູບແບບ regexp. ຕົວຢ່າງເຊັ່ນຖ້າຂະບວນການຜະລິດຜົນຂອງ "abcdefgh \ n", ຜົນຂອງ:
ຄາດຫວັງວ່າ "cd"ແມ່ນຖ້າຄໍາສັ່ງຕໍ່ໄປນີ້ປະຕິບັດ:
set expect_out (0, string) cd set expect_out (buffer) abcdແລະ "efgh \ n" ຖືກປະໄວ້ໃນ buffer ຜົນຜະລິດ. ຖ້າຂະບວນການຜະລິດຜົນໄດ້ຮັບ "abbbcbkkkka \ n", ຜົນຂອງ:
expect -indices-b "b (b *) * (k +)"ແມ່ນຖ້າຄໍາສັ່ງຕໍ່ໄປນີ້ປະຕິບັດ:
set expect_out (0, end) 10 set expect_out (0, string) bbbcabkkkk set expect_out (1, start) 2 set expect_out (1, end) 3 set expect_out (1, string) bb set expect_out (2, ເລີ່ມຕົ້ນ) 10 set expect_out (2, end) 10 set expect_out (2, string) k set expect_out (buffer) abbbcabkkkkແລະ "a \ n" ຖືກປະໄວ້ໃນ buffer ຜົນຜະລິດ. ຮູບແບບ "*" (ແລະ - ແມ່ນ "*.") ຈະຟາດຕົວບີບອັດຜົນອອກໂດຍບໍ່ໄດ້ອ່ານຜົນຜະລິດໃດໆຈາກຂະບວນການ.
ໂດຍປົກກະຕິ, ຜົນຜະລິດທີ່ຖືກຈັບແມ່ນຖືກຍົກເລີກຈາກບັຟເຟີພາຍໃນຂອງ Expect. ນີ້ອາດຈະຖືກປ້ອງກັນໂດຍ preixing ຮູບແບບທີ່ມີ flag -notransfer . ທຸງນີ້ແມ່ນເປັນປະໂຫຍດໂດຍສະເພາະໃນການທົດລອງ (ແລະສາມາດຫຍໍ້ເປັນ "ບໍ່" ເພື່ອຄວາມສະດວກໃນການທົດລອງ).
id spawn ທີ່ກ່ຽວຂ້ອງກັບຜົນຜະລິດທີ່ສົມທຽບ (ຫຼື eof ຫຼື full_buffer) ຖືກເກັບໄວ້ໃນ expect_out (spawn_id) .
ທົງເວລາ - ເວລາເຮັດໃຫ້ຄໍາສັ່ງຄາດຫມາຍໃນປະຈຸບັນຈະໃຊ້ຄ່າຕໍ່ໄປນີ້ເປັນເວລາຫມົດເວລາແທນທີ່ຈະໃຊ້ຄ່າຂອງຕົວແປເວລາ.
ໂດຍຕົວຢ່າງ, ຮູບແບບຈະກົງກັນກັບຜົນຜະລິດຈາກຂະບວນການໃນປະຈຸບັນ, ຢ່າງໃດກໍ່ຕາມ, flag -i declares ຜົນຜະລິດຈາກຊື່ spawn_id ຊື່ທີ່ຖືກຈັບກັບຮູບແບບຕ່າງໆຕໍ່ໄປນີ້ (ຕໍ່ໄປ - i ). ບັນຊີ spawn_id ຄວນຈະເປັນບັນຊີແຍກຕ່າງຫາກຂອງ spawn_ids ຫຼືຕົວແປທີ່ຫມາຍເຖິງບັນຊີລາຍຊື່ຂອງ spawn_ids ນີ້.
ຕົວຢ່າງເຊັ່ນຕົວຢ່າງຕໍ່ໄປນີ້ລໍຖ້າສໍາລັບ "ເຊື່ອມຕໍ່" ຈາກຂະບວນການປະຈຸບັນ, ຫຼື "ທຸລະກິດ", "ລົ້ມເຫລວ" ຫຼື "ລະຫັດຜ່ານທີ່ບໍ່ຖືກຕ້ອງ" ຈາກ spawn_id ທີ່ຕັ້ງຊື່ໂດຍ $ proc2.
ຄາດຫວັງວ່າ {-i $ proc2 busy {puts busy \ n exp_continue} -re "ລົ້ມເຫລວລະຫັດຜ່ານທີ່ບໍ່ຖືກຕ້ອງ" abort timeout abort connected}ຄ່າຂອງຕົວແປທົ່ວໂລກ any_spawn_id ສາມາດຖືກນໍາໃຊ້ເພື່ອຫາຮູບແບບກັບທຸກ spawn_ids ທີ່ມີຊື່ທັງຫມົດ - i flags ໃນຄໍາສັ່ງທີ່ ຄາດວ່າຈະ ຢູ່ໃນຄໍາສັ່ງ. ຕົວຢ່າງ spawn_id ຈາກ a -i flag ທີ່ບໍ່ມີຮູບແບບທີ່ກ່ຽວຂ້ອງ (ເຊັ່ນ, ປະຕິບັດຕາມທັນທີໂດຍຄົນອື່ນ -i ) ແມ່ນເຮັດໃຫ້ມີຮູບແບບອື່ນໆໃນຄໍາສັ່ງ ຄາດຫມາຍ ດຽວກັນທີ່ກ່ຽວຂ້ອງກັບ any_spawn_id.
ທຸງ -i ອາດຈະມີຊື່ເປັນຕົວແປທົ່ວໆໄປໃນກໍລະນີທີ່ຕົວແປແມ່ນອ່ານສໍາລັບບັນຊີລາຍຊື່ຂອງຈໍານວນສະກຸນໄຂ່. ຕົວປ່ຽນແປງໄດ້ຖືກ reread ເມື່ອມັນປ່ຽນແປງ. ນີ້ສະຫນອງວິທີການປ່ຽນແຫຼ່ງ I / O ໃນຂະນະທີ່ຄໍາສັ່ງຢູ່ໃນການປະຕິບັດ. ສະຖານທີ່ທີ່ສະປາສະຫນອງໃຫ້ໂດຍວິທີນີ້ແມ່ນເອີ້ນວ່າ "ເຕັກໂນໂລຢີທາງອ້ອມ".
ການກະທໍາເຊັ່ນການ ຢຸດພັກ ແລະ ສືບຕໍ່ ເຮັດໃຫ້ໂຄງສ້າງການຄວບຄຸມ (ຕົວຢ່າງ, ສໍາລັບ , proc ) ປະຕິບັດຕົວຕາມປົກກະຕິ. ຄໍາສັ່ງ exp_continue ອະນຸຍາດໃຫ້ ຄາດວ່າ ຕົວເອງຈະສືບຕໍ່ດໍາເນີນການແທນທີ່ຈະກັບຄືນຕາມປົກກະຕິ.
ນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບການຫລີກລ້ຽງການຫຼີກເວັ້ນການແຈ້ງຫຼືການຄາດຄະເນທີ່ຄາດຫວັງຄືນ. ຕົວຢ່າງຕໍ່ໄປນີ້ແມ່ນສ່ວນຫນຶ່ງຂອງຊິ້ນເພື່ອເຮັດໃຫ້ອັດຕະໂນມັດ rlogin. exp_continue ຫຼີກເວັ້ນການມີການຂຽນຄໍາສັ່ງ ຄາດຫມາຍ ທີສອງ (ເພື່ອຊອກຫາຄໍາສັ່ງອີກເທື່ອຫນຶ່ງ) ຖ້າ rlogin prompts ສໍາລັບລະຫັດຜ່ານ.
ຄາດວ່າ {password: {stty -echo send_user "password (ສໍາຫລັບ $ user) ເທິງ $ host:" expect_user -re "(*) \ n" send_user "\ n" ສົ່ງ "$ expect_out (1, string) \ r" stty echo exp_continue} ທີ່ບໍ່ຖືກຕ້ອງ {send_user "ລະຫັດຜ່ານທີ່ບໍ່ຖືກຕ້ອງຫຼືບັນຊີ \ n" ອອກ} ເວລາ {send_user "ການເຊື່ອມຕໍ່ກັບ $ host time out \ n" exit} eof {send_user \ "ການເຊື່ອມຕໍ່ກັບໂຮດລົ້ມເຫລວ: $ expect_out (buffer)" exit} - re $ prompt}ຕົວຢ່າງ, ຊິ້ນສ່ວນດັ່ງຕໍ່ໄປນີ້ອາດຈະຊ່ວຍໃຫ້ຄູ່ມືການນໍາໃຊ້ການໂຕ້ຕອບທີ່ມີແລ້ວອັດຕະໂນມັດທັງຫມົດແລ້ວ. ໃນກໍລະນີນີ້, ປາຍທາງຈະຖືກໃສ່ເຂົ້າໃນໂຫມດດິບ. ຖ້າຜູ້ໃຊ້ກົດ "+", ຕົວແປຈະເພີ່ມຂຶ້ນ. ຖ້າ "p" ຖືກກົດດັນ, ຜົນຕອບແທນຫຼາຍຈະຖືກສົ່ງໄປຫາຂະບວນການ, ບາງທີອາດຈະເຮັດໃຫ້ມັນເປັນໄປໄດ້, ແລະ "i" ຊ່ວຍໃຫ້ຜູ້ໃຊ້ສາມາດຕິດຕໍ່ກັບຂະບວນການໄດ້, ໃນແຕ່ລະກໍລະນີ, exp_continue ອະນຸຍາດໃຫ້ປະຈຸບັນ ຄາດຫວັງວ່າ ຈະສືບຕໍ່ປັບປຸງຮູບແບບຫຼັງຈາກປະຕິບັດການປະຕິບັດໃນປະຈຸບັນ.
stty raw -echo expect_after {-i $ user_spawn_id "p" {send "\ r \ r \ r" exp_continue} "+" {incr foo exp_continue} "i" {interact exp_continue} "ອອກຈາກ" ອອກ}ໂດຍຄ່າເລີ່ມຕົ້ນ, exp_continue ປັບຄ່າເວລາທີ່ໃຊ້ເວລາ. ຕົວຈັບເວລາບໍ່ໄດ້ເລີ່ມຕົ້ນໃຫມ່, ຖ້າ exp_continue ຖືກເອີ້ນດ້ວຍທົງ -continue_timer .
expect_after [expect_args]
ເຮັດວຽກຢ່າງດຽວກັນກັບ expect_before ຍົກເວັ້ນວ່າຖ້າຮູບແບບຈາກທັງສອງ ຄາດ ແລະ expect_after ສາມາດກົງກັນໄດ້, ຮູບແບບ ຄາດຫວັງຈະ ຖືກນໍາໃຊ້. ເບິ່ງຄໍາສັ່ງ expect_before ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.
expect_background [expect_args]
ໃຊ້ເວລາການໂຕ້ຖຽງດຽວກັນຕາມ ຄາດຫວັງ , ແຕ່ມັນຈະກັບຄືນທັນທີ. ຮູບແບບຕ່າງໆຈະໄດ້ຮັບການທົດສອບເມື່ອມີຂໍ້ມູນໃຫມ່ມາຮອດ. ເວລາ ຮູບແບບແລະ ຄ່າເລີ່ມຕົ້ນ ແມ່ນມີຄວາມຫມາຍທີ່ ຄາດຫວັງ ກັບ ພື້ນທີ່ ແລະຖືກຍົກເລີກຢ່າງງຽບໆ. ຖ້າບໍ່ດັ່ງນັ້ນຄໍາສັ່ງ expect_background ໃຊ້ expectations_before ແລະ expect_after ຮູບແບບຄືກັບ ຄາດວ່າຈະ ເຮັດ.
ໃນເວລາທີ່ ຄາດຄະເນຄາດຄະເນການຄາດຄະເນພື້ນທີ່ ກໍາລັງຖືກປະເມີນ, ການປຸງແຕ່ງພື້ນຫລັງສໍາລັບ id spawn ດຽວກັນແມ່ນຖືກບລັອກ. ການປະມວນຜົນພື້ນຫລັງຖືກປິດບລັອກເມື່ອປະຕິບັດການແລ້ວ. ໃນຂະນະທີ່ການປະມວນຜົນພື້ນຫລັງຖືກບລັອກ, ມັນກໍ່ສາມາດເຮັດໄດ້ (foreground) ຄາດວ່າຈະ ຢູ່ໃນ id ດຽວກັນ.
ມັນບໍ່ເປັນໄປໄດ້ທີ່ຈະປະຕິບັດ ຄາດຫວັງ ໃນຂະນະທີ່ ຄາດຫວັງວ່າ ພື້ນ ຫລັງ ຈະຖືກ ຍົກເລີກ . expect_background ສໍາລັບ idle spawn ໂດຍສະເພາະແມ່ນຖືກລຶບໂດຍການປະກາດ expect_background ໃຫມ່ທີ່ມີ idlet ດຽວກັນດຽວກັນ. ການ ຄາດຄະເນຄາດ -background ກັບຮູບແບບທີ່ບໍ່ມີການຖອນຈໍານວນທີ່ໄດ້ກໍານົດໄວ້ຈາກຄວາມສາມາດທີ່ຈະກົງກັບຮູບແບບໃນພື້ນຫລັງ.
expect_before [expect_args]
ໃຊ້ເວລາການໂຕ້ຖຽງດຽວກັນຕາມ ຄາດຫວັງ , ແຕ່ມັນຈະກັບຄືນທັນທີ. ຄູ່ຄູ່ແບບການປະຕິບັດຈາກການ ຄາດຫວັງ ທີ່ສຸດທີ່ສຸດກັບ id ດຽວກັນທີ່ມີການສ້າງແມ່ນຖືກເພີ່ມເຂົ້າໄປໃນຄໍາສັ່ງທີ່ ຄາດຫວັງ ຕໍ່ໄປນີ້. ຖ້າຮູບແບບທີ່ກົງກັນຂ້າມ, ມັນຈະຖືກປະຕິບັດຕາມຖ້າມັນຖືກລະບຸໄວ້ໃນຄໍາສັ່ງທີ່ ຄາດວ່າຈະ ຕົວເອງແລະຮ່າງກາຍທີ່ກ່ຽວຂ້ອງຖືກປະຕິບັດໃນຄໍາສັ່ງທີ່ ຄາດ ໄວ້. ຖ້າຮູບແບບຈາກທັງສອງ expect_before ແລະ ຄາດວ່າຈະ ສາມາດກົງກັນໄດ້, ຮູບແບບ expect_before ຖືກນໍາໃຊ້.
ຖ້າຮູບແບບບໍ່ຖືກກໍານົດ, id spawn ບໍ່ໄດ້ຖືກກວດສອບສໍາລັບຮູບແບບຕ່າງໆ.
ເວັ້ນເສຍແຕ່ overridden ໂດຍ flag -i , expect_before ຮູບແບບທີ່ກົງກັນກັບ id spawn ກໍານົດໃນເວລາທີ່ຄໍາສັ່ງ expect_before ໄດ້ຖືກປະຕິບັດ (ບໍ່ແມ່ນໃນເວລາທີ່ຮູບແບບຂອງມັນແມ່ນ matched).
ການໂຄສະນາ -info ເຮັດໃຫ້ expect_before ກັບຄືນກັບຂໍ້ກໍານົດໃນປະຈຸບັນຂອງຮູບແບບທີ່ມັນຈະປະສົມປະສານ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ມັນລາຍງານກ່ຽວກັບຈໍານວນປັດຈຸບັນ. ຂໍ້ກໍານົດ id spawn ຕົວເລືອກທີ່ອາດຈະຖືກມອບໃຫ້ສໍາລັບຂໍ້ມູນກ່ຽວກັບຂໍ້ມູນທີ່ເກີດຂື້ນ. ຍົກຕົວຢ່າງ
expect_before -info -i $ procຢູ່ໃນທີ່ສຸດຫນຶ່ງຂໍ້ກໍານົດກ່ຽວກັບການຜະລິດນ້ໍານົມສາມາດໄດ້ຮັບ. ທຸງຊາດ - ການກົດຂີ່ຂົ່ມຂູ່ໂດຍອັດຕະໂນມັດການຜະລິດນ້ໍາທີ່ມາຈາກຂໍ້ກໍານົດໂດຍທາງອ້ອມ.
ແທນທີ່ຈະເປັນຂໍ້ກໍານົດຂອງການຜະລິດນ້ໍານົມ, ທຸງ "- ທັງຫມົດ" ຈະເຮັດໃຫ້ "ຂໍ້ມູນ" ທີ່ຈະລາຍງານກ່ຽວກັບທຸກຄົນທີ່ມີອາຍຸ.
ຜົນຜະລິດຂອງທົງຂໍ້ມູນສາມາດຖືກນໍາມາໃຊ້ໃຫມ່ເປັນຂໍ້ໂຕ້ແຍ້ງທີ່ຄາດຫວັງໄວ້ກ່ອນ.
expect_tty [expect_args]
ແມ່ນຄ້າຍຄື ຄາດ ແຕ່ວ່າມັນອ່ານຕົວອັກສອນຈາກ / dev / tty (ເຊົ່ນ keystrokes ຈາກຜູ້ໃຊ້). ໂດຍຄ່າເລີ່ມຕົ້ນ, ການອ່ານຈະຖືກປະຕິບັດໃນໂຫມດທີ່ປຸງແຕ່ງ. ດັ່ງນັ້ນ, ສາຍຕ້ອງສິ້ນສຸດດ້ວຍການກັບຄືນເພື່ອໃຫ້ ຄາດຫວັງວ່າ ຈະເຫັນມັນ. ນີ້ອາດຈະມີການປ່ຽນແປງໂດຍຜ່ານ stty (ເບິ່ງຄໍາສັ່ງ stty ຂ້າງລຸ່ມນີ້).
expect_user [expect_args]
ແມ່ນຄ້າຍຄື ຄາດ ແຕ່ວ່າມັນອ່ານຕົວອັກສອນຈາກ stdin (ເຊົ່ນ keystrokes ຈາກຜູ້ໃຊ້). ໂດຍຄ່າເລີ່ມຕົ້ນ, ການອ່ານຈະຖືກປະຕິບັດໃນໂຫມດທີ່ປຸງແຕ່ງ. ດັ່ງນັ້ນ, ສາຍຕ້ອງສິ້ນສຸດດ້ວຍການກັບຄືນເພື່ອໃຫ້ ຄາດຫວັງວ່າ ຈະເຫັນມັນ. ນີ້ອາດຈະມີການປ່ຽນແປງໂດຍຜ່ານ stty (ເບິ່ງຄໍາສັ່ງ stty ຂ້າງລຸ່ມນີ້).
fork
ສ້າງ ຂັ້ນຕອນ ໃຫມ່. ຂະບວນການ ໃຫມ່ແມ່ນສໍາເນົາຂອງ ຂະບວນການ ຄາດຫວັງ ຂອງປະຈຸບັນ. ໃນຄວາມສໍາເລັດ, ຟັກສະແດງ ຜົນກັບ 0 ກັບ ຂະບວນການ ໃຫມ່ (ເດັກ) ແລະສົ່ງຄືນ ID ຂອງ ຂະບວນການ ຂອງເດັກໃນ ຂັ້ນຕອນ ຂອງພໍ່ແມ່. ໃນຄວາມລົ້ມເຫຼວ (ເນື່ອງຈາກບໍ່ມີຊັບພະຍາກອນ, ເຊັ່ນ: ສະຖານທີ່ແລກປ່ຽນຂໍ້ມູນ, ຫນ່ວຍຄວາມຈໍາ), ການຕອບສະຫນອງ fork -1 ກັບ ຂະບວນການ ຂອງພໍ່ແມ່, ແລະບໍ່ມີ ຂະບວນການ ຂອງເດັກແມ່ນສ້າງ.
ຂະບວນການທີ່ຖອຍຫນີອອກມາຜ່ານຄໍາສັ່ງ ອອກ , ຄືກັບ ຂະບວນການ ຕົ້ນສະບັບ. ຂະບວນການທີ່ຖືກປະຕິບັດໄດ້ຖືກອະນຸຍາດໃຫ້ຂຽນເຂົ້າໃນໄຟລ໌ log. ຖ້າທ່ານບໍ່ປະຕິເສດການແກ້ໄຂຫລືເຂົ້າສູ່ລະບົບສ່ວນໃຫຍ່ຂອງຂະບວນການ, ຜົນໄດ້ຮັບອາດຈະສັບສົນ.
ບາງການປະຕິບັດ pty ອາດຈະສັບສົນໂດຍຜູ້ອ່ານແລະນັກຂຽນຫຼາຍ, ເຖິງແມ່ນວ່າບາງຄັ້ງ. ດັ່ງນັ້ນ, ມັນເປັນສິ່ງທີ່ປອດໄພທີ່ສຸດຕໍ່ການ ຟັກ ກ່ອນກ້າມເນື້ອ.
ໂຕ້ຕອບ [string1 body1] ... [stringn [bodyn]]
ເຮັດໃຫ້ການຄວບຄຸມຂອງ ຂະບວນການ ປະຈຸບັນກັບຜູ້ໃຊ້, ດັ່ງນັ້ນ keystrokes ຖືກສົ່ງໄປຫາ ຂະບວນການ ໃນປະຈຸບັນ, ແລະ stdout ແລະ stderr ຂອງ ຂະບວນການ ໃນປະຈຸບັນແມ່ນກັບຄືນ.
ຄູ່ຮ່າງຂອງຮ່າງກາຍອາດຈະຖືກກໍານົດໄວ້ເປັນຕົວຢ່າງ, ໃນກໍລະນີທີ່ຮ່າງກາຍຖືກປະຕິບັດເມື່ອມີຂໍ້ຄວາມທີ່ຖືກຕ້ອງ. (ໂດຍຄ່າເລີ່ມຕົ້ນ, ຊ່ອຍແນ່ບໍ່ໄດ້ຖືກສົ່ງໄປຫາ ຂະບວນການ ໃນປັດຈຸບັນ.) ຄໍາສັ່ງ ນາຍແປພາສາ ແມ່ນສົມມຸດ, ຖ້າຫາກວ່າຮ່າງກາຍສຸດທ້າຍແມ່ນຫາຍໄປ.
ຖ້າການໂຕ້ຖຽງກັບຄໍາສັ່ງ ໂຕ້ຕອບ ທັງຫມົດຕ້ອງການຫຼາຍກວ່າຫນຶ່ງເສັ້ນ, ການໂຕ້ຖຽງທັງຫມົດອາດຈະຖືກ "ຂື້ນ" ເປັນຫນຶ່ງເພື່ອຫຼີກເວັ້ນການສິ້ນສຸດແຕ່ລະເສັ້ນໂດຍມີສັນຍານກັນດານ. ໃນກໍລະນີນີ້, ການທົດແທນ Tcl ປົກກະຕິຈະເກີດຂຶ້ນເຖິງແມ່ນວ່າຈະມີການຂັດຂວາງ.
ຕົວຢ່າງດັ່ງຕໍ່ໄປນີ້ຄໍາສັ່ງຕໍ່ໄປນີ້ຈະມີການພົວພັນກັບຄູ່ສາຍຂອງຮ່າງກາຍດັ່ງຕໍ່ໄປນີ້ກໍານົດໄວ້: ເມື່ອ ^ Z ຖືກກົດ, ຄາດວ່າ ຈະຖືກຍົກເລີກ. (ທຸງຂອງ ເຊື່ອງ ຄືນ restores ໂຫມດທີ່ຢູ່ປາຍຍອດ). ເມື່ອ ^ ກົດ, ຜູ້ໃຊ້ເຫັນວ່າ "ທ່ານພິມຕົວຄວບຄຸມ-A" ແລະ ຂະບວນການ ຖືກສົ່ງໄປ ^ A. ເມື່ອກົດ $, ຜູ້ໃຊ້ຈະເຫັນວັນທີ. ເມື່ອ C ຖືກກົດ, ຄາດວ່າຈະ ອອກມາ. ຖ້າ "foo" ຖືກເຂົ້າໄປ, ຜູ້ໃຊ້ຈະເຫັນ "ແຖບ". ເມື່ອ ~~ ຖືກກົດ, ນາຍແປພາສາ ຄາດວ່າ ຈະມີການພົວພັນກັນ.
set CTRLZ \ 032 interact {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "ຄຸນພິມຄວບຄຸມ -A \ n" ສົ່ງ "\ 001"} $ {send_user "ວັນທີແມ່ນ [ຮູບແບບໂມງ [ວິນາທີໂມງ]].}} \ 003 ອອກຈາກ foo {send_user" bar "} ~~}ໃນຄູ່ສາຍຂອງຮ່າງກາຍ, ສາຍຈະຖືກຈັບໃນຄໍາສັ່ງທີ່ພວກມັນຖືກລະບຸໄວ້ເປັນຂໍ້ໂຕ້ແຍ້ງ. ສາຍທີ່ກົງກັນບາງຢ່າງບໍ່ໄດ້ຖືກສົ່ງໄປຫາ ຂະບວນການ ໃນປະຈຸບັນໃນການຄາດເດົາຂອງສິ່ງທີ່ເຫລືອຢູ່. ຖ້າຫາກວ່າລັກສະນະດັ່ງກ່າວຖືກເຂົ້າໄປໃນນັ້ນກໍ່ບໍ່ສາມາດເປັນການແຂ່ງຂັນໄດ້, ແຕ່ສ່ວນຫນຶ່ງຂອງຊ່ອຍແນ່ຈະຖືກສົ່ງໄປຫາ ຂະບວນການ ທີ່ບໍ່ສາມາດເລີ່ມຕົ້ນການແຂ່ງຂັນອື່ນ. ດັ່ງນັ້ນ, ຊ່ອຍແນ່ທີ່ເປັນ substrings ຂອງຄໍາວ່າ partial ສາມາດແຂ່ງຂັນຕໍ່ມາ, ຖ້າວ່າສາຍທໍາອິດທີ່ພະຍາຍາມທີ່ຈະແຂ່ງຂັນສຸດທ້າຍກໍ່ລົ້ມເຫລວ.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ການຈັບຄູ່ສາຍແມ່ນກົງກັນຂ້າມກັບບໍ່ມີ ບັດທໍາມະຊາດ . (ໃນທາງກົງກັນຂ້າມ, ຄໍາສັ່ງທີ່ ຄາດຫວັງຈະ ໃຊ້ຮູບແບບແບບທົ່ວໄປໂດຍຄ່າເລີ່ມຕົ້ນ.) ທຸງ -ex ສາມາດຖືກນໍາໃຊ້ເພື່ອປົກປ້ອງຮູບແບບຕ່າງໆທີ່ອາດຈະກົງກັບ ການໂຕ້ຕອບຂອງ ທຸລະກິດ. ຮູບແບບເລີ່ມຕົ້ນດ້ວຍ "-" ຄວນໄດ້ຮັບການປົກປ້ອງດ້ວຍວິທີນີ້. (ທຸກສາຍທີ່ເລີ່ມຕົ້ນດ້ວຍ "-" ຈະຖືກຈອງໄວ້ສໍາລັບຕົວເລືອກໃນອະນາຄົດ.)
ທຸງຊາດຂອງທ່ານກໍາລັງຖືກຕີຄວາມວ່າເປັນຮູບແບບແບບ regexp-style. ໃນກໍລະນີນີ້, substrings ທີ່ກົງກັນຖືກເກັບໄວ້ໃນຕົວປ່ຽນແປງ interact_out ເຊັ່ນດຽວກັນກັບວິທີການ ຄາດວ່າຈະ ເກັບເອົາ output ຂອງມັນໃນ variable expect_out . ທຸງທົງໄດ້ຖືກສະຫນັບສະຫນູນຢ່າງດຽວກັນ.
ຮູບແບບ eof ແນະນໍາການປະຕິບັດທີ່ຖືກປະຕິບັດເມື່ອທ້າຍຂອງໄຟລ໌. ຮູບແບບ eof ແຍກຕ່າງຫາກອາດຈະປະຕິບັດຕາມ flag -output ໃນກໍລະນີທີ່ມັນຖືກຈັບຄູ່ຖ້າຫາກວ່າ eof ຖືກກວດພົບໃນຂະນະທີ່ຂຽນລາຍຈ່າຍ. ການປະຕິບັດຕົວຈິງແມ່ນ "ກັບຄືນ", ດັ່ງນັ້ນ ການໂຕ້ຕອບ ພຽງແຕ່ກັບຄືນມາເມື່ອໃດກໍ່ຕາມ.
ເວລາ ແບບ ເວລາ ສະແດງຄໍາແນະນໍາເວລາ (ໃນວິນາທີ) ແລະການປະຕິບັດທີ່ຖືກປະຕິບັດຫຼັງຈາກທີ່ບໍ່ມີລັກສະນະໃດໆສໍາລັບເວລາທີ່ກໍານົດ. ຮູບແບບທີ່ໃຊ້ ເວລາຫມົດເວລາ ຈະໃຊ້ກັບ ຂະບວນການ ທີ່ກໍານົດໄວ້ໃນປະຈຸບັນທີ່ສຸດ. ບໍ່ມີເວລາທີ່ກໍານົດໄວ້ໃນຕອນຕົ້ນ. ຕົວແປພິເສດ "timeout" (ໃຊ້ໂດຍຄໍາສັ່ງ ຄາດຫມາຍ ) ຈະບໍ່ມີຜົນກະທົບຕໍ່ເວລາຫມົດເວລານີ້.
ຕົວຢ່າງເຊັ່ນຄໍາສັ່ງດັ່ງຕໍ່ໄປນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອ autologout ຜູ້ໃຊ້ທີ່ບໍ່ໄດ້ພິມຫຍັງສໍາລັບຊົ່ວໂມງແຕ່ຜູ້ທີ່ຍັງໄດ້ຮັບຂໍ້ຄວາມລະບົບເລື້ອຍໆ:
interact-input $ user_spawn_id timeout 3600 return -out \ $ spawn_idຖ້າຮູບແບບແມ່ນຄໍາສັບທີ່ ຖືກ null ແລະ nulls ຖືກອະນຸຍາດ (ຜ່ານຄໍາສັ່ງ remove_nulls ), ຮ່າງກາຍທີ່ສອດຄ້ອງກັນຈະຖືກປະຕິບັດຖ້າ ASCII 0 ດຽວເທົ່ານັ້ນ. ມັນບໍ່ສາມາດຫາ 0 bytes ຜ່ານຮູບແບບ glob ຫຼື regexp.
ການຕັ້ງຄ່າຮູບແບບທີ່ມີ flag -iwrite ເຮັດໃຫ້ interchange variable (spawn_id) ຖືກຕັ້ງຄ່າໃຫ້ spawn_id ເຊິ່ງກົງກັບຮູບແບບ (ຫຼື eof).
ການກະທໍາເຊັ່ນການ ຢຸດພັກ ແລະ ສືບຕໍ່ ເຮັດໃຫ້ໂຄງສ້າງການຄວບຄຸມ (ຕົວຢ່າງ, ສໍາລັບ , proc ) ປະຕິບັດຕົວຕາມປົກກະຕິ. ຢ່າງໃດກໍ່ຕາມ ຜົນຕອບແທນ ເຮັດໃຫ້ການໂຕ້ຕອບກັບຄືນໄປຫາຜູ້ໂທຂອງຕົນ, ໃນຂະນະທີ່ inter_return ເຮັດໃຫ້ເກີດ ການພົວພັນ ກັບເຮັດໃຫ້ການກັບຄືນໃນໂທຂອງຕົນ. ຕົວຢ່າງເຊັ່ນຖ້າ "proc foo" ເອີ້ນ ການພົວພັນ ຊຶ່ງຫຼັງຈາກນັ້ນປະຕິບັດການປະຕິບັດ inter_return , proc foo ຈະກັບຄືນມາ. (ນີ້ຫມາຍຄວາມວ່າຖ້າ ໂຕ້ຕອບ ການ ແປພາສາ ຜົນຕອບແທນ ການພິມອັດຕະໂນມັດຈະເຮັດໃຫ້ການໂຕ້ຕອບຕໍ່ໄປ, ໃນຂະນະທີ່ inter_return ຈະເຮັດໃຫ້ການໂຕ້ຕອບກັບຄືນໄປຫາຜູ້ໂທຂອງມັນ.)
ໃນລະຫວ່າງ ການໂຕ້ຕອບ , ໂຫມດດິບຖືກນໍາໃຊ້ເພື່ອວ່າຕົວອັກສອນທັງຫມົດອາດຈະຖືກສົ່ງໄປຫາ ຂະບວນການ ໃນປັດຈຸບັນ. ຖ້າ ຂະບວນການ ໃນປະຈຸບັນບໍ່ຈັບສັນຍານຄວບຄຸມວຽກ, ມັນຈະຢຸດຖ້າສົ່ງສັນຍານຢຸດ (ໂດຍຄ່າເລີ່ມຕົ້ນ ^ Z). ເພື່ອເລີ່ມຕົ້ນໃຫມ່, ໃຫ້ສົ່ງສັນຍານຕໍ່ເນື່ອງ (ເຊັ່ນ: "kill-CONT"). ຖ້າທ່ານຕ້ອງການສົ່ງ SIGSTOP ໄປໃນ ຂະບວນການ ດັ່ງກ່າວ (ໂດົຍ ^ Z), ພິຈາລະນາຄິດໄລ່ຮາກຂອງ csh ກ່ອນແລະຫຼັງຈາກນັ້ນເຮັດວຽກງານຂອງທ່ານ. ໃນທາງກົງກັນຂ້າມຖ້າທ່ານຕ້ອງການສົ່ງ SIGSTOP ໄປໃຫ້ຕົວເອງ, ໃຫ້ໂທຫານາຍຫນ້າທໍາອິດ (ອາດຈະໃຊ້ຕົວອັກສອນ escape) ແລ້ວກົດ ^ Z.
ຄູ່ຄູ່ຂອງຮ່າງກາຍສາມາດຖືກນໍາໃຊ້ເປັນຕົວຢ່າງເພື່ອຫຼີກລ່ຽງການເຂົ້າແປກແລະປະຕິບັດຄໍາສັ່ງທີ່ມີປະສິດຕິພາບ. ໂຫມດປາຍທາງທີ່ຜ່ານມາຖືກນໍາໃຊ້ໃນຂະນະທີ່ຮ່າງກາຍຂອງຄູ່ເຊືອກ - ຮ່າງກາຍກໍາລັງຖືກປະຕິບັດ.
ສໍາລັບຄວາມໄວ, ການດໍາເນີນການໃນໂຫມດດິບໂດຍຄ່າເລີ່ມຕົ້ນ. ທົງ -reet resets terminal ກັບໂຫມດທີ່ມັນມີກ່ອນທີ່ຈະ ໂຕ້ຕອບ ໄດ້ຖືກປະຕິບັດ (invariably, ໂຫມດທີ່ປຸງແຕ່ງ). ໃຫ້ສັງເກດວ່າຕົວອັກສອນທີ່ເຂົ້າມາໃນເວລາທີ່ໂຫມດການປ່ຽນແປງອາດຈະສູນເສຍ (ຄຸນສົມບັດທີ່ຫນ້າເສຍດາຍຂອງຕົວຂັບຂົວໃນບາງລະບົບ). ເຫດຜົນດຽວທີ່ຈະໃຊ້ -reet ແມ່ນຖ້າການປະຕິບັດຂອງທ່ານແມ່ນຂຶ້ນຢູ່ກັບການເຮັດວຽກໃນໂຫມດທີ່ປຸງແຕ່ງ.
ທົງ -echo ສົ່ງລັກສະນະທີ່ກົງກັບຮູບແບບດັ່ງຕໍ່ໄປນີ້ກັບ ຂະບວນການ ທີ່ສ້າງໃຫ້ພວກເຂົາເປັນລັກສະນະແຕ່ລະຄົນຖືກອ່ານ. ນີ້ອາດຈະເປັນປະໂຫຍດເມື່ອຜູ້ໃຊ້ຕ້ອງເຫັນການຕອບຮັບຈາກຮູບແບບທີ່ຖືກພິມບາງສ່ວນ.
ຖ້າຮູບແບບໃດຫນຶ່ງຖືກຍົກເວັ້ນແຕ່ໃນທີ່ສຸດກໍ່ບໍ່ສາມາດກົງກັນໄດ້, ຕົວອັກສອນຈະຖືກສົ່ງໄປຫາ ຂະບວນການທີ່ ຜະລິດ. ຖ້າຫາກວ່າ ຂະບວນການທີ່ ຜະລິດຫຼັງຈາກນັ້ນສົ່ງຂໍ້ຄວາມໃຫ້ພວກເຂົາ, ຜູ້ໃຊ້ຈະເຫັນລັກສະນະສອງຄັ້ງ. -echo ແມ່ນອາດຈະເຫມາະສົມພຽງແຕ່ໃນສະຖານະການທີ່ຜູ້ໃຊ້ບໍ່ສາມາດເຮັດສໍາເລັດຮູບແບບໄດ້. ຕົວຢ່າງເຊັ່ນການຄັດລອກຕໍ່ໄປນີ້ແມ່ນຈາກ rftp, script recursive-ftp, ບ່ອນທີ່ຜູ້ໃຊ້ຖືກຮຽກຮ້ອງໃຫ້ເຂົ້າ ~ g, ~ p, ຫຼື ~ l, ເພື່ອເອົາ, ເອົາຫຼືບັນທຶກໄດເລກະທໍລີໃນປະຈຸບັນ. ເຫຼົ່ານີ້ແມ່ນຢູ່ຫ່າງໄກຈາກຄໍາສັ່ງ ftp ປົກກະຕິ, ທີ່ຜູ້ໃຊ້ບໍ່ສາມາດພິມໄດ້ ~ ປະຕິບັດຕາມສິ່ງອື່ນ, ຍົກເວັ້ນຂໍ້ຜິດພາດ, ໃນກໍລະນີນັ້ນ, ພວກເຂົາອາດຈະບໍ່ສົນໃຈຜົນໄດ້ຮັບ.
interact {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}flag- noobs ສົ່ງລັກສະນະທີ່ກົງກັບຮູບແບບດັ່ງຕໍ່ໄປນີ້ກັບ ຂະບວນການ ຜະລິດຕາມລັກສະນະທີ່ໄດ້ອ່ານ.
ນີ້ແມ່ນເປັນປະໂຫຍດເມື່ອທ່ານຕ້ອງການໃຫ້ໂຄງການ ສະທ້ອນ ກັບຮູບແບບ. ຕົວຢ່າງດັ່ງຕໍ່ໄປນີ້ອາດຈະຖືກນໍາໃຊ້ເພື່ອຕິດຕາມກວດກາບ່ອນທີ່ຜູ້ໃດຜູ້ຫນຶ່ງກໍາລັງໂທຫາ (ໂມເດັມແບບ Hayes). ແຕ່ລະຄັ້ງທີ່ "atd" ເຫັນຕົວອັກສອນບັນທຶກສ່ວນທີ່ເຫຼືອຂອງເສັ້ນ.
proc lognumber {} {interactive -nobuffer -re "(*) \ r" return puts $ log "[ຮູບແບບເວລາ [ວິນາທີໂມງ]]: dialed $ interactive_out (1, string)"} interact -nobuffer "atd" lognumberໃນລະຫວ່າງ ການໂຕ້ຕອບ , ການນໍາໃຊ້ກ່ອນຫນ້ານີ້ຂອງ log_user ຖືກ ຍົກເລີກ . ໂດຍສະເພາະ, ການໂຕ້ຕອບ ຈະບັງຄັບຜົນຜະລິດຂອງຕົນທີ່ຈະຖືກບັນທຶກ (ສົ່ງໄປຫາມາດຕະຖານຜົນຜະລິດ) ເນື່ອງຈາກວ່າມັນຖືວ່າຜູ້ໃຊ້ບໍ່ຕ້ອງການພົວພັນຢ່າງສະຫລາດ.
ທຸງ -o ເຮັດໃຫ້ຄູ່ໃດຫນຶ່ງທີ່ມີລັກສະນະດັ່ງຕໍ່ໄປນີ້ຖືກນໍາໃຊ້ກັບຜົນຂອງ ຂະບວນການ ໃນປະຈຸບັນ. ນີ້ອາດຈະເປັນປະໂຫຍດ, ສໍາລັບຕົວຢ່າງ, ເມື່ອຈັດການກັບ ເຈົ້າພາບ ທີ່ສົ່ງລັກສະນະທີ່ບໍ່ຕ້ອງການໃນໄລຍະເວທີ telnet.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ການ ຄາດຕະກໍາຄາດວ່າຜູ້ໃຊ້ຈະຂຽນ stdin ແລະອ່ານ stdout ຂອງ ຂະບວນການ ຄາດຫວັງ ຕົວມັນເອງ. ທຸງຊາດ -u (ສໍາລັບ "ຜູ້ໃຊ້") ເຮັດໃຫ້ ມີການພົວພັນ ເບິ່ງສໍາລັບຜູ້ໃຊ້ເປັນ ຂະບວນການທີ່ ຕັ້ງຊື່ໂດຍການໂຕ້ຖຽງຂອງມັນ (ເຊິ່ງຕ້ອງເປັນເອກະສານທີ່ສ້າງຂື້ນ).
ນີ້ອະນຸຍາດໃຫ້ສອງຂະບວນການທີ່ບໍ່ກ່ຽວຂ້ອງກັບການຮ່ວມກັນໂດຍບໍ່ຕ້ອງໃຊ້ເສັ້ນທາງ explicit. ເພື່ອຊ່ວຍໃນການແກ້ໄຂ, ຄາດຫວັງວ່າການກວດກາຈະສະເຫມີໄປຫາ stderr (ຫຼື stdout ສໍາລັບຂໍ້ມູນການເຂົ້າສູ່ລະບົບແລະແກ້ໄຂຂໍ້ມູນບາງຢ່າງ). ສໍາລັບເຫດຜົນດຽວກັນ, ຄໍາສັ່ງ ນາຍແປພາສາ ຈະອ່ານແບບໂຕ້ຕອບຈາກ stdin.
ຕົວຢ່າງ, fragment ດັ່ງຕໍ່ໄປນີ້ສ້າງ ຂະບວນການ ເຂົ້າສູ່ລະບົບ. ຫຼັງຈາກນັ້ນ, ມັນ dials ຜູ້ໃຊ້ (ບໍ່ໄດ້ສະແດງໃຫ້ເຫັນ), ແລະສຸດທ້າຍເຊື່ອມຕໍ່ທັງສອງຮ່ວມກັນ. ແນ່ນອນ, ຂະບວນການ ໃດກໍ່ອາດຈະຖືກແທນທີ່ສໍາລັບການເຂົ້າສູ່ລະບົບ. ຍົກຕົວຢ່າງ, ເປືອກ, ຈະຊ່ວຍໃຫ້ຜູ້ໃຊ້ເຮັດວຽກໂດຍບໍ່ມີການສະຫນອງບັນຊີແລະລະຫັດຜ່ານ.
ສະແດງຂໍ້ມູນສ່ວນຕົວຂອງສະມາຊິກເພື່ອສົ່ງຜົນຜະລິດໄປຫາຂະບວນການຫຼາຍໆ, ລາຍຊື່ບັນຊີລາຍຊື່ຂອງແຕ່ລະບັນຊີທີ່ນໍາຫນ້າໂດຍທຸງອອກ. ການເຂົ້າສໍາລັບ ກຸ່ມ ຂອງສາຍພັນທີ່ມີຜົນຜະລິດສາມາດຖືກກໍານົດໂດຍບັນຊີລາຍຊື່ id ທີ່ເກີດຂື້ນກ່ອນທີ່ຈະນໍາເອົາຂໍ້ມູນເຂົ້າ ໃສ່ . (Both- input and -output ອາດຈະເອົາລາຍການໃນຮູບແບບດຽວກັນກັບ -i flag ໃນຄໍາສັ່ງທີ່ ຄາດຫວັງ , ເວັ້ນເສຍແຕ່ວ່າ any_spawn_id ບໍ່ມີຄວາມຫມາຍໃນ ການໂຕ້ຕອບ .) ທຸກປະກົດແລະ ສາຍ (ຫຼືຮູບແບບຕໍ່ໄປນີ້) ປ້າຍເຂົ້າໃສ່ຈະປາກົດ. ຖ້າບໍ່ມີຂໍ້ ມູນ ຈະປາກົດ, -output ຫມາຍເຖິງ "-input $ user_spawn_id -output". (ຄ້າຍຄືກັນ, ມີຮູບແບບທີ່ບໍ່ມີ -input .) ຖ້າມີຂໍ້ມູນຫນຶ່ງລະບຸ, ມັນ overrides $ user_spawn_id. ຖ້າມີຂໍ້ມູນເຂົ້າສອງຄັ້ງ, ມັນແທນ $ spawn_id. ຂໍ້ມູນເພີ່ມເຕີມ - ຫມາຍໃສ່ໃນ ປ້າຍຂໍ້ມູນອາດຈະຖືກກໍານົດໄວ້.
ຂະບວນການປະກອບເຂົ້າສອງ implied ໃນຕອນຕົ້ນທີ່ມີຜົນຜະລິດຂອງພວກເຂົາລະບຸເປັນ $ spawn_id ແລະ $ user_spawn_id (ໃນທາງກັບກັນ). ຖ້າມີ flag ຂໍ້ມູນເຂົ້າມາມີ no -out flag, ຕົວອັກສອນຈາກ ຂະບວນການ ນັ້ນຈະຖືກຍົກເລີກ.
ທຸງ -i ໄດ້ ແນະນໍາການທົດແທນການໃຊ້ສະກຸນເງິນທີ່ມີຢູ່ໃນປະຈຸບັນເມື່ອບໍ່ມີການນໍາໃຊ້ຂໍ້ມູນອື່ນໃດໆ. A -i flag ຫມາຍຄວາມວ່າເປັນ -o flag.
ມັນເປັນໄປໄດ້ທີ່ຈະປ່ຽນຂະບວນການທີ່ມີການພົວພັນກັບການນໍາໃຊ້ເຕັກນິກການຜະລິດນ້ໍາມັນອ້ອມຂ້າງ. (ເຕົ້າໄຂ່ຜັກທຽມໂດຍກົງແມ່ນອະທິບາຍໃນສ່ວນຄໍາສັ່ງທີ່ຄາດຫວັງ). ຂໍ້ມູນອື່ນໆທີ່ອາດຈະຖືກກໍານົດໄວ້ໃນປ້າຍ -i, -u, -input, or -output.
interpreter [args]
ເຮັດໃຫ້ຜູ້ໃຊ້ໄດ້ຮັບການແຈ້ງເຕືອນກ່ຽວກັບການ ຄາດຫວັງ ແລະຄໍາສັ່ງ Tcl. ຜົນໄດ້ຮັບຂອງແຕ່ລະຄໍາສັ່ງຖືກພິມ.
ການກະທໍາເຊັ່ນການ ຢຸດພັກ ແລະ ສືບຕໍ່ ເຮັດໃຫ້ໂຄງສ້າງການຄວບຄຸມ (ຕົວຢ່າງ, ສໍາລັບ , proc ) ປະຕິບັດຕົວຕາມປົກກະຕິ. ຢ່າງໃດກໍ່ຕາມ ຍ້ອນກັບ ເຮັດໃຫ້ນາຍແປພາສາກັບຄືນກັບຜູ້ໂທຂອງຕົນ, ໃນຂະນະທີ່ inter_return ເຮັດໃຫ້ ນາຍພາ ສາເຮັດໃຫ້ການກັບຄືນໃນໂທຂອງຕົນ. ຕົວຢ່າງເຊັ່ນຖ້າ "proc foo" ເອີ້ນວ່າ ນາຍພາສາ ທີ່ປະຕິບັດການປະຕິບັດ inter_return , proc foo ຈະກັບຄືນ. ຄໍາສັ່ງອື່ນໆທີ່ເຮັດໃຫ້ ນາຍພາສາ ສືບຕໍ່ກະຕຸ້ນເຕືອນສໍາລັບຄໍາສັ່ງໃຫມ່.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ກະລຸນາປະກອບດ້ວຍສອງຕົວເລກ. ຈໍານວນເຕັມທໍາອິດອະທິບາຍເຖິງຄວາມເລິກຂອງການປະເມີນຜົນສະຖິຕິ (ຕົວຢ່າງ Tcl_Eval ຈໍານວນເທົ່າໃດຖືກເອີ້ນ). ຈໍານວນເຕັມທີສອງແມ່ນຕົວລະບຸປະຫວັດຂອງ Tcl. prompt ສາມາດກໍານົດໂດຍການກໍານົດຂັ້ນຕອນທີ່ເອີ້ນວ່າ "prompt1" ທີ່ມີມູນຄ່າ return ເປັນ prompt. ຖ້າຄໍາສັ່ງມີວົງຢືມເປີດ, ວົງເລັບ, ວົງເລັບ, ຫຼືວົງເລັບ, ຕົວຊີ້ວັດທີສອງ (ຕາມ "+" ຄໍາສັ່ງ "") ແມ່ນອອກຕາມໃຫມ່. ຄໍາແນະນໍາທີສອງອາດຈະກໍານົດໂດຍການກໍານົດຂັ້ນຕອນທີ່ເອີ້ນວ່າ "prompt2".
ໃນລະຫວ່າງການ ແປພາສາ , ໂຫມດການປຸງແຕ່ງແມ່ນຖືກນໍາໃຊ້, ເຖິງແມ່ນວ່າຜູ້ໂທຂອງຕົນໄດ້ໃຊ້ຮູບແບບດິບ.
ຖ້າ stdin ຖືກປິດ, ນາຍແປພາສາ ຈະກັບຄືນໄປບ່ອນເວັ້ນເສຍແຕ່ວ່າການນໍາໃຊ້ທຸງຊາດ ໃດໆ , ໃນກໍລະນີທີ່ການໂຕ້ຖຽງຕໍ່ມາຖືກເອີ້ນ.
log_file [args] [[-a] file]
ຖ້າມີຊື່ໄຟລ໌, log_file ຈະບັນທຶກບົດສະຫຼຸບຂອງກອງປະຊຸມ (ເລີ່ມຕົ້ນໃນຈຸດນັ້ນ) ໃນໄຟລ໌. log_file ຈະຢຸດການບັນທຶກຖ້າບໍ່ມີການໂຕ້ຖຽງ. ທຸກໄຟລ໌ບັນທຶກກ່ອນຫນ້ານີ້ແມ່ນປິດ.
ແທນທີ່ຈະເປັນຊື່ໄຟລ໌, ຕົວກໍານົດການໄຟລ໌ Tcl ອາດຈະຖືກສະຫນອງໃຫ້ໂດຍການນໍາໃຊ້ ທຸງ - ເປີດ ຫຼືທຸລະກິດ. ນີ້ແມ່ນຄ້າຍຄືກັນກັບຄໍາສັ່ງຂອງປາ. (ເບິ່ງ ຕົ້ນສະບັບ ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.)
ຜົນບັງຄັບໃຊ້ກໍາລັງ flag -a ຈະຖືກບັນທຶກໄວ້ທີ່ຖືກລຶບໂດຍຄໍາສັ່ງ log_user .
ໂດຍຄ່າເລີ່ມຕົ້ນ, ຄໍາສັ່ງ log_file ເພີ່ມເຕີມ ກັບແຟ້ມເກົ່າແທນທີ່ຈະຕັດໃຫ້ພວກເຂົາເພື່ອຄວາມສະດວກໃນການເຮັດການເຂົ້າສູ່ລະບົບແລະການເຂົ້າເຖິງຫລາຍຄັ້ງໃນຫນຶ່ງ session. ເພື່ອ truncate ໄຟລ໌, ໃຫ້ນໍາໃຊ້ flag -noappend .
ທຸງ -info ເຮັດໃຫ້ log_file ກັບຄືນລາຍລະອຽດຂອງການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນຂໍ້ມູນຫຼ້າສຸດທີ່ໄດ້ຮັບມາ.
log_user -info | 0 | 1
ໂດຍຄ່າເລີ່ມຕົ້ນ, ການສົນທະນາສົ່ງ / ຄາດວ່າຈະຖືກເຂົ້າສູ່ລະບົບ stdout (ແລະແຟ້ມ logfile ຖ້າເປີດ). ການເຂົ້າສູ່ລະບົບ stdout ຖືກປິດໃຊ້ໂດຍຄໍາສັ່ງ "log_user 0" ແລະ reenabled ໂດຍ "log_user 1". ການເຂົ້າສູ່ລະບົບ logfile ແມ່ນບໍ່ມີການປ່ຽນແປງ.
ທຸງ -info ເຮັດໃຫ້ log_user ກັບຄືນລາຍລະອຽດຂອງການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນຂໍ້ມູນຫຼ້າສຸດທີ່ໄດ້ຮັບມາ.
match_max [-d] [-i spawn_id] [size]
ກໍານົດຂະຫນາດຂອງ buffer (in bytes) ທີ່ໃຊ້ພາຍໃນໂດຍ ຄາດຫວັງ . ໂດຍບໍ່ມີການໂຕ້ຖຽງ ຂະຫນາດ , ຂະຫນາດໃນປະຈຸບັນຈະຖືກສົ່ງຄືນ.
ມີທຸງ -d , ຂະຫນາດເລີ່ມຕົ້ນຖືກກໍານົດ. (ຄ່າເລີ່ມຕົ້ນແມ່ນ 2000. ) ມີທົງ -i , ຂະຫນາດແມ່ນກໍານົດສໍາລັບ id spawn ຊື່, ຖ້າບໍ່ດັ່ງນັ້ນມັນຖືກກໍານົດສໍາລັບ ຂະບວນການ ໃນປັດຈຸບັນ.
overlay [- # spawn_id] [- # spawn_id] [... ] program [args]
ປະຕິບັດ "ໂປຣແກຣມຂອງໂຄງການ " ແທນທີ່ ຈະເປັນ ໂຄງການທີ່ ຄາດວ່າຈະ ປະຈຸບັນ. ການໂຕ້ຕອບ hyphen ເປົ່າບັງຄັບໃຫ້ກົດທີ່ຢູ່ທາງຫນ້າຂອງຊື່ຄໍາສັ່ງເປັນຖ້າມັນເປັນ shell ເຂົ້າສູ່ລະບົບ. ທັງຫມົດ spawn_ids ຖືກປິດເວັ້ນເສຍແຕ່ວ່າທີ່ມີຊື່ວ່າເປັນການໂຕ້ຖຽງ. ເຫຼົ່ານີ້ແມ່ນໄດ້ຖືກກໍານົດໃສ່ຕົວລະບຸຊື່ແຟ້ມ.
Spawn_ids ແມ່ນການກໍານົດແຜນທີ່ຈະກໍານົດຕົວລະບຸຊື່ສໍາລັບໂຄງການໃຫມ່ທີ່ຈະໄດ້ຮັບມໍລະດົກ. ສໍາລັບຕົວຢ່າງ, ເສັ້ນດັ່ງຕໍ່ໄປນີ້ຈະແລ່ນ chess ແລະອະນຸຍາດໃຫ້ມັນຈະໄດ້ຮັບການຄວບຄຸມໂດຍ ຂະບວນການ ໃນປະຈຸບັນ - ເວົ້າ, ເປັນຕົ້ນສະບັບ chess.
overlay-0 $ spawn_id -1 $ spawn_id-2 $ spawn_id chessນີ້ແມ່ນປະສິດທິພາບຫຼາຍກ່ວາ "ໂຕ້ຕອບ -u", ແຕ່ມັນເສຍສະຫຼະຄວາມສາມາດໃນການເຮັດການປະຕິບັດໂຄງການນັບຕັ້ງແຕ່ ຂະບວນການ ຄາດຫວັງ ບໍ່ສາມາດຄວບຄຸມໄດ້.
ໃຫ້ສັງເກດວ່າບໍ່ມີການຄວບຄຸມປາຍທາງ. ດັ່ງນັ້ນ, ຖ້າທ່ານປິດການເຊື່ອມຕໍ່ຫຼືທົດແທນການເຂົ້າຂໍ້ມູນມາດຕະຖານ, ໂຄງການທີ່ຄວບຄຸມວຽກ (shells, login, etc) ຈະບໍ່ເຫມາະສົມ.
parity [-d] [-i spawn_id] [value]
ກໍານົດບໍ່ວ່າ parity ຄວນເກັບຮັກສາໄວ້ຫຼືຖອດອອກຈາກຜົນຜະລິດຂອງຂະບວນການທີ່ຜະລິດ. ຖ້າວ່າ ມູນຄ່າ ແມ່ນສູນ, parity ຈະຖືກລອກເອົາ, ຖ້າບໍ່ດັ່ງນັ້ນມັນຈະບໍ່ຖືກໂຍກຍ້າຍ. ໂດຍບໍ່ມີການໂຕ້ແຍ້ງ ຄ່າ , ມູນຄ່າປັດຈຸບັນຈະຖືກສົ່ງຄືນ.
ມີທຸງ -d , ມູນຄ່າ parity ເລີ່ມຕົ້ນຖືກກໍານົດ. (ຄ່າເລີ່ມຕົ້ນແມ່ນ 1, ie, parity ບໍ່ໄດ້ຖືກຖອດອອກ.) ດ້ວຍ flag -i , ມູນຄ່າ parity ແມ່ນກໍານົດສໍາລັບ id spawn ຊື່, ຖ້າບໍ່ດັ່ງນັ້ນມັນຈະຖືກກໍານົດໄວ້ໃນ ຂະບວນການ ປະຈຸບັນ.
remove_nulls [-d] [-i spawn_id] [value]
ກໍານົດວ່າ nulls ແມ່ນເກັບຮັກສາໄວ້ຫຼືເອົາອອກຈາກຜົນຜະລິດຂອງຂະບວນການທີ່ຜະລິດກ່ອນທີ່ຈະຈັບຄູ່ຫຼືການເກັບຮັກສາໄວ້ໃນຕົວ ຄາດຫວັງ expect_out ຫຼື interaction_out . ຖ້າ ຄ່າ ແມ່ນ 1, nulls ຖືກລຶບ. ຖ້າ ຄ່າ ເປັນ 0, nulls ຈະບໍ່ຖືກລົບອອກ. ໂດຍບໍ່ມີການໂຕ້ແຍ້ງ ຄ່າ , ມູນຄ່າປັດຈຸບັນຈະຖືກສົ່ງຄືນ.
ດ້ວຍທຸງ -d , ຄ່າເລີ່ມຕົ້ນຖືກກໍານົດ. (ຄ່າເລີ່ມຕົ້ນແມ່ນ 1, ຄື nulls ຖືກລຶບອອກ) ດ້ວຍ flag -i , ມູນຄ່າແມ່ນກໍານົດສໍາລັບ id spawn ຊື່, ຖ້າບໍ່ດັ່ງນັ້ນມັນຈະຖືກກໍານົດໄວ້ໃນ ຂະບວນການ ປະຈຸບັນ.
ບໍ່ວ່າຈະມີການຖອນ nulls ຫຼືບໍ່, ຄາດວ່າ ຈະບັນທຶກ ntes bytes ກັບ log ແລະ stdout.
ສົ່ງ [-flags] string
ສົ່ງ ສາຍ ໄປຍັງະ ຂະບວນການ ປະຈຸບັນ. ຕົວຢ່າງ, ຄໍາສັ່ງ
ສົ່ງລັກສະນະ, helloworld ໄປສູ່ ຂະບວນການ ໃນປະຈຸບັນ. (Tcl ປະກອບດ້ວຍຄໍາສັ່ງ printf ຄ້າຍຄື ( ຮູບແບບທີ່ ເອີ້ນວ່າ) ເຊິ່ງສາມາດສ້າງສາຍສະລັບສັບຊ້ອນ arbitrarily.)
ຕົວອັກສອນຖືກສົ່ງໄປທັນທີເຖິງແມ່ນວ່າໂຄງການທີ່ມີເສັ້ນທາງເຂົ້າບັນທຶກເສັ້ນຄົງທີ່ຈະບໍ່ອ່ານຕົວອັກສອນຈົນກວ່າຕົວອັກສອນກັບຈະຖືກສົ່ງໄປ. ລັກສະນະການກັບມາແມ່ນ "\ r".
The - flag forces the argument next to be interpreted as a string instead of a flag "-" ບໍ່ວ່າຈະເປັນຫຼືບໍ່ມັນກໍ່ເບິ່ງຄືວ່າເປັນເສັ້ນທາງ. ນີ້ສະຫນອງກົນໄກທີ່ເຊື່ອຖືໄດ້ເພື່ອກໍານົດລະຫັດຕົວແທນທີ່ບໍ່ໄດ້ຖືກຂັດຂວາງໂດຍຜູ້ທີ່ເບິ່ງຄືວ່າເປັນທຸງ. (ທຸກສາຍທີ່ເລີ່ມຕົ້ນດ້ວຍ "-" ຈະຖືກຈອງໄວ້ສໍາລັບຕົວເລືອກໃນອະນາຄົດ.)
ທຸງ -i ປະກາດວ່າສາຍສະຕິງຈະຖືກສົ່ງໄປຫາຊື່ spawn_id. ຖ້າ spawn_id ແມ່ນ user_spawn_id , ແລະ terminal ຢູ່ໃນໂຫມດ raw, newlines ໃນ string ຈະຖືກແປເປັນລໍາດັບ return-newline ເພື່ອໃຫ້ພວກເຂົາປາກົດວ່າຖ້າ terminal ຢູ່ໃນໂຫມດທີ່ຜ່ານການປຸງແຕ່ງ. ທົງ -watch ປິດການແປນີ້.
ທົງຕ່ໍາຈະສົ່ງລັກສະນະທີ່ບໍ່ຖືກຕ້ອງ (0 bytes). ໂດຍຄ່າເລີ່ມຕົ້ນຫນຶ່ງ null ຖືກສົ່ງໄປ. ຈໍານວນເຕັມອາດປະຕິບັດຕາມ -null ເພື່ອສະແດງຈໍານວນ nulls ທີ່ຈະສົ່ງ.
flag- break flag ສ້າງເງື່ອນໄຂພັກຜ່ອນ. ນີ້ພຽງແຕ່ເຮັດໃຫ້ຄວາມຮູ້ສຶກຖ້າຫາກວ່າ idle ນ້ໍາຫມາຍເຖິງອຸປະກອນ tty ເປີດໂດຍ "spawn -open". ຖ້າທ່ານໄດ້ຜະລິດ ຂະບວນການ ເຊັ່ນ: tip, ທ່ານຄວນໃຊ້ສົນທິສັນຍາຂອງ tip ເພື່ອສ້າງ break.
ຜົນຜະລິດກໍາລັງດັ້ງເດີມ -s ຖືກສົ່ງໄປ "ຊ້າ", ດັ່ງນັ້ນຈຶ່ງຫຼີກເວັ້ນສະຖານະການທົ່ວໄປທີ່ເຄື່ອງຄອມພິວເຕີມີ outfile input buffer ທີ່ຖືກອອກແບບມາສໍາລັບຄົນທີ່ບໍ່ເຄີຍມີລະບົບປະຕິບັດງານດຽວ ກັນ . ຜົນຜະລິດນີ້ຖືກຄວບຄຸມໂດຍຄ່າຂອງຕົວແປ "send_slow" ເຊິ່ງໃຊ້ສອງລາຍການອົງປະກອບ. ອົງປະກອບທໍາອິດແມ່ນເປັນຈໍານວນເຕັມທີ່ອະທິບາຍເຖິງຈໍານວນ bytes ທີ່ຈະສົ່ງເປັນ atomically. ອົງປະກອບທີສອງແມ່ນຈໍານວນທີ່ແທ້ຈິງທີ່ອະທິບາຍເຖິງຈໍານວນວິນາທີທີ່ຕ້ອງສົ່ງອອກອະຕອມ. ຕົວຢ່າງ, "ກໍານົດ send_slow {10001}" ຈະບັງຄັບ "send -s" ເພື່ອສົ່ງລະຫັດທີ່ມີ 1 millisecond ໃນລະຫວ່າງ 10 ຕົວອັກສອນທີ່ຖືກສົ່ງໄປ.
ຜົນບັງຄັບໃຊ້ຂອງທົງທົງ -h ຈະຖືກສົ່ງໄປ (ບາງຢ່າງ) ຄືກັບຕົວຂອງຕົວເອງ. ຄວາມລ່າຊ້າຄ້າຍຄືມະນຸດປາກົດຂື້ນລະຫວ່າງຕົວອັກສອນ. (ສູດການຄິດໄລ່ແມ່ນອີງໃສ່ການແຈກຢາຍ Weibull, ມີການປັບປຸງເພື່ອໃຫ້ເຫມາະສົມກັບຄໍາຮ້ອງສະຫມັກນີ້.) ຜົນຜະລິດນີ້ຖືກຄວບຄຸມໂດຍມູນຄ່າຂອງຕົວແປ "send_human" ເຊິ່ງໃຊ້ເວລາຫ້າລາຍການອົງປະກອບ. ສອງອົງປະກອບທໍາອິດແມ່ນເວລາ interarrival ໂດຍສະເລ່ຍຂອງລັກສະນະໃນວິນາທີ. ຄັ້ງທໍາອິດຖືກໃຊ້ໂດຍຄ່າເລີ່ມຕົ້ນ. ຄັ້ງທີສອງຖືກນໍາໃຊ້ຢູ່ໃນຄໍາສັບຕ່າງໆທ້າຍຄໍາສັບ, ເພື່ອຈໍາລອງການຢຸດຊົ່ວຄາວທີ່ບາງຄັ້ງກໍ່ເກີດຂື້ນໃນການປ່ຽນແປງດັ່ງກ່າວ. ພາລາມິເຕີທີສາມແມ່ນມາດຕະການຂອງການປ່ຽນແປງທີ່ .1 ແມ່ນຂ້ອນຂ້າງແປກ, 1 ແມ່ນມີຄວາມເຫມາະສົມແລະ 10 ແມ່ນຂ້ອນຂ້າງປ່ຽນແປງ. ທີ່ສຸດແມ່ນ 0 ຫາບໍ່ມີ. ສອງຕົວກໍານົດການແມ່ນ, ຕາມລໍາດັບ, ທີ່ໃຊ້ເວລາ interarrival ຕໍາ່ສຸດທີ່ແລະສູງສຸດ. ຕໍາ່ສຸດແລະສູງສຸດແມ່ນໃຊ້ສຸດທ້າຍແລະ "clip" ໃນເວລາສຸດທ້າຍ. ສະເລ່ຍສຸດທ້າຍອາດຈະແຕກຕ່າງກັນໄປຈາກສະເລ່ຍໂດຍສະເພາະຖ້າມີຄ່າພຽງພໍແລະສູງສຸດ.
ເປັນຕົວຢ່າງ, ຄໍາສັ່ງຕໍ່ໄປນີ້ emulates ເປັນ typist ໄວແລະສອດຄ່ອງ:
set send_human {.1.3 1 05 2} send -h "ຂ້ອຍຫິວຂ້ອຍຈະກິນອາຫານທ່ຽງ."ໃນຂະນະທີ່ດັ່ງຕໍ່ໄປນີ້ອາດຈະມີຫຼາຍທີ່ເຫມາະສົມຫຼັງຈາກການ hangover ເປັນ:
set send_human {4 4,2 5 100} send -h "Good night party lash!"ໃຫ້ສັງເກດວ່າຂໍ້ຜິດພາດບໍ່ໄດ້ຖືກຫຼອກລວງ, ເຖິງແມ່ນວ່າທ່ານສາມາດກໍານົດສະຖານະການແກ້ໄຂຂໍ້ຜິດພາດຂອງຕົວເອງໂດຍການຕິດຕັ້ງຄວາມຜິດພາດແລະການແກ້ໄຂໃນການໂຕ້ຖຽງສົ່ງ.
ທຸງສໍາລັບການສົ່ງລັກສະນະ null, ສໍາລັບການສົ່ງ breaks, ສໍາລັບ forcing ຜົນຜະລິດຊ້າແລະສໍາລັບຜົນຜະລິດແບບຂອງມະນຸດແມ່ນສະເພາະແຕ່ກັນ. ພຽງແຕ່ຫນຶ່ງທີ່ລະບຸເທື່ອສຸດທ້າຍຈະຖືກນໍາໃຊ້. ຍິ່ງໄປກວ່ານັ້ນ, ບໍ່ມີການໂຕ້ຖຽງຊ້ໍາສາມາດລະບຸໄວ້ກັບປ້າຍສໍາລັບການສົ່ງລັກສະນະ null ຫຼືພັກຜ່ອນ.
ມັນເປັນຄວາມຄິດທີ່ດີທີ່ຈະນໍາຫນ້າທໍາອິດ ໄປ ເຖິງ ຂະບວນການ ທີ່ ຄາດຫວັງ . ຄາດວ່າ ຈະລໍຖ້າ ຂະບວນ ການເລີ່ມຕົ້ນ, ໃນຂະນະທີ່ ສົ່ງ ບໍ່ສາມາດເຮັດໄດ້. ໂດຍສະເພາະ, ຖ້າການ ສົ່ງ ທໍາອິດ ຈະ ສໍາເລັດກ່ອນທີ່ ຂະບວນການ ຈະເລີ້ມແລ່ນ, ທ່ານຈະມີຄວາມສ່ຽງທີ່ຈະມີຂໍ້ມູນຂອງທ່ານຖືກລະເລີຍ. ໃນສະຖານະການທີ່ໂຄງການແບບໂຕ້ຕອບບໍ່ມີຄໍາແນະນໍາໃນເບື້ອງຕົ້ນ, ທ່ານສາມາດນໍາ ສົ່ງ ໂດຍການຊັກຊ້າເປັນໃນ:
# ເພື່ອຫຼີກເວັ້ນການໃຫ້ຄໍາແນະນໍາແຮກເກີກ່ຽວກັບວິທີທໍາລາຍ, # ລະບົບນີ້ບໍ່ໄດ້ເຕືອນສໍາລັບລະຫັດຜ່ານພາຍນອກ. # ລໍຖ້າ 5 ວິນາທີສໍາລັບ exec ເພື່ອເຮັດສໍາເລັດການຜະລິດນ້ໍາຕານ telnet sleep.security.gov 5 ການສົ່ງລະຫັດຜ່ານ \ rexp_send ເປັນນາມແຝງສໍາລັບການ ສົ່ງ. ຖ້າທ່ານກໍາລັງໃຊ້ Expectk ຫຼືບາງ variant ອື່ນໆຂອງ Expect ໃນສະພາບແວດລ້ອມ Tk, ສົ່ງ ຖືກກໍານົດໂດຍ Tk ສໍາລັບຈຸດປະສົງທີ່ແຕກຕ່າງກັນທັງຫມົດ. exp_send ໄດ້ຖືກສະຫນອງໃຫ້ສໍາລັບຄວາມເຂົ້າໃຈລະຫວ່າງສະພາບແວດລ້ອມ. ລະຫັດລັບທີ່ຄ້າຍຄືກັນແມ່ນໄດ້ຖືກສະຫນອງໃຫ້ສໍາລັບຄໍາສັ່ງສົ່ງອື່ນຂອງ Expect ອື່ນ.
send_error [-flags] string
ແມ່ນຄ້າຍຄື ສົ່ງ , ຍົກເວັ້ນວ່າຜົນຜະລິດຖືກສົ່ງໄປ stderr ແທນທີ່ຈະເປັນ ຂະບວນການ ໃນປະຈຸບັນ.
send_log [-] string
ແມ່ນຄ້າຍຄື ສົ່ງ , ຍົກເວັ້ນວ່າສາຍອັກສອນຈະຖືກສົ່ງໄປຫາໄຟລ໌ log (ເບິ່ງ log_file .) ການໂຕ້ຖຽງຈະຖືກຍົກເວັ້ນຖ້າບໍ່ມີໄຟລ໌ເຂົ້າສູ່ລະບົບ.
send_tty [-flags] string
ແມ່ນຄ້າຍຄື ສົ່ງ , ຍົກເວັ້ນວ່າຜົນຜະລິດຖືກສົ່ງໄປຫາ / dev / tty ແທນທີ່ຈະເປັນ ຂະບວນການ ປະຈຸບັນ.
send_user [-flags] string
ແມ່ນຄ້າຍຄື ສົ່ງ , ຍົກເວັ້ນວ່າຜົນຜະລິດຖືກສົ່ງໄປ stdout ຫຼາຍກວ່າ ຂະບວນການ ປະຈຸບັນ.
sleep seconds
ເຮັດໃຫ້ສະຄິບ ນອນ ສໍາລັບຈໍານວນຂອງວິນາທີ. ວິນາທີອາດເປັນຕົວເລກທະສະນິຍົມ. ການຂັດຂວາງ (ແລະເຫດການ Tk ຖ້າທ່ານໃຊ້ Expectk) ຖືກຈັດການໃນຂະນະທີ່ຄາດວ່າຈະນອນ.
spawn [args] program [args]
ສ້າງ ຂັ້ນຕອນ ໃຫມ່ທີ່ ດໍາ ເນີນການ "ໂປແກຣມໂຄງການ ". stdin, stdout ແລະ stderr ແມ່ນເຊື່ອມຕໍ່ກັບ Expect, ດັ່ງນັ້ນພວກເຂົາເຈົ້າອາດຈະໄດ້ອ່ານແລະຂຽນໂດຍຄໍາສັ່ງອື່ນ ໆ ທີ່ ຄາດຫວັງ . ການເຊື່ອມຕໍ່ຈະຖືກ ປິດ ໂດຍ ປິດ ຫຼືຖ້າ ຂະບວນການ ຂອງມັນເອງປິດຕົວໃດໆຂອງຕົວລະຫັດແຟ້ມ.
ເມື່ອ ຂະບວນການ ຖືກເລີ່ມຕົ້ນໂດຍການ ຜະລິດ , variable spawn_id ຖືກກໍານົດໃຫ້ເປັນຄໍາອະທິບາຍໂດຍອ້າງອີງໃສ່ ຂະບວນການ ນັ້ນ. ຂະບວນການທີ່ ອະທິບາຍໂດຍ spawn_id ຖືກພິຈາລະນາ " ຂະບວນການ ໃນປະຈຸບັນ ". spawn_id ອາດຈະອ່ານຫຼືຂຽນ, ໂດຍສະເພາະແມ່ນການຄວບຄຸມວຽກ.
user_spawn_id ເປັນຕົວແປທົ່ວໂລກທີ່ມີຄໍາອະທິບາຍເຊິ່ງຫມາຍເຖິງຜູ້ໃຊ້. ຕົວຢ່າງເຊັ່ນ, ເມື່ອ spawn_id ຖືກກໍານົດຄ່ານີ້, ຄາດວ່າຈະ ປະຕິບັດຕົວຄື expect_user .
ຂ້ອຍ error_spawn_id ແມ່ນຕົວແປທົ່ວໂລກທີ່ມີຄໍາອະທິບາຍເຊິ່ງຫມາຍເຖິງຂໍ້ຜິດພາດມາດຕະຖານ. ຕົວຢ່າງເຊັ່ນ, ເມື່ອ spawn_id ຖືກກໍານົດຄ່ານີ້, ສົ່ງ ພຶດຕິກໍາເຊັ່ນ send_error .
tty_spawn_id ເປັນຕົວແປທົ່ວໂລກທີ່ມີຄໍາອະທິບາຍເຊິ່ງຫມາຍເຖິງ / dev / tty. ຖ້າ / dev / tty ບໍ່ມີ (ເຊັ່ນໃນ cron, at ຫຼື batch script) ແລ້ວ tty_spawn_id ບໍ່ໄດ້ຖືກກໍານົດ. ນີ້ອາດຈະໄດ້ຮັບການທົດສອບວ່າ:
ຖ້າ {{info}} {# / dev / tty exists} else {# / dev / tty ບໍ່ມີຢູ່ໃນ # cron, batch, or at script}ໄຂ່ມ້າ ຈະສົ່ງຄືນລະຫັດ UNIX. ຖ້າບໍ່ມີ ຂະບວນການ ໃດກໍ່ຕາມ, 0 ຈະຖືກສົ່ງຄືນ. ຕົວແປ spawn_out variable (slave, name) ຖືກກໍານົດໃຫ້ເປັນຊື່ຂອງອຸປະກອນບ້າ pty.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ປາສະ ຫຼາມຈະສົ່ງຄໍາສັ່ງແລະການໂຕ້ຖຽງ. ທົງ ໂນໂກ້ ຢຸດເຊົາການເຮັດແບບນີ້.
ທຸງ -console ສະແດງ ຜົນຜະລິດ console ຈະຖືກນໍາໄປສູ່ ຂະບວນການ ຜະລິດ. ນີ້ບໍ່ໄດ້ຖືກສະຫນັບສະຫນູນໃນລະບົບທັງຫມົດ.
ພາຍໃນ, ການ ຜະລິດນົມ ໃຊ້ pty, ເລີ່ມຕົ້ນໃນລັກສະນະດຽວກັນກັບ tty ຂອງຜູ້ໃຊ້. ນີ້ແມ່ນການເລີ່ມຕົ້ນໃຫມ່ເພື່ອໃຫ້ການຕັ້ງຄ່າທັງຫມົດແມ່ນ "ສະຕິ" (ອີງຕາມ stty (1)). ຖ້າ stty_init ຕົວແປຖືກກໍານົດ, ມັນຈະຖືກຕີລາຄາໃນຮູບແບບຂອງການໂຕ້ຖຽງທີ່ຫມັ້ນຄົງເປັນການຕັ້ງຄ່າຕໍ່ໄປອີກ. ສໍາລັບຕົວຢ່າງ, "ກໍານົດ stty_init ດິບ" ຈະເຮັດໃຫ້ເກີດການເພີ່ມເຕີມຂອງຂະບວນການທີ່ຈະເລີ່ມຕົ້ນໃນຮູບແບບດິບ. -nottycopy skips ການເລີ່ມຕົ້ນໂດຍອີງໃສ່ tty ຂອງຜູ້ໃຊ້. -nottyinit skips the initial "sane".
ຕາມປົກກະຕິ, ນໍ້າ ນົມ ໃຊ້ເວລາໃຊ້ເວລາຫນ້ອຍລົງ. ຖ້າທ່ານສັງເກດເຫັນວ່າການເກີດລູກມີຈໍານວນທີ່ໃຊ້ເວລາທີ່ສໍາຄັນ, ມັນອາດຈະພົບກັບ ptys ທີ່ມີ wedged. ຈໍານວນຂອງການທົດສອບແມ່ນດໍາເນີນການກ່ຽວກັບ ptys ເພື່ອຫຼີກເວັ້ນການຕິດພັນກັບຂະບວນການ errant. (ເຫຼົ່ານີ້ໃຊ້ເວລາ 10 ວິນາທີຕໍ່ pty wedged.) ແລ່ນຄາດວ່າຈະມີທາງເລືອກ -d ຈະສະແດງໃຫ້ເຫັນຖ້າຫາກວ່າ ຄາດວ່າ ຈະໄດ້ພົບ ptys ຫຼາຍໃນລັດແປກ. ຖ້າທ່ານບໍ່ສາມາດຂ້າຂະບວນການທີ່ ptys ເຫຼົ່ານີ້ຖືກຄັດຕິດ, ການໃຊ້ພຽງແຕ່ທ່ານອາດຈະກັບຄືນມາ.
ຖ້າ ໂປລແກລມ ບໍ່ສາມາດສະກົດສົບຜົນສໍາເລັດຍ້ອນວ່າ exec (2) ລົ້ມເຫລວ (ຕົວຢ່າງເມື່ອບໍ່ມີ ໂຄງການ ), ຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດຈະຖືກສົ່ງຄືນໂດຍການ ໂຕ້ຕອບ ຕໍ່ຫຼື ຄາດວ່າຈະໄດ້ ຮັບຄໍາສັ່ງຖ້າວ່າ ໂປລແກລມ ໄດ້ດໍາເນີນການແລະສົ່ງຂໍ້ຄວາມຂໍ້ຄວາມເປັນຜົນ. ພຶດຕິກໍານີ້ແມ່ນຜົນສະທ້ອນທໍາມະຊາດຂອງການປະຕິບັດການ ຜະລິດ . ພາຍໃນ, ເຕົ້ານົມ, ຫຼັງຈາກນັ້ນ ຂະບວນການທີ່ ບໍ່ມີການມີວິທີການທີ່ຈະຕິດຕໍ່ສື່ສານກັບ ຂະບວນການ ຄາດຫວັງ ຕົ້ນສະບັບຍົກເວັ້ນໂດຍການສື່ສານຜ່ານ spawn_id.
ປ່ອງເປີດ -open ເຮັດໃຫ້ການໂຕ້ຖຽງຕໍ່ໄປທີ່ຈະຖືກຕີຄວາມຫມາຍເປັນຕົວເລກຂອງໄຟລ໌ Tcl (ຕົວຢ່າງ, ກັບຄືນໂດຍ ເປີດ ). ຫຼັງຈາກນັ້ນມັນສາມາດຖືກນໍາໃຊ້ເຊັ່ນວ່າມັນເປັນ ຂະບວນການທີ່ ຜະລິດ. (ການລະບຸຊື່ໄຟລ໌ບໍ່ຄວນໃຊ້.) ນີ້ຊ່ວຍໃຫ້ທ່ານສາມາດຈັດການກັບອຸປະກອນດິຈິຕອນໄຟລ໌ແລະທໍ່ເປັນຂັ້ນຕອນການຜະລິດໂດຍບໍ່ໃຊ້ pty. 0 ຖືກສົ່ງກັບເພື່ອຊີ້ບອກວ່າບໍ່ມີ ຂະບວນການ ທີ່ກ່ຽວຂ້ອງ. ເມື່ອການເຊື່ອມຕໍ່ກັບ ຂະບວນການ ຜະລິດຖືກປິດ, ດັ່ງນັ້ນຕົວກໍານົດການໄຟລ໌ Tcl. ທຸງ -veaveopen ແມ່ນຄ້າຍຄືກັນກັບ -op , ຍົກເວັ້ນ -veaveopen ເຮັດໃຫ້ຕົວລະຫັດໄຟລ໌ທີ່ຖືກເປີດໃຫ້ເປີດແມ້ກະທັ້ງຫຼັງຈາກ id id ໄດ້ຖືກປິດ.
ທຸງທີ່ບໍ່ມີແມ່ນເຮັດໃຫ້ເກີດການເປີດກວ້າງແຕ່ບໍ່ມີ ຂະບວນການທີ່ ເກີດຂື້ນ. 0 ຖືກສົ່ງກັບເພື່ອຊີ້ບອກວ່າບໍ່ມີ ຂະບວນການ ທີ່ກ່ຽວຂ້ອງ. Spawn_id ຖືກຕັ້ງເປັນປົກກະຕິ.
ຕົວແປ spawn_out variable (slave, fd) ຖືກຕັ້ງຄ່າເປັນຕົວລະບຸຊື່ແຟ້ມທີ່ສອດຄ້ອງກັນກັບ slave pty. ມັນສາມາດຖືກປິດລົງໂດຍໃຊ້ "ປິດສະຫນາ".
ທົງຊື່ -ignore ຊື່ສັນຍານທີ່ຈະຖືກລະເວັ້ນໃນ ຂະບວນການທີ່ ຜະລິດ. ຖ້າບໍ່ດັ່ງນັ້ນ, ສັນຍານຈະໄດ້ຮັບການປະພຶດທໍາອິດ. ສັນຍານທີ່ມີຊື່ຢູ່ໃນຄໍາສັ່ງ trap , ຍົກເວັ້ນວ່າແຕ່ລະສັນຍານຮຽກຮ້ອງໃຫ້ມີທົງແບບແຍກຕ່າງຫາກ.
strace level
ເຮັດໃຫ້ລາຍງານດັ່ງຕໍ່ໄປນີ້ຖືກພິມກ່ອນທີ່ຈະຖືກປະຕິບັດ. (Tcl ຂອງຄໍາສັ່ງຕາມຮອຍຄໍາຕິດຕາມຕົວຊີ້ວັດ.) ລະດັບ ສະແດງໃຫ້ເຫັນເຖິງວິທີການໄກໃນ stack ໂທຫາຕາມຮອຍ. ຕົວຢ່າງເຊັ່ນຄໍາສັ່ງຕໍ່ໄປນີ້ກໍາລັງລໍຖ້າໃນຂະນະທີ່ຄົ້ນຫາລະດັບ 4 ທໍາອິດຂອງການໂທ, ແຕ່ບໍ່ມີລຸ່ມນີ້.
ການ ໂຄສະ ນາຂໍ້ມູນໄດ້ເຮັດໃຫ້ strace ກັບຄືນລາຍລະອຽດຂອງການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນຂໍ້ມູນຫຼ້າສຸດທີ່ໄດ້ຮັບມາ.
stty args
ການປ່ຽນແປງໂຫມດ terminal ຄືກັນກັບຄໍາສັ່ງ stty ພາຍນອກ.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ການຄວບຄຸມແມ່ນໄດ້ຮັບການເຂົ້າເຖິງ. ຖ້າຍັງບໍ່ມີສະຖານະແລະຂໍໃຫ້ສະຖານີຄວບຄຸມທີ່ມີການເຂົ້າເຖິງ, ສະຖານະພາບກ່ອນຫນ້ານີ້ຂອງຄຸນສົມບັດດິບແລະ echo ຈະຖືກສົ່ງກັບຄືນມາໃນແບບຟອມທີ່ສາມາດເຮັດໄດ້ຕໍ່ມາ. ຖືກນໍາໃຊ້ໂດຍຄໍາສັ່ງ.
ຕົວຢ່າງ, ການໂຕ້ຖຽງທີ່ບໍ່ຖືກຕ້ອງຫຼືເຮັດໄດ້ເຮັດໃຫ້ສັນຍາລັກເຂົ້າໄປໃນໂຫມດດິບ. ການໂຕ້ຖຽງ - ເວລາ ຫລື ປຸງແຕ່ງ ເຮັດໃຫ້ປາຍທາງເຂົ້າໄປໃນໂຫມດປຸງແຕ່ງ. ການໂຕ້ຖຽງ echo ແລະ -echo ເຮັດໃຫ້ປາຍທາງເຂົ້າໄປໃນໂຫມດ echo ແລະ noecho ຕາມລໍາດັບ.
ຕົວຢ່າງຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນວິທີການປິດການໂຕ້ຕອບຊົ່ວຄາວ. ນີ້ສາມາດຖືກນໍາໃຊ້ໃນສະຄິບອື່ນທີ່ບໍ່ແມ່ນອັດຕະໂນມັດເພື່ອຫຼີກເວັ້ນການໃສ່ລະຫັດຜ່ານໃນພວກມັນ. (ເບິ່ງການສົນທະນາເພີ່ມເຕີມກ່ຽວກັບເລື່ອງນີ້ພາຍໃຕ້ EXPECT HINTS ຂ້າງລຸ່ມນີ້.)
stty -echo send_user "ລະຫັດຜ່ານ:" expect_user -re "(. *) \ n" ຕັ້ງລະຫັດຜ່ານ $ expect_out (1, string) stty echo system args
ໃຫ້ args ກັບ sh (1) ເປັນ input, ຄືກັນກັບວ່າມັນໄດ້ຖືກພິມເປັນຄໍາສັ່ງຈາກ terminal. ຄາດຫວັງວ່າ ຈົນກ່ວາຫອຍຈະສິ້ນສຸດ. ສະຖານະການກັບຄືນມາຈາກ sh ຖືກຈັດການກັບວິທີດຽວກັນທີ່ exec ແກ້ໄຂສະຖານະການກັບຄືນຂອງມັນ.
ໃນທາງກົງກັນຂ້າມກັບ exec ທີ່ສົ່ງເສັ້ນທາງ stdin ແລະ stdout ໄປຍັງສະຄິບ, ລະບົບ ປະຕິບັດບໍ່ມີການປ່ຽນເສັ້ນທາງ (ນອກເຫນືອຈາກຂໍ້ມູນທີ່ສະແດງໂດຍຕົວຕົນເອງ). ດັ່ງນັ້ນ, ມັນກໍ່ສາມາດນໍາໃຊ້ໂຄງການທີ່ຕ້ອງໄດ້ສົນທະນາໂດຍກົງກັບ / dev / tty. ສໍາລັບເຫດຜົນດຽວກັນ, ຜົນຂອງ ລະບົບ ຍັງບໍ່ຖືກບັນທຶກໄວ້ໃນບັນທຶກ.
timestamp [args]
ຄືນ timestamp. ມີການໂຕ້ຖຽງບໍ່ມີ, ຈໍານວນວິນາທີນັບຕັ້ງແຕ່ຍຸກສະໄຫມຖືກສົ່ງຄືນ.
ທຸງຊາດຮູບແບບນໍາສະຕິງທີ່ຖືກສົ່ງກັບແຕ່ມີການປ່ຽນແທນຕາມກົດລະບຽບ POSIX ສໍາລັບໄລຍະເວລາ. ຕົວຢ່າງ:% a ຖືກແທນທີ່ດ້ວຍຊື່ວັນທີຫຍໍ້ (ເຊົ່ນ Sat). ອື່ນໆແມ່ນ:
% ຊື່ຊື່ວັນທີຫຍໍ້% ຊື່ນາມສະກຸນເຕັມ% b ຊື່ນາມສະກຸນ% B ຊື່ເຕັມວັນ% c ວັນທີເວລາໃນ: ພຸດ 6 ຕຸລາ 11:45:56 1993% d ມື້ຂອງເດືອນ (01-31% H ຊົ່ວໂມງ (00-23)% I ຊົ່ວໂມງ (01-12)% j ວັນ (001-366)% m ເດືອນ (01-12)% M ນາທີ (00-59)% p am ຫຼື pm% S second (00-61) % u ວັນ (1-7, ວັນຈັນແມ່ນມື້ທໍາອິດຂອງອາທິດ)% U ອາທິດ (00-53, ວັນອາທິດທໍາອິດແມ່ນວັນທໍາອິດຂອງອາທິດຫນຶ່ງ) ອາທິດ% V (01-53, ແບບ ISO 8601)% w ມື້ (0- 6)% W ອາທິດ (00-53, ວັນຈັນທໍາອິດແມ່ນວັນທໍາອິດຂອງອາທິດຫນຶ່ງ)% x ວັນທີທີ່ໃຊ້ເວລາ: Wed Oct 6 1993% X ເວລາໃນ: 23:59:59% y ປີ (00-99) % Y ປີໃນ: 1993z Z ເວລາ (ຫຼືບໍ່ມີຖ້າບໍ່ສາມາດກໍານົດໄດ້)%% ເປັນສັນຍານສ່ວນຮ້ອຍເປົ່າຂໍ້ກໍານົດ%% ອື່ນໆແມ່ນບໍ່ຖືກກໍານົດ. ລັກສະນະອື່ນໆຈະຖືກຜ່ານໄປບໍ່ໄດ້. ພຽງແຕ່ C ທ້ອງຖິ່ນທີ່ສະຫນັບສະຫນູນ.
ທຸງຊາດສອງຄັ້ງນໍາສະເຫນີຈໍານວນວິນາທີນັບຕັ້ງແຕ່ຍຸກສະໄຫມທີ່ຈະໃຊ້ເປັນແຫລ່ງທີ່ເປັນຮູບແບບ. ຖ້າບໍ່ດັ່ງນັ້ນ, ໃຊ້ເວລາໃນປະຈຸບັນ.
ກໍາລັງ flag gmt ກໍານົດ timestamp ທີ່ໃຊ້ເວລາ GMT . ໂດຍບໍ່ມີທົງ, ເວລາທີ່ໃຊ້ໃນທ້ອງຖິ່ນຈະຖືກນໍາໃຊ້.
trap [[command] signals]
ເຮັດໃຫ້ ຄໍາສັ່ງ ໃຫ້ຖືກປະຕິບັດໃນເວລາຮັບສັນຍານຂອງສັນຍານທີ່ໄດ້ຮັບໃນອະນາຄົດ. ຄໍາສັ່ງຖືກປະຕິບັດໃນຂອບເຂດທົ່ວໂລກ. ຖ້າ ຄໍາສັ່ງ ບໍ່ແມ່ນ, ການປະຕິບັດສັນຍານຈະຖືກສົ່ງຄືນ. ຖ້າ ຄໍາສັ່ງ ເປັນສາຍ SIG_IGN, ສັນຍານຈະຖືກຍົກເລີກ. ຖ້າ ຄໍາສັ່ງ ແມ່ນລະຫັດ SIG_DFL, ສັນຍານແມ່ນຜົນມາຈາກການຕັ້ງຄ່າຂອງລະບົບ. ສັນຍານ ແມ່ນທັງສັນຍານດຽວຫຼືລາຍຊື່ຂອງສັນຍານ. ສັນຍານອາດຈະຖືກກໍານົດຈໍານວນຕົວເລກຫຼືສັນຍາລັກຕາມສັນຍານ (3). ຄໍາແນະນໍາ "SIG" ອາດຖືກຍົກເລີກ.
ມີການໂຕ້ແຍ້ງບໍ່ມີ (ຫຼືຕົວເລກ - ຈໍານວນ), ຈັ່ນຈັບ ກັບຫມາຍເລກສັນຍາລັກຂອງຄໍາສັ່ງ trap ທີ່ກໍາລັງຖືກປະຕິບັດ.
ທົງໂຄດໂຄ້ດໃຊ້ລະຫັດກັບຂອງຄໍາສັ່ງແທນທີ່ຈະມີລະຫັດ Tcl ກ່ຽວກັບຄືນເມື່ອຄໍາສັ່ງເລີ່ມຕົ້ນເຮັດວຽກ.
ທົງ ເບື້ອງຕົ້ນ ເຮັດໃຫ້ຄໍາສັ່ງຖືກປະເມີນໂດຍໃຊ້ຕົວແປທີ່ໃຊ້ໃນເວລາທີ່ຄໍາສັ່ງເລີ່ມຕົ້ນເຮັດວຽກແທນທີ່ຈະຖືກປະກາດ.
ທຸງນາມສະກຸນດັ່ງກ່າວເຮັດໃຫ້ຄໍາສັ່ງ ຈັ່ນຈັບ ກັບຄືນຊື່ສັນຍາລັກຂອງຄໍາສັ່ງທີ່ຖືກຈັບໃນປັດຈຸບັນ.
ສັນຍາລັກ -max ເຮັດໃຫ້ຄໍາສັ່ງ trap ໃຫ້ກັບຫມາຍເລກສັນຍານທີ່ໃຫຍ່ທີ່ສຸດທີ່ສາມາດຕັ້ງຄ່າໄດ້.
ຕົວຢ່າງເຊັ່ນຄໍາສັ່ງ "trap {send_user" Ouch!}} SIGINT "ຈະພິມ" Ouch! " ທຸກຄັ້ງທີ່ຜູ້ໃຊ້ກົດ C
ໂດຍຄ່າເລີ່ມຕົ້ນ, SIGINT (ຊຶ່ງສາມາດສ້າງໂດຍການກົດ C) ແລະ SIGTERM ອາດຈະຄາດວ່າຈະອອກ. ນີ້ແມ່ນຍ້ອນການຈັ່ນຈັບດັ່ງຕໍ່ໄປນີ້, ສ້າງໂດຍຄ່າເລີ່ມຕົ້ນເມື່ອຄາດວ່າຈະເລີ້ມຕົ້ນ.
trap exit {SIGINT SIGTERM}ຖ້າທ່ານໃຊ້ທຸງຊາດ -D ເພື່ອເລີ່ມການແກ້ໄຂ debugger, SIGINT ຖືກ redefined ເພື່ອເລີ່ມຕົ້ນການ debugger ໂຕ້ຕອບ. ນີ້ແມ່ນເນື່ອງມາຈາກຈັ່ນຈັບດັ່ງຕໍ່ໄປນີ້:
trap {exp_debug 1} SIGINTຈັ່ນຈັບ bugger ສາມາດປ່ຽນແປງໄດ້ໂດຍການຕັ້ງຄ່າຕົວປ່ຽນສະພາບແວດລ້ອມ EXPECT_DEBUG_INIT ກັບຄໍາສັ່ງ trap ໃຫມ່.
ທ່ານສາມາດ, ແນ່ນອນ, override ທັງສອງເຫຼົ່ານີ້ພຽງແຕ່ໂດຍການເພີ່ມຄໍາສັ່ງ trap ກັບ script ຂອງທ່ານ. ໂດຍເສພາະຢ່າງຍິ່ງຖ້າຄຸນມີ "ຂະຫຍະອອກ SIGINT" ຂອງທ່ານເອງ, ນີ້ຈະ override ການຂີ້ເຫຍື້ອ debugger ໄດ້. ນີ້ແມ່ນມີຜົນປະໂຫຍດຖ້າທ່ານຕ້ອງການປ້ອງກັນບໍ່ໃຫ້ຜູ້ໃຊ້ເຂົ້າຫາຕົວແກ້ການແກ້ໄຂໄດ້ເລີຍ.
ຖ້າທ່ານຕ້ອງການກໍານົດຈັ່ນຈັບຂອງທ່ານເອງໃນ SIGINT ແຕ່ຍັງຕິດກັບການແກ້ໄຂ debugger ໃນເວລາທີ່ມັນເຮັດວຽກ, ໃຫ້ໃຊ້:
ຖ້າ {{[exp_debug]} {trap mystuff SIGINT}ອີກທາງເລືອກ, ທ່ານສາມາດດັກກັບຕົວແກ້ການແກ້ໄຂໂດຍນໍາໃຊ້ສັນຍານອື່ນບາງ.
trap ຈະບໍ່ປ່ອຍໃຫ້ທ່ານລະເມີດການປະຕິບັດສໍາລັບ SIGALRM ຍ້ອນວ່ານີ້ແມ່ນໃຊ້ພາຍໃນເພື່ອ ຄາດຫວັງ . ຄໍາສັ່ງປິດການກໍານົດ SIGALRM ກັບ SIG_IGN (ຍົກເວັ້ນ). ທ່ານສາມາດເປີດນໍາໃຊ້ໃຫມ່ນີ້ໄດ້ຕະຫຼອດເວລາທີ່ທ່ານປິດໃຊ້ມັນໃນລະຫວ່າງຄໍາສັ່ງຜະລິດຕະພັນຕໍ່ມາ.
ເບິ່ງສັນຍານ (3) ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.
wait [args]
ການຊັກຊ້າຈົນກ່ວາ ຂະບວນການ ຜະລິດ (ຫຼື ຂະບວນການ ໃນປະຈຸບັນຖ້າບໍ່ມີຊື່) ສິ້ນສຸດລົງ.
ລໍຖ້າ ຕາມປົກກະຕິຈະສົ່ງຄືນບັນຊີລາຍຊື່ຂອງສີ່ຈໍານວນຫນຶ່ງ. ຈໍານວນເຕັມທໍາອິດແມ່ນ pid ຂອງ ຂະບວນການ ທີ່ລໍຖ້າ. ຈໍານວນເຕັມທີສອງແມ່ນເລກທີ່ພັນທີ່ສອດຄ້ອງກັນ. ຈໍານວນເຕັມສາມແມ່ນ -1 ຖ້າມີລະບົບປະຕິບັດການເກີດຄວາມຜິດພາດຫຼື 0 ຖ້າບໍ່ດັ່ງນັ້ນ. ຖ້າຈໍານວນເຕັມສາມແມ່ນ 0, ຈໍານວນເຕັມສີ່ແມ່ນສະຖານະທີ່ສົ່ງຄືນໂດຍ ຂະບວນການ ສ້າງ. ຖ້າຈໍານວນເຕັມສາມແມ່ນ -1, ຈໍານວນເຕັມສີ່ແມ່ນມູນຄ່າຂອງ errno ກໍານົດໂດຍລະບົບປະຕິບັດການ. errorCode ຕົວແປທົ່ວໂລກຍັງຖືກກໍານົດໄວ້.
ອົງປະກອບເພີ່ມເຕີມອາດປາກົດຢູ່ໃນຕອນທ້າຍຂອງມູນຄ່າຜົນຕອບແທນຈາກການ ລໍຖ້າ . ອົງປະກອບທີຫ້າທີ່ເລືອກແມ່ນລະບຸຂໍ້ມູນຂ່າວສານ. ໃນປັດຈຸບັນ, ມູນຄ່າເທົ່າທີ່ເປັນໄປໄດ້ສໍາລັບອົງປະກອບນີ້ແມ່ນ CHILDKILLED ໃນກໍລະນີທີ່ສອງຄ່າຕໍ່ໄປແມ່ນຊື່ສັນຍາລັກແບບ C ແລະແບບອະທິບາຍສັ້ນໆ.
ທຸງ -i ປະກາດ ຂະບວນການ ທີ່ລໍຖ້າທີ່ສອດຄ້ອງກັບຊື່ spawn_id (NOT id process ). ພາຍໃນຕົວຈັດການ SIGCHLD, ມັນກໍ່ສາມາດລໍຖ້າສໍາລັບ ຂະບວນການທີ່ ເກີດໃຫມ່ໄດ້ໂດຍການໃຊ້ id id -1.
ທຸງ ໄຕ້ຫວັນນີ້ ເຮັດໃຫ້ການລໍຖ້າກັບຄືນມາໂດຍທັນທີດ້ວຍການຊີ້ບອກເຖິງການລໍຖ້າຢ່າງລວດໄວ. ເມື່ອ ຂະບວນການ ອອກຈາກ (ຫຼັງຈາກນັ້ນ), ມັນຈະຫາຍໄປໂດຍອັດຕະໂນມັດໂດຍບໍ່ຕ້ອງລໍຖ້າຢ່າງຊັດເຈນ.
ຄໍາສັ່ງ ລໍຖ້າ ຍັງສາມາດຖືກນໍາໃຊ້ລໍຖ້າສໍາລັບ ຂະບວນການ forked ໂດຍໃຊ້ການໂຕ້ຖຽງ "-i -1". ຕ່າງຈາກການນໍາໃຊ້ກັບຂະບວນການທີ່ຜະລິດ, ຄໍາສັ່ງນີ້ສາມາດຖືກປະຕິບັດໄດ້ທຸກເວລາ. ບໍ່ມີການຄວບຄຸມໃດໆທີ່ ຂະບວນການ ຈະຖືກເກັບກ່ຽວ. ຢ່າງໃດກໍຕາມ, ມູນຄ່າຜົນຕອບແທນສາມາດຖືກກວດສອບສໍາລັບ id process .
LIBRARIES
ຄາດວ່າອັດຕະໂນມັດຈະຮູ້ກ່ຽວກັບສອງຫໍສະຫມຸດທີ່ມີການກໍ່ສ້າງໃນການຄາດຄະເນສະຄິບ. ເຫຼົ່ານີ້ຖືກກໍານົດໂດຍລາຍຊື່ທີ່ມີຊື່ຢູ່ໃນຕົວແປ exp_library ແລະ exp_exec_library. ທັງສອງແມ່ນຫມາຍຄວາມວ່າມີໄຟລ໌ສາທານນູປະໂພກທີ່ສາມາດນໍາໃຊ້ໂດຍສະຄິບອື່ນໆ.
exp_library ມີເອກະສານໄຟລ໌ເອກະລາດ. exp_exec_library ມີໄຟລ໌ທີ່ຂຶ້ນກັບຖາປັດຕະຍະ. ຂຶ້ນຢູ່ກັບລະບົບຂອງທ່ານ, ທັງສອງລາຍການອາດຈະຫມົດໄປຫມົດ. ການມີຢູ່ຂອງໄຟລ໌ $ exp_exec_library / cat-buffers ອະທິບາຍວ່າທ່ານ / bin / cat buffers ຕາມລໍາດັບ.
PRETTY-PRINTING
ຄໍານິຍາມ vgrind ແມ່ນມີສໍາລັບການພິມ pretty - ຄາດຫວັງ scripts. ສົມມຸດວ່າຄໍານິຍາມ vgrind ທີ່ມີການແຈກຢາຍ Expect ແມ່ນຖືກຕິດຕັ້ງຢ່າງຖືກຕ້ອງ, ທ່ານສາມາດໃຊ້ມັນເປັນ:
vgrind -lexpect fileຕົວຢ່າງ
ມັນຫຼາຍໆຢ່າງບໍ່ໄດ້ສະແດງໃຫ້ເຫັນວ່າເຮັດແນວໃດເພື່ອໃຫ້ທຸກສິ່ງທຸກຢ່າງຮ່ວມກັນທີ່ຫນ້າ ຜູ້ຊາຍໄດ້ ອະທິບາຍ. ຂ້ອຍຂໍແນະນໍາໃຫ້ທ່ານອ່ານແລະລອງຕົວຢ່າງໃນໄດເລກະທໍລີຕົວຢ່າງຂອງການ ຄາດຄະເນ ການກະຈາຍ. ບາງຄົນແມ່ນໂຄງການທີ່ແທ້ຈິງ. ຄົນອື່ນແມ່ນພຽງແຕ່ສະແດງໃຫ້ເຫັນວິທີການສະເພາະໃດຫນຶ່ງ, ແລະແນ່ນອນ, ຄູ່ຜົວເມຍແມ່ນມີພຽງແຕ່ hacks ໄວ. ໄຟລ໌ INSTALL ມີລາຍລະອຽດຢ່າງລວດໄວຂອງບັນດາໂຄງການເຫຼົ່ານີ້.
ເອກະສານ ຄາດຫວັງ (ເບິ່ງ SEE ALSO) ຍັງມີປະໂຫຍດ. ໃນຂະນະທີ່ບາງເອກະສານທີ່ໃຊ້ syntax ທີ່ສອດຄ້ອງກັບສະບັບກ່ອນຫນ້າຂອງ Expect, ເຫດຜົນທີ່ມາພ້ອມຍັງຄົງມີຢູ່ແລະເຂົ້າໄປໃນລາຍະລະອຽດຫຼາຍກວ່າຫນ້າຜູ້ຊາຍນີ້.
CAVEATS
ສ່ວນຂະຫຍາຍອາດຈະຂັດກັບຊື່ຄໍາສັ່ງຂອງ Expect. ຕົວຢ່າງ, ການ ສົ່ງ ແມ່ນຖືກກໍານົດໂດຍ Tk ສໍາລັບຈຸດປະສົງທີ່ແຕກຕ່າງກັນທັງຫມົດ. ສໍາລັບເຫດຜົນນີ້, ຄໍາສັ່ງທີ່ ຄາດຫວັງ ຫຼາຍທີ່ສຸດແມ່ນຍັງມີ "exp_XXXX". ຄໍາສັ່ງແລະຕົວແປທີ່ເລີ່ມຕົ້ນດ້ວຍ "exp", "inter", "spawn" ແລະ "timeout" ບໍ່ມີນາມແຝງ. ໃຊ້ຊື່ຄໍາສັ່ງຂະຫຍາຍຖ້າທ່ານຕ້ອງການຄວາມເຂົ້າກັນໄດ້ລະຫວ່າງສະພາບແວດລ້ອມ.
ຄາດວ່າ ຈະໃຊ້ທັດສະນະທີ່ເປັນປະໂຫຍດຫຼາຍຂອງຂອບເຂດ. ໂດຍສະເພາະ, ຕົວແປທີ່ອ່ານໂດຍຄໍາສັ່ງສະເພາະກັບໂປແກມ Expect ຈະໄດ້ຮັບການຊອກຫາຄັ້ງທໍາອິດຈາກຂອບເຂດທ້ອງຖິ່ນແລະຖ້າບໍ່ພົບໃນຂອບເຂດທົ່ວໂລກ. ຕົວຢ່າງ, ນີ້ obviates ຄວາມຕ້ອງການທີ່ຈະເອົາ "ເວລາທົ່ວໂລກ" ໃນທຸກຂັ້ນຕອນທີ່ທ່ານຂຽນທີ່ໃຊ້ ຄາດວ່າຈະ . ໃນທາງກົງກັນຂ້າມ, ຕົວແປທີ່ຂຽນຢູ່ສະເຫມີຢູ່ໃນຂອບເຂດທ້ອງຖິ່ນ (ເວັ້ນເສຍແຕ່ຄໍາສັ່ງ "ທົ່ວໂລກ" ໄດ້ຖືກອອກມາ). ບັນຫາທີ່ພົບເລື້ອຍທີ່ສຸດແມ່ນສາເຫດທີ່ເກີດຂື້ນໃນຂັ້ນຕອນການຜະລິດ. ພາຍນອກລະບຽບການ, spawn_id ບໍ່ມີຢູ່ແລ້ວ, ດັ່ງນັ້ນ ຂັ້ນຕອນການ ຜະລິດບໍ່ສາມາດເຂົ້າເຖິງໄດ້ພຽງແຕ່ເນື່ອງຈາກວ່າມັນເປັນໄປໄດ້. ເພີ່ມ "spawn_id ທົ່ວໂລກ" ກັບຂັ້ນຕອນດັ່ງກ່າວ.
ຖ້າທ່ານບໍ່ສາມາດໃຊ້ຄວາມສາມາດໃນການສ້າງ multispawning (ເຊົ່ນລະບົບຂອງທ່ານບໍ່ສະຫນັບສະຫນູນການຄັດເລືອກ (BSD *. *), ການສໍາຫຼວດ (SVR> 2), ຫຼືສິ່ງທີ່ທຽບເທົ່າ), ຄາດວ່າ ຈະສາມາດຄວບຄຸມ ຂະບວນການ ດຽວເທົ່ານັ້ນ. ໃນກໍລະນີນີ້, ຢ່າພະຍາຍາມກໍານົດ spawn_id , ແລະທ່ານຍັງບໍ່ຕ້ອງການປະຕິບັດຂະບວນການຜ່ານ exec ໃນຂະນະທີ່ ຂະບວນການທີ່ ກໍາລັງຈະ ລ້າ . ຍິ່ງໄປກວ່ານັ້ນ, ທ່ານຈະບໍ່ສາມາດ ຄາດຫວັງ ຈາກຂະບວນການຕ່າງໆ (ລວມທັງຜູ້ໃຊ້ເປັນຫນຶ່ງ) ໃນເວລາດຽວກັນ.
ຕົວກໍານົດການຢູ່ປາຍຍອດສາມາດມີຜົນກະທົບອັນໃຫຍ່ຫຼວງໃນ scripts. ຕົວຢ່າງເຊັ່ນຖ້າສະຄິບຂຽນເພື່ອຊອກຫາສຽງ, ມັນຈະບໍ່ເຫມາະສົມຖ້າການປົດຕໍາແຫນ່ງສຽງຖືກປິດ. ສໍາລັບເຫດຜົນນີ້, ຄາດວ່າຈະກໍານົດຕົວກໍານົດການທ່າອຽງທີ່ຊັດເຈນໂດຍຄ່າເລີ່ມຕົ້ນ. ແຕ່ຫນ້າເສຍດາຍ, ສິ່ງນີ້ສາມາດເຮັດໃຫ້ສິ່ງທີ່ບໍ່ຫນ້າພໍໃຈສໍາລັບໂຄງການອື່ນໆ. ເປັນຕົວຢ່າງ, ຫອຍ emacs ຕ້ອງການປ່ຽນແປງແຜນທີ່ "ປະກະຕິ": ເສັ້ນທາງໃຫມ່ຈະໄດ້ຮັບການສະແດງໃຫ້ກັບເສັ້ນທາງໃຫມ່ແທນທີ່ຈະເປັນເສັ້ນທາງໃຫມ່ຂອງການຂົນສົ່ງແລະການຍົກເລີກ. ນີ້ອະນຸຍາດໃຫ້ຫນຶ່ງໃນການນໍາໃຊ້ emacs ເພື່ອແກ້ໄຂເສັ້ນເຂົ້າ. ແຕ່ຫນ້າເສຍດາຍ, ຄາດຫວັງວ່າບໍ່ສາມາດຄາດເດົາໄດ້ນີ້.
ທ່ານສາມາດຮ້ອງຂໍໃຫ້ຄາດຫວັງທີ່ຈະບໍ່ override ການຕັ້ງຄ່າເລີ່ມຕົ້ນຂອງຕົວກໍານົດການຢູ່ປາຍຍອດ, ແຕ່ວ່າທ່ານຕ້ອງລະມັດລະວັງຫຼາຍເມື່ອຂຽນສະຄິບສໍາລັບສະພາບແວດລ້ອມດັ່ງກ່າວ. ໃນກໍລະນີຂອງ emacs, ຫຼີກເວັ້ນການຂຶ້ນກັບສິ່ງຕ່າງໆເຊັ່ນ: ການຕອບສະຫນອງ echoing ແລະ end-of-line.
ຄໍາສັ່ງທີ່ຍອມຮັບການໂຕ້ຖຽງກັນໃນບັນຊີດຽວ (variants ຄາດຫວັງ ແລະ ການໂຕ້ຕອບ ) ໃຊ້ heuristic ເພື່ອຕັດສິນວ່າບັນຊີລາຍຊື່ແມ່ນຕົວຈິງຫນຶ່ງຫຼືຫຼາຍ. heuristic ສາມາດລົ້ມເຫຼວພຽງແຕ່ໃນກໍລະນີໃນເວລາທີ່ບັນຊີລາຍຊື່ຕົວຈິງແມ່ນການໂຕ້ຖຽງດຽວທີ່ມີ embedded \ n ຫຼາຍທີ່ມີລັກສະນະທີ່ບໍ່ແມ່ນຊ່ອງຫວ່າງລະຫວ່າງເຂົາເຈົ້າ. ນີ້ເບິ່ງຄືວ່າຈະບໍ່ຫນ້າພໍໃຈຢ່າງເຕັມທີ່, ຢ່າງໃດກໍຕາມ, ການໂຕ້ຖຽງ "- ການຫ້າມ" ສາມາດຖືກນໍາໃຊ້ເພື່ອບັງຄັບການໂຕ້ຖຽງດຽວທີ່ຈະຖືກຈັດການເປັນການໂຕ້ຖຽງດຽວ. ນີ້ສາມາດ conceivably ນໍາໃຊ້ກັບລະຫັດຄາດຫວັງຂອງເຄື່ອງທີ່ຜະລິດ. Similarly, -brace forces a single argument to be handled as multiple patterns / actions
BUGS
ມັນແມ່ນສິ່ງທີ່ຫນ້າສົນໃຈທີ່ສຸດທີ່ຈະຊື່ວ່າ "ການຮ່ວມເພດ" (ສໍາລັບ "Smart EXec" ຫຼື "Send-Expect"), ແຕ່ຄວາມຮູ້ສຶກທີ່ດີ (ຫຼືບາງທີ Puritanism) ໄດ້ຊະນະ.
ໃນບາງລະບົບ, ໃນເວລາທີ່ແກະແມ່ນເກີດ, ມັນຈົ່ມກ່ຽວກັບການບໍ່ສາມາດເຂົ້າເຖິງ tty ແຕ່ວ່າມັນເຮັດວຽກຢ່າງໃດກໍ່ຕາມ. ນີ້ຫມາຍຄວາມວ່າລະບົບຂອງທ່ານມີກົນໄກເພື່ອເພີ່ມການຄວບຄຸມທີ່ ຄາດວ່າ ຈະບໍ່ຮູ້ກ່ຽວກັບ. ກະລຸນາຊອກຫາສິ່ງທີ່ມັນແມ່ນ, ແລະສົ່ງຂໍ້ມູນນີ້ກັບຂ້ອຍ.
Ultrix 4.1 (ຢ່າງນ້ອຍຮຸ່ນທີ່ຫລ້າສຸດຢູ່ທີ່ນີ້) ພິຈາລະນາເວລາຂອງເວລາທີ່ຢູ່ເຫນືອ 1000000 ຈະເທົ່າກັບ 0.
ດິຈິຕອນ UNIX 40A (ແລະອາດຈະເປັນຮຸ່ນອື່ນໆ) ປະຕິເສດທີ່ຈະຈັດສັນ ptys ຖ້າທ່ານກໍານົດຕົວຈັດການ SIGCHLD. ເບິ່ງຫນ້າການຊ່ວຍເຫຼືອສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.
IRIX 60 ບໍ່ຈັດການສິດອະນຸຍາດ pty ຢ່າງຖືກຕ້ອງດັ່ງນັ້ນຖ້າຄາດວ່າຈະພະຍາຍາມທີ່ຈະຈັດສັນການນໍາໃຊ້ pty ທີ່ຜ່ານມາໃຊ້ໂດຍຄົນອື່ນມັນກໍ່ລົ້ມເຫລວ. ອັບເດດກັບ IRIX 6.1.
Telnet (ຢືນຢັນພາຍໃຕ້ SunOS 4.1.2) ຈະຖືກປິດຖ້າ TERM ບໍ່ຖືກກໍານົດ. ນີ້ແມ່ນບັນຫາພາຍໃຕ້ cron, ຢູ່ແລະໃນ script cgi, ເຊິ່ງບໍ່ໄດ້ກໍານົດ TERM. ດັ່ງນັ້ນ, ທ່ານຕ້ອງກໍານົດຢ່າງຊັດເຈນ - ກັບປະເພດໃດກໍ່ຕາມທີ່ບໍ່ກ່ຽວຂ້ອງ. ມັນພຽງແຕ່ຕ້ອງໄດ້ກໍານົດໃຫ້ບາງສິ່ງບາງຢ່າງ! ດັ່ງຕໍ່ໄປນີ້ອາດຈະພຽງພໍສໍາລັບກໍລະນີຫຼາຍທີ່ສຸດ.
set env (TERM) vt100ຄໍາແນະນໍາ (ຢັ້ງຢືນພາຍໃຕ້ BSDI BSD / OS 3.1 i386) ຈະຖືກປິດຖ້າ SHELL ແລະ HOME ບໍ່ຖືກກໍານົດ. ນີ້ແມ່ນບັນຫາພາຍໃຕ້ cron , ຢູ່ແລະໃນ script cgi , ເຊິ່ງບໍ່ໄດ້ກໍານົດຕົວແປສະພາບແວດລ້ອມເຫຼົ່ານີ້. ດັ່ງນັ້ນ, ທ່ານຕ້ອງກໍານົດໃຫ້ພວກເຂົາຢ່າງຊັດເຈນ - ກັບປະເພດໃດກໍ່ຕາມທີ່ບໍ່ກ່ຽວຂ້ອງ. ມັນພຽງແຕ່ຕ້ອງໄດ້ກໍານົດໃຫ້ບາງສິ່ງບາງຢ່າງ! ດັ່ງຕໍ່ໄປນີ້ອາດຈະພຽງພໍສໍາລັບກໍລະນີຫຼາຍທີ່ສຸດ.
set env (SHELL) / bin / sh set env (HOME) / usr / local / binບາງການປະຕິບັດຂອງ ptys ຖືກອອກແບບເພື່ອໃຫ້ແກ່ນເລີ້ມຜົນຜະລິດທີ່ບໍ່ໄດ້ອ່ານຫຼັງຈາກ 10 ຫາ 15 ວິນາທີ (ຈໍານວນຕົວຈິງແມ່ນການປະຕິບັດຕາມ) ຫຼັງຈາກ ຂະບວນການ ໄດ້ປິດລາຍລະອຽດຂອງໄຟລ໌. ດັ່ງນັ້ນ ຄາດຫວັງວ່າ ໂຄງການເຊັ່ນ:
ວັນເດືອນປີເກີດນອນ 20 ຄາດຈະລົ້ມເຫລວ. ເພື່ອຫຼີກເວັ້ນການນີ້, ຮຽກຮ້ອງໂຄງການທີ່ບໍ່ແມ່ນການໂຕ້ຕອບກັບ exec ແທນທີ່ຈະກ່ວາການ ຜະລິດ . ໃນຂະນະທີ່ສະຖານະການດັ່ງກ່າວແມ່ນ conceivable, ໃນການປະຕິບັດຂ້າພະເຈົ້າບໍ່ເຄີຍໄດ້ພົບເຫັນສະຖານະການທີ່ຜົນຜະລິດສຸດທ້າຍຂອງໂຄງການທີ່ມີການໂຕ້ຕອບຈິງໆຈະສູນເສຍເນື່ອງຈາກພຶດຕິກໍານີ້.
ໃນທາງກົງກັນຂ້າມ, Cray UNICOS ptys ຖິ້ມຜົນຜະລິດທີ່ບໍ່ໄດ້ອ່ານອອກມາທັນທີຫຼັງຈາກ ຂະບວນການ ໄດ້ປິດລະບົບຄໍາອະທິບາຍໄຟລ໌. ຂ້າພະເຈົ້າໄດ້ລາຍງານນີ້ໃຫ້ Cray ແລະພວກເຂົາກໍາລັງເຮັດວຽກແກ້ໄຂ.
ບາງຄັ້ງຄວາມຊັກຊ້າແມ່ນຕ້ອງມີລະຫວ່າງຄໍາຖາມແລະຄໍາຕອບ, ເຊັ່ນເມື່ອໂຕ້ຕອບ tty ກໍາລັງປ່ຽນແປງການຕັ້ງຄ່າ UART ຫຼື ອັດ ຕາການເຊື່ອມໂຍງຂອງ baud ໂດຍການຊອກຫາຈຸດເລີ່ມຕົ້ນ / ຢຸດ. ປົກກະຕິແລ້ວ, ທັງຫມົດນີ້ແມ່ນຕ້ອງການແມ່ນການນອນສໍາລັບສອງຫຼືສອງ. ເຕັກນິກທີ່ເຂັ້ມແຂງກວ່າແມ່ນການທົດລອງຈົນກ່ວາຮາດແວແມ່ນກຽມພ້ອມທີ່ຈະໄດ້ຮັບການປ້ອນຂໍ້ມູນ. ຕົວຢ່າງຕໍ່ໄປນີ້ໃຊ້ກົນລະຍຸດທັງສອງ:
ສົ່ງ "ຄວາມໄວ 9600 \ r"; ນອນ 1 ຄາດຫວັງ {timeout {ສົ່ງ "\ r"; exp_continue} $ prompt}trap-code ຈະບໍ່ເຮັດວຽກກັບຄໍາສັ່ງໃດໆທີ່ຢູ່ໃນວົງການເຫດການຂອງ Tcl ເຊັ່ນນອນ. ບັນຫາແມ່ນວ່າໃນຮອບເຫດການ, Tcl ຍົກເລີກລະຫັດສົ່ງກັບຄືນຈາກ async handlers event. ການແກ້ໄຂແມ່ນເພື່ອກໍານົດ flag ໃນລະຫັດ trap. ຫຼັງຈາກນັ້ນ, ກວດເບິ່ງທຸງທັນທີຫຼັງຈາກຄໍາສັ່ງ (ເຊົ່ນນອນ).
ຄໍາສັ່ງ expect_background ignores -timeout arguments ແລະບໍ່ມີ concept of timeouts ໂດຍທົ່ວໄປ.
& # 34; ປະຕິບັດ HINTS & # 34;
ມີສອງສິ່ງກ່ຽວກັບການ ຄາດຫວັງ ວ່າອາດຈະບໍ່ແມ່ນຄວາມເຂົ້າໃຈ. ພາກນີ້ພະຍາຍາມແກ້ໄຂບັນຫາເຫຼົ່ານີ້ດ້ວຍສອງຄໍາແນະນໍາ.
ບັນຫາທີ່ຄາດຫວັງທົ່ວໄປແມ່ນວິທີການຮັບຮູ້ການເຕືອນຂອງປ່ອງ. ນັບຕັ້ງແຕ່ການເຫຼົ່ານີ້ຖືກກໍາຫນົດເອງໂດຍຄົນອື່ນແລະແກະທີ່ແຕກຕ່າງກັນ, ອັດຕະໂນມັດ rlogin ສາມາດມີຄວາມຫຍຸ້ງຍາກໂດຍບໍ່ຮູ້ເຕືອນ. ສົນທິສັນຍາທີ່ສົມເຫດສົມຜົນແມ່ນເພື່ອໃຫ້ຜູ້ໃຊ້ສາມາດເກັບກໍາສະແດງອອກເປັນປົກກະຕິທີ່ອະທິບາຍຄໍາຖາມຂອງພວກເຂົາ (ໂດຍສະເພາະໃນທ້າຍຂອງມັນ) ໃນຕົວແປສິ່ງແວດລ້ອມ EXPECT_PROMPT. ລະຫັດດັ່ງຕໍ່ໄປນີ້ສາມາດໃຊ້ໄດ້. ຖ້າ EXPECT_PROMPT ບໍ່ມີ, ລະຫັດຍັງຄົງມີໂອກາດດີທີ່ຈະເຮັດວຽກຢ່າງຖືກຕ້ອງ.
set prompt "(% | # | \\ $) $"; $ prompt prompt {set prompt $ env (EXPECT_PROMPT)} expect-$ promptຂ້ອຍຂໍແນະນໍາໃຫ້ທ່ານຂຽນແບບ ຄາດຫວັງ ທີ່ປະກອບມີຕອນທ້າຍຂອງສິ່ງທີ່ທ່ານຄາດຫວັງ. ນີ້ຫລີກລ້ຽງຄວາມເປັນໄປໄດ້ຂອງການຕອບຄໍາຖາມກ່ອນທີ່ຈະເຫັນສິ່ງທັງຫມົດ. ນອກຈາກນັ້ນ, ໃນຂະນະທີ່ທ່ານອາດຈະສາມາດຕອບຄໍາຖາມໄດ້ກ່ອນທີ່ຈະເຫັນມັນທັງຫມົດ, ຖ້າທ່ານຕອບຄໍາຕອບຕົ້ນໆ, ຄໍາຕອບຂອງທ່ານອາດຈະສະແດງໃຫ້ເຫັນກັບຄືນສູ່ເຄິ່ງກາງຂອງຄໍາຖາມ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ການປຶກສາຫາລືຜົນໄດ້ຮັບຈະຖືກຕ້ອງແຕ່ເບິ່ງແຍງ.
ຄໍາແນະນໍາຫຼາຍທີ່ສຸດປະກອບມີລັກສະນະຂອງຊ່ອງໃນຕອນທ້າຍ. ຕົວຢ່າງເຊັ່ນ, prompt ຈາກ ftp ແມ່ນ 'f', 't', 'p', '>' ແລະ. ເພື່ອໃຫ້ກົງກັບຄໍາສັ່ງນີ້, ທ່ານຕ້ອງບັນຊີສໍາລັບແຕ່ລະຕົວອັກສອນເຫຼົ່ານີ້. ມັນເປັນຂໍ້ຜິດພາດທີ່ບໍ່ແມ່ນການປະກອບສ່ວນຫວ່າງເປົ່າ. ໃສ່ເປົ່າໃນຢ່າງຊັດເຈນ.
ຖ້າທ່ານໃຊ້ຮູບແບບຂອງແບບຟອມ X *, * ຈະກົງກັບຜົນຜະລິດທັງຫມົດທີ່ໄດ້ຮັບຈາກທ້າຍຂອງ X ກັບສິ່ງສຸດທ້າຍທີ່ໄດ້ຮັບ. ມັນອາດຈະສັບສົນແຕ່ສາມາດສັບສົນໄດ້ເພາະວ່າຄໍາວ່າ "ສິ່ງສຸດທ້າຍທີ່ໄດ້ຮັບ" ສາມາດແຕກຕ່າງກັນໄປຕາມຄວາມໄວຂອງຄອມພິວເຕີ້ແລະການປຸງແຕ່ງ I / O ໂດຍທັງສອງແກ່ນແລະໄດເວີອຸປະກອນ.
ໂດຍສະເພາະແມ່ນ, ມະນຸດມີແນວໂນ້ມທີ່ຈະເຫັນຜົນຜະລິດຂອງໂຄງການທີ່ມາຮອດໃນຂະຫນາດໃຫຍ່ (ໃນແງ່ດີ) ເມື່ອໃນຄວາມເປັນຈິງແລ້ວໂຄງການສ່ວນໃຫຍ່ແມ່ນຜະລິດຕະພັນຫນຶ່ງເສັ້ນໃນເວລາດຽວກັນ. ການສົມມຸດວ່ານີ້ແມ່ນກໍລະນີ, * ໃນຮູບແບບຂອງວັກກ່ອນຫນ້ານີ້ອາດຈະເທົ່າກັບຕອນທ້າຍຂອງເສັ້ນໃນປະຈຸບັນເຖິງແມ່ນວ່າມັນເບິ່ງຄືວ່າຈະມີຫຼາຍຂຶ້ນ, ເນື່ອງຈາກວ່າໃນເວລາຂອງການແຂ່ງຂັນທີ່ມີຜົນຜະລິດທັງຫມົດທີ່ໄດ້ຮັບ.
ຄາດວ່າ ຈະບໍ່ມີວິທີທີ່ຈະຮູ້ວ່າຜົນຜະລິດເພີ່ມເຕີມແມ່ນຈະມາເຖິງເວັ້ນເສຍແຕ່ວ່າຮູບແບບຂອງທ່ານແມ່ນບັນຊີສໍາລັບມັນ.
ເຖິງແມ່ນວ່າຈະຂຶ້ນກັບການບີບບັງຄັບເສັ້ນທາງແມ່ນບໍ່ສະຫຼາດ. ບໍ່ພຽງແຕ່ໂຄງການບໍ່ຄ່ອຍເຮັດຄໍາຫມັ້ນສັນຍາກ່ຽວກັບປະເພດຂອງການບີບອັດທີ່ເຂົາເຈົ້າເຮັດ, ແຕ່ການລະບົບການຍ່ອຍສະຫຼາຍຂອງລະບົບສາມາດທໍາລາຍສາຍການຜະລິດອອກເພື່ອໃຫ້ເສັ້ນທີ່ແຕກແຍກຢູ່ໃນສະຖານທີ່ທີ່ຄ້າຍຄືກັນ. ດັ່ງນັ້ນ, ຖ້າທ່ານສາມາດສະແດງຕົວອັກສອນນ້ອຍສຸດທ້າຍຂອງແບບໂຕ້ຕອບໃນເວລາທີ່ຂຽນແບບ, ມັນກໍ່ເປັນທັມທີ່ຈະເຮັດແບບນັ້ນ.
ຖ້າທ່ານກໍາລັງລໍຖ້າຮູບແບບໃນຜົນຜະລິດຄັ້ງສຸດທ້າຍຂອງໂຄງການແລະໂຄງການຈະປ່ອຍສິ່ງອື່ນແທນ, ທ່ານຈະບໍ່ສາມາດກວດພົບວ່າມີຄໍາທີ່ໃຊ້ ເວລາຫມົດເວລາ . ເຫດຜົນແມ່ນວ່າ ຄາດວ່າ ຈະບໍ່ຫມົດເວລາ - ແທນທີ່ມັນຈະໄດ້ຮັບການຊີ້ບອກ. ໃຊ້ແທນທີ່ນັ້ນ. ເຖິງແມ່ນວ່າດີກວ່າ, ໃຊ້ທັງສອງ. ວິທີການດັ່ງກ່າວຖ້າວ່າເສັ້ນນັ້ນຖືກຍ້າຍໄປຢູ່ຮອບໆ, ທ່ານຈະບໍ່ຕ້ອງແກ້ສາຍມັນເອງ.
Newlines ໂດຍປົກກະຕິຈະຖືກປ່ຽນແປງໄປກັບການສົ່ງກັບ, ລໍາດັບ linefeed ເມື່ອສົ່ງອອກໂດຍຕົວຂັບຂົວ. ດັ່ງນັ້ນ, ຖ້າທ່ານຕ້ອງການຮູບແບບທີ່ກົງກັນກັບສອງເສັ້ນ, ຈາກ, ເວົ້າ, printf ("foo \ nbar"), ທ່ານຄວນໃຊ້ຮູບແບບ "foo \ r \ nbar".
ການແປພາສາທີ່ຄ້າຍຄືກັນເກີດຂຶ້ນໃນເວລາທີ່ການອ່ານຈາກຜູ້ໃຊ້, ໂດຍຜ່ານ expect_user . ໃນກໍລະນີນີ້, ເມື່ອທ່ານກົດກັບຄືນ, ມັນຈະຖືກແປເປັນເສັ້ນໃຫມ່. ຖ້າຫາກ ວ່າຄາດວ່າ ຫຼັງຈາກນັ້ນຈະສົ່ງໄປທີ່ໂຄງການທີ່ຕັ້ງຄ່າ terminal ຂອງມັນກັບໂຫມດດິບ (ເຊັ່ນ telnet) ມັນຈະເປັນບັນຫາຍ້ອນວ່າໂຄງການຄາດວ່າຈະມີການກັບຄືນຈິງ. (ໂຄງການບາງຢ່າງແມ່ນການໃຫ້ອະໄພໃນຕົວຈິງແລ້ວວ່າພວກເຂົາຈະອັດຕະໂນມັດແປ້ນໃຫມ່ທີ່ຈະກັບຄືນ, ແຕ່ສ່ວນໃຫຍ່ບໍ່ເຮັດ.) ແຕ່ຫນ້າເສຍດາຍ, ບໍ່ມີທາງທີ່ຈະຄົ້ນພົບວ່າໂຄງການເຮັດໃຫ້ປາຍທາງຂອງມັນເປັນຮູບແບບດິບ.
ແທນທີ່ຈະປ້ອນຂໍ້ມູນໃຫມ່ດ້ວຍການຄືນເງິນດ້ວຍຕົນເອງ, ແກ້ໄຂແມ່ນໃຊ້ຄໍາສັ່ງ "stty raw", ເຊິ່ງຈະຢຸດການແປ. ຫມາຍເຫດ, ຢ່າງໃດກໍ່ຕາມ, ວ່ານີ້ຫມາຍຄວາມວ່າທ່ານຈະບໍ່ໄດ້ຮັບຄຸນສົມບັດການດັດແກ້ບັນທັດທີ່ຖືກປຸງແຕ່ງແລ້ວ.
ການພົວພັນ ຢ່າງແທດເຫມາະກໍ່ຕັ້ງອຸປະກອນຂອງທ່ານຢູ່ໃນໂຫມດດິບດັ່ງນັ້ນບັນຫານີ້ຈະບໍ່ເກີດຂຶ້ນຫຼັງຈາກນັ້ນ.
ມັນມັກຈະເປັນປະໂຫຍດທີ່ຈະເກັບຮັກສາລະຫັດຜ່ານ (ຫຼືຂໍ້ມູນສ່ວນຕົວອື່ນໆ) ໃນ Expect scripts. ນີ້ບໍ່ໄດ້ຖືກແນະນໍາເພາະວ່າສິ່ງທີ່ເກັບຮັກສາໄວ້ໃນຄອມພິວເຕີແມ່ນສາມາດເຂົ້າເຖິງໄດ້ໂດຍໃຜ. ດັ່ງນັ້ນ, ການໂຕ້ຖຽງກັນແບບໂຕ້ຕອບສໍາລັບລະຫັດຜ່ານຈາກສະຄິບເປັນຄວາມຄິດທີ່ສະຫລາດກວ່າການຕິດຕາມພວກມັນ. ຢ່າງໃດກໍ່ຕາມ, ບາງຄັ້ງການຝັງເຊັ່ນນີ້ແມ່ນຄວາມເປັນໄປໄດ້ເທົ່ານັ້ນ.
ແຕ່ຫນ້າເສຍດາຍ, ລະບົບເອກະສານ UNIX ບໍ່ມີວິທີການໂດຍກົງໃນການສ້າງສະຄິບທີ່ສາມາດປະຕິບັດໄດ້ແຕ່ບໍ່ສາມາດອ່ານໄດ້. ລະບົບທີ່ສະຫນັບສະຫນູນ scripts shell script ອາດຈະປະຕິບັດຕົວຢ່າງເຊັ່ນ:
ສ້າງຕາຕະລາງຄວາມ ຄາດຫວັງ (ທີ່ປະກອບດ້ວຍຂໍ້ມູນລັບ) ຕາມປົກກະຕິ. ເຮັດໃຫ້ສິດຂອງມັນເປັນ 750 (-rwxr-x ---) ແລະເປັນເຈົ້າຂອງໂດຍກຸ່ມທີ່ເຊື່ອຖືໄດ້, ຄືກຸ່ມທີ່ອະນຸຍາດໃຫ້ອ່ານມັນ. ຖ້າຈໍາເປັນ, ສ້າງກຸ່ມໃຫມ່ສໍາລັບຈຸດປະສົງນີ້. ຕໍ່ໄປ, ສ້າງ script / bin / sh ທີ່ມີສິດ 2751 (-rwxr-s-x) ທີ່ເປັນເຈົ້າຂອງກຸ່ມດຽວກັນກ່ອນຫນ້ານີ້.
ຜົນໄດ້ຮັບແມ່ນ script ທີ່ອາດຈະຖືກປະຕິບັດ (ແລະອ່ານ) ໂດຍໃຜ. ໃນເວລາທີ່ເອີ້ນວ່າ, ມັນແລ່ນ ຄາດຄາດ .
ເບິ່ງ & # 34; ເບິ່ງເຫັນ & # 34;
Tcl (3), libexpect (3)
"Exploring ຄາດ: Toolkit Tcl ອີງໃສ່ອັດຕະໂນມັດໂຄງການແບບໂຕ້ຕອບ" ໂດຍ Don Libes, pp. 602, ISBN 1-56592-090-2, O'Reilly and Associates, 1995.
"ຄາດຫວັງວ່າ: ການປິ່ນປົວຜູ້ທີ່ບໍ່ສາມາດຄວບຄຸມການຕິດຕໍ່ໄດ້" ໂດຍ Don Libes, ບັນທຶກຂອງກອງປະຊຸມສະຫະລັດອາເມລິກາ Summer 1987, Anaheim, California, 11-15 ເດືອນທັນວາ 1990.
ຂ້ອຍໃຊ້ " ຄາດວ່າ ຈະເຮັດວຽກອັດຕະໂນມັດຫນ້າທີ່ການບໍລິຫານຈັດການລະບົບ" ໂດຍ Don Libes, ການດໍາເນີນຄະນະຂອງກອງປະຊຸມການບໍລິຫານ Systems USENIX ປີ 1990, Colorado Springs, Colorado, 17-19 ຕຸລາ 1990.
ຂ້າພະເຈົ້າ "ຄາດຫວັງວ່າ: Scripts ສໍາລັບການຄວບຄຸມໂຄງການແບບໂຕ້ຕອບ" ໂດຍ Don Libes, ລະບົບຄອມພິວເຕີ້ລະບົບປະຕິບັດການຄອມພິວເຕີ້. , Vol 4, ຫມາຍເລກ 2, ວາລະສານຫນັງສືພິມຂອງມະຫາວິທະຍາໄລຄາລິຟໍເນຍ, ເດືອນພະຈິກ 1991 .. "ການທົດສອບການທົດສອບການທົດສອບແລະການປະຕິບັດການທົດສອບແບບທົດສອບແບບທົດລອງ", ໂດຍ Don Libes, ການປະຊຸມຂອງກອງປະຊຸມ Summer USENENIX, pp. 135-144, San Antonio, TX, 12-15 ມິຖຸນາ, 1992 ຂ້ອຍໄດ້ "Kibitz - ການເຊື່ອມຕໍ່ຫຼາຍໂຄງການທີ່ມີການໂຕ້ຕອບຮ່ວມກັນ" ໂດຍ Don Libes, Software - Practice & Experience, John Wiley & Sons, West Sussex, England, Vol.
23, 5, ພຶດສະພາ, 1993 .. ຂ້າພະເຈົ້າ "Debugger ສໍາລັບຄໍາຮ້ອງສະຫມັກ Tcl", ໂດຍ Don Libes, ດໍາເນີນຄະດີຂອງ 1993 Tcl / Tk Workshop, Berkeley, CA, 10-11 ເດືອນມິຖຸນາ 1993,.
AUTHOR
Don Libes, ສະຖາບັນມາດຕະຖານແລະເຕັກໂນໂລຢີແຫ່ງຊາດ
ການຍອມຮັບ
ຂໍຂອບໃຈກັບ John Ousterhout ສໍາລັບ Tcl, ແລະ Scott Paisley ສໍາລັບການດົນໃຈ. ຂໍຂອບໃຈກັບລະຫັດ autoconfiguration ຂອງ Rob Savoye ສໍາລັບ Expect.
ເອກະສານໄຟລ໌ HISTORY ຫຼາຍຂອງ evolution ຂອງ ຄາດວ່າຈະໄດ້ . ມັນເຮັດໃຫ້ອ່ານທີ່ຫນ້າສົນໃຈແລະອາດຈະໃຫ້ທ່ານຮູ້ຕື່ມອີກຕໍ່ກັບຊໍແວນີ້. ຂໍຂອບໃຈກັບປະຊາຊົນທີ່ໄດ້ກ່າວມາໃນມັນທີ່ສົ່ງຂ້າພະເຈົ້າແກ້ໄຂຂໍ້ບົກພ່ອງແລະໃຫ້ການຊ່ວຍເຫຼືອອື່ນໆ.
ການອອກແບບແລະການຈັດຕັ້ງປະຕິບັດ ຄາດຫມາຍ ໄດ້ຮັບສ່ວນຫນຶ່ງແມ່ນໂດຍລັດຖະບານສະຫະລັດແລະດັ່ງນັ້ນຈຶ່ງຢູ່ໃນຂົງເຂດສາທາລະນະ. ຢ່າງໃດກໍຕາມ, ຜູ້ຂຽນແລະ NIST ຕ້ອງການການປ່ອຍສິນເຊື່ອຖ້າຫາກວ່າໂຄງການນີ້ແລະເອກະສານຫຼືບາງສ່ວນຂອງພວກເຂົາຖືກນໍາໃຊ້.