Expect คือโปรแกรมที่พูดถึงโปรแกรมโต้ตอบอื่น ๆ ตามสคริปต์ หลังจากที่สคริปต์คาดว่าจะรู้ว่าสิ่งที่คาดหวังจากโปรแกรมและสิ่งที่ควรได้รับการตอบสนองที่ถูกต้อง ภาษาที่ตีความจะมีโครงสร้างการควบคุมสาขาและระดับสูงในการกำหนดกรอบโต้ตอบ นอกจากนี้ผู้ใช้สามารถควบคุมและโต้ตอบโดยตรงได้เมื่อต้องการจากนั้นกลับไปควบคุมสคริปต์
Expectk เป็นส่วนผสมของ Expect และ Tk มันมีลักษณะเหมือน Expect และ Tk's ปรารถนา Expect สามารถใช้งานได้โดยตรงใน C หรือ C ++ โดยไม่มี Tcl
ชื่อ "คาดหวัง" มาจากแนวคิดการส่ง / คาดหวังลำดับที่นิยมโดย uucp, kermit และโปรแกรมควบคุมโมเด็มอื่น ๆ อย่างไรก็ตามไม่เหมือน uucp คาดว่าจะเป็นแบบ generalised เพื่อให้สามารถรันเป็นคำสั่งระดับผู้ใช้กับโปรแกรมและงานต่างๆได้ คาดว่าจะสามารถพูดคุยกับหลายโปรแกรมในเวลาเดียวกัน
สิ่งที่คาดหวังได้
ตัวอย่างเช่นนี่คือบางสิ่งที่คำสั่งคาดหวังสามารถทำได้:
- ทำให้คอมพิวเตอร์ของคุณโทรกลับเพื่อให้คุณสามารถเข้าสู่ระบบได้โดยไม่ต้องเสียค่าโทร
- เริ่มเกมและหากการกำหนดค่าที่เหมาะสมไม่ปรากฏขึ้นให้เริ่มต้นใหม่อีกครั้งและอีกครั้ง) จนกว่าจะมีการส่งมอบแล้วส่งมอบการควบคุมให้กับคุณ
- เรียกใช้ fsck และในการตอบคำถามของคำตอบ "ใช่" หรือ "ไม่" หรือให้การควบคุมกลับไปหาคุณตามเกณฑ์ที่กำหนดไว้
- เชื่อมต่อกับเครือข่ายอื่นและเรียกดูจดหมายของคุณโดยอัตโนมัติเพื่อให้ดูเหมือนว่าระบบเดิมของคุณถูกส่งไปยังระบบภายในของคุณ
- ดำเนินการตัวแปรสภาพแวดล้อมไดเร็กทอรีปัจจุบันหรือข้อมูลใด ๆ ใน rlogin, telnet, tip, su หรือ chgrp
มีสาเหตุหลายประการที่เปลือกไม่สามารถปฏิบัติงานเหล่านี้ได้ ทั้งหมดนี้เป็นไปได้ด้วย Expect
โดยทั่วไป Expect จะเป็นประโยชน์สำหรับการเรียกใช้โปรแกรมใด ๆ ที่ต้องการการโต้ตอบระหว่างโปรแกรมกับผู้ใช้ สิ่งที่จำเป็นคือปฏิสัมพันธ์สามารถระบุได้ทางโปรแกรม คาดหวังยังสามารถให้การควบคุมกลับไปยังผู้ใช้โดยไม่หยุดชะงักโปรแกรมที่ถูกควบคุม ในทำนองเดียวกันผู้ใช้สามารถกลับการควบคุมสคริปต์ได้ตลอดเวลา
การใช้
คาดว่าจะอ่าน cmdfile สำหรับรายการคำสั่งที่จะรัน คาดหวังว่าจะสามารถเรียกใช้โดยปริยายในระบบที่สนับสนุน #! สัญกรณ์โดยการทำเครื่องหมายสคริปต์เป็นไฟล์ปฏิบัติการและทำบรรทัดแรกในสคริปต์:
#! / usr / local / bin / expect -f
แน่นอนเส้นทางต้องบรรยายถึงสิ่งที่คาดว่าจะมีชีวิตอยู่ / usr / local / bin เป็นเพียงตัวอย่างเท่านั้น
ธง -c จะนำคำสั่งไปใช้ก่อนที่จะใช้ในสคริปต์ คำสั่งควรถูกยกมาเพื่อป้องกันไม่ให้ถูกทำลายโดยเปลือก ตัวเลือกนี้อาจใช้หลายครั้ง คำสั่งหลายคำอาจทำงานด้วย single -c โดยการแยกด้วยเครื่องหมายอัฒภาค คำสั่งจะถูกดำเนินการตามลำดับที่ปรากฏ เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -command
ค่าสถานะ -d ช่วยให้สามารถตรวจจับการวินิจฉัยได้ซึ่งส่วนใหญ่รายงานถึงกิจกรรมภายในของคำสั่งต่างๆเช่นคาดหวังและโต้ตอบ ธงนี้มีลักษณะเช่นเดียวกับ "exp_internal 1" ที่จุดเริ่มต้นของสคริปต์ Expect พร้อมด้วยพิมพ์ Expect
ธง -D ช่วยให้ดีบักแบบโต้ตอบ ค่าจำนวนเต็มควรเป็นไปตาม ตัวดีบักจะควบคุมก่อนขั้นตอน Tcl ถัดไปถ้าค่าไม่เป็นศูนย์หรือถ้ากดปุ่ม ^ C หรือจุดหยุดทำงานหรือคำสั่งดีบักเกอร์ที่เหมาะสมอื่น ๆ จะปรากฏในสคริปต์ เมื่อใช้ Expectk ตัวเลือกนี้จะระบุเป็น -ตรวจแก้จุดบกพร่อง
ธง f จะนำไฟล์มาอ่านคำสั่ง ธงตัวเองเป็นตัวเลือกเนื่องจากเป็นประโยชน์เฉพาะเมื่อใช้ #! สัญกรณ์ดังนั้นอาร์กิวเมนต์อื่น ๆ อาจถูกจัดเตรียมไว้ในบรรทัดคำสั่ง เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -file
แฟ้มคำสั่งจะถูกอ่านลงในหน่วยความจำและดำเนินการอย่างครบถ้วน บางครั้งก็ควรอ่านไฟล์ทีละบรรทัด เพื่อที่จะบังคับให้ไฟล์ใด ๆ ได้รับการจัดการด้วยวิธีนี้ให้ใช้ค่าสถานะ -b เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -buffer
ถ้าสตริง "-" ระบุเป็นชื่อไฟล์จะมีการอ่านข้อมูลมาตรฐานแทน ใช้ "./-" เพื่ออ่านจากแฟ้มที่มีชื่อว่า "-"
สาเหตุ -i ทำให้ Expect โต้ตอบโต้ตอบสำหรับคำสั่งแทนการอ่านจากไฟล์ การแจ้งเตือนถูกยกเลิกโดยใช้คำสั่ง exit หรือเมื่อ EOF -i-flag จะสันนิษฐานถ้าไม่มีใช้ไฟล์คำสั่งหรือ -c เมื่อใช้ Expectk ตัวเลือกนี้จะถูกระบุเป็น -interactive
- อาจถูกใช้เพื่อกำหนดค่าตัวเลือกท้ายสุด วิธีนี้จะเป็นประโยชน์ถ้าคุณต้องการส่งอาร์กิวเมนต์ตัวเลือกให้กับสคริปต์ของคุณโดยไม่ได้ถูกแปลโดย Expect นี้จะมีประโยชน์ใน #! line เพื่อป้องกันการตีความที่ไม่เหมือนใครโดย Expect ตัวอย่างเช่นต่อไปนี้จะปล่อยอาร์กิวเมนต์เดิมรวมถึงชื่อสคริปต์ในตัวแปร argv .
#! / usr / local / bin / expect -
โปรดทราบว่าต้องใช้ข้อตกลง getopt (3) และ execve (2) ตามปกติเมื่อเพิ่มอาร์กิวเมนต์ลงใน #! เส้น
ไฟล์ $ exp_library / expect.rc มีอยู่โดยอัตโนมัติหากมีอยู่เว้นแต่จะมีการใช้ค่าสถานะ -N (เมื่อใช้ Expectk ตัวเลือกนี้จะระบุเป็น -NORC) ทันทีหลังจากนี้ไฟล์ ~ / .expect.rc จะได้รับการประมวลผลโดยอัตโนมัติเว้นแต่จะมีการใช้งาน -n flag ไว้ ถ้ามีการกำหนดตัวแปร DOTDIR สภาพแวดล้อมตัวแปรจะถือว่าเป็นไดเร็กทอรีและอ่าน. expect.rc จากที่นั่น เมื่อใช้ Expectk ตัวเลือกนี้จะระบุเป็น -norcการจัดหานี้เกิดขึ้นเฉพาะหลังจากดำเนินการแฟล็กใด ๆ -c
สาเหตุที่คาดว่าจะพิมพ์หมายเลขเวอร์ชันและออก ธงที่เกี่ยวข้องใน Expectk ซึ่งใช้ชื่อธงแบบยาวคือ --version
อาร์กิวเมนต์ตัวเลือกถูกสร้างขึ้นในรายการและเก็บไว้ในตัวแปรชื่อ argv และ argc ถูกเตรียมใช้งานตามความยาวของ argv
Argv0 ถูกกำหนดให้เป็นชื่อของสคริปต์หรือไบนารีหากไม่มีสคริปต์ถูกใช้ ตัวอย่างเช่นต่อไปนี้จะพิมพ์ชื่อของสคริปต์และอาร์กิวเมนต์สามตัวแรก:
send_user "$ argv0 lrange $ argv 0 2 n"
คำสั่ง
Expect ใช้ Tool Command Language Tcl ให้การควบคุมการไหล (ถ้า, สำหรับ, ทำลาย), การประเมินผลการแสดงออกและคุณสมบัติอื่น ๆ เช่น recursionand ขั้นตอนคำจำกัดความ คำสั่งที่ใช้ที่นี่ แต่ไม่ได้กำหนดไว้ (set, if, exec) เป็นคำสั่ง Tcl Expect รองรับคำสั่งเพิ่มเติม ถ้าไม่ได้ระบุไว้เป็นอย่างอื่นคำสั่งจะส่งคืนสตริงที่ว่างเปล่า
คำสั่งจะเรียงลำดับตามตัวอักษรเพื่อให้สามารถตั้งได้อย่างรวดเร็ว อย่างไรก็ตามผู้ใช้รายใหม่อาจเริ่มต้นได้ง่ายขึ้นโดยอ่านคำอธิบายเกี่ยวกับการวางไข่ส่งคาดหวังและโต้ตอบในลำดับดังกล่าว
ปิด -slave -onexec 0 | 1 -i spawn_id
ปิดการเชื่อมต่อกับกระบวนการปัจจุบัน โปรแกรมโต้ตอบส่วนใหญ่จะตรวจจับ EOF บน stdin และ exit; ดังนั้น ปิด ปกติพอเพียงที่จะฆ่ากระบวนการเช่นกัน ธง -i ประกาศกระบวนการที่จะปิดสอดคล้องกับชื่อ spawn_id
ทั้งสองคาดหวังและมีปฏิสัมพันธ์จะตรวจพบเมื่อกระบวนการปัจจุบันออกมาและปิดบังไว้โดยปริยาย แต่ถ้าคุณฆ่ากระบวนการโดยกล่าวว่า "exec kill $ pid" คุณต้องติดต่ออย่างใกล้ชิด.
ธง -onexec กำหนดว่าจะวางรหัสวางไข่ไว้ในกระบวนการที่เกิดใหม่หรือถ้ากระบวนการนี้ซ้อนทับ หากต้องการปล่อยรหัสวางไข่ให้เปิดใช้ค่า 0. ค่าจำนวนเต็มที่ไม่ใช่ศูนย์บังคับให้วางไข่ปิดลงในกระบวนการใหม่ ๆ
ธงสไลลาจะปิดทาสที่เชื่อมโยงกับรหัสวางไข่ เมื่อปิดการเชื่อมต่อทาสจะปิดโดยอัตโนมัติหากยังเปิดอยู่
ไม่ว่าการเชื่อมต่อจะปิดโดยปริยายหรืออย่างชัดเจนคุณควรเรียกใช้เพื่อรอให้ชัดเจนขึ้นช่องกระบวนการเคอร์เนลที่สอดคล้องกัน คำสั่ง close ไม่เรียกรอเนื่องจากไม่มีการรับประกันว่าการปิดการเชื่อมต่อกระบวนการจะทำให้ออกไป
debug now 0 | 1
ควบคุมดีบัก Tcl ช่วยให้คุณสามารถก้าวผ่านงบและตั้งค่าจุดสั่งหยุด
ไม่มีอาร์กิวเมนต์ 1 จะถูกส่งกลับถ้าดีบักเกอร์ไม่ทำงานมิฉะนั้น 0 จะถูกส่งกลับ
ด้วยอาร์กิวเมนต์ที่ 1 เริ่มต้นดีบักเกอร์ ด้วยอาร์กิวเมนต์ 0 ดีบั๊กจะหยุดลง ถ้าอาร์กิวเมนต์ 1 ถูกนำหน้าด้วยแฟล็ก now, debugger จะเริ่มทำงานทันที มิฉะนั้นดีบักเกอร์จะเริ่มต้นด้วยคำสั่ง Tcl ถัดไป
คำสั่งแก้ปัญหาจะไม่เปลี่ยนกับดักใด ๆ เปรียบเทียบนี้เพื่อเริ่มต้นคาดหวังกับธง -D
คำสั่ง disconnect disconnects กระบวนการ forked จาก terminal. มันยังคงทำงานอยู่เบื้องหลัง กระบวนการนี้จะมีกลุ่มกระบวนการของตัวเอง มาตรฐาน I / O ถูกเปลี่ยนเส้นทางไปที่ / dev / null
ส่วนต่อไปนี้ใช้ยกเลิกการเชื่อมต่อเพื่อเรียกใช้สคริปต์ต่อในพื้นหลัง
ถ้า {fork! = 0} ออกจากการเชื่อมต่อ . .
สคริปต์ต่อไปนี้อ่านรหัสผ่านและเรียกใช้โปรแกรมทุกๆชั่วโมงที่ต้องการรหัสผ่านในแต่ละครั้งที่มีการเรียกใช้ สคริปต์มีรหัสผ่านเพื่อให้คุณต้องพิมพ์เพียงครั้งเดียวเท่านั้น
send_user "password? " expect_user -re "(. *) n" สำหรับ {} 1 {} {if {fork! = 0} {sleep 3600; continue} ยกเลิกการวางไข่ priv_prog expect รหัสผ่าน: ส่ง "$ expect_out ( 1 สตริง) r " . . ออก}
ข้อดีของการยกเลิกการเชื่อมต่อกับคุณลักษณะของอะซิงโครนัสของเชลล์ (&) คือ Expect สามารถบันทึกพารามิเตอร์เทอร์มินัลก่อนตัดการเชื่อมต่อและนำไปใช้กับ ptys ใหม่ได้ ด้วย &, Expect ไม่มีโอกาสอ่านค่าพารามิเตอร์ของเทอร์มินัลเนื่องจากเทอร์มินอลถูกยกเลิกการเชื่อมต่อตามเวลาที่คาดว่าจะได้รับการควบคุม
ออก -opts สถานะ
สาเหตุคาดว่าจะออกหรือเตรียมทำเช่นนั้น
-onexit ธงทำให้อาร์กิวเมนต์ถัดไปถูกใช้เป็นตัวจัดการทางออก ไม่มีอาร์กิวเมนต์ตัวจัดการทางออกปัจจุบันจะถูกส่งกลับ
-ไม่มีทางออก สาเหตุธง คาดหวัง เพื่อเตรียมพร้อมในการออกจากระบบ แต่หยุดการทำงานของระบบปฏิบัติการจริง ตัวจัดการการดำเนินการออกจากผู้ใช้ที่กำหนดไว้จะทำงานเหมือนกับตัวจัดการภายในของ Expect เอง ไม่ควรดำเนินการคำสั่ง Expect เพิ่มเติม นี้จะเป็นประโยชน์ถ้าคุณกำลังเรียกใช้คาดว่าจะมีส่วนขยาย Tcl อื่น ๆ ล่ามปัจจุบัน (และหน้าต่างหลักถ้าอยู่ในสภาพแวดล้อม Tk) ยังคงอยู่เพื่อให้ส่วนขยาย Tcl อื่นสามารถล้างข้อมูลได้ ถ้าคาดหวัง ทางออก เรียกอีกครั้ง (อย่างไรก็ตามอาจเกิดขึ้นได้) ตัวดำเนินการจะไม่เรียกใช้อีกครั้ง
เมื่อออกจากการเชื่อมต่อกับกระบวนการสืบพันธุ์จะถูกปิด การปิดจะถูกตรวจพบเป็น EOF โดยกระบวนการที่เกิดขึ้น ทางออก จะไม่มีการกระทำอื่นใดนอกเหนือจากที่ปกติ _exit (2) ทำ ดังนั้นกระบอกไม้ไผ่กระบวนการที่ไม่ได้ตรวจสอบสำหรับ EOF อาจทำงานต่อไป (เงื่อนไขต่าง ๆ มีความสำคัญต่อการพิจารณาตัวอย่างเช่นสิ่งที่ส่งสัญญาณว่ากระบวนการที่เกิดขึ้นจะถูกส่งไปหรือไม่ แต่ระบบเหล่านี้ขึ้นอยู่กับระบบโดยทั่วไปจะมีการบันทึกไว้ภายใต้ exit (3)) กระบวนการที่เรียกว่า spawned จะถูกสืบทอดมาโดย init
สถานะ (หรือ 0 หากไม่ได้ระบุ) จะถูกส่งกลับเป็นสถานะการออกจาก คาดหวัง . ทางออก จะดำเนินการโดยปริยายถ้าสิ้นสุดสคริปต์
exp_continue -continue_timer
คำสั่ง exp_continue ช่วยให้ คาดหวัง ตัวเองเพื่อดำเนินการต่อไปแทนที่จะกลับมาเหมือนปกติ โดยค่าเริ่มต้น exp_continue ตั้งเวลาจับเวลาหมดเวลา -continue_timer ธงป้องกันไม่ให้ตัวตั้งเวลาเริ่มต้นใหม่ (ดู คาดหวัง สำหรับข้อมูลเพิ่มเติม.)
ค่า exp_internal -ffile
ทำให้เกิดคำสั่งเพิ่มเติมเพื่อส่งข้อมูลการวินิจฉัยไปยังภายใน คาดหวัง เพื่อ stderr ถ้า ราคา ไม่ใช่ศูนย์ เอาท์พุทนี้ถูกปิดใช้งานถ้า ราคา คือ 0 ข้อมูลการวินิจฉัยประกอบด้วยอักขระทุกตัวที่ได้รับและความพยายามทุกอย่างที่ทำเพื่อให้ตรงกับผลลัพธ์ปัจจุบันกับรูปแบบ
หากเป็นอุปกรณ์เสริม ไฟล์ มีการจัดเตรียมเอาท์พุทปกติและการแก้จุดบกพร่องทั้งหมดจะถูกเขียนลงในไฟล์นั้น (ไม่คำนึงถึงค่าของ ราคา ) แฟ้มผลลัพธ์การวินิจฉัยก่อนหน้านี้ถูกปิด
-ข้อมูล flag ทำให้ exp_internal เพื่อส่งคำอธิบายอาร์กิวเมนต์ที่ไม่ใช่ข้อมูลล่าสุดที่ได้รับ
exp_open args -i spawn_id
ส่งกลับตัวระบุไฟล์ Tcl ที่ตรงกับรหัสวางไข่เดิม ตัวระบุไฟล์สามารถใช้งานได้เหมือนกับที่เปิดโดย Tcl's เปิด คำสั่ง (รหัสวางไข่ไม่ควรใช้อีกต่อไป A รอ ไม่ควรดำเนินการ
-leaveopen ธงออก id วางไข่เปิดเพื่อเข้าถึงผ่านคำสั่ง Expect รอ ต้องดำเนินการกับรหัสวางไข่
exp_pid -i spawn_id
ส่งกลับรหัสกระบวนการที่สอดคล้องกับกระบวนการที่เกิดขึ้นในปัจจุบัน ถ้า -ผม flag จะใช้ pid ที่ส่งกลับจะตรงกับรหัสของ spawn id
exp_send
เป็นนามแฝงสำหรับ ส่ง .
exp_send_error
เป็นนามแฝงสำหรับ send_error .
exp_send_log
เป็นนามแฝงสำหรับ send_log .
exp_send_tty
เป็นนามแฝงสำหรับ send_tty .
exp_send_user
เป็นนามแฝงสำหรับ send_user .
exp_version -exit version
เป็นประโยชน์สำหรับการมั่นใจว่าสคริปต์สามารถทำงานร่วมกับเวอร์ชันปัจจุบันของ Expect ได้
ไม่มีอาร์กิวเมนต์เวอร์ชันปัจจุบันของ คาดหวัง จะถูกส่งกลับ เวอร์ชันนี้อาจถูกเข้ารหัสในสคริปต์ของคุณ ถ้าคุณรู้จริงว่าคุณไม่ได้ใช้คุณลักษณะของเวอร์ชันล่าสุดคุณสามารถระบุเวอร์ชันก่อนหน้าได้
รุ่นประกอบด้วยสามตัวเลขที่คั่นด้วยจุด อันดับแรกคือจำนวนที่สำคัญ สคริปต์ที่เขียนขึ้นสำหรับเวอร์ชันของ คาดหวัง กับตัวเลขหลักที่แตกต่างกันเกือบจะไม่ทำงานแน่นอน exp_version ส่งกลับข้อผิดพลาดหากตัวเลขหลักไม่ตรงกัน
ประการที่สองคือตัวเลขรอง สคริปต์ที่เขียนขึ้นสำหรับเวอร์ชันที่มีจำนวนน้อยกว่าเวอร์ชันปัจจุบันอาจขึ้นอยู่กับคุณลักษณะใหม่ ๆ และอาจไม่ทำงาน exp_version ส่งกลับค่าข้อผิดพลาดหากหมายเลขหลักตรงกัน แต่ตัวเลขรองสคริปต์มีค่ามากกว่าจำนวนที่เรียกใช้ คาดหวัง .
ประการที่สามคือจำนวนที่ไม่มีส่วนใดในการเปรียบเทียบเวอร์ชัน อย่างไรก็ตามจะเพิ่มขึ้นเมื่อ คาดหวัง การกระจายซอฟต์แวร์มีการเปลี่ยนแปลงในทางใด ๆ เช่นโดยเอกสารเพิ่มเติมหรือการเพิ่มประสิทธิภาพ จะมีการรีเซ็ตเป็น 0 สำหรับแต่ละรุ่นใหม่
กับ ทางออก ธง, คาดหวัง พิมพ์ข้อผิดพลาดและออกถ้าเวอร์ชันล้าสมัย
คาดว่า -opts pat1 body1 … -opts patn bodyn
รอจนกว่ารูปแบบใดรูปแบบหนึ่งจะตรงกับผลลัพธ์ของกระบวนการที่พลิกกลับช่วงเวลาที่ระบุได้ผ่านไปแล้วหรือเห็นไฟล์สิ้นสุดลง ถ้าร่างกายสุดท้ายว่างเปล่าอาจถูกละไว้
รูปแบบจากล่าสุด expect_before คำสั่งจะถูกใช้โดยปริยายก่อนรูปแบบอื่น ๆ รูปแบบจากล่าสุด expect_after คำสั่งจะถูกใช้โดยปริยายหลังจากที่มีรูปแบบอื่น ๆ
ถ้าอาร์กิวเมนต์ทั้งหมด คาดหวัง ต้องมีมากกว่าหนึ่งบรรทัดอาร์กิวเมนต์ทั้งหมดอาจถูก "ยึด" ไว้เพื่อหลีกเลี่ยงการยกเลิกแต่ละบรรทัดด้วยเครื่องหมายทับขวา ในกรณีนี้การแทนที่ Tcl ตามปกติจะเกิดขึ้นแม้จะมีวงเล็บปีกกา
หากรูปแบบเป็นคำหลัก EOF , ร่างกายที่สอดคล้องกันจะถูกดำเนินการเมื่อสิ้นสุดของแฟ้ม หากรูปแบบเป็นคำหลัก หมดเวลา , ร่างกายที่สอดคล้องกันจะถูกดำเนินการเมื่อหมดเวลา หากไม่มีการใช้คำหลัก timeout คำว่า null action จะดำเนินการเมื่อหมดเวลา ระยะหมดเวลาเริ่มต้นคือ 10 วินาที แต่อาจตั้งค่าได้เช่น 30 โดยใช้คำสั่ง "set outout 30" การหมดเวลา infinite สามารถกำหนดโดยค่า -1 หากรูปแบบเป็นคำหลัก ค่าเริ่มต้น , ตัวที่เกี่ยวข้องจะถูกดำเนินการเมื่อหมดเวลาหรือสิ้นสุดของแฟ้ม
ถ้ารูปแบบตรงกับตัวทำนองเดียวกัน คาดหวัง ส่งกลับผลลัพธ์ของเนื้อความ (หรือสตริงที่ว่างเปล่าถ้าไม่มีรูปแบบตรง) ในกรณีที่มีรูปแบบหลายรูปแบบที่ตรงกันรูปแบบที่ปรากฏขึ้นก่อนจะใช้เพื่อเลือกเนื้อหา
ทุกครั้งที่มีการส่งออกใหม่จะได้รับการเปรียบเทียบกับแต่ละรูปแบบตามลำดับที่ระบุไว้ ดังนั้นคุณอาจทดสอบเพื่อไม่ให้มีการจับคู่โดยการทำให้รูปแบบบางอย่างที่ผ่านมามีการรับประกันว่าจะปรากฏเช่นข้อความแจ้ง ในกรณีที่ไม่มีพรอมต์คุณต้องใช้ หมดเวลา (เช่นเดียวกับที่คุณทำถ้าคุณโต้ตอบด้วยตนเอง)
รูปแบบถูกระบุด้วยสามวิธี โดยค่าเริ่มต้นรูปแบบจะระบุตามด้วย Tcl's สตริงการจับคู่ คำสั่ง (รูปแบบดังกล่าวยังคล้ายกับการแสดงผลปกติของ C-shell ซึ่งมักเรียกว่า "glob") -gl ธงอาจถูกนำมาใช้เพื่อป้องกันรูปแบบที่อาจตรงกัน คาดหวัง ธงจากการทำเช่นนั้น รูปแบบที่ขึ้นต้นด้วย "-" ควรได้รับการป้องกันด้วยวิธีนี้ (สตริงทั้งหมดที่ขึ้นต้นด้วย "-" สงวนไว้สำหรับตัวเลือกในอนาคต)
ตัวอย่างเช่นส่วนต่อไปนี้จะมองหาการเข้าสู่ระบบที่ประสบความสำเร็จ (โปรดทราบว่า ทำแท้ง ถูกสันนิษฐานว่าเป็นขั้นตอนที่กำหนดไว้ในที่อื่น ๆ ในสคริปต์)
คาดหวัง {busy {ทำให้ยุ่ง n; exp_continue} ล้มเหลวยกเลิก "รหัสผ่านที่ไม่ถูกต้อง" ยกเลิกการหมดเวลายกเลิกการเชื่อมต่อ}
คำพูดเป็นสิ่งจำเป็นในรูปแบบที่สี่เนื่องจากมีช่องว่างซึ่งจะแยกรูปแบบออกจากการทำงานรูปแบบที่มีการดำเนินการเดียวกัน (เช่น 3 และ 4) จำเป็นต้องมีการแสดงการดำเนินการอีกครั้ง ซึ่งสามารถหลีกเลี่ยงได้โดยใช้รูปแบบ regexp (ดูด้านล่าง) ข้อมูลเพิ่มเติมเกี่ยวกับรูปแบบของรูปแบบโลกสามารถดูได้จากคู่มือ Tcl
รูปแบบ Regexp เป็นไปตามไวยากรณ์ที่ Tcl กำหนด regexp (ย่อมาจาก "นิพจน์ทั่วไป") คำสั่ง รูปแบบ regexp นำมาใช้กับธง -re . ตัวอย่างก่อนหน้านี้สามารถเขียนใหม่โดยใช้ regexp เป็น:
คาดหวัง {busy {ทำให้ยุ่ง n; exp_continue} -re "ล้มเหลว | รหัสผ่านไม่ถูกต้อง" ยกเลิกการหมดเวลายกเลิกการเชื่อมต่อ}
ทั้งสองรูปแบบคือ "unanchored" ซึ่งหมายความว่ารูปแบบไม่ต้องตรงกับสตริงทั้งหมด แต่สามารถเริ่มต้นและสิ้นสุดการจับคู่ได้ทุกที่ในสตริง (ตราบเท่าที่ทุกอย่างตรงกับ) ใช้ ^ เพื่อจับคู่จุดเริ่มต้นของสตริงและ $ เพื่อให้ตรงกับจุดสิ้นสุด โปรดทราบว่าถ้าคุณไม่รอให้สตริงจบการตอบสนองของคุณจะจบลงตรงกลางของสตริงเพราะจะมีการสะท้อนออกมาจากกระบวนการที่เกิดขึ้น ในขณะที่ยังให้ผลลัพธ์ที่ถูกต้องเอาต์พุตอาจดูผิดปกติ ดังนั้นการใช้ $ เป็นกำลังใจถ้าคุณสามารถอธิบายตัวอักษรที่ท้ายสตริงได้
โปรดทราบว่าในบรรณาธิการจำนวนมาก ^ และ $ ตรงกับจุดเริ่มต้นและจุดสิ้นสุดของบรรทัดตามลำดับ อย่างไรก็ตามเนื่องจากคาดว่าจะไม่ได้เป็นเส้นตรงอักขระเหล่านี้จะตรงกับจุดเริ่มต้นและจุดสิ้นสุดของข้อมูล (ในทางตรงข้ามกับเส้น) ปัจจุบันอยู่ในบัฟเฟอร์การจับคู่คาดหวัง (โปรดดูหมายเหตุด้านล่างเกี่ยวกับ "การไม่ย่อยของระบบ")
-Ex ธงทำให้รูปแบบที่จะจับคู่เป็นสตริง "แน่นอน" ทำไม่ได้การตีความของ *, ^, ฯลฯ (แม้ว่าจะต้องมีการปฏิบัติตามอนุสัญญา Tcl ตามปกติ) รูปแบบที่แน่นอนไม่มีการเปลี่ยนแปลง
-nocase flag ทำให้อักขระตัวพิมพ์ใหญ่ของเอาต์พุตสามารถเปรียบเทียบได้เหมือนกับว่าตัวพิมพ์เล็กเป็นตัวพิมพ์เล็ก รูปแบบไม่ได้รับผลกระทบ
ในขณะที่อ่านผลลัพธ์มากกว่า 2,000 ไบต์สามารถบังคับไบต์ก่อนหน้าให้ "ลืม" ได้ ซึ่งอาจมีการเปลี่ยนแปลงด้วยฟังก์ชัน match_max . (โปรดทราบว่าค่าที่มากเกินไปอาจทำให้ตัวจัดรูปแบบช้าลงได้) ถ้า patlist คือ full_buffer , ตัวที่เกี่ยวข้องจะถูกดำเนินการถ้า match_max ไบต์ได้รับและไม่มีรูปแบบอื่น ๆ ที่ตรงกัน หรือไม่ full_buffer คำหลักถูกใช้ตัวอักษรที่ลืมจะถูกเขียนไปยัง expect_out (บัฟเฟอร์)
ถ้า patlist เป็นคำหลัก โมฆะ , และ nulls ได้รับอนุญาต (ผ่าน remove_nulls คำสั่ง) ร่างกายที่สอดคล้องกันจะถูกดำเนินการถ้า ASCII เดียวถูกจับคู่ ไม่สามารถจับคู่ 0 ไบต์ผ่านรูปแบบ glob หรือ regexp
เมื่อจับคู่รูปแบบ (หรือ eof หรือ full_buffer) ผลลัพธ์ที่ตรงกันและไม่ตรงกันก่อนหน้านี้จะถูกบันทึกไว้ในตัวแปร expect_out (กันชน) . สามารถจับคู่สตาร์ทอาร์เรย์ regexp ได้สูงสุด 9 รายการในตัวแปร expect_out (1, สตริง) ตลอด expect_out (9, สตริง) . ถ้า -indices ธงใช้ก่อนรูปแบบดัชนีเริ่มต้นและสิ้นสุด (ในรูปแบบที่เหมาะสมสำหรับ lrange ) ของ 10 สตริงจะถูกเก็บไว้ในตัวแปร expect_out (X เริ่มต้น) และ expect_out (x, จบ) โดยที่ X เป็นตัวเลขตรงกับตำแหน่งสตริงในบัฟเฟอร์ 0 หมายถึงสตริงที่ตรงกับรูปแบบทั้งหมดและถูกสร้างขึ้นสำหรับรูปแบบของโลกรวมถึงรูปแบบ regexp ตัวอย่างเช่นถ้ากระบวนการผลิตผลลัพธ์ของ "abcdefgh n" ผลลัพธ์ของ:
คาดว่า "cd"
เป็นถ้างบต่อไปนี้ได้ดำเนินการ:
ตั้งค่า expect_out (0, string) cd set expect_out (buffer) abcd
และ "efgh n" จะถูกทิ้งไว้ในบัฟเฟอร์เอาท์พุท ถ้ากระบวนการผลิตผลลัพธ์ "abbbcabkkkka n" ผลของ:
คาดว่า -indices -re "b (b *). * (k +)"
เป็นถ้างบต่อไปนี้ได้ดำเนินการ:
ตั้ง expect_out (0, start) 1 set expect_out (0, end) 10 set expect_out (0, string) ตั้งค่า expect_out (1, start) 2 set expect_out (1, end) 3 ชุด expect_out (1 สตริง) bb ตั้ง expect_out (2, เริ่มต้น) 10 ชุด expect_out (2, end) 10 ชุด expect_out (2, สตริง) k set expect_out (buffer) abbbcabkkkk
และ "a n" ถูกทิ้งไว้ในบัฟเฟอร์เอาท์พุท รูปแบบ "*" (และ -re ". *") จะล้างบัฟเฟอร์เอาต์พุตโดยไม่ต้องอ่านผลลัพธ์เพิ่มเติมจากกระบวนการ
โดยปกติผลลัพธ์ที่ตรงกันจะถูกทิ้งออกจากบัฟเฟอร์ภายในของ Expect ซึ่งอาจป้องกันได้ด้วยการใช้คำนำหน้ากับรูปแบบ -notransfer ธง. ธงนี้เป็นประโยชน์อย่างยิ่งในการทดลอง (และสามารถอธิบายได้โดยย่อว่า "ไม่" เพื่อความสะดวกในขณะที่ทำการทดลอง)
ระบบจะเก็บรหัสวางไข่ที่เกี่ยวข้องกับผลลัพธ์การจับคู่ (หรือ eof หรือ full_buffer) expect_out (spawn_id) .
-หมดเวลา flag ทำให้คำสั่ง current expect ใช้ค่าต่อไปนี้เป็น timeout แทนการใช้ค่าของตัวแปร timeout
โดยค่าเริ่มต้นรูปแบบจะถูกจับคู่กับผลลัพธ์จากกระบวนการปัจจุบันอย่างไรก็ตาม -ผม flag ประกาศเอาท์พุทจากรายการ spawn_id ที่มีชื่อจะจับคู่กับรูปแบบใด ๆ ต่อไปนี้ (ขึ้นไปข้างหน้า -ผม ) รายการ spawn_id ควรเป็นรายการ spawn_ids ที่แยกกันเป็นช่องว่างหรือตัวแปรที่อ้างถึงรายการ spawn_ids
ตัวอย่างเช่นตัวอย่างต่อไปนี้รอให้ "เชื่อมต่อ" จากกระบวนการปัจจุบันหรือ "ไม่ว่าง", "ล้มเหลว" หรือ "รหัสผ่านไม่ถูกต้อง" จาก spawn_id โดยชื่อ $ proc2
คาดหวังว่า {-i $ proc2 busy {ทำให้ยุ่ง n; exp_continue} -re "ล้มเหลว | รหัสผ่านไม่ถูกต้อง" ยกเลิกการหมดเวลายกเลิกการเชื่อมต่อ}
ค่าของตัวแปรส่วนกลาง any_spawn_id อาจใช้เพื่อจับคู่รูปแบบกับ spawn_ids ใด ๆ ที่มีชื่ออยู่ทั้งหมด -ผม ธงในปัจจุบัน คาดหวัง คำสั่ง spawn_id จาก a -ผม ธงที่ไม่มีรูปแบบที่เกี่ยวข้อง (กล่าวคือตามด้วยอีกคนหนึ่ง -ผม ) จะใช้ได้กับรูปแบบอื่น ๆ ในรูปแบบเดียวกัน คาดหวัง คำสั่งที่เกี่ยวข้อง any_spawn_id
-ผม ธงยังสามารถตั้งชื่อตัวแปรระดับโลกซึ่งในกรณีนี้จะมีการอ่านตัวแปรสำหรับรายการรหัสวางไข่ ตัวแปรจะอ่านซ้ำทุกครั้งที่มีการเปลี่ยนแปลง นี่เป็นวิธีการเปลี่ยนแหล่ง I / O ในขณะที่คำสั่งกำลังทำงานอยู่ รหัสวางไข่ที่ให้มาด้วยวิธีนี้เรียกว่า id โดยกำเนิด "ทางอ้อม"
การกระทำเช่น หยุด และ ต่อ ทำให้โครงสร้างการควบคุม (กล่าวคือ สำหรับ , proc ) จะประพฤติตามปกติ คำสั่ง exp_continue ช่วยให้ คาดหวัง ตัวเองเพื่อดำเนินการต่อไปแทนที่จะกลับมาเหมือนปกติ
วิธีนี้มีประโยชน์ในการหลีกเลี่ยงความซ้ำซ้อนหรือข้อความคาดหวังซ้ำ ๆ ตัวอย่างต่อไปนี้เป็นส่วนหนึ่งของส่วนที่จะทำให้ rlogin ทำงานโดยอัตโนมัติ exp_continue หลีกเลี่ยงการเขียนวินาที คาดหวัง (เพื่อค้นหาพรอมต์อีกครั้ง) ถ้า rlogin พร้อมท์ให้ใส่รหัสผ่าน
คาดว่า {รหัสผ่าน: {stty -echo send_user "รหัสผ่าน (สำหรับ $ user) บน host $:" expect_user -re "(. *) n" send_user " n" ส่ง "$ expect_out (1, string) " stty echo exp_continue} ไม่ถูกต้อง {send_user "รหัสผ่านหรือบัญชีที่ไม่ถูกต้อง n" exit} timeout {send_user "การเชื่อมต่อกับโฮสต์ $ หมดเวลา n" exit} eof {send_user "การเชื่อมต่อไปยังโฮสต์ล้มเหลว: $ expect_out (buffer)" exit} $ 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 และถูกทิ้งไว้อย่างเงียบ ๆ ไม่เช่นนั้นexpect_background ใช้คำสั่งexpect_before และexpect_after รูปแบบเช่นเดียวกับคาดหวัง ทำ.
เมื่อexpect_background การประมวลผลพื้นหลังสำหรับรหัสวางไข่เดียวกันจะถูกบล็อก การประมวลผลเบื้องหลังจะยกเลิกการปิดกั้นเมื่อการดำเนินการเสร็จสิ้น ขณะประมวลผลพื้นหลังถูกบล็อกคุณสามารถทำ (เบื้องหน้า)คาดหวัง เกี่ยวกับรหัสวางไข่เดียวกัน
ไม่สามารถดำเนินการได้คาดหวัง ขณะที่ aexpect_background ไม่มีการบล็อกexpect_background สำหรับ ID วางไข่โดยเฉพาะจะถูกลบโดยการประกาศใหม่ expect_background ที่มีรหัสวางไข่เดียวกัน ภาษณ์expect_background ไม่มีรูปแบบเอา ID วางไข่ที่ได้รับจากความสามารถในการจับคู่รูปแบบในพื้นหลัง
expect_before expect_args
ใช้อาร์กิวเมนต์เดียวกับคาดหวัง แต่จะส่งกลับทันที รูปแบบการกระทำคู่จากล่าสุดexpect_before มี id วางไข่เดียวกันจะถูกเพิ่มโดยปริยายต่อไปนี้คาดหวัง คำสั่ง ถ้ารูปแบบตรงกับมันจะถือว่าเป็นถ้าได้รับการระบุไว้ในคาดหวัง คำสั่งตัวเองและร่างกายที่เกี่ยวข้องจะถูกดำเนินการในบริบทของคาดหวัง คำสั่ง ถ้ารูปแบบจากทั้งสองexpect_before และคาดหวัง สามารถจับคู่ได้expect_before ใช้รูปแบบ
หากไม่มีการระบุรูปแบบรหัสการวางไข่จะไม่ได้รับการตรวจสอบสำหรับรูปแบบใด ๆ
ยกเว้นกรณีที่ a-ผม ธง,expect_before รูปแบบตรงกับรหัสวางไข่ที่กำหนดไว้ในขณะที่expect_before คำสั่งถูกเรียกใช้ (ไม่ใช่เมื่อรูปแบบถูกจับคู่)
สาเหตุ - ธงข้อมูลexpect_before เพื่อคืนค่าข้อกำหนดปัจจุบันของรูปแบบที่จะจับคู่ โดยค่าเริ่มต้นจะรายงาน ID การวางไข่ปัจจุบัน อาจระบุข้อมูลรหัส id วางไข่สำหรับข้อมูลเกี่ยวกับ ID การวางไข่ ตัวอย่างเช่น
expect_before -info -i $ proc
อาจได้รับข้อกำหนดเกี่ยวกับการวางไข่มากที่สุด ธง - ตรงที่จะยับยั้งรหัสวางไข่โดยตรงที่มาจากข้อกำหนดทางอ้อมเท่านั้น
แทนที่จะเป็นข้อกำหนดเกี่ยวกับรหัสวางไข่เครื่องหมาย "-all" จะทำให้ "ข้อมูล" รายงานเกี่ยวกับรหัสการวางไข่ทั้งหมด
เอาท์พุทของอินฟอร์แฟกค์สามารถนำกลับมาใช้ซ้ำได้เนื่องจากอาร์กิวเมนต์ที่คาดว่าจะได้รับก่อน
expect_tty expect_args
ก็เหมือนคาดหวัง แต่จะอ่านอักขระจาก / dev / tty (เช่นการกดแป้นพิมพ์จากผู้ใช้) การอ่านจะดำเนินการในโหมดปรุงอาหาร ดังนั้นเส้นต้องจบลงด้วยการกลับมาเพื่อให้คาดหวัง เพื่อดูพวกเขา นี้อาจมีการเปลี่ยนแปลงผ่านทางstty (ดูstty คำสั่งด้านล่าง)
expect_user expect_args
ก็เหมือนคาดหวัง แต่จะอ่านอักขระจาก stdin (เช่นการกดแป้นพิมพ์จากผู้ใช้) การอ่านจะดำเนินการในโหมดปรุงอาหาร ดังนั้นเส้นต้องจบลงด้วยการกลับมาเพื่อให้คาดหวัง เพื่อดูพวกเขานี้อาจมีการเปลี่ยนแปลงผ่านทางstty (ดูstty คำสั่งด้านล่าง)
ส้อม
สร้างกระบวนการใหม่ กระบวนการใหม่นี้เป็นสำเนาที่ถูกต้องของปัจจุบันคาดหวัง กระบวนการ. เกี่ยวกับความสำเร็จ,ส้อม ส่งกลับ 0 ไปยังกระบวนการใหม่ (child) และส่งคืน ID กระบวนการของกระบวนการย่อยไปยังกระบวนการหลัก เกี่ยวกับความล้มเหลว (เนื่องมาจากการขาดทรัพยากรเช่นพื้นที่แลกเปลี่ยนหน่วยความจำ)ส้อม ส่งกลับค่า -1 ไปยังโพรเซสที่ผู้ปกครองและไม่มีกระบวนการลูกถูกสร้างขึ้น
กระบวนการสาละวนจะออกผ่านทางทางออก คำสั่งเช่นเดียวกับกระบวนการเดิม กระบวนการ Forked ได้รับอนุญาตให้เขียนลงในแฟ้มบันทึก ถ้าคุณไม่ปิดใช้งานการดีบักหรือเข้าสู่กระบวนการส่วนใหญ่ผลลัพธ์อาจทำให้เกิดความสับสน
การใช้งาน PPS บางอย่างอาจสร้างความสับสนโดยผู้อ่านและนักเขียนหลายคนแม้แต่ในเวลาอันใกล้ ดังนั้นจึงปลอดภัยที่สุดส้อม ก่อนกระบวนการวางไข่
<
