ველით პროგრამა, რომელიც საუბრობს სხვა ინტერაქტიული პროგრამების მიხედვით სცენარის მიხედვით. სკრიპტის შემდეგ, იცის, რა შეიძლება იყოს მოსალოდნელი პროგრამისგან და რა სწორი პასუხი უნდა იყოს. ინტერპრეტირებული ენა უზრუნველყოფს დიალოგის წარმართვის ფილიალისა და მაღალი დონის კონტროლის სტრუქტურებს. გარდა ამისა, მომხმარებელს შეუძლია მიიღოს კონტროლი და ინტერაქტიული პირდაპირ როდესაც სასურველი, შემდეგ დაბრუნების კონტროლი Script.
Expectk არის ნებისა და ტუკის ნარევი. ის იქცევა, როგორც იმედი და თ.კ-ს სურვილი. ველი შეიძლება გამოყენებულ იქნას პირდაპირ C ან C ++ გარეშე Tcl.
სახელი "ველით" მოდის იდეა გაგზავნის / ველით sequences პოპულარიზაცია uucp, kermit და სხვა მოდემი კონტროლის პროგრამები. თუმცა განსხვავებით uucp, ველით განზოგადებული ისე, რომ იგი შეიძლება აწარმოებს როგორც დონის ბრძანება ნებისმიერი პროგრამა და ამოცანა გათვალისწინებით. ველოდებით რამდენიმე პროგრამას ერთდროულად.
რას ველოდები?
მაგალითად, აქ არის რამოდენიმე რამ მოლოდინი ბრძანება შეუძლია:
- გამოიწვიეთ თქვენი კომპიუტერი დაუბრუნდეთ უკან, ასე რომ შეგიძლიათ შეხვიდეთ გადახდის გარეშე.
- დაიწყეთ თამაში და თუ ოპტიმალური კონფიგურაცია არ გამოჩნდება, ისევ ისევ და ისევ გადატვირთეთ) სანამ არ გაგიკეთებთ და შემდეგ გააკონტროლებს კონტროლს.
- აწარმოე fsck და პასუხების პასუხად, პასუხი "დიახ" ან "არა" ან მოგცემთ კონტროლის საშუალებას, წინასწარ განსაზღვრული კრიტერიუმების საფუძველზე.
- სხვა ქსელთან დაკავშირება და ავტომატურად დაიბრუნეთ თქვენი წერილი ისე, რომ თითქოს თავდაპირველად გაიგზავნა თქვენი ადგილობრივი სისტემა.
- განახორციელოს გარემოს ცვლადები, მიმდინარე დირექტორია, ან ნებისმიერი სახის ინფორმაცია rlogin, telnet, tip, su , ან chgrp
არსებობს სხვადასხვა მიზეზი, რის გამოც ჭურვი ვერ ასრულებს ამ ამოცანებს. ყველა შესაძლებელია, რომ ველოდოთ.
ზოგადად, ველით სასარგებლოა ნებისმიერი პროგრამა, რომელიც მოითხოვს ურთიერთქმედების პროგრამა და მომხმარებელი. ყველაფერი, რაც აუცილებელია, არის ის, რომ ურთიერთქმედება ხასიათდება პროგრამულად. მოლოდინი ასევე შეუძლია გააუქმოს კონტროლი მომხმარებლის გარეშე შეჩერდება პროგრამა კონტროლდება. ანალოგიურად, მომხმარებელს შეუძლია ნებისმიერ დროს დააბრუნოს კონტროლი სცენარში.
გამოყენება
ველით, რომ წაიკითხოს cmdfile ბრძანებების სიის შესასრულებლად. მოსალოდნელი შეიძლება მოიცავდეს ირიბად სისტემებს, რომლებიც მხარს უჭერენ #! ნოტაცია სკრიპტის მონიშვნის მიხედვით, შესრულებადი და სცენარის პირველი ხაზი:
#! usr / local / bin / expect -fრასაკვირველია, გზა ზუსტად უნდა აღწერო, სადაც სავარაუდოდ ცხოვრობს. / usr / local / bin არის მაგალითი.
-c flag უპირატესობას ანიჭებს ბრძანებას შესრულებული სკრიპტის წინაშე. ბრძანება უნდა იყოს ციტირებული, რათა თავიდან იქნას აცილებული ჭურვი. ეს ვარიანტი შეიძლება გამოყენებულ იქნას მრავალჯერ. მრავალრიცხოვანი ბრძანებები შეიძლება შესრულდეს ერთ-სთან ერთად მათ გამყოფი ხაზებით. ბრძანებები შესრულებულია იმისათვის, რომ ისინი გამოჩნდნენ. Expectk- ის გამოყენებისას ეს პარამეტრი განსაზღვრულია როგორც Command.
-d flag საშუალებას იძლევა გარკვეული დიაგნოსტიკური გამონაკლისი, რომელიც პირველ რიგში ატყობინებს ბრძანებების შიდა აქტივობას, როგორიცაა მოლოდინი და ურთიერთქმედება. ამ დროშას აქვს იგივე ეფექტი, როგორც "exp_internal 1" დამთავრების დამთავრების მომენტში, ასევე ეგზემპლარის ვერსია დაბეჭდილია.
-D flag საშუალებას იძლევა ინტერაქტიული გამარტივება. მთელი რიცხვი უნდა დაიცვას. Debugger მიიღებს კონტროლს მომავალი Tcl პროცედურის დაწყებამდე, თუ მნიშვნელობა არ არის ნულოვანი ან თუ C ^ დაპრესილი ან breakpoint მოხვდა, ან სხვა სათანადო გამართვის ბრძანება გამოჩნდება სკრიპტში. Expectk- ის გამოყენებისას, ეს პარამეტრი მითითებულია - Debug.
-f flag აყენებს ფაილს, რომელიც იკითხება ბრძანებები. დროშა თავად არის სურვილისამებრ, რადგან ეს არის მხოლოდ სასარგებლო გამოყენებისას #! notation, ისე, რომ სხვა არგუმენტები შეიძლება მიწოდებული ბრძანებათა ზოლზე. Expectk- ის გამოყენებისას, ეს პარამეტრი მითითებულია როგორც -file.
ჩვეულებრივ, ბრძანება ფაილი წაიკითხავს მეხსიერებაში და შესრულებულია მთლიანად. ხანდახან სასურველია წაიკითხოს ფაილები ერთი ხაზით. იმისათვის, რომ აიძულოს თვითნებური ფაილი უნდა გადაეცეს ამ გზით, გამოიყენოთ -b დროშა. Expectk- ის გამოყენებისას, ეს პარამეტრი სპეციფიკურია.
თუ სიმებიანი "-" მიწოდებულია ფაილის სახელი, სტანდარტული შეყვანა ნაცვლად წაიკითხავს. გამოიყენეთ "./-" გამოიყენეთ ფაილიდან რეალურად დასახელებული "-".
-ი დროშა იწყება მოსაზრებების ინტერპრეტაციასთან ინტერპრეტაციულად, ვიდრე ფაილების წაკითხვის ნაცვლად. მოთხოვნის შეწყვეტა წყდება გამოსვლის ბრძანებით ან EOF- ზე. -ი დროშა ითვლება, თუ არც ბრძანება და არც კოდი არ გამოიყენება. Expectk- ის გამოყენებისას, ეს პარამეტრი განსაზღვრულია როგორცინტერაქტიული.
- შეიძლება გამოყენებულ იქნეს ვარიანტების დასასრულებლად. ეს სასარგებლოა, თუ გსურთ თქვენი სკრიპტის ვარიანტის მსგავსი არგუმენტი ჩაითვალოს, რადგან ეს არ არის ინტერპრეტირებული. ეს შეიძლება სასარგებლოდ განთავსდეს #! ხაზის თავიდან აცილების მიზნით, ყოველგვარი დახრილობის ინტერპრეტაციის თავიდან ასაცილებლად. მაგალითად, შემდეგი დატოვებს ორიგინალური არგუმენტები, მათ შორის სკრიპტის სახელი ცვლადი argv .
#! / usr / local / bin / expect -გაითვალისწინეთ, რომ ჩვეულებრივი მიღება (3) და შესრულების (2) კონვენციები უნდა შეინიშნოს, როდესაც არგუმენტების დამატება #! ხაზი.
ფაილი $ exp_library / expect.rc sourced ავტომატურად თუ იმყოფება, თუ -N დროშა გამოიყენება. (Expectk- ის გამოყენებისას, ეს პარამეტრი NORC- ს იდენტურია.) ამის შემდეგ დაუყოვნებლივ, ფაილის ~ / .expect.rc- ის ავტომატურად sourced, თუ- n დროშა გამოიყენება. თუ გარემოს ცვლადი DOTDIR განისაზღვრება, იგი განიხილება, როგორც დირექტორიაში და .expect.rc იკითხება იქიდან. Expectk- ის გამოყენებისას, ეს პარამეტრი განსაზღვრულია როგორც norc. ეს დაქირავებისა ხდება მხოლოდ -c flags შესრულების შემდეგ.
-V იწვევს მისი ვერსიის ნომრის და გასვლის ბეჭდვას. შესაბამისი დროშა Expectk- ში, რომელიც დიდხანს დროშის სახელით იყენებს, არის -ვერსია.
პირობითი არგნები აგებულია სიაში და ინახება ცვლადში დაასახელა argv და. argc ინიციალიზებულია სიგრძის argv.
Argv0 განისაზღვრება სახელით სკრიპტის ან ბინარული თუ არ სცენარი გამოიყენება. მაგალითად, შემდეგი ბეჭდავს სკრიპტის სახელი და პირველი სამი არგუმენტი:
send_user "$ argv0 [lrange $ argv 0 2] \ n"ბრძანებები
ველით ინსტრუმენტის სარდლობის ენას. Tcl უზრუნველყოფს კონტროლის ნაკადის (თუ, შესვენების), გამოხატვის შეფასების და რამდენიმე სხვა მახასიათებლებს, როგორიცაა recursionand პროცედურა განმარტება. ბრძანებები გამოიყენება, მაგრამ არ არის განსაზღვრული (კომპლექტი, თუ შესრულება) არის Tcl ბრძანებები. ველით დამატებით ბრძანებებს. თუ სხვაგვარად არ არის მითითებული, ბრძანებები ცარიელი სტრიქით დააბრუნებს.
ბრძანებები ჩამოთვლილია ალფავიტის სახით ისე, რომ ისინი სწრაფად მდებარეობენ. თუმცა, ახალ მომხმარებლებს შეუძლიათ უფრო ადვილად იმოქმედონ, რომ დაიწყონ ამ ფორმით აღწერის, გაგზავნის, მოსალოდნელი და ურთიერთქმედებების აღწერა.
დახურვა [-slave] [-onexec 0 | 1] [-i spawn_id]კავშირი ხსნის მიმდინარე პროცესს . ყველაზე ინტერაქტიული პროგრამები გაიგებს EOF- ს მათი სტინისა და გასასვლელად; ამდენად, როგორც წესი, ამ პროცესის მოკვლაც საკმარისია. -ი დროშა აცხადებს პროცესს , რომ დაასახელოს დასახელებული spawn_id- ის შესაბამისი.
ორივე ელოდება და ურთიერთქმედებას აღმოაჩენს, როდესაც მიმდინარე პროცესი გადის და ირიბად ახდენს მჭიდროდ, მაგრამ თუ პროცესი მოკვლას იტყვის, "შეასრულოს მკვლელობა $ pid", თქვენ უნდა გამოაცხადოთ მჭიდროდ .
The -onexec დროშის განსაზღვრავს თუ არა spawn id დახურულია ნებისმიერი ახალი გამონაბოლქვი პროცესები ან თუ პროცესი overlayed. იმისათვის, რომ მოშორებულიყო, გამოიყენეთ ღირებულება 0-ის.
სველი დროშა იხურება მონათის მონაკვეთთან დაკავშირებული მონა. როდესაც კავშირი დაიხურება, მონა ავტომატურად დაიხურება, თუ ის ჯერ კიდევ ღიაა.
მიუხედავად იმისა, კავშირი დაიხურება მინიშნებულად ან პირდაპირ, უნდა დაგირეკავთ დალოდებით, რომ გაირკვეს შესაბამისი ბირთვის პროცესი სლოტი. მჭიდრო ბრძანება არ დაუკმაყოფილებს მას შემდეგ, რაც არ არსებობს იმის გარანტია, რომ პროცესი კავშირი დაიხურება მის გასასვლელად.
შეცდომა [[-და] 0 | 1]აკონტროლებს Tcl debugger- ს, რომელიც საშუალებას გაძლევთ გააძლიეროთ განცხადებები და მითითებული breakpoints.
არგუმენტებით, 1 დაბრუნდა, თუ არ არის გაშვებული, წინააღმდეგ შემთხვევაში 0 დაბრუნდა.
ერთად 1 არგუმენტი, debugger დაიწყო. 0 არგუმენტით, შეწყვეტილია დებს. თუ 1 არგუმენტი წინამორბედს ატარებს, დაუყოვნებლივ დაიწყება დიაგრამა. წინააღმდეგ შემთხვევაში, debugger იწყება შემდეგი Tcl- ის განცხადებით.
გამართვის ბრძანება არ იცვლება ნებისმიერი ხაფანგები. შეადარეთ ეს -D დროშის მოლოდინის დაწყებას.
გათიშვის ბრძანება ტერმინალზე გაყალბებული პროცესის გაწყვეტაა. ეს გრძელდება ფონზე. პროცესს მისცემს საკუთარი პროცესის ჯგუფი. სტანდარტული I / O გადამისამართება / dev / null .
შემდეგი ფრაგმენტი იყენებს გამორთვას სკრიპტის სკრიპტის გასაგრძელებლად.
თუ {[ჩანგალი]! = 0} გათიშეთ. . .შემდეგი სკრიპტი კითხულობს პაროლს და შემდეგ გადის პროგრამას ყოველ საათში, რომელიც ითხოვს პაროლი ყოველ ჯერზე გაშვებას. სკრიპტი გვაძლევს პაროლს ისე, რომ მხოლოდ ერთხელ შეიტანოთ იგი.
send_user "პაროლი? \" expect_user -re "(. *) \ n" {{fork] = = {{fork] = =} {sleep 3600; გააგრძელეთ spawn priv_prog გააგრძელეთ პაროლი: გააგზავნეთ "$ expect_out 1, სიმებიანი) \ r ". . . გასასვლელიუპირატესობა გამოიყენოთ გარსის ასინქრონული პროცესის ფუნქციის გამორთვა (და), რომ ველოდოთ ტერმინალის პარამეტრების შენახვას ადრე გათიშვაზე და მოგვიანებით ვრცელდება მათ ახალი ptys. და, ველოდებით ტერმინალის პარამეტრების წაკითხვის შანსს, რადგან ტერმინალი უკვე გათიშულია იმ დროისთვის.
გასასვლელი [სტატუსი]იწვევს მოულოდნელად ან სხვაგვარად მოამზადოს ამის გაკეთება.
ერთჯერადი დროშა იწვევს მომდევნო არგუმენტს, როგორც გასასვლელად. გარეშე არგუმენტი, მიმდინარე გასასვლელი კურატორმა დაბრუნდა.
-თელექტრონული დროშა იწყება მოლოდინში გასასვლელად, მაგრამ ოპერაციის სისტემაში რეალურად დაბრუნების კონტროლის შეწყვეტა. მომხმარებლის განსაზღვრული გასასვლელი კურატორმა აწარმოებს ასევე ეგზემპლარი საკუთარი შიდა ჰოლდინგი. შემდგომი მოსალოდნელია ბრძანებები უნდა შესრულდეს. ეს არის სასარგებლო თუ თქვენ იყენებთ სხვა Tcl გაგრძელებას. ამჟამინდელი თარჯიმანი (და მთავარი ფანჯარა, თუ TK გარემოში) რჩება ისე, რომ სხვა Tcl გაგრძელებები გაწმენდა. თუ ველოდებით გასვლას კვლავ მოუწოდა (თუმცა ეს შეიძლება მოხდეს), დამლაგებლები არ ხელახლა.
გამოდის, რომ დახურული ყველა პროცესის დახურვა დახურულია. დახურვა გამოვლინდება როგორც EOF- ის მიერ წარმოქმნილი პროცესები. გასასვლელი არ იღებს სხვა ქმედებებს, გარდა იმ შემთხვევისა, როდესაც ჩვეულებრივი _exit (2) პროცედურა აკეთებს. ამგვარად, განვითარებული პროცესები, რომლებიც არ შეამოწმებენ EOF- ს, შეიძლება გააგრძელონ გასაშვებად. (სხვადასხვა პირობები მნიშვნელოვანია განსაზღვრას, მაგალითად, თუ რა სიგნალები იგზავნება გაცვლითი პროცესი, მაგრამ ეს სისტემაშია დამოკიდებული, როგორც წესი, გასასვლელად (3). დოკუმენტირებული პროცესები, რომლებიც აგრძელებენ აწარმოებს მემკვიდრეობით init.
სტატუსის (ან 0 თუ არ არის მითითებული) დაბრუნდა, როგორც Exit სტატუსი ველით . გამოსვლა ირიბად შესრულდება თუ სცენარის დასრულება მოხდება.
exp_continue [-continue_timer]
ბრძანება exp_continue იძლევა საშუალებას, რომ გააგრძელოს შესრულება, ვიდრე დაბრუნების როგორც ჩვეულებრივ. ნაგულისხმევი exp_continue აღადგინოთ დროის შეყოვნების ტაიმერი. კონტეინერი_მატარებლის დროშა უარს იტყვის ტაიმერის გადატვირთვაზე. (იხილეთ მეტი ინფორმაციისთვის.)
exp_internal [-f ფაილი] ღირებულება
იწვევს შემდგომი ბრძანებების გამოაგზავნოს დიაგნოსტიკური ინფორმაცია შიდა უნდა ველოდოთ stderr თუ მნიშვნელობა არის არასამთავრობო ნულოვანი. ეს გამომავალი გამორთულია, თუ მნიშვნელობა არის 0. დიაგნოსტიკური ინფორმაცია მოიცავს ყველა ხასიათს, და ყველა მცდელობა, რომელიც შეესაბამება მიმდინარე გამომავალს ნიმუშების წინააღმდეგ.
იმ შემთხვევაში, თუ სურვილისამებრ ფაილი მიეწოდება, ყველა ნორმალური და გამართვის გამომავალი ამ ფაილზე წერია (ღირებულების ღირებულების მიუხედავად ). ნებისმიერი წინა დიაგნოსტიკური გამომავალი ფაილი დახურულია.
ინფო დროშა იწვევს exp_internal დაბრუნების აღწერა უკანასკნელი არასამთავრობო ინფორმაცია არგუმენტები.
exp_open [args] [-i spawn_id]
დააბრუნებს Tcl ფაილის იდენტიფიკატორს, რომელიც შეესაბამება თავდაპირველ მარკირებას. ფაილის იდენტიფიკატორი შეიძლება იქნას გამოყენებული, თითქოს გაიხსნა Tcl- ის ღია ბრძანება. (სპონდის id აღარ უნდა იქნას გამოყენებული, დაველოდოთ არ უნდა შესრულდეს.
ფრიადური დროშა ტოვებს ეგზემპლარი ID- ს გახსნას და ელოდება ბრძანებას. მოლოდინი უნდა შესრულდეს ქვიშის იდენტულად.
exp_pid [-i spawn_id]
დააბრუნებს პროცესის პირადობას, რომელიც შეესაბამება ამჟამად მიმდინარეობს. თუ მე -4 დროშა გამოიყენება, ეს ჯარი იმაზე მიუთითებს, რომ მოცემული ეგზემპლარი.
exp_send
არის გაფრთხილება.
exp_send_error
არის alias for send_error .
exp_send_log
არის alias for send_log .
exp_send_tty
არის გზავნილის გაგზავნა .
exp_send_user
არის alias for send_user .
exp_version [[-exit] ვერსია]
სასარგებლოა იმის დასადასტურებლად, რომ სკრიპტი შეესაბამება მოლოდინს არსებულ ვერსიას.
არგუმენტების გარეშე, მოლოდინში არსებული ვერსია დაბრუნდა. ეს ვერსია შეიძლება სკრიპტში იყოს კოდირებული. თუ რეალურად იცით, რომ არ იყენებთ ბოლო ვერსიების თავისებურებებს, შეგიძლიათ მიუთითოთ ადრე ვერსია.
ვერსიები შედგება წერტილებით გამოყოფილი სამი ნომრით. პირველი არის ძირითადი ნომერი. სკრიპტები დაწერილი ვერსიების მოსალოდნელია სხვადასხვა ძირითადი რიცხვი თითქმის არ იმუშავებს. exp_version დააბრუნებს შეცდომას, თუ ძირითადი ნომრები არ ემთხვევა.
მეორე უმნიშვნელო ნომერია. სკრიპტები, რომლებიც უფრო მეტია, ვიდრე ვერსიაზე, ვიდრე ახალი ვერსიით, შესაძლოა დამოკიდებული იყოს ზოგიერთ ახალ ფუნქციასთან და არ აწარმოებს. exp_version დააბრუნებს შეცდომას, თუ ძირითადი ნომრები შეესაბამება, მაგრამ სკრიპტის უმნიშვნელო რიცხვი მეტია გაშვებული მოსალოდნელია .
მესამე არის ნომერი, რომელიც არ თამაშობს მონაწილეობას ვერსია შედარებით. თუმცა, ეს არის გაზრდილი, როდესაც Expect პროგრამული განაწილება შეიცვალა არანაირად, როგორიცაა დამატებითი დოკუმენტაცია ან ოპტიმიზაცია. ყოველი ახალი მცირე ვერსიის მიხედვით გადატვირთულია 0.
With -exit flag, ველით ბეჭდავს შეცდომა და გასასვლელად თუ ვერსია არ არის თარიღი.
ველოდოთ [[ობებს] pat1 body1] ... [-პეტები] patn [bodyn]
მოლოდინში, სანამ ერთ-ერთი ნიმუში არ შეესაბამება გაფართოებული პროცესის გამომუშავებას, მითითებული დროის მონაკვეთი გავიდა, ან ბოლომდე ჩანს ფაილი. თუ საბოლოო ორგანო ცარიელია, შეიძლება გამოტოვებული იყოს.
ნიმუშების უახლესი მოლოდინიდან მოყვანილი ბრძანებები ირიბად გამოიყენება ნებისმიერი სხვა ნიმუშების წინაშე. ნიმუშები უახლესი expect_after ბრძანებით ირიბად გამოიყენება ნებისმიერი სხვა ნიმუშების შემდეგ.
თუ არგუმენტები მთლიანად მოლოდინს მოითხოვს ერთზე მეტ ხაზს, ყველა არგუმენტი შეიძლება იყოს "braced" ერთში ისე, რომ თავიდან იქნას აცილებული თითოეული ხაზის უკუსვლა. ამ შემთხვევაში, ჩვეულებრივი Tcl- ის ჩანაცვლებიც მოხდება, მიუხედავად braces.
თუ ნიმუში არის საკვანძო სიტყვა eof , შესაბამისი ორგანო ხორციელდება ბოლოს- of- ფაილი. თუ ნიმუში არის საკვანძო სიტყვის შესრულება, შესაბამისი ორგანო შესრულებულია დროის შეყვანის დროს. თუ დროის შეყვანის სიტყვა არ გამოიყენება, ჩამორთმეული null action შესრულებულია დროის გასვლის შემდეგ. ნაგულისხმევი შეყოვნება პერიოდი 10 წამი, მაგრამ შეიძლება მითითებული, მაგალითად 30, ბრძანება "მითითებული დროის 30". უსასრულო შეყოვნება შეიძლება შეფასდეს ღირებულების -1-ით. თუ ნიმუში არის სიტყვით ნაგულისხმევი , შესაბამისი ორგანო შესრულებულია ან შეყოვნების ან დასრულების შემდეგ.
თუ ნიმუში შეესაბამება, მაშინ შესაბამისი ორგანო ხორციელდება. ველით ბრუნვის შედეგს სხეულის (ან ცარიელი სიმებიანი თუ არა ნიმუში შესაბამისი). იმ შემთხვევაში, რომ მრავალი ნიმუში შეესაბამება, პირველად გამოჩნდება სხეულის შესარჩევად.
ყოველ ჯერზე ახალი გამომავალი ჩამოდის, იგი შედარებით თითოეული ნიმუში მიზნით ისინი ჩამოთვლილი. ამდენად, შეგიძლიათ შეამოწმოთ მატჩის არარსებობა უკანასკნელი ნიმუშის გაკეთების გზით, რაც გამოჩნდება გარანტირებული, მაგალითად, სწრაფი. იმ შემთხვევებში, როდესაც არ არის სწრაფი, უნდა გამოვიყენოთ დროთა განმავლობაში (ისევე, როგორც თქვენ იქნებოდა თუ ხელით ურთიერთქმედებდა).
ნიმუშები მოცემულია სამი გზით. ჩვეულებრივ, თარგების მითითება, როგორც Tcl- ს სიმებიანი მატჩის ბრძანებით. (ასეთი ნიმუშები ასევე შეესაბამება C-shell რეგულარული გამონათქვამებს, როგორც წესი, უწოდებენ "გლობუს" ნიმუშებს). გლ flag შეიძლება გამოყენებულ იქნას ისეთი ნიმუშების დასაცავად, რომლებიც სხვაგვარად შეიძლება ემთხვეოდეს იმ დროშებს, რომლებიც ამას აკეთებენ. ამ გზით უნდა შეიცავდეს "-" ნებისმიერი ნიმუში. ("-" დაწყებული ყველა სტრიქონები დაცულია სამომავლო ვარიანტებისთვის).
მაგალითად, შემდეგი ფრაგმენტი ეძებს წარმატებულ შესვლას. (გაითვალისწინეთ, რომ აბორტი ითვლება დამწერლობაში სხვაგან განსაზღვრული პროცედურა.)
ველით {დაკავებულია \ n დაკავებულია \ n; exp_continue} ვერ მოხერხდა შეწყვეტა "არასწორი პაროლი" შეწყვეტა შეწყვეტა შეწყვიტა}შეთავაზებები აუცილებელია მეოთხე ნიმუშზე, რადგან იგი შეიცავს სივრცეს, რომელიც სხვაგვარად გამოყოფს მოქმედებისგან. ნიმუშები იგივე ქმედებებით (როგორიცაა მე -3 და მე -4) მოითხოვს, რომ კვლავ მოქმედებენ. ეს შეიძლება თავიდან იქნას აცილებული regexp სტილის ნიმუშების გამოყენებით (იხ. ქვემოთ). გლობალური სტილის ნიმუშების ჩამოყალიბების შესახებ დამატებითი ინფორმაცია შეგიძლიათ იხილოთ Tcl სახელმძღვანელოში.
Regexp- ის სტილის ნიმუშები მიჰყევით სინტაქსს Tcl- ის Regexp- ით (მოკლედ "რეგულარული გამოხატვისთვის") ბრძანება. regexp ნიმუშები დაინერგა დროშა -თ . წინა მაგალითი შეიძლება გადაწერილი იყოს regexp- ის გამოყენებით:
ველით {დაკავებულია \ n დაკავებულია \ n; exp_continue} -მა "ვერ შეძლო | პაროლი არასწორია"ორივე ტიპის ნიმუშები "გაუფერულებაა". ეს იმას ნიშნავს, რომ ნიმუშები არ უნდა შეესაბამებოდეს მთელ სიგრძეს, მაგრამ შეიძლება დაიწყოს და დასრულდება მატჩის სადმე სიმებიანი (სანამ ყველაფერი სხვაგან შეესაბამება). გამოიყენეთ სტრიქონის დასაწყისის შესატყვისი და $ დასასრულს. გაითვალისწინეთ, რომ თუ არ დაველოდებით ბოლომდე სიმებიანი, თქვენი რეაგირება ადვილად შეიძლება დასრულდეს შუა სიმებიანი, რადგან ისინი გამოეხმაურა განვითარდა პროცესში. მიუხედავად იმისა, რომ ჯერ კიდევ აწარმოებს სწორ შედეგებს, გამონაკლისი გამოიყურება არაბუნებრივი. ამდენად, გამოყენების $ არის წახალისება, თუ თქვენ შეგიძლიათ ზუსტად აღწერს სიმბოლოების ბოლოს სიმებიანი.
გაითვალისწინეთ, რომ ბევრ რედაქტორში, ^ და $ შეესაბამება ხაზების დაწყებას და დასასრულს. თუმცა, რადგან ველი არ არის ხაზი ორიენტირებული, ეს სიმბოლოები შეესაბამება მონაცემების დასაწყისსა და დასასრულს (განსხვავებით ხაზებისგან) ამჟამად მოსალოდნელი დამთხვევის ბუფერში. (ასევე, ნახეთ შენიშვნა "სისტემაში დიახ".)
-Flag დრო იწვევს ნიმუში უნდა შეესაბამებოდეს "ზუსტი" სიმებიანი. არ არის ინტერპრეტაცია *, ^ და ა.შ. (თუმცა ჩვეულებრივი Tcl კონვენციები მაინც უნდა შეინიშნოს). ზუსტი ნიმუშები ყოველთვის გაუთავებელია.
ბლოკნოტის დროშა იწვევს ზედა ნაწილების სიმბოლოებს შეადაროთ, თითქოს ისინი პატარა ასოები იყვნენ. ნიმუში არ არის დაზარალებული.
2000-ზე მეტი ბაიტის გამომავალი კითხვის დროს კითხვის ნიშნის ქვეშ აყენებს წინასწარ "ბატონობას". ეს შეიძლება შეიცვალოს ფუნქცია match_max- ით . (გაითვალისწინეთ, რომ ზედმეტად დიდი ღირებულებები შეიძლება შეამცირონ ნიმუში matcher.) თუ პატრიოტი არის full_buffer , შესაბამისი ორგანო ხორციელდება, თუ match_max ბაიტი მიღებული და სხვა ნიმუშები არ შეესაბამება. გამოიყენება თუ არა full_buffer keyword, დავიწყებული პერსონაჟები წერია expect_out (ბუფერი).
თუ პატრიოტი საკვანძო სიტყვით არის null და ნებადართულია ნებადართული ( წაშლა _nulls ბრძანების მეშვეობით), შესაბამისი ორგანო შესრულებულია, თუ ერთჯერადი ASCII 0 შეესაბამება. შეუძლებელია გლობალური ან regexp ნიმუშების მეშვეობით 0 ბიტიანი შესატყვისი.
ნიმუში (ან eof ან full_buffer) შესატყვისი, ნებისმიერი შესატყვისი და ადრე შეუსაბამო გამომავალი შენახულია ცვლადი expect_out (ბუფერი) . 9 Regexp შემცვლელი მატჩები შენახულია ცვლადში expect_out (1, string) , expect_out (9, string) . თუ სტრიქონების დროშა გამოყენებულია ნიმუშის დაწყებამდე, 10 სტრიქონზე დაწყებული და დამთავრებული ინდექსები ინახება ცვლადების მოლოდინში expect_out (X, დაწყების) და expect_out (X და ბოლოს) სადაც X არის ციფრი, შეესაბამება ბუფერში არსებულ პოზიციას. 0 ეხება სტრინგებს, რომლებიც შეესაბამება მთელ ნიმუშს და გენმოდირებულია გლობუსის შაბლონებისთვის და რეგესპ-ნიმუშებით. მაგალითად, თუ პროცესი წარმოშობილია "abcdefgh \ n" - ის output, შედეგი:
ველით "cd"თითქოს შემდეგი განცხადებები შესრულდა:
მითითებული expect_out (0, სიმებიანი) cd set expect_out (ბუფერი) abcdდა "efgh \ n" დარჩა გამომავალი ბუფერში. თუ პროცესი წარმოებული გამომავალი "abbbcabkkkka \ n", შედეგი:
ველოდოთ -ინტექსტებს "b" (b *). * (k +) "თითქოს შემდეგი განცხადებები შესრულდა:
(1, დასასრული) 2 Set expect_out (1, დასასრული) 3 კომპლექტი expect_out (1, სიმებიანი) bb setcout მოლოდინში (2, დაწყების) 10 კომპლექტი expect_out (2, ბოლოს) 10 set expect_out (2, სიმებიანი) k set expect_out (ბუფერი) abbbcabkkkkდა "a \ n" დარჩა გამომავალი ბუფერში. ნიმუში "*" (და "არ" * * ") გამოიმუშავებს გამომუშავებას ბუფერის გარეშე პროცესიდან რაიმე გამომავლის გარეშე.
ჩვეულებრივ, შესაბამისი გამომავალი უგულებელყოფილია ეგპ-ის შიდა ბუფერისგან. ეს შეიძლება თავიდან აიცილონ ნიმუშის პრეფიქსით -ნათვალთვალის დროშა. ეს დროშა განსაკუთრებით სასარგებლოა ექსპერიმენტში (და შეიძლება შემოიფარგლება "არ არის" ხელსაყრელი, ექსპერიმენტში).
შესაბამისი გამომავალი (ანუ eof ან full_buffer) ასოცირებული ქვიშიანი პიქტოფონი ინახება მოლოდინში (spawn_id) .
მიმდინარე დროშის დროშა იწვევს მიმდინარე მოლოდინს ბრძანებას, გამოიყენოს შემდეგი მნიშვნელობა, როგორც შეყოვნების ხანგრძლივობის გამოყენების ნაცვლად.
ჩვეულებრივ, შაბლონები შეესაბამება გამომავალს მიმდინარე პროცესისგან, თუმცა- -ის დროშა გამოაქვს გამოტანილი spawn_id სიის გამონაკლისი, რომელიც შეესაბამება შემდეგ მოდელებს (up-to -i ). Spawn_id სიაში უნდა იყოს სპილენძის ცალკეული სია ან ცვლადი მითითება spawn_ids- ის მსგავსი სიის შესახებ.
მაგალითად, მომდევნო მაგალითი ელოდება მიმდინარე პროცესს "დაკავშირებულია" ან "დაკავებული", "ჩაიშალა" ან "არასწორი პაროლი", რომელიც $ proc2- ის მიერ დასახელებული spawn_id- ისგან არის.
ველით {-i $ proc2 დაკავებულია {აყენებს დაკავებულია \ n; exp_continue} -მა "ვერ შეძლო | პაროლი არასწორია"გლობალური ცვლადი any_spawn_id- ის ღირებულება შეიძლება გამოყენებულ იქნეს ნებისმიერი spawn_ids- ის მოდელების შესაგროვებლად, რომლებიც ყველა სხვა- Spawn_id- ის დროშისგან, რომელიც არ არის ასოცირებული ნიმუში (ანუ, მოჰყვა დაუყოვნებლივ სხვა- ai), ხელმისაწვდომი გახდება ნებისმიერი სხვა შაბლონებისთვის იგივე მოლოდინის ბრძანება, რომელიც დაკავშირებულია any_spawn_id- სთან.
-ი დროშა ასევე შეუძლია გლობალური ცვლადის დასახელება, რომლის მიხედვითაც ცვლადი წაიკითხავს ქვიშიან ების სიას. ცვლადი შეცვლის როდესაც შეცვლის. ეს უზრუნველყოფს გზა I / O წყაროს შეცვლისას, ხოლო ბრძანება შესრულებულია. Spawn ids გათვალისწინებული ამ გზით უწოდებენ "არაპირდაპირი" spawn იწვევს.
ქმედებები, როგორიცაა შესვენება და განაგრძობს კონტროლის სტრუქტურებს (ანუ, proc , for ) ჩვეულებრივი გზით მოიქცნენ. ბრძანება exp_continue იძლევა საშუალებას, რომ გააგრძელოს შესრულება, ვიდრე დაბრუნების როგორც ჩვეულებრივ.
ეს გამოსადეგია აშკარა მარყუჟების თავიდან აცილების ან განმეორებითი მოლოდინების შესახებ. შემდეგი მაგალითია ფრაგმენტის ნაწილი rlogin ავტომატიზირება. Exp_continue avoids მქონე დაწერა მეორე მოლოდინი განაცხადი (მოსაძებნად სწრაფი ერთხელ) თუ rlogin მოთხოვნა დაგავიწყდათ.
ველით {პაროლი: {stty -echo send_user "პაროლი $ (მომხმარებლისთვის) $ host:" expect_user -re "(. *) \ n" send_user "\ n" send "$ expect_out (1, string) \ r" stty echo exp_continue} არასწორი {send_user "არასწორი პაროლი ან ანგარიში \ n" exit} დრო ამოიწურა {send_user "კავშირი $ hosted გარეთ \ n" exit} eof {send_user \ "კავშირი ვერ მოხერხდა: $ expect_out (ბუფერი)" exit} - ხელახლა $ prompt}მაგალითად, შემდეგი ფრაგმენტი შეიძლება დაეხმაროს მომხმარებლის სახელმძღვანელოს ურთიერთქმედებას, რომელიც უკვე მთლიანად ავტომატიზირებულია. ამ შემთხვევაში ტერმინალი ნედლი რეჟიმშია მოთავსებული. თუ მომხმარებელი "+" აწვება, ცვლადი იზრდება. თუ "p" დაპრესილია, რამდენიმე ბრუნდება გადაეგზავნება პროცესს, შესაძლოა, გარკვეულწილად გაბრაზდეს და "მე" მომხმარებელს საშუალებას აძლევს ურთიერთქმედებას, ეფექტურად მოახდინოს სკრიპტის კონტროლი. ყოველ შემთხვევაში, exp_continue საშუალებას იძლევა მიმდინარე მოლოდინი გააგრძელოს ნიმუში შესაბამისი შემდეგ შესრულების მიმდინარე აქცია.
მწვავე ნედლეული ლოდინი expect_after {-i $ user_spawn_id "p" {გააგზავნეთ \ r \ r \ r "; exp_continue} "+" {incr foo; exp_continue} "i" {ურთიერთქმედება; exp_continue} "დატოვა" გასასვლელიჩვეულებრივ, exp_continue გადატვირთვის დროითი ტაიმერი. ტაიმერი არ არის განახლებული, თუ exp_continue ეწოდება -continue_timer დროშა.
expect_after [expect_args]
მუშაობს იდენტურად მოლოდინში, გარდა იმ შემთხვევებისა, როდესაც ორივე მოლოდინი და მოლოდინი შეიძლება შეესაბამებოდეს. იხილეთ expect_before ბრძანება დამატებითი ინფორმაციისთვის.
expect_background [expect_args]
იმავე არგუმენტებს, როგორც მოსალოდნელია , იღებს დაუყოვნებლივ. ნიმუშები შემოწმებულია მაშინ, როდესაც ახალი შეყვანა ჩამოდის. ნიმუში შეყოვნება და ნაგულისხმევი უაზროა მოლოდინში და მდუმარედ უგულებელყოფილია. წინააღმდეგ შემთხვევაში, expect_background ბრძანება იყენებს expect_before და expect_after ნიმუშების ისევე როგორც ველით აკეთებს.
მიმდინარეობს შეფასების მოლოდინში მოქმედება, დაბლოკვის პროცესის ფონური პროცესი დაბლოკილია. პროცესის დასრულებისას ფონის დამუშავება ბლოკირებადია. მიუხედავად იმისა, რომ ფონური დამუშავება დაბლოკილია, შესაძლებელია ამის გაკეთება (წინა პლანზე) მოლოდინი იმავე ქვიშის ხატულაზე.
შეუძლებელია ველოდოთ შესრულების მოლოდინს, ხოლო მოლოდინს ველი expect_background კონკრეტული spawn id წაიშალოს გამოცხადების ახალი expect_background იგივე spawn id. დეკლარაცია მოლოდინში არ არის ნიმუში, რომელიც შლის ფონზე შლის ფონზე შაბლონებისგან.
expect_before [expect_args]
იმავე არგუმენტებს, როგორც მოსალოდნელია , იღებს დაუყოვნებლივ. Pattern- სამოქმედო წყვილი უახლესი expect_before იგივე spawn id არის მინიშნებით დაემატა ნებისმიერი შემდეგი ველით ბრძანებები. თუ ნიმუში შეესატყვისება, იგი განიხილება, თითქოს ეს იყო განსაზღვრული მოლოდინში ბრძანება, და მასთან დაკავშირებული ორგანო შესრულებულია სამომავლო ბრძანების კონტექსტში. თუ მოლოდინები ორივე მოლოდინს და მოლოდინს ემთხვევა, მოიგებს მოლოდინს .
თუ ნიმუში არ არის განსაზღვრული, ქვიშის id არ შემოწმდება ნებისმიერი შაბლონებისთვის.
იმ შემთხვევაში, თუ არ დაუშვებელია მიერ -i დროშა, მოლოდინით განაწილება ნიმუშების წინააღმდეგ შეიცავდეს ქვიშის ნიშნულს , რომელიც განსაზღვრულია იმ დროს, რომ მოქმედება მოქმედებდა (არა, როდესაც მისი ნიმუში შეესაბამება).
ინფო დროშა იწვევს მოლოდინს , თუ რა მოდელების დაბრუნებას ახდენს დღევანდელი სპეციფიკაციები. თავდაპირველად, იგი იუწყება მიმდინარე spawn id. სურვილისამებრ გაყალბების id სპეციფიკაცია შეიძლება მიეწოდოს ინფორმაცია ამ ქვიშის იდენტურობას. მაგალითად
expect_before -info -i $ procუმეტესი ნაწილისაგან შეიძლება მიეთითოს. დროშა-პირდაპირი ზეგავლენის ქვეშ აყენებს პირდაპირ სპლოვან იდებს, რომლებიც მხოლოდ არაპირდაპირი სპეციფიკადან მოდის.
აეროპორტის სპეციფიკის ნაცვლად, დროშა "ყველა" გამოიწვევს "ყველაფრის" გავრცელებას ყველა spawn id.
გამომავალი დროშა შეიძლება იყოს გამოყენებული როგორც არგუმენტი მოლოდინში.
expect_tty [expect_args]
ჰგავს მოლოდინს, მაგრამ ნათქვამია გმირები / dev / tty (ანუ მომხმარებლის მხრიდან გასაღებები). ჩვეულებრივ, კითხულობს დამზადებულია დამზადებულ რეჟიმში. ამდენად, ხაზები უნდა დაბრუნდეს, რათა ველოდოთ მათ. ეს შეიძლება შეიცვალოს მეშვეობით stty (იხ. Stty ბრძანება ქვემოთ).
expect_user [expect_args]
ჰგავს მოლოდინს, მაგრამ ნათქვამია, რომ სიმბოლოები stdin- სგან (მაგ. ჩვეულებრივ, კითხულობს დამზადებულია დამზადებულ რეჟიმში. ამდენად, ხაზები უნდა დაბრუნდეს, რათა ველოდოთ მათ. ეს შეიძლება შეიცვალოს მეშვეობით stty (იხ. Stty ბრძანება ქვემოთ).
ჩანგალი
ქმნის ახალ პროცესს . ახალი პროცესი არის მიმდინარე მოლოდინის პროცესის ზუსტი ასლი. წარმატებულად, ჩანგალი ახდენს ახალ (ბავშვის) პროცესს 0 და ბავშვის პროცესის პროცესი ID- ს მშობელი პროცესისთვის დააბრუნებს. მარცხი (რესურსების ნაკლებობის გამო, მაგ., სვოპ სივრცე, მეხსიერება), ჩანგალი დააბრუნებს -1 მშობლის პროცესს და არ შექმნის ბავშვის პროცესი .
ჩამონტაჟებული პროცესები გასასვლელი ბრძანების მეშვეობით გასასვლელად , ისევე, როგორც ორიგინალური პროცესი . ჩამონტაჟებული პროცესები ნებადართულია ჟურნალებისთვის. თუ არ გათიშავთ უმეტეს პროცესებში დეტაგინგს ან ჩაკეტვას, შედეგი შეიძლება დამაბნეველი იყოს.
რამოდენიმე დასკვნის გაკეთება შესაძლოა დაბნეული იყოს მრავალი მკითხველისა და მწერლების მიერ, მაშინაც კი, ამდენად, უსაფრთხოა ჩანერგვის პროცესის დაწყებამდე.
ურთიერთქმედება [string1 body1] ... [stringn [bodyn]]
აკონტროლებს მიმდინარე პროცესს მომხმარებლისთვის, ასე რომ გასაღებები გადაეგზავნება მიმდინარე პროცესს და მიმდინარე პროცესის STDUTE და stderr დაბრუნდა.
სიმებიანი სხეულის წყვილი შეიძლება დადგინდეს არგუმენტებით, იმ შემთხვევაში, თუ სხეულის შესრულება ხდება შესაბამისი სტრიქონით. (ჩვეულებრივ, სტრინგი არ გადაუგზავნის მიმდინარე პროცესს ). თარჯიმნის ბრძანება იძენს, თუ საბოლოო ორგანო აკლია.
თუ მთელი ინტერაქტიული განცხადების არგუმენტები მოითხოვს ერთზე მეტ ხაზს, ყველა არგუმენტი შეიძლება იყოს "braced" ერთში ისე, რომ თავიდან იქნას აცილებული თითოეული ხაზის უკუქცევით. ამ შემთხვევაში, ჩვეულებრივი Tcl- ის ჩანაცვლებიც მოხდება, მიუხედავად braces.
მაგალითად, შემდეგი ბრძანება ეყრდნობა ინტერაქციას შემდეგი სიმებიანი სხეულის წყვილებით: როდესაც Z ზე დაჭერილია, მოლოდინი შეჩერებულია. ( რეზიუმე დროშის რეჟიმი აღადგენს ტერმინალის რეჟიმებს.) როდესაც A- ზე დაჭერილია, მომხმარებელი ხედავს "თქვენ აკრეფილი კონტროლი- A" და პროცესი იგზავნება ^ A. როდესაც $ დაპრესილი, მომხმარებლის ხედავს თარიღი. როდესაც C არის დაჭერილი, ელოდა ველოდებით . თუ "foo" შედის, მომხმარებლის ხედავს "ბარი". როდესაც ~~ დაპრესილი, ველოდოთ თარჯიმანი interactively.
კომპლექტი CTRLZ \ 032 ურთიერთქმედება {-რესტის $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "თქვენ აკრეფილი კონტროლის- a \ n"; გააგზავნეთ "\ 001"} $ {send_user "თარიღი [საათის ფორმატი [საათის წამი]]."} \ 003 exit foo {send_user "bar"} ~~}სიმებიანი სხეულის წყვილებში სიმები ერთმანეთთან შეესაბამება მათ, როგორც არგუმენტებს. ნაკაწრები, რომლებიც ნაწილობრივ ემთხვევა მიმდინარე პროცესს არ მოჰყავთ დარჩენილი მოლოდინის მოლოდინში. თუ სიმბოლოები შედიან იმგვარად, რომ აღარ შეიძლება იყოს მატჩი, მხოლოდ სტრიქონის ნაწილი გადაეგზავნება იმ პროცედურას , რომელიც შესაძლოა შეუძლებელია სხვა მატჩზე. ამგვარად, ნაწილობრივი მატჩების ქვედანაყოფები შეიძლება მოგვიანებით შეესაბამებოდეს იმ შემთხვევაში, თუ ორიგინალური სტრიქონები, რომლებიც შეესაბამება მატჩს, საბოლოოდ ვერ ხერხდება.
ჩვეულებრივ, სიმებიანი დამთხვევა ზუსტი არ არის ველური ბარათებით . (ამის საპირისპიროდ, ველოდებით ბრძანებას გლობალური სტილის გლობალური სტილის მიხედვით). ეს დროშა შეიძლება გამოყენებულ იქნას იმ ნიმუშების დაცვის მიზნით, რომლებიც სხვაგვარად შეიძლება შეესაბამებოდეს დროშების ურთიერთქმედებას . ამ გზით უნდა შეიცავდეს "-" ნებისმიერი ნიმუში. ("-" დაწყებული ყველა სტრიქონები დაცულია სამომავლო ვარიანტებისთვის).
ეს დროშა ძალებს ძალუძს რეგლამენტური სტილის ნიმუშად განიხილოს. ამ შემთხვევაში, შესაბამისი substrings ინახება ცვლადი interact_out მსგავსად გზა ელოდება მაღაზიებში მისი გამომავალი ცვლადი expect_out . ანალოგიური დროშაც მსგავსია.
ნიმუში eof წარუდგენს ქმედებას, რომელიც შესრულებულია ბოლოს- of-file. ცალკე eof ნიმუში შეიძლება ასევე დაიცვას -უფასო დროშა, თუ ამ შემთხვევაში იგი შეესაბამება თუ eof გამოვლენილი წერილობით გამომავალი. ნაგულისხმევი eof ქმედება არის "დაბრუნების", ისე, რომ ურთიერთქმედება უბრალოდ დააბრუნებს ნებისმიერ EOF.
ნიმუში შეყოვნება წარუდგენს შეყოვნებას (წამებში) და მოქმედებს, რომელიც შესრულებულია მას შემდეგ, რაც სიმბოლო არ არის წაკითხული მოცემულ დროს. დროის მონაცემი ეხება ბოლო დროს მითითებულ პროცესს . არ არსებობს ნაგულისხმევი შეყოვნება. სპეციალური ცვლადი "შეყოვნება" (გამოიყენება მოლოდინით ბრძანება) არ მოქმედებს ამ დროში.
მაგალითად, შეიძლება გამოყენებულ იქნას შემდეგი განცხადების გამოყენება autologout წევრებს, რომლებიც არ აკრეფილი არაფერი საათში, მაგრამ მაინც მაინც ხშირი სისტემის შეტყობინებები:
ურთიერთქმედება - $ user_spawn_id დროის შეყვანა 3600 დაბრუნების შესახებ \ $ spawn_idთუ ნიმუში არის საკვანძო სიტყვა null და ნებადართულია ნებადართული ( წაშლა _nulls ბრძანების მეშვეობით), შესაბამისი ორგანო ხორციელდება, თუ ერთჯერადი ASCII 0 შეესაბამება. შეუძლებელია გლობალური ან regexp ნიმუშების მეშვეობით 0 ბიტიანი შესატყვისი.
ნიმუშის პრეპარატის დროშა- ირიტის წინაპირობას იწვევს ცვლადი interact_out (spawn_id) , რომელიც შეიქმნება spawn_id- ზე, რომელიც შეესაბამება ნიმუში (ან eof).
ქმედებები, როგორიცაა შესვენება და განაგრძობს კონტროლის სტრუქტურებს (ანუ, proc , for ) ჩვეულებრივი გზით მოიქცნენ. თუმცა დაბრუნების მიზეზები ურთიერთქმედება დაბრუნების მისი Caller, ხოლო inter_return იწვევს ურთიერთქმედება გამოიწვიოს დაბრუნების მისი Caller. მაგალითად, თუ "proc foo" მოუწოდა ურთიერთქმედება, რომელიც შემდეგ შესრულებული action inter_return , proc foo დაბრუნდება. (ეს იმას ნიშნავს, რომ თუკი ინტერაქტიული ინტერპრეტაციის ინტერპრეტატორი ინტერპრეტაციულად აკრეფილი დაბრუნების შედეგად გამოიწვევს ურთიერთქმედებას, მაშინ, როდესაც ინტერ_რეშენი ხელს შეუწყობს მის დამრეკებელთან დაბრუნებას.
ურთიერთქმედებისას , ნედლეული გამოიყენება ისე, რომ ყველა სიმბოლო გადაეცემა მიმდინარე პროცესს . თუ მიმდინარე პროცესი არ იჭერს სამუშაოს კონტროლის სიგნალებს, ის შეწყდება, თუ გათიშული სიგნალი (ნაგულისხმევი ^ Z). განაახლეთ ის გაგრძელება, გააგზავნეთ სიგნალი (როგორიცაა "kill -CONT"). თუ სინამდვილეში გსურთ SIGSTOP- ს ასეთი პროცესის გასაგზავნად (Z ^), განიხილეთ CSH- ის პირველი და შემდეგ თქვენი პროგრამის გაშვება. მეორეს მხრივ, თუ გსურთ SIGSTOP- ს გამოგზავნა, მოუთხოვოთ პირველი ზარის თარჯიმანი (ალბათ გაქცევის ხასიათის გამოყენებით) და შემდეგ დააჭირეთ ღილაკს ^ Z.
სიმებიანი სხეულის წყვილი შეიძლება გამოყენებულ იქნას როგორც მოკლედ, რათა თავიდან იქნას აცილებული თარჯიმნის და შესასრულებლად შესრულებული ბრძანებები. წინა ტერმინალის რეჟიმი გამოიყენება, ხოლო სიმებიანი სხეულის სხეული ხორციელდება.
სიჩქარე, ქმედებები შესრულდეს ნედლეულის რეჟიმში. რეზიუმე დროშის გადატვირთვის რეჟიმი ტერმინალის რეჟიმში, რომელიც მანამდე ადრე იყო შესრულებული (უცვლელად, მოხარშული რეჟიმი). გაითვალისწინეთ, რომ სიმბოლოები შევიდა, როდესაც რეჟიმი ჩართულია შეიძლება დაკარგა (სამწუხარო თვისება ტერმინალის მძღოლი ზოგიერთ სისტემა). გამოიყენეთ ერთადერთი მიზეზი, თუ თქვენი ქმედება დამოკიდებულია მოხარშული რეჟიმში გაშვებით.
The -echo flag აგზავნის სიმბოლოებს, რომლებიც შეესაბამება შემდეგ ნიმუშს იმ პროცედურასთან, რომელიც მათ შექმნილ ხასიათს ატარებს. ეს შეიძლება სასარგებლო იყოს, როდესაც მომხმარებელმა უნდა იხილოს კავშირი ნაწილობრივ აკრეფილი ნიმუშებისგან.
თუ ნიმუში იწერება, მაგრამ საბოლოოდ ვერ შეასრულა, სიმბოლოები იგზავნება გაღრმავებული პროცესი . თუ შემობრუნებული პროცესი შემდეგ აფიქსირებს მათ, მომხმარებელი დაინახავს პერსონაჟებს ორჯერ. -ჩოჩი სავარაუდოდ მხოლოდ იმ შემთხვევაშია შესაძლებელი, როდესაც მომხმარებელი ნაკლებად სავარაუდოა, რომ არ შეავსოთ ნიმუში. მაგალითად, შემდეგი ამონაწერი არის rftp, რეკურსიული- ftp სკრიპტი, სადაც მომხმარებელი ითხოვს შეიყვანოთ ~ g, ~ p, ან ~ ლ, რომ მიიღოთ, დააყენოს ან ჩაიწეროს მიმდინარე დირექტორია რეკურსიულად. ეს არის დაშორებული ნორმალური FTP ბრძანებებიდან, რომ მომხმარებელი ნაკლებად სავარაუდოა აკრიტიკოს ~ რასაც მოჰყვება არაფერი, გარდა შეცდომით, ამ შემთხვევაში, ისინი, ალბათ, მხოლოდ იგნორირებას უკეთებენ შედეგს.
interact {-cheo ~ g {getcurdirectory 1} -cheo ~ l {getcurdirectory 0} -cheo ~ p {putcurdirectory}}The- nobuffer flag აგზავნის სიმბოლოებს, რომლებიც ემთხვევა შემდეგ ნიმუშს გამომავალი პროცესისთვის, როგორც სიმბოლოების წაკითხვისას.
ეს სასარგებლოა, როდესაც გსურთ პროგრამა გამომეყენებინათ ნიმუში. მაგალითად, შეიძლება გამოყენებულ იქნას მონიტორინგი, სადაც პირი დარეკვა (Hayes სტილის მოდემი). ყოველ ჯერზე "ATD" ჩანს სკრიპტის დანარჩენი ხაზი.
\\ "ინტერაქცია -ნაბუკერი-არ არის" (. *) \ r "დაბრუნდება $ დარეგისტრირებას" [საათის ფორმატში]: დარეკეთ $ interact_out (1, სიმებიანი) "} interact -nobuffer" atd "lognumberინტერაქციის დროს, log_user- ის წინა გამოყენება იგნორირებულია. კერძოდ, ურთიერთქმედება აიძულებს გამოაქვეყნოს მისი გამომუშავება (სტანდარტული გამომუშავებაზე), რადგან ითვლება, რომ მომხმარებელს არ სურს ბრმად ურთიერთქმედება.
დროშის დროშა იწვევს მომდევნო პროცესის გამომუშავებისას გამოყენებულ საკვანძო სხეულებს. ეს შეიძლება სასარგებლო იყოს, მაგალითად, როდესაც მასპინძლებს უძღვებიან არასასურველი პერსონაჟები ტელნეტ სესიის დროს.
ჩვეულებრივ, ურთიერთქმედება ელოდება მომხმარებელს, რომ წერა სდდს და ეპოვა პროცესი . -ი დროშა ("მომხმარებლისთვის") ქმნის ურთიერთქმედება მომხმარებელს, როგორც მისი არგუმენტის მიერ დასახელებული პროცესი (რომელიც უნდა იყოს მორგებული იდენტიფიკატორი).
ეს საშუალებას აძლევს ორი შეუსაბამო პროცესს შეუერთდეს ერთობლივი მარკირების გარეშე. დიაგნოზის დასახმარებლად, დიაგნოსტიკას ყოველთვის ეწვევა stderr (ან stdout გარკვეული ხე და გამართვის ინფორმაცია). ამავე მიზეზით, თარჯიმნის ბრძანება წაკითხული interdwinly საწყისი stdin.
მაგალითად, შემდეგი ფრაგმენტი ქმნის შესვლას. მერე აკრიფეთ მომხმარებელი (არ არის ნაჩვენები) და საბოლოოდ აკავშირებს ორს ერთად. რა თქმა უნდა, ნებისმიერი პროცესი შეიძლება შეიცვალოს შესვლისთვის. მაგალითად, შელი მომხმარებელს საშუალებას აძლევს მუშაობდეს ანგარიშის და პაროლის გამოყენების გარეშე.
Spawn login set login $ spawn_id spawn tip მოდემი # აკრიფეთ უკან out მომხმარებლის # დააინსტალირეთ მომხმარებლის შესვლა ინტერაქტიული -u $ loginგამოსასვლელად სხვადასხვა პროცესების გასაგზავნად, ჩამოთვალეთ თითოეული ატრაქციონის სიის სია, რომელიც წინა პლანზეა . გამომავალი ჯგუფის გამონაკლისის შეყვანა შეიძლება განისაზღვროს -პუნქტიანი დროშის სიის მიერ. (ორივე შეყვანა და შეყვანა შეიძლება მოიცავდეს იგივე ფორმას, როგორც -ი დროშა მოლოდინის ბრძანებაში, გარდა იმისა, რომ any_spawn_id არ არის მნიშვნელოვანი ურთიერთქმედებაში .) ყველა შემდეგი დროშა და სიმები (ან ნიმუშები) შეყვანის დროშა გამოჩნდება. თუ არ შეყვება გამოჩნდება, შეყვანა გულისხმობს "-იწერეთ $ user_spawn_id-output". (ანალოგიურად, ნიმუშებით, რომლებსაც არ გააჩნიათ - შეყვანა .) თუ ერთი შეყვანა არის მითითებული, ის overrides $ user_spawn_id. თუ მეორე შეყვანის არის მითითებული, ეს overrides $ spawn_id. დამატებითი შეყვანის დროშა შეიძლება იყოს მითითებული.
ორი ნაგულისხმევი შეყვანის პროცესი ნაგულისხმევია იმისათვის, რომ გამოითვალოს $ spawn_id და $ user_spawn_id (საპირისპიროდ). თუ შეყვანის დროშა არ ჩანს გამონაკლის დროშა, ამ პროცესის სიმბოლოები უგულებელყოფილია.
-ი დროშა ამჟღავნებს ამჟამინდელ spawn_id- ს ჩანაცვლებას, როდესაც სხვა დანამატის ან არხების დროშა არ გამოიყენება. A -ის დროშა გულისხმობს -ო flag.
შესაძლებელია შეცვალოს პროცესები, რომლებიც ინტერაქციას იწყებენ არაპირდაპირი სპლოვანების გამოყენებით. (არაპირდაპირი სპლოვანი იდენტები აღწერილია განყოფილებაში მოლოდინში ბრძანების შესახებ). ირიბი სპოიანი იდენტიფიკატორები შეიძლება მითითებული იყოს -i, -u, -ნაწილება, ან- output flags.
თარჯიმანი [args]
იწვევს მომხმარებლის interactively მოთხოვნილი მოსალოდნელი და Tcl ბრძანებები. თითოეული ბრძანების შედეგი იბეჭდება.
ქმედებები, როგორიცაა შესვენება და განაგრძობს კონტროლის სტრუქტურებს (ანუ, proc , for ) ჩვეულებრივი გზით მოიქცნენ. თუმცა დაბრუნების მიზეზს თარჯიმანი დაუბრუნებს მის დამრეკველს , ხოლო ინტერ_რეტერნი იძლევა თარჯიმანს , გამოიწვიოს მისი დამრეკლეში დაბრუნება. მაგალითად, თუ "proc foo" - ს თარჯიმანი უწოდა, რომელიც შემდეგ შესრულებულ იქნა inter_return- ის , proc foo დაბრუნდებოდა. ნებისმიერი სხვა ბრძანება იძლევა თარჯიმანს, რომ გააგრძელოს ახალი ბრძანებები.
ნაგულისხმევი, სწრაფი შეიცავს ორ რიცხვს. პირველი რიცხვი აღწერს შეფასების დასტის სიღრმეს (ანუ რამდენჯერ აღინიშნება Tcl_Eval). მეორე რიცხვი Tcl ისტორიის იდენტიფიკატორია. სწრაფი შეიძლება შეიქმნას პროცედურის განსაზღვრაში, სახელწოდებით "prompt1", რომლის დაბრუნების ღირებულება მომდევნო მოთხოვნად იქცევა. თუ განაცხადი ღიაა კოტირებების, პარენებისა, ფრჩხილების ან ფრჩხილების შესახებ, ახლანდელზე ახდენს მეორადი სწრაფი (ნაგულისხმევი "+>"). მეორადი სწრაფი შეიძლება შეიქმნას პროცედურის განსაზღვრაში, სახელწოდებით "prompt2".
თარჯიმნის განმავლობაში , მოხარშული რეჟიმი გამოიყენება, მაშინაც კი, თუ მისი აბონენტი ნედლეულის გამოყენებით იყენებდა.
თუ სდდინი დაიხურება, თარჯიმანი დაბრუნდება თუ არ არის გამოყენებული დროშა, თუ ამ შემთხვევაში მომდევნო არგუმენტი მოიწვევა.
log_file [args] [[-a] ფაილი]
თუ ფაილის სახელის მინიჭება ხდება, log_file- ს ჩაიწერს სხდომის ტექსტს (ამ ეტაპზე). log_file შეაჩერებს ჩანაწერს, თუ არ არსებობს არგუმენტი. ნებისმიერი წინა ჟურნალის ფაილი დახურულია.
ფაილის სახელის ნაცვლად, Tcl ფაილის იდენტიფიკატორი შეიძლება უზრუნველყოფილი იქნეს -ოპ- ან- გადაფრენის დროშებით. ეს არის სპონვის ბრძანების მსგავსი. (იხ. დამატებითი ინფორმაციისთვის იხილეთ)
A-flag დროშის გამოძახება, რომელიც log_user ბრძანებით ჩავარდა .
ჩვეულებრივ, log_file ბრძანება ძველი ფაილების ნაცვლად აყენებს მათ ნაცვლად, რათა შესაძლებელი გახდეს ერთი სესიის შეჩერების შესაძლებლობა. ფაილების დასამატებლად, გამოიყენეთ არა- არასასურველი დროშა.
-info flag იწვევს log_file დაბრუნების აღწერა უკანასკნელი არასამთავრობო ინფორმაცია არგუმენტები მოცემული.
log_user -info | 0 | 1
ჩვეულებრივ, გაგზავნის / ელოდება დიალოგის შესასვლელად stdout (და logfile თუ ღია). Stdout- ზე შესასვლელად გამორთულია ბრძანება "log_user 0" და reenabled "log_user 1". Logfile- ზე შესვლა უცვლელია.
The -info flag იწვევს log_user დაბრუნების აღწერა უახლესი არაფრის არგუმენტები მოცემული.
match_max [-d] [-i spawn_id] [ზომა]
განსაზღვრავს ბუფერის ზომა (ბაიტებში), რომელიც გამოიყენება იძულებით გამოყენებული იძულებით. ზომის არგუმენტის გარეშე, მიმდინარე ზომა დაბრუნდა.
-d flag- ით, ნაგულისხმევი ზომა არის მითითებული. (თავდაპირველი default არის 2000.) -i დროშის მიხედვით, ზომა არის დასახელებული spawn id- სთვის, წინააღმდეგ შემთხვევაში იგი მიმდინარე პროცესისთვის არის დადგენილი.
overlay [- # spawn_id] [- # spawn_id] [...] პროგრამა [args]
ახორციელებს პროგრამას "მიმდინარე სავარაუდო პროგრამის" ფარგლებში, რომელიც წყვეტს. შიშველი ჰიპენ არგუმენტი აიძულებს აიძულოს ბრძანების სახელით, თითქოს ეს შელგადანაა. ყველა spawn_ids დახურულია, გარდა იმ დასახელებით, რომლებიც დაასახელა არგუმენტები. ეს მიმაგრებულია დასახელებული ფაილის იდენტიფიკატორებზე.
Spawn_ids შედის, რათა შეიტანოს იდენტიფიკატორები ახალი პროგრამისთვის მემკვიდრეობით. მაგალითად, შემდეგი ხაზი გადის ჭადრაკს და საშუალებას აძლევს მას აკონტროლონ მიმდინარე პროცესი - ამბობენ, ჭადრაკის ოსტატი.
overlay -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id ჭადრაკიეს უფრო ეფექტურია, ვიდრე "ურთიერთქმედება- u", თუმცა ეს მსხვერპლს აკეთებს პროგრამირების ურთიერთქმედების უნარი, რადგან ველოდებით პროცესი აღარ არის კონტროლი.
გაითვალისწინეთ, რომ არ არის საკონტროლო ტერმინალი. ამდენად, თუ თქვენ შეწყვიტეთ ან შეასწორეთ სტანდარტული შეყვანა, პროგრამები, რომლებიც სამუშაოს კონტროლს (ჭურვი, შემოსვლა და ა.შ.) არ იშლება სწორად.
პარიტეტი [-d] [-i spawn_id] [ღირებულება]
განსაზღვრავს თუ არა პარიტეტი უნდა შეინარჩუნოს ან გაშიფრულიყო გამოხატული პროცესების გამომუშავება. თუ მნიშვნელობა ნულოვანია, პარიტეტი ჩამოშორებულია, წინააღმდეგ შემთხვევაში ეს არ არის გათიშული. არარსებობის არგუმენტით, მიმდინარე ღირებულება დაბრუნდა.
-d flag- ზე, ნაგულისხმევი პარიტეტული მნიშვნელობა არის მითითებული. (თავდაპირველი ნაგულისხმევი არის 1, ანუ, პარიტეტი არ არის გათიშული.) -ი დროშის მიხედვით, პარიტეტული მნიშვნელობა დადგენილია, რომ დასახელებული ეპოქის ID- სთვის არის მითითებული, წინააღმდეგ შემთხვევაში, მიმდინარე პროცესია .
remove_nulls [-d] [-i spawn_id] [ღირებულება]
განსაზღვრავს თუ არა ნიუსები ინახება ან ამოღებულ იქნას გამოხატული პროცესების გამომუშავება ნიმუში შესატყვისი ან მოძრავი ცვლადი მოლოდინში ან ინტერქტოუტში . თუ მნიშვნელობა არის 1, nulls ამოღებულია. თუ მნიშვნელობა 0, nulls არ მოიხსნება. არარსებობის არგუმენტით, მიმდინარე ღირებულება დაბრუნდა.
-d flag- ით, ნაგულისხმევი მნიშვნელობა არის მითითებული. (თავდაპირველი ნაგულისხმევი არის 1, ანუ, nulls ამოღებულია.) -i დროშის მიხედვით, მნიშვნელობა აქვს დასახელებული spawn id- სთვის, წინააღმდეგ შემთხვევაში იგი მიმდინარე პროცესისთვის არის დადგენილი.
თუ არა nulls ამოღებულ, ველით ჩაიწეროს null ბაიტი შესვლა და stdout.
გაგზავნეთ [-ფლაგმენტები] სტრიქონი
აგზავნის სიას მიმდინარე პროცესში . მაგალითად, ბრძანება
აგზავნის გმირებს, helloworld მიმდინარე პროცესში . (Tcl მოიცავს printf მსგავსი ბრძანება (ე.წ. ფორმატში ), რომელსაც შეუძლია შექმნას თვითნებურად კომპლექსური სტრიქონები.)
სიმბოლოები იგზავნება დაუყოვნებლივ, თუმცა პროგრამების ხაზით დამონტაჟებული პროგრამები არ იბეჭდება პერსონაჟებამდე, სანამ დაბრუნების ხასიათი არ გაიგზავნება. დაბრუნების სიმბოლო აღნიშნავს "\ r".
- დროშა აიძულებს მომდევნო არგუმენტი განიმარტოს, როგორც სიმებიანი, ვიდრე დროშა. ნებისმიერი სტრიქონი შეიძლება წინ უძღოდეს "-" ის, თუ არა ის რეალურად ჰგავს დროშას. ეს უზრუნველყოფს საიმედო მექანიზმს, რომ განსაზღვროს ცვლადი სტრიქონები, რომლებიც შემთხვევით ჰგავს დროშებს. ("-" დაწყებული ყველა სტრიქონები დაცულია სამომავლო ვარიანტებისთვის).
-ი დროშა აღნიშნავს, რომ სტრინგს ეწოდება სახელით spawn_id. თუ spawn_id არის user_spawn_id , და ტერმინალის ნედლეულ რეჟიმშია, სიმებიანი ტექსტები ახალ თარგმანში თარგმნის , რათა ისინი გამოჩნდნენ, თითქოს ტერმინალის დამზადება მოხდა. ამ თარგმანის გამორთვა.
Null flag აგზავნის null სიმბოლოები (0 bytes). ჩვეულებრივ, ერთი null იგზავნება. რიცხვმა შეიძლება დაიცვას -ნაკლებად მიუთითოს, თუ რამდენი გაანგარიშება.
შეჯახების დროშა ქმნის შესვენების მდგომარეობას. ეს მხოლოდ აზრია, თუ spawn id ეხება tty მოწყობილობა გაიხსნა მეშვეობით "spawn -open". თუ თქვენ შეიტანთ პროცესს, როგორიცაა წვერი, თქვენ უნდა გამოიყენოთ წვერი კონვენციის შესვენების შესვენების.
დროშის ძალების გამოყოფა "ნელა" უნდა გაიგზავნოს, რითაც თავიდან იქნას აცილებული საერთო სიტუაცია, სადაც კომპიუტერი აღმავალდება შეყვანის ბუფერზე, რომელიც განკუთვნილია ადამიანისთვის, რომელიც არასოდეს გამოუვათ იმავე ბუფერისთვის . ეს გამომუშავება აკონტროლებს ცვლადის "send_slow" მნიშვნელობას, რომელიც იღებს ორ ელემენტთა სიას. პირველი ელემენტი არის მთელი რიცხვი, რომელიც აისახება ატომთა რიცხვის ბატარეების რაოდენობაზე. მეორე ელემენტი რეალური რიცხვია, რომელიც აღწერს წამების რაოდენობას, რომლითაც ატომური აგზავნიან გამოყოფა. მაგალითად, "მითითებული send_slow {10 .001}" აიძულებს "გაგზავნის- s" გაგზავნას strings ერთად 1 მილიწამში შორის თითოეულ 10 სიმბოლოებს.
-h დროშის ძალების გამოგზავნა გაიგზავნება (გარკვეულწილად) მოსწონს ადამიანი რეალურად აკრეფით. ადამიანის მსგავსი დაგვიანებები გამოჩნდება სიმბოლოებს შორის. (ალგორითმი ეფუძნება ვაიბლის დისტრიბუციას, ამ მოდელის შესატყვისი ცვლილებებით). ეს გამომუშავება აკონტროლებს ცვლადის "send_human" მნიშვნელობით, რომელიც ხუთ ელემენტთა სიას იღებს. პირველი ორი ელემენტია წამების საშუალო შუალედური დრო წამებში. პირველი გამოიყენება ნაგულისხმევი. მეორე გამოიყენება სიტყვა დასასრულით, რათა შეიტანოს დახრილობა, რომელიც ხანდახან ასეთ ცვლილებებზე ხდება. მესამე პარამეტრი არის ცვალებადობის ზომა, სადაც 1 საკმაოდ ცვალებადია, 1 არის გონივრული ცვლადი და 10 სრულიად გარდაუვალია. უკიდურესობა უსასრულობაა 0. ბოლო ორი პარამეტრი, შესაბამისად, მინიმუმ და მაქსიმალურ შუალედურ დროში. მინიმალური და მაქსიმალური გამოყენება ბოლო და "კლიპი" საბოლოო დრო. საბოლოო საშუალო შეიძლება საკმაოდ განსხვავებული იყოს საშუალო თუ მინიმალური და მაქსიმალური კლიპის საკმარისი ღირებულებები.
მაგალითად, შემდეგი ბრძანება ემყარება სწრაფ და თანმიმდევრებელ ტიპოსტს:
მითითებული send_human {.1 .0 1 .05 2} send -h "მე ვარ მშიერი, მოდით ლანჩი."ხოლო შემდეგ შეიძლება უფრო შესაფერისი შემდეგ hangover:
მითითებული send_human {.4 .4 .2 .5 100} send -h "Goodd party party lash night!"გაითვალისწინეთ, რომ შეცდომები არ არის მოდელირებული, თუმცა შეცდომის შეცდომებისა და შესწორებების შეტანა შეგიძლიათ შეცდომაში შესული შეცდომების შეცდომებზე.
დროშები გაგზავნის ნულოვანი სიმბოლოები, გაგზავნის შესვენების, forcing ნელი გამომავალი და ადამიანის სტილის გამომავალი არიან ურთიერთგამომრიცხავი. მხოლოდ ერთი მითითებული ბოლო გამოყენებული იქნება. უფრო მეტიც, არცერთი სიმებიანი არგუმენტი შეიძლება მითითებული იყოს ფლაგებთან ერთად, თუ რა ხასიათს ატარებს null სიმბოლოები ან შესვენებები.
ეს არის კარგი იდეა, რომ წინ უპირველესად გააგზავნოს პროცესი მოლოდინით . ველით დაველოდებით პროცესის დაწყებას, ხოლო გაგზავნის ვერ. კერძოდ, თუ პროცესი იწყება პროცესის დაწყებამდე, თქვენ აწარმოებთ თქვენი მონაცემების იგნორირებას. იმ შემთხვევებში, როდესაც ინტერაქტიული პროგრამები არ წარმოადგენენ თავდაპირველ პროექტს, შეგიძლიათ გამოგზავნოთ დაგვიანებით, როგორც:
# რათა თავიდან იქნას აცილებული ჰაკერების მინიშნება, თუ როგორ უნდა დაარღვიოთ, # ეს სისტემა არ ითხოვს გარე პაროლს. # დაველოდოთ 5 წამს, რათა შეასრულოთ სპლონი telnet ძალიან.secure.gov ძილის 5 გააგზავნე პაროლი \ rexp_send არის alias გაგზავნის. თუ თქვენ იყენებთ Expectk- ს ან სხვა ვარიანტს Tk- ს გარემოში, გაგზავნის განისაზღვრება Tk- ს სრულიად განსხვავებული მიზნისთვის. exp_send გათვალისწინებულია თავსებადობას შორის გარემოში. ანალოგიური aliases მოცემულია სხვა მოსალოდნელი სხვა გაგზავნის ბრძანებები.
send_error [-flags] სიმებიანი
ისევე როგორც გაგზავნილი , გარდა იმისა, რომ გამომავალი გამოგზავნილია stderr ვიდრე მიმდინარე პროცესი .
send_log [-] სტრიქონი
გარდა იმისა, რომ გაგზავნის , გარდა იმისა, რომ სიმებიანი არის მხოლოდ გაგზავნილი log ფაილი (იხ. log_file .) არგუმენტები იგნორირებულია, თუ არ log ფაილი ღიაა.
send_tty [-flags] სიმებიანი
ჰგავს გაგზავნას , გარდა იმისა, რომ გამომავალი ეგზავნება / dev / tty ვიდრე მიმდინარე პროცესს .
send_user [-flags] სიმებიანი
ჰგავს გაგზავნას , გარდა იმისა, რომ გამომავალი გამოდის stdout ვიდრე მიმდინარე პროცესი .
ძილის წამი
იწვევს სკრიპტს ძილისთვის მოცემულ წამში. წამი შეიძლება იყოს ათობითი რიცხვი. ინტერპრეტები (და TK მოვლენები თუ თქვენ იყენებთ Expectk) დამუშავებას, ხოლო ველოდებით სძინავს.
spawn [args] პროგრამა [args]
ქმნის ახალ პროცესს გაშვებული "პროგრამა args". მისი stdin, stdout და stderr უკავშირდება მოსალოდნელია, რომ მათ შეიძლება წაიკითხოთ და დაწერილი სხვა ველით ბრძანებები. კავშირი დაარღვევს დახურვას ან თუ პროცესს თავად ახდენს რომელიმე ფაილის იდენტიფიკატორი.
პროცესის დაწყების პროცესში , ცვლადი spawn_id არის მითითებული, რომ აღწერს ამ პროცესს . Spawn_id- ის მიერ აღწერილი პროცესი ითვლება "მიმდინარე პროცესს ". spawn_id შეიძლება წაიკითხოთ ან დაწერილი, ფაქტობრივად, სამუშაო კონტროლის უზრუნველყოფა.
user_spawn_id არის გლობალური ცვლადი, რომელიც შეიცავს დეტაქსტორს, რომელიც ეხება მომხმარებელს. მაგალითად, როდესაც spawn_id არის მითითებული ამ ღირებულების, ველით ისეთი ქმედებები, როგორიცაა expect_user .
I შეცდომა _spawn_id არის გლობალური ცვლადი, რომელიც შეიცავს დეფლექტორს, რომელიც ეხება სტანდარტულ შეცდომას. მაგალითად, როდესაც spawn_id დადგენილია ამ მნიშვნელობით, გააგზავნეთ ქცევები, როგორიცაა send_error .
tty_spawn_id არის გლობალური ცვლადი, რომელიც შეიცავს დეფიქსტორს, რომელიც ეხება / dev / tty- ს. თუ / dev / tty არ არსებობს (როგორიცაა cron, at ან batch script), მაშინ tty_spawn_id არ არის განსაზღვრული. ეს შეიძლება გამოცდილი იყოს:
თუ [[ინფორმაცია vars tty_spawn_id]} {# / dev / tty არსებობს} სხვა {# / dev / tty არ არსებობს # ალბათ cron, batch ან script)სპონსმა დააბრუნა UNIX- ის პროცესის id. თუ პროცესი არ შეიცვლება, 0 დაბრუნდა. ცვლადი spawn_out (მონა, სახელი) არის მითითებული pty მონა მოწყობილობის სახელით.
თავდაპირველად, spawn ეხმიანება ბრძანების სახელი და არგუმენტები. ნონოჩის დროშა ამზადებს სპონეს .
კონოლის დროშა იწვევს კონსოლირების გამოყოფას, რათა გადანაწილდეს შემუშავებული პროცესი . ეს არ არის მხარდაჭერილი ყველა სისტემასთან.
შიგნით, spawn იყენებს pty, ინიციალიზაცია იგივე გზა, როგორც მომხმარებლის tty. ეს კიდევ უფრო ინიციალიზებულია ისე, რომ ყველა პარამეტრი "საზიანოა" (stty (1) მიხედვით). თუ ცვლადი stty_init განისაზღვრება, იგი ინტერპრეტირებულია სტიმული არგუმენტების სტილში შემდგომი კონფიგურაციის სახით. მაგალითად, "კომპლექტი stty_init ნედლეული" გამოიწვევს უფრო მეტად შეიცავდეს პროცესების ტერმინალებს ნედლეულის რეჟიმში. -ნატოტიკოპია იწყება ინიციალიზაციისას, რომელიც ეფუძნება მომხმარებელთა tty. nottyinit skips "sane" ინიციალიზაციისას.
ჩვეულებრივ, სპონსმა ცოტა დრო დასჭირდეს შეასრულოს. თუ შეამჩნევთ მნიშვნელოვან რაოდენობას, მაშინ სავარაუდოა, რომ გაჩნდება ptys. რიგი ტესტები აწარმოებს ptys, რათა თავიდან ავიცილოთ entanglements errant პროცესები. (ეს მიიღებს 10 წამს თითო ped.) Running ველით -d ვარიანტი გამოჩნდება, თუ ველით არის encountering ბევრი ptys უცნაური შტატები. თუ თქვენ ვერ დაამარცხებთ იმ პროცესებს, რომელთა მიმაგრებაც ამ ptys- ს შედის, თქვენი გადატვირთვა შეიძლება გადატვირთოთ.
თუ პროგრამა არ შეიძლება წარმატებით შეიქმნას, რადგან შესრულება (2) ვერ ხერხდება (მაგ., როდესაც პროგრამა არ არსებობს), შეცდომის შეტყობინება მომავალი ინტერაქტივით დაგიბრუნდებათ ან ბრძანებას ელოდება , თითქოს პროგრამის გაშვება და წარმოების შეცდომა როგორც გამომავალი. ეს ქცევა ბუნების შედეგია ბუნტის განხორციელების შესახებ. იძულებით, spawn ჩანგლები, რის შემდეგაც spawned პროცესი არ აქვს საშუალება დაუკავშირდეს ორიგინალური ველით პროცესი გარდა კომუნიკაციის მეშვეობით spawn_id.
ტერმინების დროშა იწვევს მომდევნო არგუმენტს, როგორც Tcl ფაილის იდენტიფიკატორი (ანუ ღია სახით დაბრუნდა.) მაშინ შეიძლება გამოყენებულ იქნეს, თითქოს ეს იყო შემუშავებული პროცესი . (ფაილის იდენტიფიკატორი აღარ უნდა იქნას გამოყენებული.) ეს საშუალებას მოგცემთ მკურნალობა ნედლეულის მოწყობილობებს, ფაილებს და მილსადენებს, როგორც გაფართოებული პროცესები Pty- ის გამოყენების გარეშე. 0 უბრუნდება მიუთითოს არ არსებობს ასოცირებული პროცესი . როდესაც დაკავშირებულია გაფართოებული პროცესის კავშირი დახურულია, ასე რომ არის Tcl ფაილის იდენტიფიკატორი. ლაინ-სამაშველო დროშა მსგავსია -ხვერი, გარდა იმისა, რომ ფრენის იდენტიფიკატორი იტოვებს გახსნას მას შემდეგაც კი, რაც დახურულია.
ვალი დროშის იწყება pty უნდა გაიხსნას, მაგრამ არ პროცესი შეიცავდა. 0 უბრუნდება მიუთითოს არ არსებობს ასოცირებული პროცესი . Spawn_id არის როგორც წესი.
ცვლადი spawn_out (მონა, fd) არის მითითებული ფაილების იდენტიფიკატორი, რომელიც შეესაბამება pty slave- ს. ეს შეიძლება დახურული იყოს "მჭიდროდ".
ინკორტის დროშის სახელწოდება იძლევა სიგნალს, რომელიც იგნორირებული უნდა იქნას შემუშავებულ პროცესში . წინააღმდეგ შემთხვევაში, სიგნალები მიიღებენ სტანდარტულ საქციელს. სიგნალები დასახელებულნი არიან ხაფანგის ბრძანებაში, გარდა იმისა, რომ თითოეული სიგნალი მოითხოვს ცალკე დროშას.
strace დონეზე
იწვევს შემდეგ განცხადებებს დაბეჭდილი სანამ შესრულდება. (Tcl ის კვალი ბრძანება კვალი ცვლადები.) დონე მიუთითებს რამდენად შორს ქვემოთ ზარის დასტის კვალი. მაგალითად, შემდეგი ბრძანება მართავს ეგზემპლარს პირველი 4 დონის ზარის შესამოწმებლად, მაგრამ არცერთი ქვემოთ არ არის.
The -info flag იწვევს strace დაბრუნების აღწერა უკანასკნელი არასამთავრობო ინფორმაცია არგუმენტები მოცემული.
stty args
ცვლის ტერმინალის რეჟიმებს, როგორიცაა გარე Stty ბრძანება.
ჩვეულებრივ, საკონტროლო ტერმინალის შემოწმება ხდება. სხვა ტერმინალების გამოყენება შეიძლება "ბრძანების შედეგად დაბრუნდეს სტატუსის მოთხოვნები", თუ სტატუსი არ არის მოთხოვნილი და საკონტროლო ტერმინალის შემოწმება, ნედლი და ეხოის ატრიბუტების წინა სტატუსი დაბრუნდა იმ ფორმით, გამოიყენება ბრძანება.
მაგალითად, არგუმენტები ნედლეული ან აკუმულატორი დააყენა ტერმინალის ნედლეულ რეჟიმში. არგუმენტები ანაბარი ან მოხარშული ტერმინალის ჩაყრაში . არგუმენტები echo და -cheo დააყენა ტერმინალი echo და noecho რეჟიმში შესაბამისად.
შემდეგი მაგალითი გვიჩვენებს, თუ როგორ შეიძლება დროებით გამორთოთ განმეორება. ეს შეიძლება გამოყენებულ იქნას სხვაგვარად ავტომატური სკრიპტებით, რათა თავიდან იქნეს აცილებული პაროლების ჩადგმა. (იხილეთ დამატებითი დისკუსია ქვემოთ მოყვანილი EXPECT მინიშნებები.)
stty -echo send_user "პაროლი:" expect_user -re "(. *) \ n" პაროლის დაყენება $ expected_out (1, string) stty echo სისტემა არგუმენტირებს
აძლევს args to sh (1) როგორც შეყვანის, ისევე როგორც თითქოს იყო აკრეფილი, როგორც ბრძანება ტერმინალის. ველით, სანამ ჭურვი წყდება. საპასუხო მდგომარეობიდან დაბრუნების სტატუსიც იგივეა, რაც აღმასრულებელმა დააბრუნებს დაბრუნების სტატუსს.
შესრულებისგან განსხვავებით, რომელიც სკრიდს გადაჰყავს და სკრიდს გადაჰყავს, სისტემა არ ასრულებს გადამისამართებას (გარდა სტრიქონის მიერ მითითებული). ამდენად, შესაძლებელია პროგრამების გამოყენება, რომელიც პირდაპირ უნდა ელაპარაკოს / dev / tty. ამავე მიზეზით, სისტემის შედეგები არ არის ჩაწერილი ჟურნალში.
დროის სარტყელი [args]
დააბრუნებს დროის ნიშნულს. არგუმენტების გარეშე, ეპოქის შემდეგ წამიანი რიცხვი დაბრუნდა.
ფორმის დროშა შემოიფარგლება სტრინგით, რომელიც დაბრუნებულია, მაგრამ შემცვლელებით, რომელიც შემუშავებულია POSIX- ის წესებით strftime. მაგალითად% შეიცვალა შემოვლითი კვირის სახელით (ანუ Sat). სხვა არიან:
შემოთავაზებული შაბლონის დასახელება% s სრული რიცხვითი სახელი% B გაანგარიშებული თვის სახელი% B სრული თვის დასახელება% c თარიღი დრო, როგორც: ოთხ ოქტ 6 11:45:56 1993% d დღე (01-31% საათში (00-23)% I საათი (01-12)% j დღე (001-366)% m თვე (01-12)% M წუთი (00-59)% ან ვარდნა S მეორე (00-61) U დღე (1-7, ორშაბათი კვირაში პირველი დღე) U კვირა (00-53, პირველი კვირა კვირაში პირველი დღეა) V კვირა (01-53, ISO 8601 სტილი) w დღე (0- 6) W კვირიანი (00-53, პირველი ორშაბათი კვირაში პირველი დღეა) x თარიღი დრო, როგორც: ოთხ ოქტ 6 1993% X დრო, როგორც: 23:59:59% y წელი (00-99) Y წელი, როგორც: 1993% Z timezone (ან არაფერი თუ არა განსაზღვრული) %% შიშველი პროცენტი ნიშანისხვა სპეციფიკაციები განუსაზღვრელია. სხვა სიმბოლოები გადაეცემა ხელუხლებელი. მხოლოდ C ლოკალი არის მხარდაჭერილი.
სეგმენტის დროშა რამდენიმე წამს წარუდგენს მას შემდეგ, რაც ეპოქა უნდა იქნას გამოყენებული წყაროდან, რომლის ფორმატირებაც. წინააღმდეგ შემთხვევაში, მიმდინარე დრო გამოიყენება.
GMT დროშის დროშის გამოყენება არ არის დროშა, ადგილობრივი დროის სარტყელი გამოიყენება.
ხაფანგში [[ბრძანება] სიგნალები]
იძლევა მოცემული ბრძანების შესრულებას რომელიმე მოცემულ სიგნალის მომავალი მიღებიდან. ბრძანება შესრულებულია გლობალური მასშტაბით. თუ ბრძანება არ არსებობს, სიგნალის აქცია დაბრუნდა. თუ ბრძანება სიმებიანი SIG_IGN, სიგნალები იგნორირებულია. თუ ბრძანება სიღრმე SIG_DFL, სიგნალები გამოიწვიოს სისტემის ნაგულისხმები. სიგნალები ან სიგნალები ან სიგნალები. სიგნალები შეიძლება მითითებული იყოს რიცხვით ან სიმბოლურად, როგორც სიგნალის მიხედვით (3). "SIG" პრეფიქსი შეიძლება გამოტოვებული იყოს.
არგუმენტით (ან არგუმენტით), ხაფანგი უბრუნებს ხაფანგის ბრძანების სიგნალს.
კოდის დროშა იყენებს ბრძანების დაბრუნების კოდს, თუ კოდის Tcl- ის დაბრუნებას აპირებდა, როდესაც თავდაპირველად გაშვებული ბრძანება დაიწყო.
თხრიან დროშას იწვევს ბრძანება, რომლითაც შეფასდება თარჯიმნის აქტიური გამოყენება იმ დროს, როცა ბრძანება დაიწყო, ვიდრე ხაფანგში გამოცხადდა.
სახელი დროშის იწვევს ხაფანგში ბრძანება დაბრუნებას სიგნალი სახელი ხაფანგში ბრძანება გაკეთებული ხორციელდება.
მაგნიტური დროშა იწვევს ხაფანგის ბრძანებას ყველაზე დიდი სიგნალის დაბრუნების თაობაზე.
მაგალითად, ბრძანება "ხაფანგში {send_user" Ouch! "} SIGINT" ბეჭდვა "Ouch!" ყოველ ჯერზე მომხმარებლის დაჭერით ^ C.
ჩვეულებრივ, SIGINT (რომელიც შეიძლება წარმოიშვას C ^ დაჭერით) და SIGTERM გამოიწვიოს გამოდის გასვლა. ეს გამოწვეულია შემდეგ ტრაპზე, რომელიც იწყება, როდესაც იწყება ველით.
ხაფანგში გასვლა {SIGINT SIGTERM}თუ თქვენ იყენებთ -D- ს დროშა debugger- ს დასაწყებად, SIGINT- ს გადააქვს ინტერაქტიული დიააგრეგის დაწყება. ეს არის შემდეგი ხაფანგის გამო:
ხაფანგში {exp_debug 1} SIGINTშეცდომა შეიძლება შეიცვალოს გარემოს ცვლადის EXPECT_DEBUG_INIT- ის ახალი ხაფანგის ბრძანებით.
თქვენ შეგიძლიათ, რა თქმა უნდა, გადააჭარბოთ ორივე მათგანს მხოლოდ ტრაფარეტული ბრძანებების დამატება თქვენს სკრიპტში. კერძოდ, თუ თქვენ გაქვთ საკუთარი "ხაფანგში გასვლა SIGINT", ეს გადააჭარბებს debugger ხაფანგში. ეს სასარგებლოა თუ გსურთ, რომ თავიდან იქნას აცილებული მომხმარებლებისთვის, რათა გაეცნოთ debugger ყველა.
თუ გინდა, რომ განსაზღვროთ საკუთარი ხაფანგი SIGINT- ზე, მაგრამ ისევ დრაგგერთან, როდესაც ის გაშვებულია, გამოიყენეთ:
თუ {! [exp_debug]} {trap mystuff SIGINT}გარდა ამისა, თქვენ შეგიძლიათ ხაფანგში debugger გამოყენებით სხვა სიგნალი.
ხაფანგი არ მოგცემთ SIGALRM- ის მოქმედების გადალახვას, რადგან ეს იძულებულია გამოიყენოს იძულებით მოსალოდნელი . გათიშვის ბრძანება SIGALRM- ს SIG_IGN- ს (იგნორირება) ადგენს. ამის შემდეგ თქვენ შეგიძლიათ გააგრძელოთ ის, თუ ის გამორთეთ მას შემდგომ სპონვის ბრძანებების დროს.
დამატებითი ინფორმაციისთვის იხილეთ სიგნალი (3).
დაველოდოთ [args]
შეფერხებები სანამ არ იშლება (ან მიმდინარე პროცესი, თუ არცერთი დასახელებული არ არის) წყდება.
დაველოდოთ ნორმალურად დააბრუნებს ოთხი რიცხვების სიას. პირველი რიცხვი არის პროცესი, რომელიც დაელოდა პროცესს . მეორე რიცხვი არის შესაბამისი spawn id. მესამე რიცხვი არის -1 თუ ოპერაციული სისტემის შეცდომა მოხდა, ან 0 სხვაგვარად. თუ მესამე რიცხვი 0 იყო, მეოთხე რიცხვი არის სტატუსის დაბრუნების შემობრუნება. თუ მესამე რიცხვი -1 იყო, მეოთხე რიცხვი არის ოპერაციული სისტემის მიერ შექმნილ შეცდომის ღირებულება. გლობალური ცვლადი შეცდომა კოდიც არის მითითებული.
დამატებითი ელემენტები შეიძლება გამოჩნდეს დაბრუნების ღირებულების დასასრულს. სურვილისამებრ მეხუთე ელემენტს განსაზღვრავს ინფორმაციის კლასი. ამჟამად, ამ ელემენტის ერთადერთი შესაძლო მნიშვნელობა არის CHILDKILLED, რომლის დროსაც შემდეგი ორი მნიშვნელობაა C- სტილის სიგნალის სახელი და მოკლე ტექსტური აღწერა.
-ი დროშა აცხადებს პროცესს , რომ დაასახელოს დაასახელოს spawn_id (არ პროცესი id). SIGCH- ის ხელსაწყოს შიგნით, შესაძლებელია მოითმინოთ ნებისმიერი spawned პროცესი გამოყენებით spawn id -1.
ლოდინი დროშის იწვევს დაველოდოთ დაბრუნების დაუყოვნებლივ მითითებით წარმატებული დაველოდოთ. როდესაც პროცესი გადის (შემდგომში), იგი ავტომატურად გაქრება უშუალო დატვირთვის საჭიროების გარეშე.
დაველოდოთ ბრძანება ასევე შეიძლება გამოყენებულ იქნას დაჩქარებული პროცესისთვის არგუმენტების გამოყენებით "-i -1". მისი გამოყენებისგან განსხვავებით, ეს ბრძანება შეიძლება შესრულდეს ნებისმიერ დროს. არ არსებობს კონტროლი, რომლის დროსაც ხდება გადამუშავება . თუმცა, დაბრუნების მნიშვნელობა შეიძლება შემოწმდეს პროცესის id.
ლიბერალები
ველით ავტომატურად იცის ორი ჩაშენებული ბიბლიოთეკების მოსალოდნელი სკრიპტები. ეს განისაზღვრება ცვლადები exp_library და exp_exec_library- ში. ორივე იგულისხმება სასარგებლო ფაილების შესაცვლელად, რომლებიც შეიძლება გამოყენებულ იქნას სხვა სკრიპტებით.
exp_library შეიცავს არქიტექტურულ-დამოუკიდებელ ფაილებს. exp_exec_library შეიცავს არქიტექტურულ-დამოკიდებულ ფაილებს. თქვენი სისტემის მიხედვით, ორივე დირექტორი შეიძლება მთლიანად ცარიელი იყოს. $ Exp_exec_library / cat-buffers- ის ფაილის არსებობა აღწერს თუ არა თქვენი / bin / cat buffers default.
ქაღალდი
Vgrind განმარტება ხელმისაწვდომია საკმაოდ ბეჭდვისთვის მოსალოდნელი სკრიპტები. სავარაუდოდ განაწილება განაწილებული ვექტორებით განსაზღვრული ვარგისიანობის განსაზღვრა სწორად დაყენებულია, შეგიძლიათ გამოიყენოთ იგი:
vgrind -lexpect ფაილიმაგალითები
ბევრი არ არის აშკარა, თუ როგორ უნდა დააყენოს ყველაფერი ერთად, რომ კაცი გვერდი აღწერს. მე მოგიწოდებთ წაიკითხოთ და გაეცანი მაგალითების მაგალითს განაწილების ველით . ზოგიერთი მათგანი რეალური პროგრამებია. სხვები მხოლოდ გარკვეული ტექნიკის საილუსტრაციოდ არიან, რა თქმა უნდა, წყვილი მხოლოდ სწრაფი ჰაკებია. INSTALL- ს ფაილი აქვს ამ პროგრამების სწრაფი მიმოხილვა.
სავარაუდო ნაშრომები (იხილეთ აგრეთვე) სასარგებლო იქნება. მიუხედავად იმისა, რომ ზოგიერთი ნაშრომი გამოიყენებს სინტაქსს, რომელიც შეესაბამება წინა ვერსიებს, თანმხლები რაციონალურობა ჯერ კიდევ მოქმედებს და უფრო დეტალურად შედის ამ კაცის გვერდზე.
გადანაწილება
გაფართოებები შეიძლება დაეჯახონ ეგპტის ბრძანების სახელებს. მაგალითად, გაგზავნის განისაზღვრება Tk სრულიად განსხვავებული მიზნით. ამ მიზეზით, სავარაუდო ბრძანებების უმრავლესობა ასევე ხელმისაწვდომია როგორც "exp_XXXX". ბრძანებები და ცვლადები იწყება "ექსპ", "ინტერ", "სპავნი" და "დროითი" არ აქვთ aliases. გამოიყენეთ გაფართოებული ბრძანების სახელები, თუ საჭიროა ამ თავსებადობას შორის გარემოში.
ველოდოთ სკოპინგის საკმაოდ ლიბერალურ ხედს. კერძოდ, ცვლადები კითხულობენ ბრძანებებს, რომლებიც სპეციფიკურ პროგრამას ეხება, თავიდან უნდა იქნას მოძიებული ადგილობრივ ფარგლებს გარეთ და თუ არ მოიძებნება გლობალური მასშტაბით. მაგალითად, ეს ხელს უშლის "გლობალური შეყოვნების" მოთავსების აუცილებლობას ყველა პროცედურაში, რასაც მოეთხოვებთ. მეორე მხრივ, დაწერილი ცვლადები ყოველთვის ადგილობრივ დონეზეა (თუ "გლობალური" ბრძანება არ გაიცემა). ყველაზე გავრცელებული პრობლემაა ეს მიზეზი, როდესაც სპლონი შესრულებულია პროცედურაში. პროცედურის გარეთ, spawn_id აღარ არსებობს, ამიტომ გაფართოებული პროცესი აღარ არის ხელმისაწვდომი მხოლოდ სკოპინგის გამო. დაამატეთ "global spawn_id" ასეთ პროცედურას.
თუ ვერ შეძლებთ მრავალმხრივი შესაძლებლობების ჩართვას (ანუ თქვენი სისტემა მხარს არ უჭერს არც აირჩიეთ (BSD *. *), გამოკითხვა (SVR> 2) და არც რაიმე ეკვივალენტი), ველოდებით მხოლოდ ერთი პროცესის კონტროლს. ამ შემთხვევაში არ ცდილობენ spawn_id- ს შექმნას, არც პროცესის გატარება და არც პროცესის გაშვება. გარდა ამისა, თქვენ ვერ შეძლებთ ველოდოთ მრავალჯერადი პროცესების (მათ შორის მომხმარებლის, როგორც ერთი) ერთდროულად.
ტერმინალის პარამეტრები შეიძლება ჰქონდეს დიდი ეფექტი სკრიპტებით. მაგალითად, თუ სკრიპტი დაწერილია ეპოქის გამოსაყოფად, ის გაუგებარია, თუ გამეორდება გამეორება. ამ მიზეზით, ველით ძალების ტერმინალური პარამეტრების ნაგულისხმევი. სამწუხაროდ, ეს შეიძლება გააკეთოს რამ უსიამოვნო სხვა პროგრამებს. მაგალითად, emacs ჭურვი სურს შეცვალოს "ჩვეულებრივი" mappings: newlines მისაღებად mapped to newlines ნაცვლად გადაზიდვის-დაბრუნების newlines და echoing გამორთულია. ეს საშუალებას იძლევა ერთი გამოიყენოს emacs შესწორება ხაზის რედაქტირება. სამწუხაროდ, ველოდებით, რომ ეს არ არის შესაძლებელი.
თქვენ შეგიძლიათ მოითხოვოთ, რომ ველოდოთ ტერმინალის პარამეტრების ნაგულისხმევ პარამეტრს, მაგრამ მაშინ ძალიან ფრთხილად უნდა იყოთ ასეთი სცენარისთვის სკრიპტების დაწერისას. იმ შემთხვევაში, თუ emacs, თავიდან ასაცილებლად რამ, როგორიცაა echoing და ბოლოს- of-line რუკები.
ბრძანებები, რომლებიც მიღებულია არგუმენტები ერთ სიაში ( ველით ვარიანტებს და ურთიერთქმედებას ) გამოიყენოს ევრისტიკული გადაწყვეტილება, თუ სიაში არის ერთი არგუმენტი ან ბევრი. ევრაზიული ვერ შეძლებს მხოლოდ იმ შემთხვევაში, როდესაც სიაში რეალურად წარმოადგენს ერთ არგუმენტს, რომელსაც აქვს მრავალრიცხოვანი ჩანართები \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ ეს, როგორც ჩანს, საკმარისად წარმოუდგენელია, თუმცა არგუმენტი "ნობრესი" შეიძლება გამოყენებულ იქნეს ერთი არგუმენტის დასადებად ერთი არგუმენტის სახით. ეს შეიძლება ძნელად გამოყენებული იქნას მანქანით წარმოქმნილი ეგზემპლარად. ანალოგიურად, -ძალიან ძალების ერთი არგუმენტი უნდა გაუმკლავდეს, როგორც მრავალჯერადი ნიმუშების / ქმედებები.
BUGS
მართლაც მაცდური იყო პროგრამის "სქესის" სახელი (ან "სმარტ EXEC" ან "გამოხატვა"), მაგრამ კარგი გრძნობა (ან უბრალოდ პურიტანიზმი) გაიმარჯვა.
ზოგიერთ სისტემაში, როდესაც shell შეიცვლება, იგი ჩივის, რომ ვერ შეძლო tty წვდომის მაგრამ მაინც გადის. ეს იმას ნიშნავს, რომ თქვენს სისტემას აქვს მექანიზმი, რომელიც იძენს მაკონტროლებელ Tty რომ ველით არ იცის შესახებ. გთხოვთ, გაირკვეს ის, რაც არის და გააგზავნეთ ეს ინფორმაცია.
Ultrix 4.1 (მინიმუმ უახლესი ვერსიები გარშემო) განიხილავს 1000000-ზე მეტი ვადებში 0-ზე.
ციფრული UNIX 4.0A (და ალბათ სხვა ვერსიები) უარს ამბობს ptys გამოყოფა, თუ თქვენ განსაზღვრავს SIGCHLD დამმუშავებლის. დამატებითი ინფორმაცია იხილეთ გრანტის გვერდზე.
IRIX 6.0 არ მართავს Pty ნებართვების სწორად ისე, რომ თუ ველოდებით მცდელობას გამოყოფილი pty ადრე გამოყენებული ვინმე, იგი ვერ. განახლება IRIX 6.1.
Telnet (დამოწმებული მხოლოდ ქვეშ SunOS 4.1.2) კიდია თუ ვადა არ არის დადგენილი. ეს არის პრობლემის ქვეშ cron, at და cgi სკრიპტები, რომლებიც არ განსაზღვრავენ TERM. ამრიგად, უნდა გამოვყოთ ის მკაფიოდ - რა ტიპისა, როგორც წესი, შეუსაბამოა. ეს მხოლოდ უნდა იყოს მითითებული რაღაც! შემდეგი შემთხვევებისთვის საჭიროა საკმარისი რაოდენობა.
მითითებული env (TERM) vt100Tip (დამოწმებული მხოლოდ BSDI BSD / OS 3.1 i386- ის ფარგლებში) იკეტება თუ არ არის დაყენებული SHELL და HOME. ეს არის პრობლემის ქვეშ cron , at და cgi სკრიპტები, რომელიც არ განსაზღვრავს ამ გარემოს ცვლადები. ამგვარად, თქვენ უნდა გამოაყოლოთ მათ - რა ტიპისა, როგორც წესი, შეუსაბამოა. ეს მხოლოდ უნდა იყოს მითითებული რაღაც! შემდეგი შემთხვევებისთვის საჭიროა საკმარისი რაოდენობა.
env (shell) / bin / sh set env (მთავარი) / usr / local / binზოგიერთი შესრულების ptys განკუთვნილია ისე, რომ ბირთვის ისვრის მოშორებით ნებისმიერი unread გამომავალი შემდეგ 10 დან 15 წამი (ფაქტობრივი ნომერი არის განხორციელება დამოკიდებული) პროცესი დახურულია ფაილი descriptor. ამგვარად, ველით პროგრამებს, როგორიცაა
spawn თარიღი ძილის 20 მოველითჩაიშლება. ამის თავიდან ასაცილებლად, მოიყვანეთ არასამთავრობო ინტერაქტიული პროგრამები შესრულებაზე , ვიდრე სპონს . მიუხედავად იმისა, რომ ასეთი სიტუაციები წარმოუდგენელია, პრაქტიკულად მე არასოდეს შევხვდი სიტუაციას, რომელიც საბოლოო შედეგს ნამდვილად ინტერაქტიული პროგრამა დაიკარგება ამ ქცევის გამო.
მეორეს მხრივ, Cray UNICOS ptys გადაყარეთ ნებისმიერი წაუკითხავი გამომავალი დაუყოვნებლივ მას შემდეგ, რაც პროცესი დახურულია ფაილის დეპოზიტორი. მე ამის შესახებ შევიტყვე, და ისინი მუშაობენ სარემონტო სამუშაოზე.
ზოგჯერ დაგვიანებით საჭიროა სწრაფი და რეაგირება, როგორიცაა, როდესაც tty ინტერფეისი იცვლება UART პარამეტრები ან შესატყვისი baud განაკვეთები ეძებს დაწყების / გაჩერება ბიტი. როგორც წესი, ყველა ეს მოითხოვს სძინავს მეორე ან ორი. უფრო მტკიცე ტექნიკა არის ისევ, სანამ აპარატი მზად არის შეყვანის მიღება. შემდეგი მაგალითი იყენებს ორივე სტრატეგიას:
გააგზავნეთ "სიჩქარე 9600 \ r"; ძილი 1 მოსალოდნელია {შეყოვნება {გაგზავნა \ r "; exp_continue} $ prompt}ხაფანგი კოდი არ იმუშავებს ნებისმიერი ბრძანებით, რომელიც ზის TCL- ის ღონისძიების მარყუჟში, როგორიცაა ძილი. პრობლემა ის არის, რომ იმ შემთხვევაში, მარყუჟის, Tcl უარყოფს დაბრუნების კოდების საწყისი async ღონისძიების handlers. Workaround არის დროშა ვაგონში ხაფანგში. შემდეგ შეამოწმეთ დროშა მაშინვე ბრძანება (ანუ ძილი).
Expect_background ბრძანება უგულებელყოფს-არგუმენტირებს არგუმენტები და არ აქვს კონცეფცია timouts ზოგადად.
& # 34; EXPECT მინიშნებები & # 34;
არსებობს რამდენიმე რამ მოსალოდნელია, რომ შეიძლება იყოს არასამთავრობო ინტუიციური. ეს სექცია ცდილობს რამდენიმე საკითხის მოგვარება რამდენიმე შეთავაზებით.
საერთო მოსალოდნელი პრობლემაა, თუ როგორ უნდა აღიაროს shell მოთხოვნა. ვინაიდან ისინი განსხვავებულად განსხვავებულად განსხვავებულნი არიან და განსხვავებულ ჭურვებით, პორტატული ავტომატიზირებული rlogin შეიძლება იყოს რთული გარეშე იცის სწრაფი. გონივრული კონვენცია არის მომხმარებლების რეგულარული გამოხატვა, რომელიც აღწერს მათი სწრაფი (კერძოდ, მისი ბოლოს) გარემოს ცვლად EXPECT_PROMPT- ს. კოდექსის მსგავსი გამოყენება შეიძლება. თუ EXPECT_PROMPT არ არსებობს, კოდი ჯერ კიდევ აქვს სწორად ფუნქციონირების კარგი შანსი.
set prompt "(% | # | \\ $) $"; # default prompt catch {set prompt $ env (EXPECT_PROMPT)} ველით -re $ promptმე მოგიწოდებთ, დაწერონ მოლოდინი ნიმუშები, რომელიც მოიცავს ბოლოს რაც თქვენ მოელით. ეს თავიდან აცილებს შესაძლებლობას, პასუხი გასცეს კითხვას მთელი საქმის ნახვამდე. გარდა ამისა, როდესაც თქვენ კარგად შეძლებთ კითხვებზე პასუხის გაცემას, სანამ ისინი მთლიანად ხედავთ, თუ უპასუხებთ ადრესატს, შეიძლება პასუხად გამოეხმაუროთ კითხვის შუაში. სხვა სიტყვებით რომ ვთქვათ, შედეგად დიალოგი სწორი იქნება, მაგრამ შეხედეთ სკამს.
ყველაზე მოთხოვნად მოიცავს სივრცის სიმბოლოს ბოლოს. მაგალითად, ftp არის "f", "t", "p", ">" და. ამ პროპტის შესაგროვებლად, თითოეულ ამ სიმბოლოზე უნდა მიუთითოთ. ეს არის საერთო შეცდომა, რომ არ იყოს ცარიელი. განათავსეთ ცარიელი მკაფიოდ.
X * ფორმატის ნიმუშის გამოყენების შემთხვევაში * შეესაბამება X- ის ბოლოს მიღებული ყველა გამომავალი ბოლომდე მიღებულს. ეს ჟღერს ინტუიურობას, მაგრამ შეიძლება გარკვეულწილად დამაბნეველი იყოს, რადგან ფრაზა "ბოლო რამის მიღება" შეიძლება განსხვავდებოდეს კომპიუტერული სიჩქარისა და I / O- ის დამუშავებაზე, როგორც ბირთვისა და მოწყობილობის მძღოლის მეშვეობით.
კერძოდ, ადამიანები, როგორც ჩანს, ხედავენ პროგრამულ გამოცემას უზარმაზარი მოცულობით (ატომიურად), როდესაც რეალურად ბევრი პროგრამა წარმოებს გამომავალ ერთ ხაზს. თუ ვთქვათ, რომ წინა პარაგრაფის ნიმუში შეიძლება შეესაბამებოდეს მიმდინარე ხაზის ბოლოს, თუმცა, როგორც ჩანს, უფრო მეტია, რადგან მატჩის დროს, რომელიც იყო მიღებული ყველა გამომავალი.
ველოდოთ არ იცის, რომ შემდგომი გამომავალი მოდის, თუ თქვენი ნიმუში კონკრეტულად ანგარიშები მას.
თუნდაც ხაზის ორიენტირებული buffering დამოკიდებულია არაგონივრულია. არა მარტო პროგრამების იშვიათად გააკეთებენ დაპირებები ტიპის buffering ისინი, მაგრამ სისტემის დიახ შეიძლება შესვენება გამომავალი ხაზები ისე, რომ ხაზები დაარღვიოს ერთი შეხედვით შემთხვევითი ადგილებში. ამდენად, თუ თქვენ შეგიძლიათ გამოხატოთ უკანასკნელი რამდენიმე სიმბოლო, როდესაც წერის ნიმუშები წერს, ეს ბრძენია.
თუ თქვენ გელოდებათ პროგრამის საბოლოო შედეგების ნიმუში და პროგრამის ნაცვლად რაღაც ნაცვლად, თქვენ ვერ შეძლებთ აღმოაჩინონ, რომ დროის შეყვანის სიტყვით. ამის მიზეზი ის არის, რომ მოლოდინი არ შეასრულებს დროულს - ამის ნაცვლად ის მიიღებს მითითებას. გამოიყენეთ ეს ნაცვლად. კიდევ უკეთესი, გამოიყენეთ ორივე. ასე რომ, თუ ეს ხაზი ოდესმე გადაადგილდება, თქვენ არ გექნებათ შეცვალონ ხაზი.
Newlines, როგორც წესი, გადაიყვანეს გადაზიდვის დაბრუნების, linefeed sequences როდესაც გამომავალი მიერ ტერმინალის მძღოლი. ამდენად, თუ გინდათ ნიმუში, რომელიც პირდაპირ შეესაბამება ორ ხაზს, ვთქვათ, printf ("foo \ nbar"), უნდა გამოიყენოთ ნიმუში "foo \ r \ nbar".
მსგავსი თარგმანი ხდება მაშინ, როდესაც კითხულობს მომხმარებლის მეშვეობით expect_user . ამ შემთხვევაში, როცა დააბრუნებთ დაბრუნებას, ის თარგმანს ახალ ხაზს გადასცემს. თუ ველით , რომ პროგრამაში, რომელიც ტერმინალს ნედლეულ რეჟიმში ადგენს (როგორც telnet), იქნება პრობლემა, რადგან პროგრამა ნამდვილ დაბრუნებას ელოდება. (ზოგიერთი პროგრამა მართლაც აპატიებს იმას, რომ ისინი ავტომატურად თარგმნიან ახალ ხაზებს, მაგრამ არა უმეტეს.) სამწუხაროდ, არ არსებობს გზა იმის გასარკვევად, რომ პროგრამა ტერმინალს ნედლეულ რეჟიმში დააყენებს.
ნაცვლად იმისა, რომ ხელახლა შეცვალონ ახალი ხაზები, გამოსავალია გამოიყენოს ბრძანება "მყარი ნედლი", რომელიც შეწყვეტს თარგმანს. შენიშვნა, თუმცა, ეს იმას ნიშნავს, რომ აღარ მიიღებთ მოხარშული ხაზების რედაქტირების ფუნქციებს.
ურთიერთქმედება ირიბად ადგენს ტერმინალს ნედლეულ რეჟიმში, ასე რომ, ეს პრობლემა არ წარმოიქმნება.
ხშირად სარგებლობს პაროლების (ან სხვა პირადი ინფორმაციის) შესანახად სკრიპტების მოსაპოვებლად. ეს არ არის რეკომენდირებული, რადგან კომპიუტერში შენახული ყველაფერი არის მგრძნობიარე, რომელსაც ვინმე იყენებს. ამდენად, ინტერაქტიული სიტყვებიდან პაროლებისთვის არის სასურველი იდეა, ვიდრე სიტყვასიტყვით. მიუხედავად ამისა, ზოგჯერ ასეთი ჩანართი არის ერთადერთი შესაძლებლობა.
სამწუხაროდ, UNIX- ს ფაილური სისტემა არ აქვს პირდაპირი სკრიპტის შექმნას, რომელიც არის შესრულებული, მაგრამ არა წაკითხვადი. სისტემები, რომლებიც უზრუნველყოფენ setgid shell სკრიპტები შეიძლება ირიბად simulate ეს შემდეგნაირად:
შექმენით მოსალოდნელი სკრიპტი (რომელიც შეიცავს საიდუმლო მონაცემებს) როგორც ყოველთვის. მისი ნებართვა იყოს 750 (-rwxr-x ---) და ეკუთვნოდა სანდო ჯგუფს, ანუ ჯგუფს, რომლის წაკითხვაც შესაძლებელია. საჭიროების შემთხვევაში, ამ მიზნით ახალი ჯგუფის შექმნა. შემდეგი, შექმენით / bin / sh სცენარი ნებართვები 2751 (-rwxr-s - x), რომელიც ეკუთვნის იგივე ჯგუფს, როგორც ადრე.
შედეგი არის სცენარი, რომელიც შეიძლება შესრულდეს (და წაიკითხეთ) ვინმეს მიერ. როდესაც მოიყვანა, ის გადის სცენარის მოლოდინში.
& # 34; იხილეთ აგრეთვე # 34;
Tcl (3), libexpect (3)
"შეისწავლის მოსალოდნელი: Tcl-Based Toolkit ავტომატური ინტერაქტიული პროგრამების" მიერ დონ Libes, pp. 602, ISBN 1-56592-090-2, O'Reilly და Associates, 1995.
"მოსალოდნელია: დონ ლიბესის მიერ ამ უკონტროლო შეჯერების განკურნება " 1990 წლის USENIX კონფერენციის პროცესი, ანაჰემი, კალიფორნია, 1990 წლის 11-15 ივნისი.
1990 წლის 17-19 ოქტომბერს კოლორადო სპრინგსი, კოლორადო სპრინგსის ადმინისტრაციის კონფერენცია, "დონ ლიუბის" სისტემის, " ველოდოთ სისტემის ადმინისტრაციული ამოცანების ავტომატიზირებას".
დონა Libes, Computing Systems - ის მიერ "ინტერვიუები ინტერაქტიული პროგრამების სკრიპტებით", "ვაშინგტონში" 1990 წლის იანუ- , ტომი 4, No. 2, კალიფორნიის უნივერსიტეტის პრესის ჟურნალები, ნოემბერი 1991. დონ ლიუბის, "1992 წლის საზაფხულო კონფერენციის", "სანდრო ანტონიო, TX, 1992 წლის 12-15 ივნისს, დონ ლიბსის, "ჯეიბ ვილე და სონსი", დასავლეთ საჩესი, ინგლისი, Vol.
1993 წლის მაისში, 1993 წლის 10 მაისი, 1993 წლის 23 მაისს, №5, 1993 წლის მაისში, 1993 წლის Tcl / Tk სემინარის ბერკლი, CA, დონ ლიუბების მიერ, "Tcl აპლიკაციების გამავრცელებელი".
AUTHOR
დონ ლიბსები, სტანდარტებისა და ტექნოლოგიების ეროვნული ინსტიტუტი
ACKNOWLEDGMENTS
მადლობა ჯონ ოისტერჰუტისთვის Tcl და სკოტ პაისლი შთაგონებისთვის. მადლობა Rob Savoye ამისთვის ველით ავტოკონფიგურაციის კოდი.
ისტორიაში დოკუმენტების დიდი ნაწილი მოლოდინში ევოლუციაა. ეს საინტერესო კითხვას იძლევა და შესაძლოა მოგაწოდოთ ეს პროგრამა. მადლობა ხალხში, რომელიც გამომიგზავნა bug შეცდომები და მისცა სხვა დახმარება.
აშშ-ს მთავრობამ ნაწილობრივ დაიმსახურა საპროგნოზო დაპროექტება და განხორციელება და, შესაბამისად, საზოგადოებრივ დომენში. თუმცა ავტორს და ნისტს კრედიტს სურს, თუ ეს პროგრამა და დოკუმენტაცია ან მათი ნაწილი გამოიყენება.