Ang Linux / Unix Command Asahan

Ang inaasahan ay isang programa na nagsasalita sa iba pang mga interactive na programa ayon sa isang script. Kasunod ng script, inaasahan ng Expect kung ano ang maaaring inaasahan mula sa isang programa at kung ano ang nararapat na tugon. Ang isang interpreted na wika ay nagbibigay ng mga istraktura ng kontrol sa pagsasanib at mataas na antas upang idirekta ang dialog. Bilang karagdagan, maaaring kontrolin ng user at direktang makipag-ugnay kapag nais, pagkatapos ay bumalik na kontrol sa script.

Ang Expectk ay isang halo ng Expect and Tk. Ito ay gumaganap tulad ng inaasahan at inaasahan ng Tk. Ang inaasahan ay maaari ding gamitin nang direkta sa C o C ++ na walang Tcl.

Ang pangalan na "Asahan" ay mula sa ideya ng magpadala / asahan ang mga pagkakasunud-sunod na pinapakalat ng uucp, kermit at iba pang mga programang kontrol sa modem. Gayunpaman hindi tulad ng uucp, inaasahan ay pangkalahatan upang maaari itong tumakbo bilang command ng user-level na may anumang programa at gawain sa isip. Asahan ay maaaring makipag-usap sa maraming mga programa sa parehong oras.

Ano ang Magagawa ng Asahan

Halimbawa, narito ang ilang mga bagay na magagawa ng inaasahang utos:

• Pakawalan ang iyong computer upang i-dial ka pabalik, upang makapag-log in ka nang hindi nagbabayad para sa tawag.
• Magsimula ng isang laro at kung ang pinakamainam na configuration ay hindi lilitaw, i-restart ito muli at muli) hanggang sa ito ay, at pagkatapos ay ibigay ang kontrol sa iyo.
• Patakbuhin ang fsck , at bilang tugon sa mga tanong nito, sagutin ang "oo" o "hindi" o ibalik ang kontrol sa iyo, batay sa predetermined criteria.
• Kumonekta sa isa pang network at awtomatikong kunin ang iyong mail upang lumitaw ito kung ito ay orihinal na ipinadala sa iyong lokal na sistema.
• Magdala ng mga variable sa kapaligiran, kasalukuyang direktoryo, o anumang uri ng impormasyon sa buong rlogin, telnet, tip, su , o chgrp

Mayroong iba't ibang mga kadahilanan kung bakit hindi maaaring isagawa ng shell ang mga gawaing ito. Ang lahat ay posible sa inaasahan.

Sa pangkalahatan, ang Asahan ay kapaki-pakinabang para sa pagpapatakbo ng anumang programa na nangangailangan ng pakikipag-ugnayan sa pagitan ng programa at ng gumagamit. Lahat ng kailangan ay ang pakikipag-ugnayan ay maaaring characterized sa programming. Asahan ay maaari ring magbigay ng kontrol sa likod ng gumagamit nang hindi pahintu-hiwalay ang programa. Katulad nito, ang user ay maaaring bumalik control sa script sa anumang oras.

Paggamit

Inaasahan nagbabasa ng cmdfile para sa isang listahan ng mga utos upang isagawa. Ang inaasahan ay maaaring mahigpit na mahihingi sa mga sistema na sumusuporta sa #! notasyon sa pamamagitan ng pagmamarka ng script bilang executable at paggawa ng unang linya sa script:

#! / usr / local / bin / expect -f

Siyempre, ang landas ay dapat tumpak na naglalarawan kung saan inaasahan ang buhay. / usr / local / bin ay isang halimbawa lamang.

Ang flag na -c ay nagsisimula sa isang command na maisagawa bago ang alinman sa script. Ang utos ay dapat na naka-quote upang maiwasan ang pagiging nasira ng shell. Maaaring gamitin ang pagpipiliang ito nang maraming beses. Maramihang mga utos ay maaaring isagawa sa isang solong -c sa pamamagitan ng paghihiwalay sa mga ito sa mga semicolon. Ang mga utos ay pinapatupad sa pagkakasunud-sunod na lumilitaw. Kapag gumagamit ng Expectk, tinukoy ang opsyong ito bilang-komand.

Ang -d na flag ay nagbibigay-daan sa ilang diagnostic output, na pangunahing nag-uulat ng panloob na aktibidad ng mga utos tulad ng inaasahan at nakikipag-ugnayan. Ang bandilang ito ay may parehong epekto bilang "exp_internal 1" sa simula ng script na inaasahan, kasama ang bersyon ng Expect ay nakalimbag.

Ang -D na bandila ay nagbibigay-daan sa isang interactive na debugger. Dapat sundin ang isang integer value. Ang debugger ay magkakontrol bago ang susunod na pamamaraan ng Tcl kung ang halaga ay di-zero o kung ang isang ^ C ay pinindot o isang breakpoint ay pindutin, o iba pang naaangkop na debugger command ay lumilitaw sa script. Kapag gumagamit ng Expectk, tinukoy ang opsyong ito bilang - Debug.

Ang -f flag ay nagsisimula sa isang file kung saan magbasa ng mga command. Ang bandila mismo ay opsyonal na ito ay kapaki-pakinabang lamang kapag ginagamit ang #! notasyon, upang ang iba pang mga argumento ay maibibigay sa command line. Kapag gumagamit ng Expectk, tinukoy ang opsyong ito bilang -file.

Bilang default, ang command file ay mababasa sa memorya at papatayin sa kabuuan nito. Paminsan-minsan ay kanais-nais na basahin ang mga file ng isang linya sa isang pagkakataon. Upang pilitin ang mga di-makatwirang mga file na hawakan sa ganitong paraan, gamitin ang -b na bandila. Kapag gumagamit ng Expectk, tinukoy ang opsyong ito bilang -buffer.

Kung ang string "-" ay ibinigay bilang isang filename, ang karaniwang input ay binabasa sa halip. Gamitin ang "./-" upang basahin mula sa isang file na talagang pinangalanang "-".

Ang -i flag nagiging sanhi ng inaasahan upang interactive na prompt para sa mga utos sa halip ng pagbabasa ng mga ito mula sa isang file. Tinapos ang pag-prompt sa pamamagitan ng command exit o sa EOF. Ang -i flag ay ipinapalagay na kung alinman sa isang command file o -c ay ginagamit. Kapag gumagamit ng Expectk, tinukoy ang opsyong ito bilang -interactive.

- Maaaring gamitin upang mabawasan ang dulo ng mga pagpipilian. Ito ay kapaki-pakinabang kung nais mong ipasa ang isang opsyon-tulad ng argumento sa iyong script nang hindi ito binigyang-kahulugan ng inaasahan. Maaari itong gamitin nang kapaki-pakinabang sa #! linya upang maiwasan ang anumang pagpapahiwatig ng bandila sa pamamagitan ng Inaasahan. Halimbawa, ang mga sumusunod ay iiwan ang mga orihinal na argumento kasama ang pangalan ng script sa variable argv .

#! / usr / local / bin / expect -

Tandaan na ang karaniwang getopt (3) at execve (2) na mga kombensiyon ay dapat na sundin kapag nagdadagdag ng mga argumento sa #! linya.

Ang file na $ exp_library / expect.rc ay awtomatikong gagamitin kung kasalukuyan, maliban kung ang -N flag ay ginagamit. (Kapag gumagamit ng Expectk, tinukoy ang opsyon na ito bilang -NORC.) Kaagad pagkatapos nito, awtomatikong galing ang file ~ / .expect.rc, maliban kung ang -n flag ay ginagamit. Kung tinukoy ang variable na DOTDIR ng kapaligiran, ito ay itinuturing bilang direktoryo at .expect.rc ay binasa mula roon. Kapag gumagamit ng Expectk, tinukoy ang opsyong ito bilang -norc. Ang pagkuha na ito ay nangyayari lamang pagkatapos maisagawa ang anumang mga flags ng -c.

-v nagiging sanhi Maghintay na i-print ang numero ng bersyon nito at lumabas. Ang nararapat na bandila sa Expectk, na gumagamit ng mahabang pangalan ng bandila, ay -bugbog.

Ang mga opsyonal args ay binuo sa isang listahan at naka-imbak sa variable na may pangalang argv at. Ang argc ay pinasimulan sa haba ng argv.

Ang argv0 ay tinukoy na ang pangalan ng script o binary kung walang script na ginagamit. Halimbawa, ang sumusunod na mga kopya ang pangalan ng script at ang unang tatlong argumento:

send_user "$ argv0 [lrange $ argv 0 2] \ n"

Mga utos

Inaasahan ay gumagamit ng Tool Command Language. Ang Tcl ay nagbibigay ng control flow (kung, para, break), pagsusuri ng expression at ilang iba pang mga tampok tulad ng recursion at kahulugan ng pamamaraan. Ang mga utos na ginamit dito ngunit hindi tinukoy (nakatakda, kung, exec) ay mga utos ng Tcl. Ang inaasahan ay sumusuporta sa mga karagdagang utos. Maliban kung tinukoy, ang mga utos ay ibabalik ang walang laman na string.

Ang mga utos ay nakalista ayon sa alpabeto upang mabilis na maabot ang mga ito. Gayunpaman, mas madaling makahanap ng mga bagong user sa pamamagitan ng pagbabasa ng mga paglalarawan ng mga itlog ng isda, ipadala, inaasahan, at makipag-ugnayan, sa utos na iyon.

isara [-slave] [-onexec 0 | 1] [-i spawn_id]

Isinasara ang koneksyon sa kasalukuyang proseso . Karamihan sa mga interactive na programa ay makikitang EOF sa kanilang stdin at exit; kaya malapit na ang mga suffice upang patayin ang proseso pati na rin. Ang -i flag ay nagpapahayag ng proseso upang isara ang nararapat sa pinangalanang spawn_id.

Ang parehong inaasahan at nakikipag-ugnayan ay tiktikan kapag lumabas ang kasalukuyang proseso at halos magsasara, ngunit kung papatayin mo ang proseso sa pamamagitan ng, sabihin, "exec kill $ pid", kailangan mong tahasang tumawag nang malapit .

Tinutukoy ng flag ng -onexec kung ang id ng isda ay sarado sa anumang mga bagong proseso ng pagpapagana o kung ang proseso ay overlayed. Upang mag-iwan ng isang id ng bukang-bukong, gamitin ang halaga 0. Ang isang di-zero na integer na halaga ay pinipilit ang mga itlog ng isda na sarado sa anumang mga bagong proseso.

Isinasara ng flag -llave ang alipin na nauugnay sa spawn id. Kapag ang koneksyon ay sarado, ang alipin ay awtomatikong sarado pati na rin kung bukas pa rin ito.

Hindi mahalaga kung ang koneksyon ay sarado nang sarado o tahasang, dapat kang tumawag ng paghihintay upang i-clear ang katugmang kernel na proseso ng kernel. Ang malapit na utos ay hindi tumawag sa paghihintay dahil walang garantiya na ang pagsasara ng isang koneksyon sa proseso ay magiging dahilan upang lumabas ito.

debug [[-now] 0 | 1]

kumokontrol sa isang Tcl debugger na nagpapahintulot sa iyo na hakbang sa pamamagitan ng mga pahayag at magtakda ng mga breakpoint.

Walang mga argumento, ang isang 1 ay ibabalik kung ang debugger ay hindi tumatakbo, kung hindi, isang 0 ay ibinalik.

Sa isang argumento, nagsimula ang debugger. Sa isang 0 argument, ang debugger ay tumigil. Kung ang isang argumento ay nauna sa pamamagitan ng -nang bandila, ang debugger ay nagsimula kaagad. Kung hindi, ang debugger ay nagsimula sa susunod na pahayag ng Tcl.

Ang utos ng debug ay hindi nagbabago ng anumang mga traps. Ihambing ito sa simula Maghintay sa -D flag.

Ang disconnect command ay nagtatanggal ng isang proseso ng tinidor mula sa terminal . Patuloy itong tumatakbo sa background. Ang proseso ay binibigyan ng sarili nitong pangkat ng proseso. Ang standard I / O ay na-redirect sa / dev / null .

Gumagamit ang sumusunod na fragment na idiskonekta upang magpatuloy na patakbuhin ang script sa background.

kung ang {[fork]! = 0} lumabas sa exit. . .

Ang sumusunod na script ay bumabasa ng isang password at pagkatapos ay nagpapatakbo ng isang programa sa bawat oras na hinihingi ng isang password sa bawat oras na ito ay tumakbo. Nagbibigay ang script ng password upang mayroon ka lamang i-type ito nang isang beses.

ipadala_user "password? \" expect_user -re "(. *) \ n" para sa {} 1 {} {if {[fork]! = 0} {sleep 3600; 1, string) \ r ". . . exit}

Ang isang kalamangan sa paggamit ng pag-disconnect sa shell na tampok na asynchronous na proseso (&) ay ang inaasahan na maaaring i-save ang mga parameter ng terminal bago ang pagtatanggal at pagkatapos ay ilapat ang mga ito sa mga bagong ptys. Sa & amp; Expect ay hindi magkaroon ng pagkakataon na basahin ang mga parameter ng terminal dahil ang terminal ay naka-disconnect ng oras Expect na natatanggap ng kontrol.

exit [-opts] [kalagayan]

nagiging dahilan upang lumabas o maghandang gawin ito.

Ang -onexit flag ay nagiging sanhi ng susunod na argument na gagamitin bilang isang handler sa exit. Kung walang argumento, ang kasalukuyang handler na exit ay ibabalik.

Ang -noexit na bandila ay nagdudulot ng Paghihintay upang maghanda upang lumabas ngunit huminto sa pagbalik ng aktwal na pagbabalik sa operating system. Ang user-defined na handler na exit ay tumatakbo pati na rin ang sariling mga panloob na humahawak ng Expect. Walang karagdagang Mga inaasahang utos ang dapat isagawa. Ito ay kapaki-pakinabang kung tumatakbo ka Maghintay sa iba pang mga extension ng Tcl. Ang kasalukuyang interpreter (at pangunahing window kung nasa kapaligiran ng Tk) ay mananatiling upang ang iba pang mga extension ng Tcl ay malinis. Kung ang exit ng Expit ay tinatawag na muli (gayunpaman ito ay maaaring mangyari), ang mga humahawak ay hindi muling paglilipat.

Sa paglabas, ang lahat ng koneksyon sa mga proseso ng pagsasagawa ay sarado. Ang pagsasara ay napansin bilang isang EOF sa pamamagitan ng mga proseso ng pagsasagawa. Ang exit ay walang iba pang mga pagkilos na lampas sa kung ano ang ginagawa ng normal na _exit (2) pamamaraan. Samakatuwid, ang mga proseso ng pagproseso na hindi nag-check para sa EOF ay maaaring patuloy na tumakbo. (Ang iba't ibang mga kundisyon ay mahalaga sa pagtukoy, halimbawa, kung ano ang mga senyales ng isang proseso na tinatangkilik ay ipapadala, ngunit ang mga ito ay nakasalalay sa sistema, kadalasang dokumentado sa ilalim ng exit (3).) Ang mga naipong proseso na patuloy na tatakbo ay pagmana ng init.

katayuan (o 0 kung hindi tinukoy) ay ibinalik bilang ang exit status ng Expect . exit ay ipinatupad lamang kung ang dulo ng script ay naabot.

exp_continue [-continue_timer]
Ang command exp_continue ay nagbibigay-daan sa asahan mismo na ipagpatuloy ang pag-e-execute sa halip na bumalik gaya ng karaniwan. Sa pamamagitan ng default exp_continue Nire-reset ang timeout timer. Pinipigilan ng flag ng -continue_timer ang timer upang mai-restart. (Tingnan ang inaasahan para sa karagdagang impormasyon.)

exp_internal [-f file] na halaga
nagiging sanhi ng karagdagang mga utos upang magpadala ng diagnostic na impormasyon sa panloob na Maghintay sa stderr kung ang halaga ay hindi zero. Ang output na ito ay hindi pinagana kung ang halaga ay 0. Ang diagnostic na impormasyon ay kinabibilangan ng bawat character na natanggap, at bawat pagtatangka na ginawa upang tumugma sa kasalukuyang output laban sa mga pattern.

Kung ang opsyonal na file ay ibinibigay, ang lahat ng normal at debugging na output ay isinulat sa file na iyon (hindi alintana ang halaga ng halaga ). Anumang naunang diagnostic output file ay sarado.

Ang flag na -info ay nagiging sanhi ng exp_internal upang ibalik ang isang paglalarawan ng pinakahuling argumento na hindi pang impormasyon na ibinigay.

exp_open [args] [-i spawn_id]
Nagbabalik ng isang Tcl file identifier na tumutugma sa orihinal na itlog ng isda id. Pagkatapos ay maaaring gamitin ang tagatukoy ng file bilang kung binuksan ito ng bukas na utos ng Tcl. (Ang id ng spawn ay hindi na dapat gamitin. Ang paghihintay ay hindi dapat isagawa.

Ang -leaveopen flag ay nag-iiwan ng mga spawn id na bukas para sa pag-access sa pamamagitan ng Mga utos na inaasahan. Ang paghihintay ay kailangang isagawa sa id ng itlog.

exp_pid [-i spawn_id]
Nagbabalik ang proseso ng id na nakaayon sa kasalukuyang proseso ng pagpapagana. Kung ang -i flag ay ginagamit, ang pid ay bumalik ay tumutugma sa na ng ibinigay na itlog ng isda id.

exp_send
ay isang alyas para ipadala .

exp_send_error
ay isang alias para sa send_error .

exp_send_log
ay isang alias para sa send_log .

exp_send_tty
ay isang alias para sa send_tty .

exp_send_user
ay isang alias para sa send_user .

exp_version [[-exit] version]
ay kapaki-pakinabang para sa pagtiyak na ang script ay tugma sa kasalukuyang bersyon ng Asahan.

Walang mga argumento, ang kasalukuyang bersyon ng Asahan ay ibinalik. Ang bersyon na ito ay maaaring naka-encode sa iyong script. Kung alam mo talaga na hindi ka gumagamit ng mga tampok ng mga pinakabagong bersyon, maaari mong tukuyin ang isang naunang bersyon.

Ang mga bersyon ay binubuo ng tatlong numero na pinaghihiwalay ng mga tuldok. Una ang pangunahing numero. Ang mga script na isinulat para sa mga bersyon ng Inaasahan na may ibang pangunahing numero ay halos tiyak na hindi gumagana. nagbabalik ang exp_version ng error kung hindi tumutugma ang mga pangunahing numero.

Pangalawa ay ang menor de edad na numero. Ang mga script na isinulat para sa isang bersyon na may mas malaking menor de edad kaysa sa kasalukuyang bersyon ay maaaring depende sa ilang mga bagong tampok at hindi maaaring tumakbo. Ang pagbabalik ng exp_version ay isang error kung tumutugma ang mga pangunahing numero, ngunit ang mas maliit na bilang ng script ay mas malaki kaysa sa pagpapatakbo ng inaasahan .

Ikatlo ay isang numero na walang bahagi sa paghahambing ng bersyon. Gayunpaman, ito ay incremented kapag ang Expect software pamamahagi ay nabago sa anumang paraan, tulad ng sa pamamagitan ng karagdagang mga dokumentasyon o pag-optimize. I-reset ito sa 0 sa bawat bagong menor de edad na bersyon.

Gamit ang -exit na bandila, Maghintay ng mga kopya ng isang error at labasan kung ang bersyon ay wala na sa petsa.

asahan [[-opts] pat1 body1] ... [-opts] patn [bodyn]
naghihintay hanggang sa ang isa sa mga pattern ay tumutugma sa output ng isang spawned na proseso, ang isang tinukoy na tagal ng panahon ay lumipas, o isang end-of-file ay nakikita. Kung ang huling katawan ay walang laman, maaari itong iwanan.

Ang mga pattern mula sa pinakahuling expect_before command ay kaparehong ginagamit bago ang anumang iba pang mga pattern. Ang mga pattern mula sa pinakahuling expect_after na utos ay kaparehong ginagamit pagkatapos ng anumang iba pang mga pattern.

Kung ang mga argumento sa buong pahayag ay nangangailangan ng higit sa isang linya, ang lahat ng mga argumento ay maaaring "braced" sa isa upang maiwasan ang pagwawakas ng bawat linya sa isang backslash. Sa isang kaso na ito, ang karaniwang mga pagkalipol ng Tcl ay magaganap sa kabila ng mga tirante.

Kung ang isang pattern ay ang keyword na eof , ang kaukulang katawan ay papatayin sa dulo ng file. Kung ang isang pattern ay ang timeout ng keyword, ang kaukulang katawan ay isasagawa sa oras ng pag-timeout. Kung walang ginamit na keyword ng timeout, ang isang walang-kapantay na pagkilos na null ay papatupad sa oras ng pag-timeout. Ang tagal ng default na timeout ay 10 segundo ngunit maaaring itakda, halimbawa sa 30, sa pamamagitan ng command na "itakda ang timeout 30". Ang isang walang-katapusang pag-timeout ay maaaring itinalaga ng halaga -1. Kung ang isang pattern ay ang default na keyword, ang kaukulang katawan ay isasagawa sa alinman sa timeout o end-of-file.

Kung ang isang pattern tumutugma, pagkatapos ay ang kaukulang katawan ay naisakatuparan. asahan ang nagbabalik ng resulta ng katawan (o ang walang laman na string kung walang pattern na naitugmang). Sa kaganapan na tumutugma ang maramihang mga pattern, ang unang lumilitaw ay ginagamit upang pumili ng isang katawan.

Sa bawat oras na dumating ang bagong output, ito ay inihambing sa bawat pattern sa pagkakasunud-sunod ng mga ito ay nakalista. Sa gayon, maaari mong subukan ang kawalan ng isang tugma sa pamamagitan ng paggawa ng huling pattern ng isang bagay na garantisadong upang lumitaw, tulad ng isang prompt. Sa mga sitwasyon kung saan walang prompt, kailangan mong gumamit ng timeout (tulad ng gagawin mo kung manu-mano kang nakikipag-ugnayan).

Ang mga pattern ay tinukoy sa tatlong paraan. Bilang default, tinukoy ang mga pattern tulad ng command ng pagtutugma ng Tcl ng string . (Ganitong mga pattern ay katulad din sa C-shell regular expression na karaniwang tinutukoy bilang "glob" pattern). Maaaring magamit ang flag ng -gl upang protektahan ang mga pattern na maaaring tumugma sa inaasahan ng mga flag mula sa paggawa nito. Anumang pattern na nagsisimula sa isang "-" ay dapat protektado sa ganitong paraan. (Lahat ng mga string na nagsisimula sa "-" ay nakalaan para sa mga pagpipilian sa hinaharap.)

Halimbawa, ang sumusunod na fragment ay naghahanap ng isang matagumpay na pag-login. (Tandaan na i- abort ay itinuturing na isang pamamaraan na tinukoy sa ibang lugar sa script.)

asahan (abala {naglalagay abala \ n; exp_continue} Nabigo i-abort ang "hindi wastong password" abort timeout i-abort konektado}

Kinakailangan ang mga panipi sa ikaapat na pattern dahil naglalaman ito ng isang espasyo, na kung saan ay maaaring paghiwalayin ang pattern mula sa pagkilos. Ang mga pattern na may parehong aksyon (tulad ng sa ika-3 at ika-4) ay nangangailangan ng paglilista muli ng mga aksyon. Maaari itong maiwasan sa pamamagitan ng paggamit ng mga estilo ng estilo ng regexp (tingnan sa ibaba). Ang karagdagang impormasyon tungkol sa pagbubuo ng mga pattern ng estilo ng globo ay matatagpuan sa manwal ng Tcl.

Ang mga estilo ng regexp style ay sinusunod ang syntax na tinukoy ng regulasyon ng Tcl (maikli para sa "regular expression") na utos. Ang mga regexp pattern ay ipinakilala sa bandila -re . Ang nakaraang halimbawa ay maaaring muling isinulat gamit ang isang regexp bilang:

asahan (abala {naglalagay abala \ n; exp_continue} -re "failed | invalid password" abort timeout abort konektado}

Ang parehong mga uri ng mga pattern ay "unanchored". Nangangahulugan ito na hindi dapat tumugma ang mga pattern sa buong string, ngunit maaari itong magsimula at tapusin ang tugma sa kahit saan sa string (hangga't lahat ng iba ay tumutugma). Gamitin ^ upang tumugma sa simula ng isang string, at $ upang tumugma sa dulo. Tandaan na kung hindi ka maghintay para sa dulo ng isang string, ang iyong mga tugon ay maaaring madaling end up sa gitna ng string habang ang mga ito ay echoed mula sa proseso ng spawned. Habang gumagawa pa rin ng tamang mga resulta, ang output ay maaaring tumingin hindi natural. Kaya, ang paggamit ng $ ay hinihikayat kung maaari mong eksaktong ilarawan ang mga character sa dulo ng isang string.

Tandaan na sa maraming mga editor, ang ^ at $ ay tumutugma sa simula at dulo ng mga linya ayon sa pagkakabanggit. Gayunpaman, dahil ang inaasahan ay hindi oriented na linya, tumutugma ang mga character na ito sa simula at dulo ng data (kumpara sa mga linya) na kasalukuyang inaasahang buffer matching. (Gayundin, tingnan ang tala sa ibaba sa "hindi pagkatunaw ng sistema.")

Ang -ex flag ay nagiging sanhi ng pattern na maitugma bilang isang "eksaktong" string. Walang pagpapakahulugan ng *, ^, atbp ang ginawa (bagaman ang karaniwang mga convention ng Tcl ay dapat pa rin sundin). Ang mga eksaktong mga pattern ay palaging hindi nakalaan.

Ang -nocase flag ay nagdudulot ng mga uppercase character ng output upang ihambing na kung sila ay maliliit na character. Ang pattern ay hindi apektado.

Habang nagbabasa ng output, higit sa 2000 bytes ang puwersahin ang mga naunang byte na "nakalimutan". Ito ay maaaring mabago gamit ang function match_max . (Tandaan na ang sobrang malalaking halaga ay maaaring makapagpabagal sa pattern matcher.) Kung ang patlist ay full_buffer , ang kaukulang katawan ay papatayin kung natanggap ang match_max bytes at walang iba pang mga pattern na naitugma. Kung ginagamit o hindi ang full_buffer keyword, ang nakalimutan na mga character ay nakasulat sa expect_out (buffer).

Kung ang patlist ay ang null na keyword, at ang nulls ay pinapayagan (sa pamamagitan ng command na remove_nulls ), ang kaukulang katawan ay papatayin kung ang isang solong ASCII 0 ay katugma. Ito ay hindi posible upang tumugma 0 bytes sa pamamagitan ng glob o regexp pattern.

Sa pagtutugma ng isang pattern (o eof o full_buffer), anumang tumutugma at dati walang kaparis na output ay naka-save sa variable na expect_out (buffer) . Hanggang sa 9 na regexp substring match ang naka-save sa variable na expect_out (1, string) sa pamamagitan ng expect_out (9, string) . Kung ang -indices flag ay ginagamit bago ang isang pattern, ang mga panimulang at pangwakas na mga indeks (sa isang form na angkop para sa lrange ) ng 10 mga string ay naka-imbak sa mga variable expect_out (X, simulan) at expect_out (X, katapusan) kung saan ang X ay isang digit, tumutugma sa posisyon ng substring sa buffer. 0 ay tumutukoy sa mga string na tumutugma sa buong pattern at ay binuo para sa mga pattern ng glob pati na rin ang mga pattern ng regexp. Halimbawa, kung ang isang proseso ay gumawa ng output ng "abcdefgh \ n", ang resulta ng:

umasa "cd"

ay parang ang mga sumusunod na pahayag ay naisakatuparan:

set expect_out (0, string) cd set expect_out (buffer) abcd

at "efgh \ n" ay naiwan sa output buffer. Kung ang isang proseso ay gumawa ng output na "abbbcabkkkka \ n", ang resulta ng:

umasa -indices -re "b (b *). * (k +)"

ay parang ang mga sumusunod na pahayag ay naisakatuparan:

set expect_out (0, simulan) 1 set expect_out (0, string) bbbcabkkkk set expect_out (1, simulan) 2 set expect_out (1, (2, simulan) 10 set expect_out (2, katapusan) 10 set expect_out (2, string) k set expect_out (buffer) abbbcabkkkk

at "isang \ n" ay naiwan sa output buffer. Ang pattern na "*" (at -re ". *") Ay mag-flush sa output buffer nang hindi magbabasa ng anumang karagdagang output mula sa proseso.

Karaniwan, ang pinarehang output ay itinapon mula sa mga panloob na buffer ng Expect. Maaaring maiiwasan ito sa pamamagitan ng pag- prefix ng isang pattern sa -notransfer flag. Ang bandila na ito ay lalong kapaki-pakinabang sa pag-eksperimento (at maaaring i-abbreviate sa "-not" para sa kaginhawaan habang eksperimento).

Ang spawn id na nauugnay sa pagtutugma ng output (o eof o full_buffer) ay naka-imbak sa expect_out (spawn_id) .

Ang -timeout flag ay nagiging sanhi ng kasalukuyang inaasahang utos na gamitin ang sumusunod na halaga bilang isang timeout sa halip na gamitin ang halaga ng variable ng timeout.

Sa pamamagitan ng default, ang mga pattern ay naitugma laban sa output mula sa kasalukuyang proseso, subalit ang -i flag ay nagpapahayag ng output mula sa pinangalanang listahan ng spawn_id matugtog laban sa anumang sumusunod na mga pattern (hanggang sa susunod na -i ). Ang lista ng spawn_id ay dapat na isang whitespace separated list ng spawn_ids o isang variable na tumutukoy sa naturang listahan ng spawn_ids.

Halimbawa, naghihintay ang sumusunod na halimbawa ng "konektado" mula sa kasalukuyang proseso, o "abala", "nabigo" o "hindi wastong password" mula sa spawn_id na pinangalanang ng $ proc2.

asahan ang {-i $ proc2 busy {naglalagay ng abala \ n; exp_continue} -re "failed | invalid password" abort timeout abort konektado}

Ang halaga ng global variable any_spawn_id ay maaaring gamitin upang tumugma sa mga pattern sa anumang spawn_ids na pinangalanan sa lahat ng iba pang mga flags ng -i sa kasalukuyang command na inaasahan . Ang spawn_id mula sa isang -i na flag na walang nauugnay na pattern (ibig sabihin, kasunod na agad ng isa pang -i ) ay ginawang magagamit sa anumang iba pang mga pattern sa parehong command na inaasahan na nauugnay sa any_spawn_id.

Ang -i na band ay maaaring pangalanan din ng isang pandaigdigang variable kung saan ang variable ay binabasa para sa isang listahan ng mga elliptical spade. Ang variable ay reread tuwing nagbabago ito. Nagbibigay ito ng isang paraan ng pagbabago ng I / O pinagmulan habang ang utos ay nasa pagpapatupad. Ang mga uhaw na ids na ibinigay sa ganitong paraan ay tinatawag na "di-tuwirang" mga ung-ung ung-ung.

Ang mga pagkilos tulad ng break at magpatuloy ng mga istraktura ng control sanhi (ibig sabihin, para sa , proc ) upang kumilos sa karaniwang paraan. Ang command exp_continue ay nagbibigay-daan sa asahan mismo na ipagpatuloy ang pag-e-execute sa halip na bumalik gaya ng karaniwan.

Ito ay kapaki-pakinabang para sa pag-iwas sa tahasang mga loop o paulit-ulit na inaasahan ng mga pahayag. Ang sumusunod na halimbawa ay bahagi ng isang piraso upang i-automate ang rlogin. Ang exp_continue ay nag- iwas sa pagsulat ng isang pangalawang pahayag (upang hanapin muli ang prompt) kung ang rlogin ay nag-uudyok para sa isang password.

umasa {Password: {stty -echo send_user "password (para sa $ user) sa $ host:" expect_user -re "(. *) \ n" send_user "\ n" send "$ expect_out (1, string) echo exp_continue} hindi tamang {send_user "hindi wastong password o account \ n" exit} Ang timeout ng koneksyon sa 'send_user' sa $ host ay natalo \ n "exit} eo {send_user \" na koneksyon sa host ay nabigo: $ expect_out (buffer) "exit} - muling $ prompt}

Halimbawa, ang sumusunod na fragment ay maaaring makatulong sa gabay ng gumagamit ng pakikipag-ugnayan na ganap na awtomatiko. Sa kasong ito, ang terminal ay inilalagay sa raw mode. Kung pinindot ng gumagamit ang "+", isang variable ay incremented. Kung pinindot ang "p", ang ilang mga pagbalik ay ipinadala sa proseso, marahil ay poket ito sa ilang mga paraan, at "ako" ay nagbibigay-daan sa gumagamit na makipag-ugnay sa proseso, na epektibong pagnanakaw ng kontrol mula sa script. Sa bawat kaso, pinahihintulutan ng exp_continue ang kasalukuyang inaasahan na magpatuloy sa pagtutugma ng pattern pagkatapos maisagawa ang kasalukuyang aksyon.

stty raw -echo expect_after {-i $ user_spawn_id "p" {send "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {nakikipag-ugnayan; exp_continue} "umalis" exit}

Sa pamamagitan ng default, exp_continue Nire-reset ang timeout timer. Ang timer ay hindi na-restart, kung exp_continue ay tinatawag na sa -continue_timer bandila.

expect_after [expect_args]
gumagana nang magkatulad sa inaasahan_sa bago maliban kung ang mga pattern mula sa parehong inaasahan at expect_after ay maaaring tumugma, ang inaasahang pattern ay ginagamit. Tingnan ang expect_before command para sa karagdagang impormasyon.

expect_background [expect_args]
tumatagal ang parehong argumento tulad ng inaasahan , gayunpaman ito ay bumalik kaagad. Sinusubok ang mga pattern tuwing dumating ang bagong input. Ang pattern ng timeout at default ay walang kahulugan sa expect_background at tahimik na itinapon. Kung hindi man, ang expect_background command ay gumagamit ng expect_before at expect_after na mga pattern tulad ng inaasahan .

Kapag sinusuri ang mga aksyon ng expect_background , ang pagpoproseso ng background para sa parehong id ng itlog ay naharang. Naka-unblock ang pagpoproseso ng background kapag nakumpleto ang pagkilos. Habang naka-block ang pagpoproseso ng background, posible na gawin ang isang (foreground) na inaasahan sa parehong id ng itlog ng isda.

Hindi posible na magsagawa ng isang inaasahan habang ang isang expect_background ay naka-unblock. ang expect_background para sa isang partikular na id ng itlog ay tinanggal sa pamamagitan ng pagdeklara ng isang bagong expect_background na may parehong id ng itlog ng isda. Ang pagpapahayag ng expect_background na walang pattern ay nagtatanggal ng ibinigay na id ng spawn mula sa kakayahan upang tumugma sa mga pattern sa background.

expect_before [expect_args]
tumatagal ang parehong argumento tulad ng inaasahan , gayunpaman ito ay bumalik kaagad. Ang mga pares ng pattern ng pagkilos mula sa pinakahuling expect_before na may parehong id ng itlog ay ganap na idinagdag sa anumang sumusunod na mga utos. Kung ang isang pattern ay tumutugma, ito ay itinuturing na kung ito ay tinukoy sa inaasahan na utos mismo, at ang nauugnay na katawan ay naisakatuparan sa konteksto ng inaasahang utos. Kung ang mga pattern mula sa parehong inaasahan_sa bago at inaasahan ay maaaring tumugma, ang pattern ng inaasahan_before ay ginagamit.

Kung walang tinukoy na pattern, ang id ng spawn ay hindi siniyasat para sa anumang mga pattern.

Maliban kung nabagsak ng isang -i na bandila, inaasahang_before tumutugma ang mga pattern laban sa id ng spawn na tinukoy sa oras na ang inaasahan_before command ay naisakatuparan (hindi kapag ang pattern ay naitugmang).

Ang flag ng -info ay nagdudulot ng inaasahan_sa bago upang ibalik ang mga kasalukuyang pagtutukoy kung anong mga pattern ang tutugma nito. Sa pamamagitan ng default, ito ay nag-uulat sa kasalukuyang spawn id. Ang isang opsyonal na spawn id specification ay maaaring ibigay para sa impormasyon sa na itlog ng isda id. Halimbawa

expect_before -info -i $ proc

Sa karamihan ng isang spawn id pagtutukoy ay maaaring ibigay. Ang flag -indirect suppresses direct spawn id na dumating lamang mula sa hindi direktang mga pagtutukoy.

Sa halip ng isang spawn id specification, ang bandila "-all" ay magdudulot ng "-info" na mag-ulat sa lahat ng spawn ids.

Ang output ng bandang -info ay maaaring magamit muli bilang argumento sa inaasahan_sa bago.

expect_tty [expect_args]
ay tulad ng inaasahan ngunit nagbabasa ito ng mga character mula sa / dev / tty (ie mga keystroke mula sa user). Bilang default, ang pagbabasa ay ginaganap sa lutong mode. Kaya, ang mga linya ay dapat magtapos sa isang pagbabalik sa pagkakasunud-sunod upang asahan na makita ang mga ito. Ito ay maaaring mabago sa pamamagitan ng stty (tingnan ang stty command sa ibaba).

expect_user [expect_args]
ay tulad ng inaasahan ngunit bumabasa ito ng mga character mula sa stdin (ie keystroke mula sa user). Bilang default, ang pagbabasa ay ginaganap sa lutong mode. Kaya, ang mga linya ay dapat magtapos sa isang pagbabalik sa pagkakasunud-sunod upang asahan na makita ang mga ito. Ito ay maaaring mabago sa pamamagitan ng stty (tingnan ang stty command sa ibaba).

tinidor
Lumilikha ng isang bagong proseso . Ang bagong proseso ay isang eksaktong kopya ng kasalukuyang inaasahang proseso . Sa tagumpay, ang fork ay babalik 0 sa bagong (anak) na proseso at ibabalik ang ID ng proseso ng proseso ng bata sa proseso ng magulang. Sa kabiguan (karaniwan dahil sa kakulangan ng mga mapagkukunan, halimbawa, swap space, memorya), ang babala ay nagbabalik -1 sa proseso ng magulang, at walang proseso ng anak ay nilikha.

Ang mga proseso sa pag-alis ay lumabas sa pamamagitan ng command na exit , tulad ng orihinal na proseso . Pinapayagan ang mga proseso ng pag-usig upang sumulat sa mga file ng pag-log. Kung hindi mo i-disable ang debugging o pag-log in sa karamihan ng mga proseso, ang resulta ay maaaring nakalilito.

Ang ilang mga pagpapatupad ng pty ay maaaring malito ng maraming mambabasa at manunulat, kahit na ilang sandali. Kung gayon, ito ay pinakaligtas na magaan bago magpalabas ng mga proseso.

makipag-ugnayan [string1 body1] ... [stringn [bodyn]]
ay nagbibigay ng kontrol sa kasalukuyang proseso sa gumagamit, upang ang mga keystroke ay ipapadala sa kasalukuyang proseso , at ang stdout at stderr ng kasalukuyang proseso ay ibinalik.

Ang mga pares ng katawan ay maaaring itukoy bilang mga argumento, kung saan ang katawan ay papatayin kapag ang kaukulang string ay ipinasok. (Sa pamamagitan ng default, ang string ay hindi ipinadala sa kasalukuyang proseso .) Ang utos ng interpreter ay ipinapalagay, kung ang huling katawan ay nawawala.

Kung ang mga argumento sa buong pahayag na nakikipag-ugnayan ay nangangailangan ng higit sa isang linya, ang lahat ng mga argumento ay maaaring "braced" sa isa upang maiwasan ang pagwawakas ng bawat linya sa isang backslash. Sa isang kaso na ito, ang karaniwang mga pagkalipol ng Tcl ay magaganap sa kabila ng mga tirante.

Halimbawa, ang sumusunod na utos ay nakikipag-ugnayan sa mga sumusunod na mga pares ng string-body na tinukoy: Kapag ^ Z ay pinindot, Inaasahan ang inaasahan . (Ang -reset na flag ay nagpapanumbalik ng mga mode ng terminal.) Kapag ^ A ay pinindot, makikita ng user ang "nag-type ka ng isang control-A" at ang proseso ay ipinadala sa isang ^ A. Kapag ang $ ay pinindot, nakikita ng gumagamit ang petsa. Kapag ^ C ay pinindot, Maghintay ng mga labasan. Kung ang "foo" ay ipinasok, nakikita ng gumagamit ang "bar". Kapag pinindot ang ~ ~, ang interpreter ng Expect ay nagpapatakbo nang interactively.

set CTRLZ \ 032 interact {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "nag-type ka ng control-A \ n"; magpadala ng "\ 001"} $ {send_user "Ang petsa ay [format ng orasan [segundo ng segundo]]."} \ 003 exit foo {send_user "bar"} ~~}

Sa mga pares ng string-katawan, ang mga string ay katugma sa pagkakasunud-sunod na nakalista bilang argumento. Ang mga string na bahagyang tumutugma ay hindi ipinapadala sa kasalukuyang proseso sa pag-asam ng natitirang darating. Kung ipinasok ang mga character na kaya't hindi na posibleng maging isang tugma, tanging ang bahagi ng string ay ipapadala sa proseso na hindi maaaring magsimula ng isa pang tugma. Kaya, ang mga string na substrings ng mga bahagyang tugma ay maaaring tumugma sa ibang pagkakataon, kung ang orihinal na mga string na sinusubukan na tumutugma sa huli ay nabigo.

Bilang default, ang pagtutugma ng string ay eksaktong walang mga ligaw na baraha . (Sa kabilang banda, ang inaasahang utos ay gumagamit ng mga pattern ng estilo ng globo bilang default.) Ang -ex na band ay maaaring magamit upang protektahan ang mga pattern na maaaring tumugma sa mga nakikipag-ugnayan na flag mula sa paggawa nito. Anumang pattern na nagsisimula sa isang "-" ay dapat protektado sa ganitong paraan. (Lahat ng mga string na nagsisimula sa "-" ay nakalaan para sa mga pagpipilian sa hinaharap.)

Ang -re flag ay nagpapalakas ng string na ipakahulugan bilang isang estilo ng estilo ng regexp. Sa kasong ito, ang pagtutugma ng mga substrip ay naka-imbak sa variable na interact_out katulad sa inaasahan ng mga tindahan sa output nito sa variable na expect_out . Ang -index flag ay sinusuportahan din.

Ang pattern eof introduces isang aksyon na naisakatuparan sa end-of-file. Ang isang magkahiwalay na pattern ng eof ay maaari ding sundin ang -output na bandang kung saan ito ay naitugma kung ang isang e-detected ay nakikita habang nagsusulat ng output. Ang default na aksyon ay "bumalik", kaya ang pakikipag - ugnayan ay nagbalik lamang sa anumang EOF.

Ang pattern ng timeout ay nagpapakilala ng isang timeout (sa ilang mga segundo) at pagkilos na naisakatuparan pagkatapos ng walang mga character na nabasa para sa isang naibigay na oras. Nalalapat ang pattern ng timeout sa pinakahuling tinukoy na proseso . Walang default na timeout. Ang espesyal na variable na "timeout" (ginagamit ng inaasahang utos) ay hindi nakakaapekto sa oras na ito.

Halimbawa, ang sumusunod na pahayag ay maaaring magamit sa mga gumagamit ng autologout na hindi nag-type ng anumang bagay sa loob ng isang oras ngunit sino pa ring nakakakuha ng madalas na mga mensahe ng system:

nakikipag-ugnayan -input $ user_spawn_id timeout 3600 return -output \ $ spawn_id

Kung ang pattern ay ang null na keyword, at nulls ay pinapayagan (sa pamamagitan ng command na remove_nulls ), ang kaukulang katawan ay papatayin kung ang isang solong ASCII 0 ay katugma. Ito ay hindi posible upang tumugma 0 bytes sa pamamagitan ng glob o regexp pattern.

Ang prefacing ng isang pattern na may bandila - ang sanhi ng variable na interact_out (spawn_id) upang itakda sa spawn_id na tumutugma sa pattern (o eof).

Ang mga pagkilos tulad ng break at magpatuloy ng mga istraktura ng control sanhi (ibig sabihin, para sa , proc ) upang kumilos sa karaniwang paraan. Gayunpaman ang pagbabalik ay nagiging sanhi ng pakikipag-ugnayan upang bumalik sa tumatawag nito, habang ang inter_return ay nagiging sanhi ng pakikipag - ugnay upang maging sanhi ng isang pagbalik sa tumatawag nito. Halimbawa, kung tinatawag na "proc foo" na nakikipag-ugnayan na pagkatapos ay isagawa ang pagkilos na inter_return , ang proc foo ay babalik. (Nangangahulugan ito na kung nakikipag-ugnayan ang interpreter ng tawag na interactive na pag-type ng return ay magpapatuloy ang pakikipag-ugnayan, habang ang inter_return ay magiging sanhi ng pakikipag-ugnay upang bumalik sa tumatawag nito.)

Sa panahon ng pakikipag-ugnayan , ginagamit ang hilaw na mode upang ang lahat ng mga character ay maipasa sa kasalukuyang proseso . Kung ang kasalukuyang proseso ay hindi nakakuha ng mga signal control ng trabaho, ito ay titigil kung nagpadala ng stop signal (sa pamamagitan ng default ^ Z). Upang i-restart ito, magpadala ng isang patuloy na signal (tulad ng sa pamamagitan ng "kill -CONT"). Kung gusto mo talagang magpadala ng isang SIGSTOP sa ganitong proseso (sa pamamagitan ng ^ Z), isaalang-alang muna ang pagtatanim ng csh at pagkatapos ay patakbuhin ang iyong programa. Sa kabilang banda, kung nais mong magpadala ng isang SIGSTOP sa Expect mismo, unang tawag interpreter (marahil sa pamamagitan ng paggamit ng isang escape character), at pagkatapos ay pindutin ang ^ Z.

Ang mga pares ng katawan ay maaaring gamitin bilang isang takigrapya para sa pag-iwas sa pagpasok sa interpreter at magsagawa ng mga utos na interactively. Ang nakaraang terminal mode ay ginagamit habang ang katawan ng isang pares ng string-katawan ay pinaandar.

Para sa bilis, ang mga pagkilos ay gumanap sa raw mode bilang default. Ang -reset na flag resets ang terminal sa mode na ito bago makipag - ugnay ay naisakatuparan (walang paltos, luto na mode). Tandaan na ang mga character na ipinasok kapag ang mode ay inililipat ay maaaring mawawala (isang kapus-palad na tampok ng terminal driver sa ilang mga system). Ang tanging dahilan upang gamitin -reset ay kung ang iyong pagkilos ay nakasalalay sa pagtakbo sa lutong mode.

Nagpapadala ang flag ng -echo ng mga character na tumutugma sa sumusunod na pattern pabalik sa proseso na nakabuo ng mga ito habang binabasa ang bawat karakter. Maaaring ito ay kapaki-pakinabang kapag ang gumagamit ay kailangang makakita ng feedback mula sa mga bahagyang naka-type na mga pattern.

Kung ang isang pattern ay echoed ngunit sa huli ay hindi tumutugma, ang mga character ay ipinadala sa proseso ng spawned. Kung ang proseso ng spawned pagkatapos ay magpahid sa kanila, makikita ng user ang mga character nang dalawang beses. Maaaring angkop lamang ang -echo sa mga sitwasyon kung saan ang gumagamit ay malamang na hindi makumpleto ang pattern. Halimbawa, ang sumusunod na sipi ay mula sa rftp, ang recursive-ftp script, kung saan ang user ay sinenyasan na pumasok sa ~ g, ~ p, o ~ l, upang makuha, ilagay, o i-lista ang kasalukuyang direktoryo nang recursively. Ang mga ito ay napakalayo mula sa mga normal na ftp na utos, na ang gumagamit ay malamang na hindi i-type ~ sinundan ng anumang bagay, maliban sa pagkakamali, kung saan, malamang na hindi nila papansinin ang resulta.

makipag-ugnayan {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}

Ang -nobuffer flag nagpapadala ng mga character na tumutugma sa sumusunod na pattern sa sa proseso ng output habang binabasa ang mga character.

Ito ay kapaki-pakinabang kapag nais mong hayaan ang isang programa echo back ang pattern. Halimbawa, ang mga sumusunod ay maaaring gamitin upang subaybayan kung saan ang isang tao ay pag-dial (isang estilo Hayes-estilo). Sa bawat oras na "atd" ay nakikita ang script log ang natitirang bahagi ng linya.

(), (), (), (), (), (), ()

Sa panahon ng pakikipag-ugnay , ang nakaraang paggamit ng log_user ay binabalewala. Sa partikular, ang pakikipag-ugnayan ay pinipilit ang output nito na ma-log (ipinadala sa karaniwang output) dahil ito ay itinuturing na ang user ay hindi nais na makipag-ugnayan nang walang taros.

Ang -o flag ay nagiging sanhi ng anumang sumusunod na mga pares ng key-katawan na ilalapat sa output ng kasalukuyang proseso . Ito ay maaaring maging kapaki-pakinabang, halimbawa, kapag ang pakikitungo sa mga host na nagpapadala ng mga hindi gustong character habang nasa isang sesyon ng telnet.

Sa pamamagitan ng default, nakikipag-ugnayan ang Inaasahan ng gumagamit na magsulat stdin at pagbabasa stdout ng proseso ng Asahan mismo. Ang -u flag (para sa "user") ay nakikipag-ugnayan sa pagtingin sa gumagamit bilang proseso na pinangalanan sa pamamagitan ng argument nito (na dapat ay isang spawned id).

Pinapayagan nito ang dalawang hindi nauugnay na mga proseso upang maisama nang hindi gumagamit ng isang tahasang loop. Upang tulungan ang pag-debug, palaging ang mga diagnostic na pumunta sa stderr (o stdout para sa ilang impormasyon sa pag-log at pag-debug). Sa parehong dahilan, ang interpreter command ay magbabasa nang interactively mula sa stdin.

Halimbawa, ang sumusunod na fragment ay lumilikha ng proseso sa pag- login. Pagkatapos ay naka-dial ang user (hindi ipinapakita), at sa wakas ay nag-uugnay sa dalawa nang magkasama. Siyempre, ang anumang proseso ay maaaring mapalitan para sa pag-login. Ang isang shell, halimbawa, ay magpapahintulot sa gumagamit na magtrabaho nang walang supplying isang account at password.

i-spawn login set login $ spawn_id spawn tip modem # i-dial out sa user # connect user upang mag-login makipag-ugnay -u $ login

Upang magpadala ng output sa maramihang mga proseso, ilista ang bawat listahan ng id ng itlog ng isinalin na prefaced ng isang -output na bandila. Ang input para sa isang pangkat ng mga output spawn id ay maaaring matukoy ng isang listahan ng itlog ng isda id na prefaced ng isang -input na bandila. (Parehong -input at -output ay maaaring tumagal ng mga listahan sa parehong anyo ng -i flag sa inaasahang utos, maliban na ang any_spawn_id ay hindi makabuluhan sa pakikipag-ugnay .) Ang lahat ng sumusunod na mga flag at string (o mga pattern) ay nalalapat sa input na ito hanggang sa isa pa - Lumilitaw ang flag ng input. Kung walang lumalabas, ipinapakita ng -output ang "-input $ user_spawn_id -output". (Katulad nito, may mga pattern na walang -input .) Kung tinukoy ang isang -input , binabaluktot nito ang $ user_spawn_id. Kung tinukoy ang ikalawang -input , binabawasan nito ang $ spawn_id. Maaaring tinukoy ang karagdagang mga flag ng impormas.

Ang dalawang ipinahiwatig na mga proseso ng input ay default sa pagkakaroon ng kanilang mga output na tinukoy bilang $ spawn_id at $ user_spawn_id (sa reverse). Kung ang isang -input na bandila ay lilitaw na walang -output na bandila, ang mga character mula sa prosesong iyon ay itinapon.

Ang -i flag ay nagpapakilala ng isang kapalit para sa kasalukuyang spawn_id kapag walang iba pang mga -input o -output na mga flag ang ginagamit. Ang bandang A -i ay nagpapahiwatig ng isang -o bandila.

Posible na baguhin ang mga proseso na nakikipag-ugnayan sa pamamagitan ng paggamit ng mga di-tuwirang mga ung-ung. (Hindi direktang mga ungib ids ay inilarawan sa seksyon sa inaasahan na utos.) Ang mga di-tuwirang mga ungib na ungay ay maaaring tinukoy sa -i, -u, -input, o -output na mga flag.

interpreter [args]
nagiging sanhi ng interactively ang user na na-prompt para sa mga inaasahan at Tcl utos. Ang resulta ng bawat utos ay nakalimbag.

Ang mga pagkilos tulad ng break at magpatuloy ng mga istraktura ng control sanhi (ibig sabihin, para sa , proc ) upang kumilos sa karaniwang paraan. Gayunpaman bumalik nagiging sanhi ng interpreter upang bumalik sa tumatawag nito, habang inter_return nagiging sanhi ng interpreter upang maging sanhi ng isang bumalik sa tumatawag nito. Halimbawa, kung tinatawag na "proc foo" ang interpreter na pagkatapos ay isagawa ang pagkilos inter_return , ang proc foo ay babalik. Ang anumang iba pang utos ay nagiging sanhi ng interpreter upang ipagpatuloy ang pagdikta para sa mga bagong utos.

Bilang default, ang prompt ay naglalaman ng dalawang integer. Inilalarawan ng unang integer ang lalim ng pagsusuri stack (ibig sabihin, ilang beses na tinatawag na Tcl_Eval). Ang pangalawang integer ay ang Tcl history identifier. Ang prompt ay maaaring itakda sa pamamagitan ng pagtukoy sa isang pamamaraan na tinatawag na "prompt1" na ang halaga ng pagbabalik ay nagiging susunod na prompt. Kung ang isang pahayag ay may bukas na mga panipi, parens, braces, o braket, isang pangalawang prompt (sa pamamagitan ng default na "+>") ay ibinibigay sa newline. Ang pangalawang prompt ay maaaring itakda sa pamamagitan ng pagtukoy ng isang pamamaraan na tinatawag na "prompt2".

Sa panahon ng interpreter , ginagamit ang luto na mode, kahit na ang tumatawag nito ay gumagamit ng hilaw na mode.

Kung ang stdin ay sarado, ang interpreter ay babalik maliban kung ang ginamit na bandila, kung saan ang kasunod na argument ay ginagamit.

log_file [args] [[-a] file]
Kung ang isang filename ay ibinigay, ang log_file ay magtatala ng isang transcript ng session (simula sa puntong iyon) sa file. Ang log_file ay titigil sa pagtatala kung walang ibinigay na argumento. Anumang nakaraang log file ay sarado.

Sa halip na isang filename, ang isang Tcl file identifier ay maaaring ipagkaloob sa pamamagitan ng paggamit ng -open o -leaveopen na mga flag. Ito ay katulad ng command spawn . (Tingnan ang mga itlog ng isda para sa higit pang impormasyon.)

Ang -isang flag pwersa output na naka-log na pinigilan ng log_user command.

Sa pamamagitan ng default, ang log_file command ay nagdadagdag sa mga lumang file sa halip na i-truncate ang mga ito, para sa kaginhawahan na i-off ang pag-log off at sa maraming beses sa isang sesyon. Upang i-truncate ang mga file, gamitin ang -nagdagdag ng bandila.

Ang flag ng -info ay nagdudulot ng log_file upang ibalik ang isang paglalarawan ng pinakahuling argumentong hindi pang impormasyon na ibinigay.

log_user -info | 0 | 1
Sa pamamagitan ng default, ang ipadala / asahan ang dialog ay naka-log sa stdout (at isang logfile kung bukas). Ang pag-log sa stdout ay hindi pinagana ng command na "log_user 0" at muling na-enable sa pamamagitan ng "log_user 1". Ang pag-log sa logfile ay hindi nagbabago.

Ang flag ng -info ay nagiging sanhi ng log_user upang ibalik ang isang paglalarawan ng pinakahuling argumento na hindi pang impormasyon na ibinigay.

match_max [-d] [-i spawn_id] [size]
tumutukoy sa laki ng buffer (sa bytes) na ginagamit sa loob sa pamamagitan ng inaasahan . Na walang sukat na argumento, ang kasalukuyang laki ay ibinalik.

Gamit ang -d na bandila, ang default na laki ay nakatakda. (Ang unang default ay 2000.) Gamit ang -i bandila, ang sukat ay nakatakda para sa pinangalanang id ng itlog ng isda, kung hindi man ito nakatakda para sa kasalukuyang proseso .

overlay [- # spawn_id] [- # spawn_id] [...] program [args]
executes "program args" sa lugar ng kasalukuyang programa ng inaasahan , na tinatapos. Ang isang hubad na argument ng hyphen ay nagtutulak ng isang gitling sa harap ng pangalan ng command na parang ito ay isang shell ng pag-login. Lahat ng spawn_ids ay sarado maliban sa mga pinangalanan bilang argumento. Ang mga ito ay naka-map sa mga pinangalang mga pagkakakilanlan ng file.

Ang Spawn_ids ay nai-map upang mag-file ng mga pagkakakilanlan para sa pagmamay-ari ng bagong programa. Halimbawa, ang sumusunod na linya ay nagpapatakbo ng chess at pinahihintulutan itong kontrolin ng kasalukuyang proseso - halimbawa, isang master ng chess.

overlay -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id chess

Ito ay mas mahusay kaysa sa "nakikipag-ugnayan -u", gayunpaman, ito ay nagsasakripisyo ng kakayahang magawa ang pakikipag-ugnayan na na-program dahil hindi na kontrol ang proseso ng inaasahan .

Tandaan na walang ipinagkakaloob na pagkontrol ng terminal. Kung gayon, kung tatanggalin mo o palitawin ang karaniwang input, ang mga program na gumagawa ng kontrol sa trabaho (mga shell, pag-login, atbp) ay hindi gagana ng maayos.

pagkakapare-pareho [-d] [-i spawn_id] [halaga]
ay tumutukoy kung ang parity ay dapat manatili o mabubunot mula sa output ng mga proseso ng spawned. Kung ang halaga ay zero, ang parity ay nakuha, kung hindi, ito ay hindi nakuha. Nang walang argumento halaga , ang kasalukuyang halaga ay ibinalik.

Sa bandang -d , ang halaga ng default na parity ay nakatakda. (Ang unang default ay 1, ibig sabihin, ang parity ay hindi nakuha.) Sa pamamagitan ng -i flag, ang parity value ay nakatakda para sa pinangalanang id ng isda, kung hindi man ito nakatakda para sa kasalukuyang proseso .

remove_nulls [-d] [-i spawn_id] [value]
ay tumutukoy kung ang mga null ay napananatili o inalis mula sa output ng mga proseso ng spawned bago ang pagtutugma ng pattern o pag-iimbak sa variable na expect_out o interact_out . Kung ang halaga ay 1, nulls ay aalisin. Kung ang halaga ay 0, nulls ay hindi tinanggal. Nang walang argumento halaga , ang kasalukuyang halaga ay ibinalik.

Gamit ang -d na bandila, ang default na halaga ay nakatakda. (Ang unang default ay 1, ibig sabihin, nulls ay inalis.) Gamit ang -i flag, ang halaga ay nakatakda para sa pinangalanang id ng isda, kung hindi man ito nakatakda para sa kasalukuyang proseso .

Kung tinanggal o hindi ang nulls, aasahan ang mga inaasahang null bytes sa log at stdout.

magpadala ng [-flags] na string
Nagpapadala ng string sa kasalukuyang proseso . Halimbawa, ang utos

magpadala ng "kumusta sa mundo"

nagpapadala ng mga character, helloworld sa kasalukuyang proseso . (Tcl nagsasama ng isang printf -tulad ng command (tinatawag na format ) na maaaring bumuo ng mga arbitrarily kumplikadong mga string.)

Ang mga character ay agad na ipinadala kahit na ang mga program na may input ng line-buffered ay hindi magbabasa ng mga character hanggang sa ipadala ang return character. Ang isang return character ay tinutukoy na "\ r".

Ang - flag na pwersa ang susunod na argumento na ipakahulugan bilang isang string sa halip na isang bandila. Anumang string ay maaaring mauna sa pamamagitan ng "-" kung ito man ay talagang mukhang isang bandila. Nagbibigay ito ng isang maaasahang mekanismo upang tukuyin ang mga variable na mga string nang hindi nasaktan ng mga hindi sinasadyang hitsura ng mga flag. (Lahat ng mga string na nagsisimula sa "-" ay nakalaan para sa mga pagpipilian sa hinaharap.)

Ipinapahayag ng flag na -i na ang string ay ipapadala sa pinangalanang spawn_id. Kung ang spawn_id ay user_spawn_id , at ang terminal ay nasa hilaw na mode, ang mga bagong linya sa string ay isinalin upang bumalik-bagong mga pagkakasunud-sunod ng linya upang lumitaw ang mga ito kung ang terminal ay nasa lutong mode. Hindi pinapagana ng flag ng karayom ang pagsasalin na ito.

Ang -null na flag ay nagpapadala ng null characters (0 bytes). Bilang default, ang isang null ay ipinadala. Ang isang integer ay maaaring sundin ang -null upang ipahiwatig kung gaano karaming mga nulls upang magpadala.

Ang bumagsak na bandila ay bumubuo ng kondisyon ng pahinga. Ito lamang ang makatuwiran kung ang spawn id ay tumutukoy sa isang tty device na binuksan sa pamamagitan ng "spawn -open". Kung nagsagawa ka ng isang proseso tulad ng tip, dapat mong gamitin ang tip ng kombensyon para sa pagbuo ng pahinga.

Ang mga pwersa ng pwersa ng bandila ay ipapadala na "dahan-dahan", kaya maiiwasan ang karaniwang sitwasyon kung saan ang isang computer outtype ng isang input buffer na idinisenyo para sa isang tao na hindi kailanman ay maaaring i-type ang parehong buffer . Ang output na ito ay kinokontrol ng halaga ng variable na "send_slow" na kumukuha ng dalawang listahan ng elemento. Ang unang elemento ay isang integer na naglalarawan ng bilang ng mga byte upang magpadala ng atomically. Ang ikalawang sangkap ay isang tunay na numero na naglalarawan ng bilang ng mga segundo kung saan ang atomic na nagpapadala ay dapat na pinaghiwalay. Halimbawa, "itakda ang send_slow {10 .001}" ay puwersahin "magpadala -s" upang magpadala ng mga string na may 1 millisecond sa pagitan ng bawat 10 character na ipinadala.

Ang -h flag pwersa output ay ipapadala (medyo) tulad ng isang tao na aktwal na pag-type. Lumilitaw sa pagitan ng mga character ang mga tao tulad ng mga pagkaantala. (Ang algorithm ay batay sa isang pamamahagi Weibull, na may mga pagbabago upang umangkop sa partikular na application.) Ang output na ito ay kinokontrol ng halaga ng variable na "send_human" na kumukuha ng limang listahan ng elemento. Ang unang dalawang elemento ay karaniwang interarrival na oras ng mga character sa ilang segundo. Ang una ay ginagamit bilang default. Ang pangalawa ay ginagamit sa mga endings ng salita, upang gayahin ang mga mahiwagang pag-pause na paminsan-minsan ay nangyari sa naturang mga transisyon. Ang ikatlong parameter ay isang sukatan ng pagkakaiba-iba kung saan .1 ay lubos na variable, 1 ay makatwirang variable, at 10 ay medyo invariable. Ang sobra ay 0 hanggang infinity. Ang huling dalawang parameter ay, ayon sa pagkakabanggit, isang minimum at maximum na interarrival na oras. Ang pinakamaliit at pinakamataas na ginamit sa huling at "clip" sa huling oras. Ang sukdulang average ay maaaring maging lubos na naiiba mula sa ibinigay na average kung ang minimum at maximum na clip sapat na halaga.

Bilang halimbawa, ang sumusunod na utos ay nagpapalabas ng mabilis at pare-pareho na typist:

itakda send_human {.1 .3 1 .05 2} magpadala -h "Ako ay nagugutom.

habang ang mga sumusunod ay maaaring maging mas angkop pagkatapos ng hangover:

itakda ang send_human {.4 .4 .2 .5 100} magpadala -h "Goodd party nightmare night!"

Tandaan na ang mga error ay hindi kunwa, bagaman maaari mong i-set up ang iyong mga sitwasyon ng pagwawasto ng error sa pamamagitan ng pag-embed ng mga pagkakamali at pagwawasto sa isang ipadala na argumento.

Ang mga bandila para sa pagpapadala ng mga character na null, para sa pagpapadala ng mga break, dahil sa pagpilit ng mabagal na output at para sa output ng estilo ng tao ay eksklusibo. Tanging ang tinukoy na huling gagamitin. Higit pa rito, walang argumento ng string na maaaring tinukoy sa mga flag para sa pagpapadala ng null character o break.

Mahusay na ideya na mauna ang unang ipadala sa isang proseso sa inaasahan . asahan ang maghihintay para magsimula ang proseso , habang hindi maaaring magpadala . Sa partikular, kung ang unang ipadala ay makumpleto bago tumakbo ang proseso ay tumatakbo, pinatatakbo mo ang panganib na ang iyong data ay hindi pinansin. Sa mga sitwasyon kung saan ang mga interactive na programa ay nag-aalok ng walang paunang prompt, maaari mong mauna magpadala ng pagkaantala gaya sa:

# Upang maiwasan ang pagbibigay ng mga pahiwatig ng hack sa kung paano masira, # hindi pinapansin ng system na ito ang isang panlabas na password. # Maghintay ng 5 segundo para sa exec upang makumpleto ang mga itlog ng isda telnet very.secure.gov matulog 5 magpadala ng password \ r

Ang exp_send ay isang alyas para ipadala. Kung gumagamit ka ng Expectk o iba pang variant ng Expect sa kapaligiran Tk, ipadala ang tinukoy ng Tk para sa isang ganap na magkaibang layunin. Ang exp_send ay ibinigay para sa pagiging tugma sa pagitan ng mga kapaligiran. Ang mga katulad na alyansa ay ibinibigay para sa iba pang mga utos na ipinadala ng iba pang inaasahan.

send_error [-flags] string
ay tulad ng ipadala , maliban na ang output ay ipinadala sa stderr sa halip na ang kasalukuyang proseso .

send_log [-] string
ay tulad ng ipadala , maliban na ang string ay ipinadala lamang sa log file (tingnan log_file .) Ang mga argumento ay hindi pinansin kung walang log file ay bukas.

send_tty [-flags] string
ay tulad ng ipadala , maliban na ang output ay ipinadala sa / dev / tty sa halip na ang kasalukuyang proseso .

send_user [-flags] string
ay tulad ng ipadala , maliban na ang output ay ipinadala sa stdout sa halip na sa kasalukuyang proseso .

mga segundo ng pagtulog
nagiging sanhi ng pagtulog ng script para sa ibinigay na bilang ng mga segundo. Ang mga segundo ay maaaring isang decimal na numero. Ang mga interrupts (at ang mga kaganapan sa Tk kung gumagamit ka ng Expectk) ay naproseso habang inaasahang matutulog.

spawn [args] program [args]
Lumilikha ng isang bagong proseso na tumatakbo sa "program args". Ang stdin, stdout at stderr nito ay konektado sa Inaasahan, upang maaari silang basahin at isulat ng iba pang Mga utos na inaasahan . Ang koneksyon ay nasira sa pamamagitan ng malapit o kung ang proseso mismo magsasara ng alinman sa mga file identifier.

Kapag ang isang proseso ay nagsimula sa pamamagitan ng mga itlog ng isda , ang variable na spawn_id ay nakatakda sa isang tagapaglarawan na tumutukoy sa prosesong iyon. Ang proseso na inilarawan sa spawn_id ay itinuturing na "kasalukuyang proseso ". Ang spawn_id ay maaaring basahin o nakasulat, sa bisa ng pagkontrol ng trabaho.

Ang user_spawn_id ay isang pandaigdigang variable na naglalaman ng isang tagapaglarawan na tumutukoy sa gumagamit. Halimbawa, kapag ang spawn_id ay nakatakda sa halagang ito, inaasahan ang mga behaves tulad ng expect_user .

. Ang error_spawn_id ay isang pandaigdigang variable na naglalaman ng isang tagapaglarawan na tumutukoy sa karaniwang error. Halimbawa, kapag ang spawn_id ay nakatakda sa halagang ito, magpadala ng mga behaves tulad ng send_error .

Ang tty_spawn_id ay isang pandaigdigang variable na naglalaman ng isang tagapaglarawan na tumutukoy sa / dev / tty. Kung ang / dev / tty ay hindi umiiral (tulad ng sa isang cron, sa, o batch script), pagkatapos ay hindi tinukoy ang tty_spawn_id . Ito ay maaaring masuri bilang:

kung ang {[info vars tty_spawn_id]} {# / dev / tty exists} else {# / dev / tty does not exist # probably in cron, batch, or at script}

ibinalik muli ang UNIX process id. Kung walang proseso ay tinutukoy, 0 ay ibinalik. Ang variable na spawn_out (alipin, pangalan) ay nakatakda sa pangalan ng aparatong pty na alipin.

Bilang default, ang mga spawn ay nagpapahiwatig ng command name at argumento. Ang -noecho flag hihinto ang itlog ng isda mula sa paggawa nito.

Ang flag na -console ay nagiging sanhi ng console output upang i-redirect sa proseso ng spawned. Hindi ito sinusuportahan sa lahat ng mga sistema.

Sa panloob, ang mga spawn ay gumagamit ng isang pty, sinimulan sa parehong paraan tulad ng tty ng gumagamit. Ito ay karagdagang nasimulan upang ang lahat ng mga setting ay "maliwanag" (ayon sa stty (1)). Kung ang variable na stty_init ay tinukoy, ito ay binigyang-kahulugan sa estilo ng mga argumento ng stty bilang karagdagang pagsasaayos. Halimbawa, "itakda ang stty_init raw" ay magdudulot ng karagdagang mga terminal ng proseso ng pagsisimula upang magsimula sa raw mode. -nottycopy skips ang initialization batay sa tty ng gumagamit. -nottyinit skips ang "sane" initialization.

Karaniwan, ang mga itlog ng isda ay tumatagal ng kaunting oras upang maisagawa. Kung napansin mo ang mga itlog ng isda na kumukuha ng isang malaking halaga ng oras, marahil ito ay nakakaranas ng mga ptys na maipit. Ang isang bilang ng mga pagsubok ay pinapatakbo sa mga ptys upang maiwasan ang mga pagkakasalungat sa mga maling proseso. (Ang mga ito ay tumagal ng 10 segundo sa bawat wedged pty.) Ang Running Expect na may -d option ay magpapakita kung ang inaasahan ay nakatagpo ng maraming mga ptys sa mga kakaibang estado. Kung hindi mo mapapatay ang mga proseso kung saan naka-attach ang mga ito, maaaring mag-reboot ang iyong tanging paraan.

Kung ang programa ay hindi maaaring matagumpay na maisagawa dahil ang exec (2) ay nabigo (halo kapag wala ang programa ), isang mensahe ng error ay ibabalik ng susunod na nakikipag-ugnayan o umasa ng command na kung ang program ay tumakbo at gumawa ng mensahe ng error bilang output. Ang pag-uugali na ito ay isang likas na resulta ng pagpapatupad ng mga itlog ng isda . Sa panloob, nagtatapon ng mga tinidor, pagkatapos ay ang paraan ng pagsasalita ay walang paraan upang makipag-usap sa orihinal na proseso ng inaasahan maliban sa komunikasyon sa pamamagitan ng spawn_id.

Ang -open na flag ang nagiging sanhi ng susunod na argumento upang mabigyang-kahulugan bilang Tcl file identifier (ibig sabihin, ibinalik sa pamamagitan ng bukas .) Ang spawn id ay maaaring magamit bilang kung ito ay isang proseso ng spawned. (Hindi dapat gamitin ang tagatukoy ng file.) Hinahayaan ka nitong gamutin ang mga raw na device, file, at pipeline bilang mga proseso ng pagpapagana nang hindi gumagamit ng pty. 0 ay ibinalik upang ipahiwatig walang nauugnay na proseso . Kapag ang koneksyon sa proseso ng isinasagawa ay sarado, gayon din ang Tcl file identifier. Ang -leaveopen na bandila ay katulad sa -pagbukas maliban na -leveopen nagiging sanhi ng file identifier na iniwan bukas kahit na pagkatapos ng spawn id ay sarado.

Ang -pty flag ay nagiging sanhi ng isang pty na mabubuksan ngunit walang proseso ang nagsanay. 0 ay ibinalik upang ipahiwatig walang nauugnay na proseso . Ang Spawn_id ay nakatakda gaya ng dati.

Ang variable spawn_out (alipin, fd) ay naka-set sa isang file identifier na naaayon sa pty alipin. Maaari itong sarado gamit ang "close -slave".

Ang -ignore na bandila ay nagsasabing isang senyas na hindi papansinin sa proseso ng pagsasagawa. Kung hindi man, ang mga signal ay makakakuha ng default na pag-uugali. Ang mga senyas ay pinangalanan bilang nasa utos ng bitag , maliban na ang bawat senyas ay nangangailangan ng isang hiwalay na bandila.

antas ng strace
nagiging sanhi ng mga sumusunod na pahayag na ipi-print bago maisakatuparan. (Sinusubaybay ng mga bakas ng Tcl ang mga variable ng variable.) Ang antas ay nagpapahiwatig kung gaano kalayo pababa sa tawag na stack upang sumubaybay. Halimbawa, ang sumusunod na command ay tumatakbo sa inaasahan habang sinusubaybayan ang unang 4 na antas ng mga tawag, ngunit wala sa ibaba iyon.

asahan -c "strace 4" script.exp

Ang flag ng -info ay nagiging sanhi ng strace upang ibalik ang isang paglalarawan ng pinakahuling mga argumentong hindi pang impormasyon na ibinigay.

stty args
nagbabago ang mga terminal mode katulad sa panlabas na command stty.

Sa pamamagitan ng default, ang kontroladong terminal ay na-access. Ang iba pang mga terminal ay maaaring ma-access sa pamamagitan ng pagdagdag ng "Mga kahilingan para sa katayuan na ibalik ito bilang resulta ng utos. Kung walang katayuan ay hiniling at ang pagkontrol ng terminal ay na-access, ang nakaraang katayuan ng raw at echo na mga katangian ay ibinalik sa isang anyo na maaaring mamaya ginamit ng utos.

Halimbawa, ang raw argumento o ang mga argumento ay ilagay ang terminal sa hilaw na mode. Ang mga pangangatwiran- lutong o lutong ilagay ang terminal sa lutong mode. Ang mga argumento echo at -echo ay ilagay ang terminal sa echo at noecho mode ayon sa pagkakabanggit.

Ang sumusunod na halimbawa ay nagpapakita kung paano pansamantala huwag paganahin ang pag-echo. Magagamit ito sa kung hindi man-awtomatikong mga script upang maiwasan ang pag-embed ng mga password sa mga ito. (Tingnan ang higit pang diskusyon dito sa ilalim ng EXPECT HINTS sa ibaba.)

stty -echo send_user "Password:" expect_user -re "(. *) \ n" magtakda ng password $ expect_out (1, string) stty echo

sistema args
nagbibigay ng args sa sh (1) bilang input, tulad ng kung ito ay nai-type bilang isang command mula sa isang terminal. Inaasahan na maghintay hanggang matapos ang shell. Ang katayuan ng pagbalik mula sa sh ay hinahawakan sa parehong paraan na pinangasiwaan ng exec ang katayuan ng pagbalik nito.

Sa kaibahan sa exec na nagre-redirect sa stdin at stdout sa script, ang system ay gumaganap ng walang pag-redirect (bukod sa ipinahiwatig ng string mismo). Kaya, posible na gumamit ng mga program na dapat direktang makipag-usap sa / dev / tty. Sa parehong dahilan, ang mga resulta ng sistema ay hindi naitala sa log.

timestamp [args]
nagbabalik ng isang timestamp. Walang mga argumento, ang bilang ng mga segundo mula noong panahon ay ibinalik.

Ang -format na bandila ay nagpapakilala ng isang string na ibinalik ngunit may mga pamalit na ginawa ayon sa mga panuntunan ng POSIX para sa strftime. Halimbawa% a ay pinalitan ng isang abbreviated na pangalan sa araw ng linggo (ibig sabihin, Sat). Ang iba ay:

% a buong pangalan ng araw na pang-araw-araw% Buong pangalan ng araw ng linggo% b maikling pangalan ng buwan% B buong pangalan ng buwan% c petsa-oras tulad ng: Wed Oct 6 11:45:56 1993% d araw ng buwan (01-31% H oras (00-23)% Oras ko (01-12)% j araw (001-366)% m buwan (01-12)% M minuto (00-59)% p am o pm% S second (00-61) % u araw (1-7, Lunes ay unang araw ng linggo)% U linggo (00-53, unang Linggo ay unang araw ng linggo isa)% V linggo (01-53, ISO 8601 estilo)% w araw (0- 6)% W linggo (00-53, unang Lunes ay unang araw ng linggo isa)% x petsa-oras tulad ng sa: Wed Oktubre 6 1993% X oras tulad ng sa: 23:59:59% y taon (00-99) % Y taon tulad ng sa: 1993% Z timezone (o wala kung hindi matutukoy) %% isang hubad na porsyento ng pag-sign

Ang iba pang mga pagtutukoy sa% ay hindi natukoy. Ang iba pang mga character ay mapasa sa pamamagitan ng hindi nagalaw. Ang lokal na C ay sinusuportahan lamang.

Ang -seconds flag ay nagpapakilala ng ilang mga segundo dahil ang epoch ay gagamitin bilang isang mapagkukunan kung saan mag-format. Kung hindi, ang kasalukuyang oras ay ginagamit.

Ang -gmt bandila pwersa pwersa ng timestamp upang gamitin ang GMT timezone. Na walang bandila, ginagamit ang lokal na timezone.

bitag [[command] signal]
nagiging sanhi ng ibinigay na utos na isasagawa sa hinaharap na pagtanggap ng alinman sa mga ibinigay na signal. Ang utos ay isinasagawa sa pandaigdigang saklaw. Kung ang utos ay wala, ang pagkilos ng signal ay ibinalik. Kung ang command ay ang string SIG_IGN, ang mga signal ay hindi pinansin. Kung ang command ay ang string SIG_DFL, ang mga signal ay resulta sa default ng system. Ang signal ay alinman sa isang solong signal o isang listahan ng mga signal. Ang mga senyas ay maaaring tinukoy ayon sa bilang o simbolo ayon sa signal (3). Maaaring tanggalin ang prefix na "SIG".

Na walang mga argumento (o ang argument -number), ang bitag ay nagbabalik sa numero ng signal ng command na bitag na kasalukuyang pinapatupad.

Ang -code na flag ay gumagamit ng return code ng command sa lugar ng anumang code na Tcl ay tungkol sa upang bumalik kapag ang command na orihinal na nagsimula na tumatakbo.

Ang flag na -interp ay nagiging sanhi ng command na masuri gamit ang interpreter na aktibo sa oras na nagsimula ang command na tumakbo sa halip na kapag ipinahayag ang bitag.

Ang flag ng -name ay nagiging sanhi ng utos ng bitag upang ibalik ang pangalan ng signal ng bitbit na utos na kasalukuyang pinapatakbo.

Ang -max flag ay nagiging sanhi ng bitag command upang ibalik ang pinakamalaking numero ng signal na maaaring itakda.

Halimbawa, ang utos na "bitag {send_user" Ouch! "} SIGINT" ay mag-print "Ouch!" sa bawat oras na ang gumagamit ay nagpindot ^ C.

Sa pamamagitan ng default, SIGINT (na kadalasan ay maaaring mabuo sa pamamagitan ng pagpindot ^ C) at SIGTERM sanhi Maghintay upang lumabas. Ito ay dahil sa mga sumusunod na bitag, na nilikha bilang default kapag nagsisimula ang inaasahan.

bitag exit {SIGINT SIGTERM}

Kung gagamitin mo ang -D na bandila upang simulan ang debugger, muling tinukoy ang SIGINT upang simulan ang interactive debugger. Ito ay dahil sa sumusunod na bitag:

bitag {exp_debug 1} SIGINT

Ang bitag ng debugger ay maaaring mabago sa pamamagitan ng pagtatakda ng variable ng kapaligiran na EXPECT_DEBUG_INIT sa isang bagong command na bitag.

Maaari mong, siyempre, i-override ang parehong mga ito sa pamamagitan lamang ng pagdaragdag ng mga utos ng bitag sa iyong script. Sa partikular, kung mayroon kang sariling "bitag na lumabas sa SIGINT", ito ay sasaputin ang bitag ng debugger. Ito ay kapaki-pakinabang kung nais mong pigilan ang mga gumagamit na makarating sa debugger sa lahat.

Kung nais mong tukuyin ang iyong sariling bitag sa SIGINT ngunit pa rin bitag sa debugger kapag ito ay tumatakbo, gamitin ang:

kung {! [exp_debug]} {bitag na mystuff SIGINT}

Bilang kahalili, maaari mong bitag sa debugger gamit ang ilang iba pang signal.

ang bitag ay hindi magbibigay-daan sa iyo na i-override ang pagkilos para sa SIGALRM dahil ginagamit ito sa loob sa Inaasahan . Ang command ng pag-disconnect ay nagtatakda ng SIGALRM sa SIG_IGN (huwag pansinin). Maaari mong muling paganahin ito hangga't hindi mo pinagana ito sa mga sumusunod na mga command spawn.

Tingnan ang signal (3) para sa higit pang impormasyon.

maghintay [args]
Ang mga pagkaantala hanggang sa isang proseso ng tinutukoy (o ang kasalukuyang proseso kung wala ay pinangalanan) ay tinatapos.

maghintay ng normal na nagbabalik ng isang listahan ng apat na integer. Ang unang integer ay ang pid ng proseso na hinintay. Ang pangalawang integer ay ang katumbas na id ng spawn. Ang ikatlong integer ay -1 kung naganap ang isang error sa operating system, o kung hindi man. Kung ang ikatlong integer ay 0, ang ika-apat na integer ay ang katayuan na ibinalik ng proseso ng tinutukoy. Kung ang ikatlong integer ay -1, ang ika-apat na integer ay ang halaga ng errno na itinakda ng operating system. Ang global variable errorCode ay nakatakda rin.

Ang mga karagdagang elemento ay maaaring lumitaw sa dulo ng halaga ng pagbabalik mula sa paghihintay . Isang opsyonal na ikalimang sangkap ang nagpapakilala sa isang uri ng impormasyon. Sa kasalukuyan, ang tanging posibleng halaga para sa sangkap na ito ay CHILDKILLED kung saan ang susunod na dalawang halaga ay ang pangalan ng signal ng C-estilo at maikling paglalarawan ng teksto.

Ang -i flag ay nagdedeklara ng proseso upang maghintay kaayon sa pinangalanang spawn_id (HINDI ang proseso id). Sa loob ng isang handler ng SIGCHLD, posible na maghintay para sa anumang proseso ng spawned sa pamamagitan ng paggamit ng mga itlog ng isda id -1.

Ang -nowait flag ay nagiging sanhi ng paghihintay upang bumalik kaagad sa pahiwatig ng isang matagumpay na paghihintay. Kapag lumabas ang proseso (mamaya), awtomatiko itong mawawala nang hindi nangangailangan ng isang tahasang paghihintay.

Ang command na paghihintay ay maaari ring magamit ng paghihintay para sa isang proseso ng tinidor gamit ang mga argumento "-i -1". Hindi tulad ng paggamit nito sa mga proseso ng spawned, ang utos na ito ay maaaring isagawa sa anumang oras. Walang kontrol kung aling proseso ang aani. Gayunpaman, maaaring i-check ang halaga ng pagbalik para sa proseso ng id.

MGA LIBRARYA

Awtomatikong inaasahan ang inaasahan tungkol sa dalawang built-in na mga aklatan para sa Mga script ng inaasahan. Ang mga ito ay tinukoy ng mga direktoryo na pinangalanang sa mga variable exp_library at exp_exec_library. Ang parehong ay sinadya upang maglaman ng mga utility na mga file na maaaring magamit sa pamamagitan ng iba pang mga script.

Ang exp_library ay naglalaman ng mga file na independiyenteng arkitektura. Ang exp_exec_library ay naglalaman ng mga file na umaasa sa arkitektura. Depende sa iyong system, ang parehong mga direktoryo ay maaaring ganap na walang laman. Ang pagkakaroon ng file $ exp_exec_library / cat-buffers ay naglalarawan kung ang iyong / bin / cat buffers sa pamamagitan ng default.

Pag-print ng PRETTY

Ang isang kahulugan ng vgrind ay magagamit para sa pretty-printing Expect scripts. Ipagpalagay na ang kahulugan ng vgrind na ibinigay sa pamamahagi ng inaasahan ay na-install nang tama, maaari mo itong gamitin bilang:

vgrind -lexpect file

MGA HALIMBAWA

Maraming hindi maliwanag kung paano magkasama ang lahat ng bagay na inilalarawan ng pahina ng tao . Hinihikayat ko kayo na basahin at subukan ang mga halimbawa sa halimbawa ng pamamahagi ng inaasahang pamamahagi. Ang ilan sa kanila ay mga tunay na programa. Ang iba ay nakapagpapakita lamang ng ilang mga diskarte, at siyempre, ang ilang ay mabilis na mga hack lamang. Ang INSTALL na file ay may mabilis na pangkalahatang-ideya ng mga programang ito.

Ang mga inaasahang papeles (tingnan ang MAKITA din) ay kapaki-pakinabang din. Habang ang ilang mga papeles ay gumagamit ng syntax na naaayon sa naunang mga bersyon ng Asahan, ang mga kasamang rationales ay may-bisa pa at mas maraming detalye kaysa sa pahinang ito ng tao.

CAVEATS

Maaaring sumalungat ang mga extension sa mga pangalan ng command ng Expect. Halimbawa, ang pagpapadala ay tinukoy ng Tk para sa isang ganap na magkaibang layunin. Para sa kadahilanang ito, ang karamihan sa mga umasa ng mga utos ay magagamit din bilang "exp_XXXX". Ang mga utos at mga variable na nagsisimula sa "exp", "inter", "spawn", at "timeout" ay walang mga alias. Gamitin ang mga pinalawak na pangalan ng command kung kailangan mo ang pagkakatugma sa pagitan ng mga kapaligiran.

Ang pag-asa ay tumatagal ng isang mas liberal na pagtingin sa scoping. Sa partikular, ang mga variable na binabasa ng mga utos na tiyak sa programa ng Inaasahan ay hahanapin muna mula sa lokal na saklaw, at kung hindi natagpuan, sa pandaigdigang saklaw. Halimbawa, pinipigilan nito ang pangangailangan na ilagay ang "global timeout" sa bawat pamamaraan na isinulat mo na gumagamit ng inaasahan . Sa kabilang banda, ang mga variable na nakasulat ay laging nasa lokal na saklaw (maliban kung ang isang "pandaigdigang" utos ay inilabas). Ang pinaka-karaniwang problema na sanhi nito ay kapag ang mga itlog ng isda ay pinaandar sa isang pamamaraan. Sa labas ng pamamaraan, ang spawn_id ay hindi na umiiral, kaya ang proseso ng pang- spawned ay hindi na ma-access dahil lang sa scoping. Magdagdag ng isang "global spawn_id" sa gayong pamamaraan.

Kung hindi mo maaaring paganahin ang multispawning na kakayahan (ibig sabihin, ang iyong system ay sumusuporta sa alinman sa piliin ang (BSD *. *), Poll (SVR> 2), o isang bagay na katumbas), Maghintay lamang magagawang makontrol ang isang solong proseso sa isang pagkakataon. Sa kasong ito, huwag susubukan na magtakda ng spawn_id , o hindi mo dapat ipatupad ang mga proseso sa pamamagitan ng exec habang tumatakbo ang isang proseso ng spawned. Bukod dito, hindi mo magagawang asahan mula sa maraming proseso (kabilang ang user bilang isa) sa parehong oras.

Ang mga parameter ng terminal ay maaaring magkaroon ng malaking epekto sa mga script. Halimbawa, kung ang isang script ay nakasulat upang hanapin ang pag-echo, ito ay magkakamali kapag naka-off ang echoing. Para sa kadahilanang ito, asahan ang mga pwersa ng mga parameter ng sane na default ng default. Sa kasamaang palad, ito ay maaaring gumawa ng mga bagay na hindi kanais-nais para sa iba pang mga programa. Bilang isang halimbawa, nais ng mga emacs shell na baguhin ang "karaniwan" na mga mappings: ang mga bagong linya ay nakamtan sa mga bagong linya sa halip na mga bagong linya ng carriage-return, at hindi pinagana ang echoing. Pinapayagan nito ang isa na gumamit ng mga emac upang i-edit ang input line. Sa kasamaang palad, hindi inaasahan ng inaasahan na ito.

Maaari mong hilingin na ang Expect ay hindi ma-override ang default na setting ng mga parameter ng terminal, ngunit kailangang maingat ka sa pagsulat ng mga script para sa gayong mga kapaligiran. Sa kaso ng mga emacs, iwasan depende sa mga bagay tulad ng echoing at end-of-line mappings.

Ang mga utos na tumanggap ng mga argumento na itinatag sa isang listahan (ang mga inaasahan na variant at nakikipag - ugnayan ) ay gumagamit ng heuristic upang magpasiya kung ang listahan ay talagang isang argument o marami. Ang heuristic ay maaaring mabigo lamang sa kaso kapag ang listahan ay aktwal na kumakatawan sa isang solong argumento na may maraming naka-embed na \ n sa mga di-whitespace character sa pagitan nila. Ito ay tila sapat na hindi maari, gayunpaman ang argumento "-nobrace" ay maaaring gamitin upang pilitin ang isang solong argumento na hawakan bilang isang solong argumento. Maaaring magamit ito sa pag-asa ng code na inaasahan ng makina. Sa katulad na paraan, ang isang puwersa ay nagtutulak ng isang argument na hawakan bilang maramihang mga pattern / pagkilos.

BUGS

Ito ay talagang kaakit-akit na pangalanan ang "sex" na programa (para sa alinman sa "Smart EXec" o "Send-EXPect"), ngunit may kabuluhan (o marahil lamang Puritanismo) ang napananaigan.

Sa ilang mga sistema, kapag ang isang shell ay tinutukoy, nagrereklamo ito tungkol sa hindi ma-access ang tty ngunit tumatakbo pa rin. Nangangahulugan ito na ang iyong system ay may isang mekanismo para sa pagkakaroon ng pagkontrol ng tty na hindi inaasahan ng Expect . Mangyaring alamin kung ano ito, at ipadala sa akin ang impormasyong ito.

Ang Ultrix 4.1 (hindi bababa sa mga pinakabagong bersyon sa paligid dito) ay isinasaalang-alang ang mga timeout sa itaas 1000000 upang maging katumbas ng 0.

Ang Digital UNIX 4.0A (at marahil iba pang mga bersyon) ay tumangging maglaan ng ptys kung tinutukoy mo ang isang handler ng SIGCHLD. Tingnan ang pahinang grantpt para sa higit pang impormasyon.

Ang IRIX 6.0 ay hindi hawakan ang mga pahintulot ng pty nang wasto upang kung ang inaasahang pagtatangka upang maglaan ng isang pty na dati nang ginagamit ng ibang tao, nabigo ito. Mag-upgrade sa IRIX 6.1.

Ang Telnet (napatunayan lamang sa ilalim ng SunOS 4.1.2) ay nakabitin kung ang TERM ay hindi nakatakda. Ito ay isang problema sa ilalim ng cron, at sa cgi script, na hindi tumutukoy sa TERM. Kaya, kailangan mong itakda ito nang malinaw - kung anong uri ang karaniwang hindi nauugnay. Kailangan lang itong itakda sa isang bagay! Ang mga sumusunod ay marahil ay sapat para sa karamihan ng mga kaso.

set env (TERM) vt100

Tip (na napatunayan lamang sa ilalim ng BSDI BSD / OS 3.1 i386) ay nag-hang kung ang SHELL at HOME ay hindi nakatakda. Ito ay isang problema sa ilalim ng cron , at sa cgi script, na hindi tumutukoy sa mga variable ng kapaligiran. Kaya, dapat mong itakda ang mga ito nang tahasang - kung anong uri ang kadalasang hindi nauugnay. Kailangan lang itong itakda sa isang bagay! Ang mga sumusunod ay marahil ay sapat para sa karamihan ng mga kaso.

set env (SHELL) / bin / sh set env (HOME) / usr / local / bin

Ang ilang mga pagpapatupad ng ptys ay dinisenyo upang ang kernel throws ang layo ng anumang hindi pa nababasa na output pagkatapos ng 10 hanggang 15 segundo (aktwal na numero ay depende sa pagpapatupad) pagkatapos na sarado na ang proseso ng file descriptor. Kaya Maghintay ng mga programa tulad ng

umasa ng petsa ng pagtulog 20 inaasahan

mabibigo. Upang maiwasan ito, tumawag sa mga di-interactive na programa na may exec kaysa sa mga itlog ng isda . Habang ang mga sitwasyong ito ay maaaring maipakita, sa pagsasanay ay hindi ko nakatagpo ang isang sitwasyon kung saan ang huling output ng isang tunay na interactive na programa ay mawawala dahil sa pag-uugali na ito.

Sa kabilang banda, ang Cray UNICOS ptys ayusin ang anumang hindi pa nababasa na output kaagad pagkatapos na sarado na ang proseso ng file descriptor. Ako ay iniulat ito sa Cray at sila ay nagtatrabaho sa isang pag-aayos.

Kung minsan ang isang pagkaantala ay kinakailangan sa pagitan ng isang prompt at isang tugon, tulad ng kapag ang isang tty interface ay nagbabago ang mga setting ng UART o pagtutugma ng mga baud rate sa pamamagitan ng paghanap ng mga start / stop bits. Karaniwan, ang lahat ng ito ay nangangailangan ay ang pagtulog para sa isang segundo o dalawa. Ang isang mas mahusay na pamamaraan ay upang muling subukan hanggang sa ang hardware ay handa na upang makatanggap ng input. Ang sumusunod na halimbawa ay gumagamit ng parehong estratehiya:

magpadala ng "bilis 9600"; matulog 1 asahan {timeout {send "\ r"; exp_continue} $ prompt}

Ang bitag -code ay hindi gagana sa anumang utos na nakaupo sa loop ng kaganapan ng Tcl, tulad ng pagtulog. Ang problema ay na sa loop ng kaganapan, Tinatanggal ng Tcl ang mga return code mula sa mga handler ng kaganapan ng async. Ang isang workaround ay upang magtakda ng bandila sa code ng bitag. Pagkatapos ay suriin agad ang bandila pagkatapos ng utos (ibig sabihin, matulog).

Ang expect_background command ignores -timeout arguments at walang konsepto ng timeouts sa pangkalahatan.

& # 34; EXPECT HINTS & # 34;

Mayroong ilang mga bagay tungkol sa Inaasahan na maaaring hindi madaling maunawaan. Ang seksyon na ito ay nagtatangkang tugunan ang ilan sa mga bagay na ito na may ilang mga mungkahi.

Ang isang karaniwang inaasahang problema ay kung paano makilala ang mga senyas ng shell. Dahil ang mga ito ay naiiba na naiiba sa pamamagitan ng iba't ibang mga tao at iba't ibang mga shell, maaaring maging mahirap automating rlogin mahirap na walang alam ang prompt. Ang isang makatwirang kombensyon ay ang magkaroon ng mga gumagamit ng tindahan ng isang regular na expression na naglalarawan ng kanilang prompt (lalo na, ang dulo ng ito) sa kapaligiran variable EXPECT_PROMPT. Maaaring gamitin ang code na tulad ng sumusunod. Kung wala ang EXPECT_PROMPT, ang code ay may magandang pagkakataon na gumana nang wasto.

set prompt "(% | # | \\ $) $"; # default prompt catch {set prompt $ env (EXPECT_PROMPT)} expect -re $ prompt

Hinihikayat ko kayong sumulat ng mga inaasahang mga pattern na kasama ang katapusan ng anumang inaasahan ninyong makita. Naiwasan nito ang posibilidad ng pagsagot sa isang tanong bago makita ang buong bagay. Bilang karagdagan, habang maaari mong sagutin ang mga tanong bago makita ang mga ito nang buo, kung masagot mo nang maaga, ang iyong sagot ay maaaring lumitaw na muli sa gitna ng tanong. Sa ibang salita, ang nagreresultang dialogo ay magiging tama ngunit ang hitsura ng pag-uusap.

Kasama sa karamihan ng mga senyas ang isang espasyo ng character sa dulo. Halimbawa, ang prompt mula sa ftp ay 'f', 't', 'p', '>' at. Upang tumugma sa prompt na ito, dapat mong i-account ang bawat isa sa mga character na ito. Karaniwang pagkakamali na huwag isama ang blangko. Ilagay ang blangko nang tahasan.

Kung gumagamit ka ng isang pattern ng form X *, ang * ay tutugma sa lahat ng output na natanggap mula sa dulo ng X sa huling bagay na natanggap. Ang tunog ay madaling maunawaan ngunit maaaring medyo nakakalito dahil ang pariralang "huling bagay na natanggap" ay maaaring mag-iba depende sa bilis ng computer at sa pagpoproseso ng I / O kapwa ng kernel at driver ng aparato.

Sa partikular, ang mga tao ay may posibilidad na makita ang output ng programa na darating sa malaking mga chunks (atomically) kapag sa katunayan ang karamihan sa mga programa ay gumagawa ng output ng isang linya sa isang pagkakataon. Sa pag-aakala na ito ang kaso, ang * sa pattern ng nakaraang talata ay maaaring tumugma lamang sa dulo ng kasalukuyang linya kahit na mukhang higit pa, dahil sa oras ng tugma na ang lahat ng output na natanggap.

asahan ay walang paraan ng pag-alam na ang karagdagang output ay darating maliban kung ang iyong pattern partikular na account para dito.

Kahit na depende sa buffering na nakatuon sa linya ay hindi mabuti. Hindi lamang ang mga programa ay bihirang gumawa ng mga pangako tungkol sa uri ng buffering na ginagawa nila, ngunit ang sistema ng hindi pagkatunaw ng pagkain ay maaaring masira ang mga linya ng output upang ang mga linya ay lumalabag sa tila mga random na lugar. Kaya, kung maaari mong ipahayag ang huling ilang mga character ng isang prompt kapag pattern ng pagsulat, ito ay matalino na gawin ito.

Kung ikaw ay naghihintay para sa isang pattern sa huling output ng isang programa at ang programa ay nagpapalabas ng isang bagay sa halip, hindi mo magagawang makita na may timeout keyword. Ang dahilan dito ay ang pag- asa ay hindi pag-timeout - sa halip ay makakakuha ito ng isang pahiwatig. Gamitin iyon sa halip. Kahit na mas mabuti, gamitin ang pareho. Sa ganoong paraan kung ang linyang iyon ay palipat-lipat sa paligid, hindi mo na kailangang i-edit ang linya mismo.

Ang mga bagong linya ay kadalasang na-convert sa carriage return, mga linefeed sequence kapag ang output ng terminal driver. Kaya, kung nais mo ang isang pattern na tahasang tumutugma sa dalawang linya, mula sa, sabihin, printf ("foo \ nbar"), dapat mong gamitin ang pattern na "foo \ rbar".

Ang isang katulad na pagsasalin ay nangyayari kapag nagbabasa mula sa user, sa pamamagitan ng expect_user . Sa kasong ito, kapag pinindot mo ang pagbabalik, i-translate ito sa isang bagong linya. Kung Inaasahan pagkatapos ay ipinapasa na sa isang programa na nagtatakda ng terminal nito sa hilaw na mode (tulad ng telnet), magkakaroon ng problema, habang ang programa ay umaasa sa isang tunay na pagbabalik. (Ang ilang mga programa ay tunay na mapagpatawad dahil awtomatiko nilang isasalin ang mga bagong linya upang bumalik, ngunit ang karamihan ay hindi.) Sa kasamaang palad, walang paraan upang malaman na ang isang programa ay ilagay ang terminal nito sa hilaw na mode.

Sa halip na manwal na palitan ang mga bagong linya ng mga pagbalik, ang solusyon ay ang paggamit ng command na "stty raw", na hihinto sa pagsasalin. Gayunman, tandaan na nangangahulugan ito na hindi ka na makakakuha ng lutok na mga tampok sa pag-edit ng linya.

nakikipag-ugnayan nang tahasan na nagtatakda ng iyong terminal sa hilaw na mode upang ang problemang ito ay hindi babangon pagkatapos.

Madalas itong kapaki-pakinabang upang mag-imbak ng mga password (o iba pang pribadong impormasyon) sa Mga script ng inaasahan . Hindi ito inirerekomenda dahil ang anumang bagay na nakaimbak sa isang computer ay madaling kapitan ng pag-access ng sinuman. Kaya, ang interactively pagdikta para sa mga password mula sa isang script ay isang mas matalinong ideya kaysa sa pagpapasok ng mga ito nang literal. Gayunpaman, kung minsan ang pag-embed na ito ay ang tanging posibilidad.

Sa kasamaang palad, ang UNIX file system ay walang direktang paraan ng paglikha ng mga script na maaaring maipapatupad ngunit hindi mababasa. Ang mga system na sumusuporta sa mga script ng setgid shell ay maaaring di-tuwirang gayahin ito bilang mga sumusunod:

Lumikha ng script na inaasahan (na naglalaman ng lihim na data) gaya ng dati. Gawin ang mga pahintulot nito ay 750 (-rwxr-x ---) at pagmamay-ari ng isang pinagkakatiwalaang grupo, ibig sabihin, isang grupo na pinapayagan na basahin ito. Kung kinakailangan, lumikha ng isang bagong grupo para sa layuning ito. Susunod, lumikha ng script na / bin / sh na may mga pahintulot na 2751 (-rwxr-s - x) na pag-aari ng parehong grupo tulad ng dati.

Ang resulta ay isang script na maaaring isagawa (at basahin) ng sinuman. Kapag hilingin, pinapatakbo nito ang script na inaasahan .

& # 34; TINGNAN ALAMIN & # 34;

Tcl (3), libexpect (3)
"Exploring Expect: A Tcl-Based Toolkit for Automating Interactive Programs" ni Don Libes, pp. 602, ISBN 1-56592-090-2, O'Reilly and Associates, 1995.
"Inaasahan: Pagmamalas ng Mga Walang Kontrolable na Tama ng Interactivity" ni Don Libes, Mga Pamamaraan ng Tag-init 1990 USENIX Conference, Anaheim, California, Hunyo 11-15, 1990.
. "Paggamit ng inaasahan sa Pag-automate ng Mga Gawain sa Pangangasiwa ng System" ni Don Libes, Mga Pagpapatuloy ng 1990 USENIX Malaking Pag-install ng Mga Sistema ng Pangangasiwa ng Kumperensya, Colorado Springs, Colorado, Oktubre 17-19, 1990.
. "Tcl: Isang Naka-embed na Wika ng Paaralan" ni John Ousterhout, Mga Pamamaraan ng Taglagas 1990 USENIX Conference, Washington, DC, Enero 22-26, 1990 ... "Ako ay umaasa: Mga Script para sa Pagkontrol ng mga Interactive Program" ni Don Libes, Computing Systems , Vol. 4, No. 2, Press Journal ng Unibersidad ng California, Nobyembre 1991 .. "Pagsusuri sa Pag-uusisa at Pagsasaayos ng Pagsusuri sa Interactive Program", ni Don Libes, Mga Pamamaraan ng Tag-init 1992 Conference ng USENIX, pp. 135-144, San Antonio, TX, Hunyo 12-15, 1992 .. Ako "Kibitz - Pagkonekta ng Maramihang Interactive Programs Magkasama", ni Don Libes, Software - Practice & Karanasan, John Wiley & Sons, West Sussex, England, Vol.

23, No. 5, May, 1993 .. "Isang Debugger para sa Tcl Applications", ni Don Libes, Mga Pamamaraan ng 1993 Tcl / Tk Workshop, Berkeley, CA, Hunyo 10-11, 1993.

AUTHOR

Don Libes, National Institute of Standards and Technology

MGA KUWENTA

Salamat sa John Ousterhout para sa Tcl, at Scott Paisley para sa inspirasyon. Salamat sa Rob Savoye para sa Autoconfiguration code ng inaasahan.

Ang HISTORY file ay nagsasabing halos lahat ng ebolusyon ng inaasahan . Ginagawa itong kawili-wiling pagbabasa at maaaring magbigay sa iyo ng karagdagang pananaw sa software na ito. Salamat sa mga taong binanggit dito na nagpadala sa akin ng mga pag-aayos ng bug at nagbigay ng ibang tulong.

Ang disenyo at pagpapatupad ng Expect ay binayaran para sa bahagi ng gobyerno ng US at samakatuwid nasa pampublikong domain. Gayunpaman ang may-akda at NIST ay gusto ng credit kung ang program at dokumentasyon o mga bahagi ng mga ito ay ginagamit.