Az Expect egy olyan program, amely más szkriptnek megfelelő interaktív programokkal beszél. A forgatókönyv után az Expect tudja, mi várható a programtól, és mi a helyes válasz. Az értelmezett nyelv elágazó és magas szintű vezérlő struktúrákat biztosít a párbeszéd irányításához. Ezenkívül a felhasználó közvetlenül átveheti a vezérlést, és közvetlenül is léphet kapcsolatba egymással, majd visszaadhatja a parancsfájlt.
Az Expectk az Expect és a Tk keveréke. Úgy viselkedik, mint az Expect és a Tk kívánsága. A várakozás közvetlenül felhasználható a C vagy a C ++ -re is a Tcl nélkül.
Az "Expect" név az uucp, kermit és egyéb modemvezérlési programok által népszerűsített send / expect szekvenciák ötletéből származik. Ugyanakkor az uucp-tól eltérően az Expect általános, így felhasználó-szintű parancsként futtatható bármilyen program és feladat szem előtt tartásával. A várakozás egyszerre több programkal is beszélhet.
Mit várhat el?
Például itt vannak olyan dolgok, amelyeket az elvárt parancs tehet:
- Hagyja a számítógépet, hogy tárcsázzon, így be tud jelentkezni anélkül, hogy fizetne a hívásért.
- Indítsa el a játékot, és ha az optimális konfiguráció nem jelenik meg, akkor újra és újra indítsa újra), amíg meg nem történik, majd adja át az irányítást.
- Az fsck futtatásával válaszoljon az "igen" vagy a "nem" válaszra, vagy válaszoljon rá, előre meghatározott kritériumok alapján.
- Csatlakozzon egy másik hálózathoz, és automatikusan behívja az e-mailt úgy, hogy úgy tűnjön, mintha eredetileg a helyi rendszerbe lenne elküldve.
- Tartalmazza a környezeti változókat, az aktuális könyvtárat vagy bármilyen információt az rlogin, a telnet, a tip, a su vagy a chgrp
Számos oka van annak, hogy a shell nem tudja elvégezni ezeket a feladatokat. Minden lehetséges az Expect-tal.
Az Expect általában olyan programok futtatására használható, amelyek a program és a felhasználó közötti interakciót igénylik. Minden, ami szükséges, hogy az interakció programozhatóan jellemezhető. Az elvárás a felhasználó számára is visszaadhatja a vezérlést anélkül, hogy megállítaná a programot. Hasonlóképpen a felhasználó bármikor visszaadhatja a vezérlést a szkripthez.
Használat
Várja, hogy cmdfile-t olvas a végrehajtandó parancsok listájához. A várakozás implicit módon hívható fel a #! jelölést a parancsfájl futtathatóként való megjelölésével és az első sorral a szkriptben:
#! / usr / local / bin / expect -fTermészetesen az útvonalnak pontosan meg kell határoznia, hogy hol várható az élet. / usr / local / bin csak egy példa.
A -c flag előtagolja a végrehajtandó parancsot, mielőtt a parancsfájlba kerülne. A parancsot idézni kell, hogy megakadályozza a héj megtörését. Ez az opció többször is használható. Több parancs végrehajtható egy -c-vel, ha pontosvesszővel elválasztja őket. A parancsok a sorrendben kerülnek végrehajtásra. Az Expectk használata esetén ez a beállítás -command.
A -d zászló lehetővé teszi a diagnosztikai kimeneteket, amelyek elsősorban olyan parancsok belső aktivitását jelentik, mint például a várakozás és az interakció. Ez a jelző ugyanazt a hatást érti, mint az "exp_internal 1" egy Expect szkript elején, valamint az Expect verziója.
A -D flag lehetővé teszi az interaktív hibakeresőt. Egy egész számot kell követnie. A hibakereső átveszi a vezérlést a következő Tcl eljárás előtt, ha az érték nem nulla, vagy ha a ^ C megnyomása, vagy egy töréspont megérinti, vagy más megfelelő hibakereső parancs jelenik meg a szkriptben. Az Expectk használata esetén ez az opció a következőképpen van megadva: - Debug.
A -f zászló előtagolja azt a fájlt, amelyről parancsokat olvashat. Maga a zászló nem kötelező, mivel csak a #! jelölést, hogy más argumentumokat is megadhasson a parancssorban. Az Expectk használatakor ez a beállítás -file.
Alapértelmezés szerint a parancsfájl a memóriába kerül, és teljes egészében végrehajtásra kerül. Időnként kívánatos egy sorban fájlok olvasása. Annak érdekében, hogy a tetszőleges fájlokat ilyen módon kezelje, használja a -b zászlót. Az Expectk használata esetén ez a beállítás -buffer.
Ha a "-" karakterláncot filenévként adja meg, akkor a szabványos bemenetet olvassa el. Használja a "./-" fájlt a "-" nevű fájlból.
A -i zászló elvárja, hogy interaktívan kérje a parancsokat, ahelyett, hogy egy fájlt olvasna. A kérés a kilépési parancson vagy az EOF-en keresztül ér véget. A -i flag akkor feltételezhető, ha sem parancsfájl, sem -c nem használatos. Az Expectk használatakor ez az opció interaktív.
- használható az opciók végeinek elhatárolására. Ez akkor hasznos, ha opcionális argumentumot kíván átadni a szkriptnek, anélkül, hogy az Expect értelmezi. Ez hasznos lehet a #! vonalat, hogy megakadályozza az Expect által alkalmazott lobogó szerinti értelmezést. Például az alábbiak hagyják el az eredeti argumentumokat, beleértve a script nevét az argv változóban.
#! / usr / local / bin / expect -Ne feledje, hogy a szokásos getopt (3) és execve (2) konvenciókat figyelembe kell venni az argumentumok hozzáadásakor a #! vonal.
A $ exp_library / expect.rc fájl akkor kerül automatikusan beszerzésre, ha jelen van, hacsak nem használjuk a -N-zászlót. (Az Expectk használatakor ez az opció NORC-ként van megadva.) Azonnal ez után a ~ / .expect.rc fájl automatikusan kerül beszerzésre, kivéve, ha a -n jelzőt használjuk. Ha a DOTDIR környezeti változót definiálták, akkor ez egy könyvtárként kezelendő, és a .expect.rc olvasó innen olvasható. Az Expectk használata esetén ez a lehetőség -norc. Ez a beszerzés csak a -c jelzők végrehajtása után következik be.
-v oka Várja, hogy kinyomtassa verziószámát és kilép. A megfelelő lobogó az Expectkben, amely hosszú zászlóneveket használ, a -version.
Az opcionális argseket egy listába építjük és az argv és. Az argc az argv hosszáig inicializálódik.
Az Argv0 a szkript neve vagy bináris, ha nem használ szkriptet. Például a következő kinyomtatja a parancsfájl nevét és az első három argumentumot:
send_user "$ argv0 [lrange $ argv 0 2] \ n"parancsok
Várja a Tool Command Language használatát. A Tcl biztosítja a vezérlőáramlást (ha, töréshez), az expresszálás értékeléséhez és számos más olyan funkcióhoz, mint a rekurzió és az eljárás meghatározása. Az itt használt, de nem definiált parancsok (set, if, exec) a Tcl parancsok. Expect további parancsokat támogat. Hacsak másképp nincs megadva, a parancsok visszaadják az üres karakterláncot.
A parancsok betűrendben vannak felsorolva, így azok gyorsan megtalálhatók. Azonban az új felhasználók könnyebben el tudnak kezdeni azzal, hogy elolvassák az ívás, a küldés, a várakozás és az interakció leírásait ebben a sorrendben.
bezár [-slave] [-onexec 0 | 1] [-i spawn_id]bezárja a kapcsolatot az aktuális folyamattal . A legtöbb interaktív program észleli az EOF -et a stdin-on és a kilépéskor; így közel áll a folyamat leöléséhez. A -i flag kijelenti, hogy a folyamat a megnevezett spawn_id-nek megfelelően zárul.
Mind a várakozás, mind a kölcsönhatás észleli, amikor a jelenlegi folyamat kilép, és hallgatólagosan lezárul, de ha elpusztítja a folyamatot , mondjuk "exec kill $ pid", akkor kifejezetten hívni kell .
Az -onexec zászló határozza meg, hogy a spawn azonosító minden újonnan létrehozott folyamatnál zárt állapotban van-e, vagy ha a folyamat átfedésben van. Ha egy spawn id nyitva van, akkor használja a 0 értéket. Egy nem zéró egész számérték az összes új folyamatban zárt állapotban rejti a spawnot.
A -slave zászló lezárja a szálat, amely a spawn idhez kapcsolódik. A kapcsolat bezárásakor a slave automatikusan zárva van, ha még nyitva van.
Függetlenül attól, hogy a kapcsolat implicit vagy explicit módon zárva van-e, várjon, hogy tisztítsa meg a megfelelő rendszermag- processz slot-ot. A bezárás parancs nem hívja meg a várakozást, mivel nincs garancia arra, hogy a folyamatkapcsolat bezárása miatt kilép.
debug [[-now] 0 | 1]vezérli a Tcl hibakeresőt, amely lehetővé teszi a kimutatások végrehajtását és a töréspontok beállítását.
Az argumentumok nélkül az 1-et visszaadja, ha a hibakereső nem fut, különben 0 lesz visszaadva.
1 argumentummal a debugger elindul. 0 argumentummal a debugger leáll. Ha egy 1 argumentumot megelőz a -now flag, a debugger azonnal elindul. Ellenkező esetben a hibakereső a következő Tcl utasítással kezdődik.
A hibakereső parancs nem változtatja meg a csapdákat. Ehhez hasonlítsa össze az elvárást a -D flag paranccsal.
A szétkapcsolási parancs leválasztja a villás folyamatot a terminálról . A háttérben fut. A folyamat saját folyamatcsoportot kapott. A szabványos I / O átirányítás a / dev / nullra .
A következő töredék a leválasztást használja, hogy továbbra is futtassa a szkriptet a háttérben.
ha {[fork]! = 0} kilép a kapcsolatból. . .A következő parancsfájl olvassa be a jelszavát, majd minden órában fut egy olyan programot, amely minden alkalommal fut, ha jelszót kér. A parancsfájl megadja a jelszót, így csak egyszer kell beírnia.
send_user "jelszó? \" expect_user -re "(. *) \ n" for {} 1 {} {ha {[fork]! = 0} {alvás 3600; folytatás} disconnect spawn priv_prog expect Jelszó: küldés "$ expect_out 1, karakterlánc) \ r ". . . Kilépés}A héj-aszinkron folyamat funkció (&) fölötti kihasználás előnye, hogy az Expect a kapcsolódás előtt mentheti a terminálparamétereket, majd később alkalmazhatja őket új ptys-re. A & és az Expect-nek nincs esélye a terminál paramétereinek olvasására, mivel a terminál már le van választva attól az időponttól kezdve, amikor az Expect az irányítást kapja.
kilépés [-opts] [állapot]okok A kilépéshez vagy más módon való felkészüléshez várakozik.
A -onexit zászló a következõ argumentumot használja kimeneti kezelõként . Érvek nélkül az aktuális kilépési kezelő visszakerül.
A -nonexit zászló elvárja, hogy felkészüljön a kilépéshez, de ne hagyja abba az effektív visszaküldést az operációs rendszer felé. A felhasználó által definiált kilépési kezelő fut, valamint az Expect saját belső kezelői. Nem kell elvárni a parancsok elvárását. Ez akkor hasznos, ha az Expect más Tcl kiterjesztésekkel fut. Az aktuális tolmács (és a főablak, ha a Tk környezetben) marad, így más Tcl kiterjesztések is tisztíthatók. Ha az Expect kilépési módját ismételten hívják (bár ez előfordulhat), a kezelők nem ismétlődnek.
A kilépéskor minden csatlakozás az elindított folyamatokhoz zárva van. A bezárást EOF-ként fogják fel az elindított folyamatok. a kilépés nem jár más lépésekkel, mint a szokásos _exit (2) eljárás. Így továbbra is futtathatók azok az eleven folyamatok, amelyek nem ellenőrzik az EOF-et. (Különböző feltételek fontosak például annak meghatározásához, hogy milyen jeleket fogalmaznak meg az eljuttatott folyamat, de ezek rendszerfüggőek, jellemzően a kimenet (3) alatt vannak dokumentálva.) A folyamatban lévő futtatott folyamatokat az init örökölti.
állapot (vagy 0, ha nincs megadva) az Expect kilépési állapota. a kimenet implicit módon végrehajtásra kerül, ha a parancsfájl vége elérte.
exp_continue [-continue_timer]
A exp_continue parancs lehetővé teszi számodra , hogy folytassa a végrehajtást ahelyett, hogy visszatérne, ahogyan általában. Alapértelmezés szerint a exp_continue visszaállítja az időtúllépési időzítőt. A -continue_timer jelző megakadályozza, hogy az időzítő újrainduljon. (Lásd várni további információért.)
exp_internal [-f fájl] értéket
további parancsokat küld a belső diagnosztikai információk küldésére az Expect to stderr értékre, ha az érték nem nulla. Ez a kimenet le van tiltva, ha az érték 0. A diagnosztikai információ magában foglalja a beérkezett összes karaktert és minden kísérletet, amely az aktuális kimenetnek a mintákhoz való illeszkedését eredményezi.
Ha az opcionális fájl beérkezik, az összes normál és hibakereső kimenet az adott fájlra kerül (az érték értékétől függetlenül). Bármely korábbi diagnosztikai kimeneti fájl bezáródik.
Az -info zászló exp_internal visszaküldést ad a legfrissebb, nem infor- mációs információkkal.
exp_open [args] [-i spawn_id]
visszaad egy Tcl fájl azonosítót, amely megfelel az eredeti spawn idnek. A fájlazonosítót úgy lehet használni, mintha a Tcl nyitott parancsával nyitotta volna meg. (A spawn azonosítót nem szabad többé használni, a várakozást nem szabad végrehajtani.
A -leaveopen zászló nyitva hagyja a spawn azonosítót az Expect parancsok eléréséhez. Várakozást kell végrehajtani a spawn azonosítóban.
exp_pid [-i spawn_id]
visszaadja az aktuálisan létrehozott folyamatnak megfelelő folyamatazonosítót. Ha a -i jelzőt használjuk, a visszatartott pid megfelel a megadott spawn azonosítójának.
exp_send
alias a küldéshez .
exp_send_error
a send_error álnév.
exp_send_log
a send_log aliasja .
exp_send_tty
a send_tty alias.
exp_send_user
egy alias a send_user számára .
exp_version [[-exit] verzió]
hasznos annak biztosítására, hogy a szkript kompatibilis legyen az Expect aktuális verziójával.
Bármelyik argumentum nélkül visszaküldi az Expect aktuális verzióját. Ezt a verziót ezután kódolhatja a szkriptben. Ha tényleg tudja, hogy nem használja a legutóbbi verziók jellemzőit, megadhat egy korábbi verziót.
A verziók három számot tartalmaznak pontokkal elválasztva. Az első a legnagyobb szám. Az Expect más nagyszámú változataira írt parancsfájlok szinte biztosan nem működnek. A exp_version hibát ad vissza, ha a főbb számok nem egyeznek.
A második a kisebb szám. Az olyan verziókhoz írt parancsfájlok, amelyeknél kisebb a szám, mint az aktuális verzió, bizonyos új funkcióktól függhetnek és esetleg nem futnak. A exp_version hibát ad vissza, ha a főbb számok egyeznek, de a szkript kisebb száma nagyobb, mint a futó Expect .
A harmadik olyan szám, amely nem játszik szerepet a verzió összehasonlításában. Azonban növeli, ha az Expect szoftver elosztását bármilyen módon megváltoztatja, például további dokumentációval vagy optimalizálással. Minden új kisebb verzióra 0-ra áll vissza.
Az exex jelzővel az Expect hibát nyomtat, és kilép, ha a verzió elavult.
várjon [[-opts] pat1 body1] ... [-opts] patn [bodyn]
amíg az egyik mintázat meg nem egyezik a létrehozott folyamat kimenetével, egy megadott időtartam eltelt, vagy megjelenik egy fájl vége. Ha a végleges test üres, akkor el lehet hagyni.
A legutóbbi expect_before parancsok mintáit implicit módon használják más minták előtt. A legutóbbi expect_after parancs mintáit implicit módon használják más minták után.
Ha az egész elvárható utasításhoz tartozó argumentumok több mint egy sort igényelnek, akkor az összes argumentum "beilleszthető" egybe, hogy elkerülje az egyes sorok visszalépésével történő lezárását. Ebben az esetben a szokásos Tcl helyettesítések a zárójelek ellenére jönnek létre.
Ha egy minta az eof kulcsszó, akkor a megfelelő test a fájl végén végződik. Ha egy minta a kulcsszó időtúllépése , akkor a megfelelő szervezet az időtúllépés után kerül végrehajtásra. Ha nincs időkorlátos kulcsszó, akkor implicit null műveletet hajt végre az időtúllépésnél. Az alapértelmezett időtúllépés időtartama 10 másodperc, de beállítható például 30, a "set timeout 30" paranccsal. Végtelen időtúllépés jelölhető a -1 értékkel. Ha a minta a kulcsszó alapértelmezése , akkor a megfelelő testület végrehajtása az időtúllépés vagy a fájlvég-fájl végén történik.
Ha egy minta egyezik, akkor a megfelelő test végrehajtásra kerül. elvárja, hogy visszaadja a test eredményét (vagy az üres karakterláncot, ha nem illeszkedik a minta). Abban az esetben, ha többszörös minták egyeznek, az először megjelenő eszközzel kiválasztják a testet.
Minden alkalommal, amikor az új kimenet érkezik, minden egyes minta szerint összehasonlítjuk őket. Így tesztelheti a mérkőzés hiányát azáltal, hogy az utolsó minta valami garantáltan megjelenik, például egy prompt. Olyan esetekben, amikor nincs kérés, időtúllépést kell használnia (csakúgy, mint ha manuálisan működne együtt).
A mintákat három módon határozzák meg. Alapértelmezés szerint a minták a Tcl string-egyezési parancsával vannak megadva. (Az ilyen minták hasonlóak a C-shell szabályos kifejezésekhez, amelyeket általában "glob" mintáknak neveznek). A -gl flag felhasználható olyan minták védelmére, amelyek egyébként elvárható jelzőlámpákkal rendelkeznek . Minden "-" -el kezdődő mintát védeni kell. (A "-" -al kezdődő összes karakterlánc a jövőbeli opciókra van fenntartva.)
Például a következő töredék egy sikeres bejelentkezést keres. (Megjegyezzük, hogy a megszakítás feltételezhetően a parancsfájl máshol meghatározott eljárás.)
{busy {elfoglalt \ n; exp_continue} sikertelen megszakítás "érvénytelen jelszó" megszakítása időtúllépés megszakadt kapcsolatban}Idézetek szükségesek a negyedik mintán, mivel tartalmaz egy olyan helyet, amely különben elválasztja a mintát a cselekvéstől. Az azonos művelettel rendelkező minták (például a 3. és a 4.) megkövetelik az akciók ismételt felsorolását. Ez elkerülhető a regexp-stílusú minták használatával (lásd alább). A globális stílusú minták kialakításáról a Tcl kézikönyvben olvashat bővebben.
A Regexp-stílusú minták követik a Tcl regexp (short for "regular expression") parancs által definiált szintaxist. A regexp mintákat a -re jelöli . Az előző példa átírható egy regexp használatával:
{busy {elfoglalt \ n; exp_continue} -re "sikertelen | érvénytelen jelszó" abort timeout megszakítása csatlakoztatva}Mindkét típusú mintát "letartóztatták". Ez azt jelenti, hogy a mintáknak nem kell megfelelniük a teljes karakterláncnak, de bárhova bárhol megkezdhetik és befejezhetik a mérkőzést (mindaddig, amíg minden más megegyezik). Használja a ^ -ot, hogy megegyezzen a string elején, és $ a végéhez illő. Ne felejtsd el, hogy ha nem vársz a string végére, akkor a válaszadatok könnyen eljuthatnak a karakterlánc közepére, mivel visszhangzik a létrehozott folyamatból. Miközben még mindig helyes eredményeket produkál, a kimenet természetellenesnek tűnhet. Így a $ használata biztató, ha pontosan leírhatod a karakterlánc végén lévő karaktereket.
Megjegyezzük, hogy sok szerkesztőben a ^ és a $ egyezik a sor elejével és végével. Mivel azonban a várakozások nem vonalasak, ezek a karakterek megegyeznek az elvárható pufferben jelenleg lévő adatok (szemben a sorokkal) sor elejére és végére. (Lásd még a "rendszerindex emésztésről" szóló megjegyzést.)
Az ex- zászló azt eredményezi, hogy a minta "pontos" karakterláncnak felel meg . A *, ^, stb. Értelmezést nem végezzük (bár a szokásos Tcl egyezményeket még mindig be kell tartani). Pontos minták mindig lehorgonyoznak.
A -nocase zászló a kimenet nagybetűs karaktereit hasonlítja össze, mintha kisbetűk lennének. A mintát nem érinti.
A kimenet olvasása során több mint 2000 bájt képes arra, hogy a korábbi bájtokat "elfelejtsék". Ez megváltoztatható a match_max függvénnyel . (Ne feledje, hogy a túl nagy értékek lelassíthatják a mintázókészüléket.) Ha a listázó teljes_buffer , akkor a megfelelő testület végrehajtásra kerül, ha a match_max bájtok érkeztek, és más minták nem illeszkedtek. Függetlenül attól, hogy a teljes_buffer kulcsszó szerepel-e vagy sem, az elfelejtett karaktereket a következőre várjuk: wait_out (buffer).
Ha a patlist a null kulcsszó, és az nulls megengedett (a remove_nulls paranccsal), akkor a megfelelő test végrehajtódik, ha egyetlen ASCII 0-t illesztünk . Nem lehet 0 bájtot egy glob vagy regexp mintán keresztül egyezni.
Egy minta (vagy eof vagy full_buffer) illesztése után bármelyik egyező és korábban páratlan kimenet a variancia expect_out (buffer) változóba kerül . Legfeljebb 9 regexp szubsztringel egyezik a wait_out (1, string) változókban a expect_out (9, string) függvényben . Ha az index- jelzőt egy minta előtt használjuk, akkor a 10 karakterlánc kezdő és záró indexei (a formanyomtatvány formában) a wait_out (X, start) és a expect_out (X, vég) változókban vannak tárolva, ahol X egy számjegy, megfelel a pufferben lévő aljpozíciónak. A 0 olyan vonalakra utal, amelyek megfeleltek a teljes mintának és generálják a glob mintákat, valamint a regexp mintákat. Ha például egy folyamat abcdefgh \ n kimenetét eredményezte, akkor az eredmény:
várakozás "cd"olyan, mintha a következő kijelentéseket végrehajtanák:
set expect_out (0, karakterlánc) cd set expect_out (buffer) abcdés az "efgh \ n" a kimeneti pufferben marad. Ha egy folyamat az "abbbcabkkkka \ n" kimenetet eredményezte, az eredmény:
várakozás -indexek -re "b (b *). * (k +)"olyan, mintha a következő kijelentéseket végrehajtanák:
set expect_out (0, start) 1 set expect_out (0, vég) 10 set expect_out (0, string) bbbcbkkkk set expect_out (1, start) 2 set expect_out (1, vég) (2, indítás) 10 set expect_out (2, vég) 10 set expect_out (2, string) k set expect_out (puffer) abbbcabkkkkés "a \ n" marad a kimeneti pufferben. A "*" minta (és a ". *") A kimeneti puffert öblítené anélkül, hogy több folyamatot olvasna ki a folyamatból.
Normális esetben az illesztett kimenetet az Expect belső pufferjei elhagyták. Ez megakadályozható úgy, hogy előhív egy mintát a -notransfer zászlóval. Ez a zászló különösen hasznos a kísérletezés során (és a kísérletezés során a "-not" rövidítéssel kényelmessé tehető).
Az illesztési kimenethez (vagy eof vagy full_buffer) társított spawn id a expect_out (spawn_id) -ben van tárolva.
A -timeout jelző az aktuális elvárható parancsot használja a következő érték időzítésként történő használatára a timeout változó értéke helyett.
Alapértelmezés szerint a mintákat az aktuális folyamat kimenetével egyezik meg, de a -i flag deklarálja, hogy a megadott spawn_id listából származó kimenetet bármelyik következő mintához (az elkövetkező -i-ig ) illeszteni kell. A spawn_id listának vagy a spawn_ids vagy a spawn_ids ilyen listájára hivatkozó változónak kell lennie.
Például a következő példa a $ proc2 nevű spawn_id nevű "kapcsolódott" a jelenlegi folyamattól, vagy "foglalt", "sikertelen" vagy "érvénytelen jelszót" várja.
{-i $ proc2 elfoglalt} {busy} \ n; exp_continue} -re "sikertelen | érvénytelen jelszó" abort timeout megszakítása csatlakoztatva}Az any_spawn_id globális változó értéke használható bármely olyan spawn_ids esetén, amelyek minden más -i jelzővel meg vannak nevezve a jelenlegi elvárható parancsban. A -i zászló nélküli spawn_id-t (vagyis közvetlenül egy másik -i ) követi minden olyan mintához, amely ugyanaz a várandós parancs, amely bármely_spawn_idhez kapcsolódik .
A -i flag globális változót is nevezhet, amely esetben a változó a spawn idek listájára kerül. A változó újra változik, amikor változik. Ez biztosítja az I / O forrást a parancs végrehajtása közben. Az így megadott űrlapokat "közvetett" idők nevezik.
Az olyan műveletek, mint a megszakítás és a folytatás, vezérlési struktúrákat okoznak (pl. Proc ), hogy a szokásos módon viselkedjenek. A exp_continue parancs lehetővé teszi számodra , hogy folytassa a végrehajtást ahelyett, hogy visszatérne, ahogyan általában.
Ez hasznos kifejezett hurkok vagy ismételt elvárások elkerülésére. A következő példa része egy töredéknek a rlogin automatizálására. A exp_continue elkerülheti, hogy írjon egy második várakozó nyilatkozatot (újra felteszi a promptot), ha a rlogin jelszót kér.
várjon {password: {stty -echo send_user "jelszó ($ felhasználó esetén) $ host esetén:" expect_user -re "(. *) \ n" send_user "\ n" küldés "$ expect_out (1, string) \ r" echo exp_continue} hibás {send_user "érvénytelen jelszó vagy fiók \ n" kilépés} timeout {send_user "kapcsolat a $ host időzítéséhez \ n" exit} eof {send_user \ "kapcsolat a gazdagéphez nem sikerült: $ wait_out (buffer) re $ prompt}Például az alábbi töredék segíthet a felhasználói útmutatóban a már teljesen automatizált interakciónak. Ebben az esetben a terminál nyers üzemmódba kerül. Ha a felhasználó megnyomja a "+" gombot, egy változó növekszik. Ha megnyomja a "p" billentyűt, akkor több visszajelzést küldünk a folyamatba, talán valamilyen módon megpróbáljuk megindítani, és az "i" segítségével a felhasználó léphet kapcsolatba a folyamattal, hatékonyan ellopva a parancsfájl vezérlését. Minden esetben a exp_continue lehetővé teszi az aktuálisnak, hogy az aktuális művelet végrehajtása után folytassa a mintaegyeztetést.
stty raw -echo expect_after {-i $ user_spawn_id "p" {küldés "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "kilépés" exit}Alapértelmezés szerint a exp_continue visszaállítja az időtúllépési időzítőt. Az időzítő nem indul újra, ha exp_continue a -continue_timer jelzővel hívja .
expect_after [expect_args]
működik azonos módon a várakozás előtt, kivéve, ha a mindkét elvárásból és a várakozásból következő minták egyeznek, akkor a várakozási mintát használják. További információkért tekintse meg az expect_before parancsot.
expect_background [expect_args]
ugyanazokat az érveket veszi igénybe, mint amire számít , de azonnal visszatér. A mintákat akkor teszteljük, amikor új bemenet érkezik. A minta időtúllépése és az alapértelmezés értelmetlen a wait_background-ra és csendben eldobásra kerül. Ellenkező esetben a expect_background parancs elvárható előtte és expect_after minták, mint várják .
Ha a várakozás visszaszámláló műveleteket értékelik, akkor ugyanazt az azonosító azonosítót háttér feldolgozása blokkolja. A háttér feldolgozása feloldásra kerül, amikor a művelet befejeződik. Míg a háttérfeldolgozás blokkolva van, lehetőség van egy (előtér) elvárására ugyanazon a azonosító azonosítón.
Nem lehet végrehajtani a várakozást, amíg a várakozó visszahívás feloldásra kerül. egy adott spawn-azonosítóra vonatkozó expect_background törlésre kerül, ha egy új expect_background-ot azonos spawn azonosítóval deklarálunk. A minta nélküli minta elvárása visszavonja az adott spawn azonosítót a háttérben lévő minták illesztésének képességéről.
expect_before [expect_args]
ugyanazokat az érveket veszi igénybe, mint amire számít , de azonnal visszatér. A legutóbbi elvárásokkal azonos azonosítójú azonosítójú mintapárti pártok implicit módon hozzá vannak adva a következő elvárható parancsokhoz. Ha egy minta egyezik, akkor úgy kezeljük, mintha az elvárt utasításban lett volna megadva, és a társított test a váró parancs kontextusában kerül végrehajtásra. Ha a mindkét elvárásból és a várakozásból származó minták megegyeznek, akkor a várakozás előtt a minta használatos.
Ha nincs megadva mintázat, a spawn azonosító nincs bejelölve semmilyen mintához.
Ha nem jelöli meg a -i zászló, várjon , amíg a minták megegyeznek az elvárt parancssor végrehajtásakor definiált spawn azonosítóval (nem akkor, ha a minta illeszkedik).
Az -info zászló elvárja, hogy visszaadja a jelenlegi specifikációkat, hogy milyen mintákat fog összeilleszteni. Alapértelmezés szerint az aktuális spawn-azonosítót jelenti. Opcionális spawn id specifikáció adható meg azon spawn azonosító információval kapcsolatban. Például
expect_before -info -i $ procLegfeljebb egy spawn id specifikáció adható. A zászló-közvetett elrejti azokat a közvetlen spawn ideket, amelyek csak közvetett adatokból származnak.
A spawn id specifikáció helyett a "-all" jelző "-info" jelzést ad az összes spawn idről.
Az info-jelző kimenete újra felhasználható az elvárásnak tekintendő argumentumnak.
expect_tty [expect_args]
olyan, mint várni, de karaktereket olvas a / dev / tty-ból (vagyis a felhasználó billentyűleütései). Alapértelmezés szerint az olvasás főzött módban történik. Így a vonalaknak vissza kell térniük ahhoz, hogy elvárják őket. Ez változhat stty- en keresztül (lásd az alábbi stty parancsot).
expect_user [expect_args]
olyan, mint várni, de a karaktereket a stdin-ből (azaz a felhasználó billentyűleütéseitől) olvasja. Alapértelmezés szerint az olvasás főzött módban történik. Így a vonalaknak vissza kell térniük ahhoz, hogy elvárják őket. Ez változhat stty- en keresztül (lásd az alábbi stty parancsot).
Villa
új folyamatot hoz létre. Az új folyamat a jelenlegi Expect folyamat pontos másolata. A sikertelenül a fork 0 értéket ad az új (gyermek) folyamatnak, és a gyermek folyamat folyamatazonosítóját a szülőfolyamathoz adja vissza. Hiba esetén (változatlanul a források hiánya, pl. Swap-terület, memória), a fork visszatér a szülőprocesszushoz -1, és nem keletkezik gyermekfolyamat.
A forrasztott folyamatok a kilépési parancson keresztül kilépnek , akárcsak az eredeti folyamat . A forrasztott folyamatok a naplófájlokba írhatók. Ha nem engedélyezi a hibakeresést vagy a naplózást a folyamatok többségében, az eredmény zavaró lehet.
Néhány pty implementációt sok olvasó és író megzavarhat, akár pillanatnyilag is. Így a legbiztonságosabb az ívási folyamatok előtt.
interakció [string1 body1] ... [stringn [bodyn]]
megadja az aktuális folyamat vezérlését a felhasználó számára, így a billentyűleütéseket az aktuális folyamathoz küldik, és az aktuális folyamat stdout és stderr értéke visszakerül.
A karakterlánc-párok paraméterek argumentumként adhatók meg, amely esetben a test végrehajtásra kerül, amikor a megfelelő karakterlánc be van adva. (Alapértelmezés szerint a karakterlánc nem kerül elküldésre az aktuális folyamathoz .) A tolmácsparancsot feltételezzük, ha a végleges test hiányzik.
Ha az egész interaktív utasításhoz tartozó argumentumok több mint egy sort igényelnek, akkor az összes argumentum "felragasztott" egybe, hogy elkerülje az egyes sorok visszalépésével történő lezárását. Ebben az esetben a szokásos Tcl helyettesítések a zárójelek ellenére jönnek létre.
Például a következő parancs fut együtt a következő sztring-test párokkal: Amikor ^ Z megnyomja, az Expect felfüggesztésre kerül. (A -reset zászló visszaállítja a terminál üzemmódokat.) Amikor a ^ A gombot lenyomja, a felhasználó látja, hogy "beírt egy vezérlést", és a folyamatot ^ A-nak küldik. A $ gomb megnyomásakor a felhasználó látja a dátumot. Amikor megnyomja a ^ C gombot, az Expect kilép. Ha a "foo" be van írva, a felhasználó látja a "bar" -t. Amikor megnyomja az ~~ gombot, az Expect tolmács interaktív módon fut.
állítsa be a CTRLZ \ 032 interakciót {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "megadtad a vezérlést -A \ n"; "{0000}"} $ {send_user "A dátum [óra formátum [óra másodperc]]."} \ 003 kilépés foo {send_user "bar"} ~~}A sztring-test párokban a karakterláncok sorrendje a sorrendben szerepel, mint argumentumok. A részlegesen illeszkedő karakterláncokat nem a jelenlegi folyamatba küldi, a fennmaradó rész előtt. Ha a karakterek be vannak írva úgy, hogy többé nem lehet egyezés, akkor csak a karakterlánc része kerül elküldésre a folyamathoz , amely nem indíthatja el újra a mérkőzést. Így a részleges mérkőzések részhalmazai később is megegyezhetnek, ha az eredeti szálak, amelyek megpróbálták összeilleszteni, végül nem sikerülnek.
Alapértelmezés szerint a karakterláncegyezés pontos, nem tartalmaz vadkártyákat . (Ezzel szemben a várakozó parancs alapértelmezés szerint glob-stílusú mintákat használ.) Az -ex zászló használható olyan minták védelmére, amelyek egyébként kölcsönhatásba lépnek a zászlókkal. Minden "-" -el kezdődő mintát védeni kell. (A "-" -al kezdődő összes karakterlánc a jövőbeli opciókra van fenntartva.)
A -re jelző arra kényszeríti a karakterláncot, hogy egy regexp-stílusú mintát értelmezzen. Ebben az esetben a megfelelő sztringek a változó interact_out változóban tárolódnak, ahogy elvárják, hogy a változó expect_out változatát tárolja . Az index- jelző hasonlóan támogatott.
Az eof minta bemutat egy műveletet, amelyet a fájl végén végzünk . Egy külön eof- minta is követheti a kimeneti zászlót, mely esetben akkor illeszkedik, ha egy eof-ot észlel a kimenet írásakor. Az alapértelmezett eof művelet "return", így az interakció egyszerűen visszatér bármely EOF-hez.
A minta időtúllépés időtúllépést (másodpercek alatt) és műveletet hajt végre, miután egy adott időre nem olvasta fel karaktereket. Az időtúllépési minta a legutóbb meghatározott eljárásra vonatkozik . Nincs alapértelmezett időtúllépés. A "timeout" speciális változó (amelyet a váró parancs használ) nem befolyásolja ezt az időtúllépést.
Például a következő nyilatkozatot használhatják azon felhasználók autológálásához, akik nem írták be semmit egy órára, de gyakran rendszeres üzeneteket kapnak:
interakció -input $ user_spawn_id timeout 3600 return -output \ $ spawn_idHa a mintázat a null kulcsszó, és az nulls engedélyezett (az remove_nulls paranccsal), akkor a megfelelő test végrehajtódik, ha egyetlen ASCII 0-t illesztünk . Nem lehet 0 bájtot egy glob vagy regexp mintán keresztül egyezni.
A minta leképezése a flag- iwrite-lel az interaktív_out (spawn_id) változót a spawn_id-re állítja be, amely megfelelt a mintának (vagy eof).
Az olyan műveletek, mint a megszakítás és a folytatás, vezérlési struktúrákat okoznak (pl. Proc ), hogy a szokásos módon viselkedjenek. A visszatérés azonban kölcsönhatásba lép vissza a hívójához, míg az inter_return kölcsönhatás okozza a hívó visszatérését. Például, ha a "proc foo" nevű interakciót végrehajtotta az inter_return művelet, a proc foo visszatér. (Ez azt jelenti, hogy ha kölcsönhatás közben a tolmács interaktív módon írja a visszatérést , az interakció folytatódni fog, míg az inter_return az interakciót visszatéríti a hívójához.)
Az interakció során a nyers módot használják úgy, hogy minden karakter átadódjon az aktuális folyamatnak . Ha az aktuális folyamat nem veszi észre a munka vezérlő jeleket, akkor az megáll, ha megállási jelet küld (alapértelmezés szerint ^ Z). Ha újraindítja, küldjön egy folytonos jelet (például "kill -CONT"). Ha valóban egy SIGSTOP-t szeretne küldeni egy ilyen folyamathoz (^ Z), fontolja meg először a csh megteremtését, majd futtassa a programot. Másrészt, ha egy SIGSTOP-ot szeretnénk elküldeni a Várakozásnak, az első hívás tolmácsot (talán egy escape karaktert használva), majd nyomjuk meg a ^ Z gombot.
A karakterlánc-párok rövidítéseként használhatók, hogy elkerüljék a tolmács bejutását és a parancsok interaktív végrehajtását. Az előző terminál üzemmódot használjuk, míg a karosszéria-pár testének végrehajtása történik.
A sebesség érdekében a műveletek alapértelmezés szerint nyers üzemmódban futnak. A -reset zászló visszaállítja a terminált olyan üzemmódba, amellyel az interakció végrehajtása megtörtént (mindig, főzött mód). Ne feledje, hogy az üzemmód átkapcsolásakor beadott karakterek elveszhetnek (a terminálvezérlő szerencsétlen tulajdonsága egyes rendszereknél). A -reset használatának egyetlen oka az, ha a művelet fõzött módban való futtatásától függ.
A -echo zászló olyan karaktereket küld vissza, amelyek megfelelnek a következő mintának az egyes karakterek olvasásakor keletkező folyamathoz . Ez hasznos lehet, ha a felhasználónak részleges beillesztett mintákból kell visszajelzést kapnia.
Ha a mintát visszhangozzák, de végül nem sikerül összeegyeztetni, akkor a karaktereket a létrehozott folyamatba küldi. Ha a létrehozott folyamat visszhangozza őket, a felhasználó kétszer látja a karaktereket. -echo valószínűleg csak olyan helyzetekben alkalmazható, ahol a felhasználó valószínűleg nem tudja befejezni a mintát. Például a következő kivonat az rftp-ből, a rekurzív ftp parancsfájlból áll, ahol a felhasználónak kéri a ~ g, ~ p vagy ~ l bejegyzést a jelenlegi könyvtár rekurzív megjelenítéséhez, feladásához vagy listájához. Ezek olyan messze vannak a normál ftp parancsoktól, hogy a felhasználó valószínűleg nem írja be a ~ semmit, csak tévesen, és ebben az esetben valószínűleg csak figyelmen kívül hagyják az eredményt.
interakció {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}A -nobuffer zászló olyan karaktereket küld, amelyek megfelelnek a következő mintanak a kimeneti folyamatba karakterek olvasásakor.
Ez akkor hasznos, ha vissza szeretné hagyni, hogy a program visszhangozza a mintát. Például az alábbiakat lehet használni annak figyelemmel kísérésére, hogy egy személy tárcsázza (Hayes-stílusú modemet). Minden alkalommal, amikor az "atd" látható, a parancsfájl naplózza a sor többi részét.
proc lognumber {} {interact -nobuffer -re "(. *) \ r" vissza hozza $ logot "[clock formátum [óra másodperc]]: tárcsázott $ interact_out (1, karakterlánc)"} interact -nobuffer "atd" lognumberAz interakció során a log_user korábbi használatát figyelmen kívül hagyja. Különösen a kölcsönhatás fogja kényszeríteni a kimenetét, hogy naplózásra kerüljön (a szabványos kimenetre küldve), mivel feltételezhető, hogy a felhasználó nem akar vakon egymásba lépni.
A -o flag azt jelenti, hogy az aktuális folyamat kimenetére bármelyik következő kulcs-test párt alkalmazzuk. Ez hasznos lehet például a nemkívánatos karakterek telnet-munkamenetben történő elküldésére szolgáló gazdagépekkel kapcsolatban.
Alapértelmezés szerint az interakció elvárja, hogy a felhasználó írjon stdin-t, és olvassa el az Expect folyamat magasságát. A -u flag (a "user" -nek) kölcsönhatásba keresi a felhasználót az argumentum által megnevezett folyamatnak (melynek létre kell hoznia egy ívott azonosítót).
Ez két egymástól független folyamat összekapcsolását teszi lehetővé anélkül, hogy explicit hurokra lenne szükség. A hibakereséshez való hozzáférés érdekében a Várja a diagnosztika mindig a stderr (vagy a stdout bizonyos naplózási és hibakeresési információkhoz) Ugyanezen okból a tolmács parancs interaktívan olvasható a stdin-ből.
Például az alábbi töredék létrehoz egy bejelentkezési folyamatot . Ezután tárcsázza a felhasználót (nem látható), és végül összekapcsolja a kettőt. Természetesen bármely folyamat helyettesítheti a bejelentkezést. Például egy héj lehetővé teszi a felhasználó számára, hogy fiók és jelszó megadása nélkül dolgozhasson.
spawn login set bejelentkezés $ spawn_id spawn tip modem # tárcsázás vissza a felhasználóhoz # connect user to login interact -u $ loginHa több folyamathoz szeretné elküldeni a kimenetet, felsorolja az összes spawn id listát, amelyet egy kimeneti zászló előzetesen megnevezett. A kimeneti ív azonosítóinak egy csoportjának bemenete meghatározható egy spawn id-listával, amelyet egy bemeneti jelzővel előzetesen meg lehet adni. (Mindkét bemenet és kimenet ugyanazt a formát öltheti, mint a -i jelző a váró parancsban, kivéve, hogy any_spawn_id nem értelmezhető az interakcióban .) Minden következő zászló és karakterlánc (vagy mintázat) megjelenik a bemeneti jelző. Ha nem jelenik meg a - bemenet, akkor a kimenet jelentése: "-input $ user_spawn_id -output". (Hasonlóképpen olyan mintákkal is, amelyeknek nincs bemenetük .) Ha egy bemenet van megadva, felülbírálja a $ user_spawn_idet. Ha megad egy második bemenetet, felülírja a $ spawn_id értéket. További bemeneti jelzők megadhatók.
A két implikált bemeneti folyamat alapértelmezés szerint a kimeneteiket $ spawn_id és $ user_spawn_id (fordított) értékekkel határozza meg. Ha a -input- jelző megjelenik, és a kimeneti jelző nem jelenik meg, akkor az adott folyamat karaktereit el kell dobni.
A -i zászló bevezeti az aktuális spawn_id helyettesítőjét, amikor nincs más bemeneti vagy kimeneti jelző. A -i zászló jelentése -o flag.
Lehetőség van arra, hogy megváltoztassuk a folyamatokat, amelyekkel kapcsolatba lépnek a közvetett spawn idek használatával. (A közvetett spawn idek leírása a váró parancs szakaszában található.) A közvetett spawn idek meghatározhatók a -i, -u, -input vagy -out flagokkal.
tolmács [args]
hogy a felhasználó interaktív módon megkérdezze az Expect és a Tcl parancsokat. Az egyes parancsok eredményét kinyomtatják.
Az olyan műveletek, mint a megszakítás és a folytatás, vezérlési struktúrákat okoznak (pl. Proc ), hogy a szokásos módon viselkedjenek. Azonban a visszaküldés miatt a tolmács visszaküldi a hívóját, míg az inter_return a tolmács által okozott visszatérést okozza. Például, ha a "proc foo" nevű tolmács, amely végrehajtotta az inter_return műveletet, a proc foo visszatér. Bármelyik parancs segítségével a tolmács folytatja az új parancsok kérését.
Alapértelmezés szerint a parancs két egész számot tartalmaz. Az első egész szám az értékelési verem mélységét írja le (azaz, hogy hányszor hívták a Tcl_Eval-ot). A második egész szám a Tcl történelem azonosítója. A prompt beállítható egy "prompt1" nevű eljárással, amelynek visszatérési értéke a következő prompt lesz. Ha egy nyilatkozat nyitott idézőjelekkel, parensekkel, zárójelekkel vagy zárójelekkel rendelkezik, másodlagos prompt (alapértelmezés szerint "+>") új sorral kerül kiállításra. A másodlagos promptot a "prompt2" nevű eljárás meghatározásával lehet beállítani.
A tolmács közben a főtt üzemmódot használják, még akkor is, ha a hívó nyers üzemmódot használt.
Ha a stdin zárva van, akkor a tolmács visszatér, hacsak nem használják a -eof flagot , ebben az esetben a későbbi érvet hívják.
log_file [args] [[-a] fájl]
Ha fájlnév van megadva, a log_file felvesz egy átiratot a munkamenetről (ekkor kezdődik) a fájlban. A log_file leállítja a felvételt, ha nincs argumentum. Minden korábbi naplófájl le van zárva.
A fájlnév helyett egy Tcl fájl azonosító adható meg a -open vagy a -leaveopen zászlók használatával. Ez hasonló a spawn parancshoz. (További információkért lásd a spawnot .)
Az a -a jelző erők, amelyeket a log_user parancs elnyelte, be kell jelentkezniük.
Alapértelmezés szerint a log_file parancs a régi fájlokhoz kapcsolódik, nem pedig a csonkoláshoz, annak érdekében, hogy egy nap folyamán egyszerre többször is kikapcsolhatja a bejelentkezést. A fájlok csonkolásához használja a -noappend zászlót.
Az info- jelző a log_file-t visszaadja a legfrissebb nem-info-argumentumok leírásának.
log_user -info | 0 | 1
Alapértelmezés szerint a küldés / várakozás párbeszéd naplózásra kerül az stdout-ba (és nyitott naplófájl esetén). A stdout naplózását a "log_user 0" parancs letiltja, és a "log_user 1" újra engedélyezi. A naplófájlba való bejelentkezés nem változik.
Az -info zászlóval a log_user visszaküldi a legfrissebb nem információs argumentumok leírását.
match_max [-d] [-i spawn_id] [méret]
meghatározza a puffer (byte-ban) méretét, amelyet a várakozáson belül használ. Méret nélkül , az aktuális méret visszakerül.
A -d jelzővel az alapértelmezett méret van beállítva. (Az alapértelmezett alapértelmezés 2000.) A -i jelzővel a méret a megadott spawn azonosítóra van beállítva, különben az aktuális folyamat beállítása .
overlay [- # spawn_id] [- # spawn_id] [...] program [args]
végrehajtja a "program args" -t az aktuális Expect program helyett, amely véget ér. A csupasz kötőjel argumentum a parancsnév előtti kötőjelet kényszerít, mintha bejelentkezési héj lenne. Minden spawn_ids zárva van, kivéve az argumentumként megadottakat. Ezek a fájlok azonosítására kerülnek.
A Spawn_ids leképezve az új program örökléséhez szükséges file-azonosítót. Például az alábbi sorban sakk fut, és lehetővé teszi, hogy az aktuális folyamat vezérelje - mondjuk egy sakk master.
átfedés -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id sakkEz hatékonyabb, mint a "interaktív -u", azonban feláldozza a programozott interakció képességét, mivel az Expect folyamat már nem ellenőrzött.
Ne feledje, hogy nincs vezérlő terminál. Így ha a szabványos bemeneteket lecsatlakoztatja vagy újratölti, akkor a programvezérlő programok (héjak, bejelentkezés stb.) Nem működnek megfelelően.
paritás [-d] [-i spawn_id] [érték]
meghatározza, hogy a paritásokat meg kell-e tartani vagy le kell-e vonni a kivett folyamatok kimeneteléről. Ha az érték nulla, a paritás megszűnik, ellenkező esetben nem lesz megfosztva. Értéke nélküli érték esetén az aktuális érték visszaadódik.
A -d jelzővel az alapértelmezett paritásérték kerül beállításra. (A kezdeti alapértelmezett értéke 1, azaz a paritás nincs lecsupaszítva.) Az -i jelzővel a paritásértéket a megnevezett spawn id számára állítjuk be, ellenkező esetben az aktuális folyamat beállítása .
remove_nulls [-d] [-i spawn_id] [érték]
meghatározza, hogy a nullokat megőrzik vagy eltávolítják-e a létrehozott folyamatok kimenetéről, mielőtt a mintaegyeztetést vagy a változó expect_out vagy interact_out változót tárolnák . Ha az érték 1, a nullák eltávolításra kerülnek. Ha az érték 0, a nullákat nem távolítjuk el. Értéke nélküli érték esetén az aktuális érték visszaadódik.
A -d jelzővel az alapértelmezett érték van beállítva. (A kezdeti alapértelmezett értéke 1, vagyis az nullok eltávolításra kerülnek.) A -i jelzővel az érték be van állítva a megnevezett spawn id számára, ellenkező esetben az aktuális folyamat beállítása .
Ha az nullokat eltávolítják vagy sem, akkor az Expect null bájtokat rögzít a naplóba és a stdoutba.
küldjön [-flags] karakterláncot
Húzza a jelenlegi folyamatot . Például a parancsot
elküldi a helloworld karaktereket a jelenlegi folyamatnak . (A Tcl tartalmaz egy printf -like parancsot (úgynevezett formátumot ), amely önkényesen összetett karakterláncokat képes létrehozni.)
A karakterek azonnal elküldésre kerülnek, bár a vonal által pufferelt bemenetű programok nem fogják olvasni a karaktereket, amíg visszatérő karaktert nem küldenek. A visszatérő karaktert "\ r" jelöli.
A - zászló arra kényszeríti a következő érvet, hogy inkább zászló helyett húrként értelmezhető. Minden karaktersorozatot megelőzhet a "-", függetlenül attól, hogy valóban zászlónak tűnik-e. Ez megbízható mechanizmust biztosít a változó karakterláncok meghatározásához, anélkül, hogy azok véletlenül zászlóknak tűnnének. (A "-" -al kezdődő összes karakterlánc a jövőbeli opciókra van fenntartva.)
A -i flag kijelenti, hogy a karakterláncot a megnevezett spawn_id-nek kell elküldeni. Ha a spawn_id a user_spawn_id és a terminál nyers üzemmódban van, akkor a stringben lévő új sorok a return-newline sorozatokra fordulnak úgy, hogy úgy jelennek meg, mintha a terminál főzött módban lenne. A -raw flag letiltja ezt a fordítást.
A -null flag küld nulla karaktereket (0 bájt). Alapértelmezés szerint egy null küld. Egy egész szám követheti a -null értéket annak jelzésére, hogy hány nullot kell elküldeni.
A -break flag generál egy törési feltétel. Ennek csak akkor van értelme, ha a spawn id egy "spawn-open" keresztül megnyitott tty eszközre utal. Ha olyan folyamatot hoztál létre, mint a csúcs, akkor használd a csúcsegyezményt egy szünet generálásához.
A -s zászló erőket a "lassan" küldött kimenetre kerül, így elkerülhető a közös eset, amikor a számítógép egy bemeneti puffert tartalmaz, amelyet olyan ember számára terveztek, aki soha nem írná le ugyanazt a puffert . Ezt a kimenetet a "send_slow" változó értéke szabályozza, amely két elem listát vesz fel. Az első elem olyan egész szám, amely leírja a bájtok számát, hogy atomszerűen küldjön. A második elem egy valós szám, amely leírja a másodpercek számát, amellyel az atomi küldéseket el kell különíteni. Például a "set send_slow {10 .001}" beállítás "send -s" -et kényszerít, ha a 10 karakterből álló karakterek között 1 milliszekundumot kell küldeni.
A -h flag erők küldeni kell (kissé), mint egy ember ténylegesen gépelés. Emberi jellegű késedelmek jelennek meg a karakterek között. (Az algoritmus egy Weibull-eloszláson alapul, ennek módosítására az adott alkalmazásnak megfelel.) Ezt a kimenetet a "send_human" változó értéke szabályozza, amely öt elemet tartalmazó listát tartalmaz. Az első két elem a másodpercek közötti karakterek átlagos beérkezési ideje. Az első az alapértelmezett. A második szót a szó befejeződésekor használják, hogy szimulálják azokat a finom szüneteket, amelyek esetenként ilyen átmeneteknél fordulnak elő. A harmadik paraméter a változékonyság mérőszáma, ahol .1 meglehetősen változó, 1 ésszerűen változó, 10 pedig teljesen változatlan. A szélsőségek 0-tól a végtelenig terjednek. Az utolsó két paraméter egy minimális és maximális érkezési idő. A minimális és a maximális értéket utoljára használják, és a "klip" a végső idő. A végső átlag egészen eltérhet az adott átlagtól, ha a minimális és a maximális klip megfelelő értékeket tartalmaz.
Például a következő parancs emulálja a gyors és következetes gépírást:
set send_human {.1 .3 1 .05 2} küldés -h "Éhes vagyok, csináljunk ebédet."míg az alábbi esetleg megfelelőbb a másnaposság után:
set send_human {.4 .4 .2 .5 100} küldje el -h "Goodd party lash éjszaka!"Ne feledje, hogy a hibákat nem szimulálták, bár hibajavítási helyzeteket is beállíthat úgy, hogy hibákat és korrekciókat helyez el a küldési argumentumban.
A null karakterek küldésére szolgáló zászlók, a szünetek elküldéséhez, a lassú kimenetelítéshez és az emberi stílusú kimenethez kölcsönösen kizárják egymást. Csak az utoljára megadottat fogják használni. Ezenkívül nem lehet sztring argumentumot megadni a zászlókkal null karakterek vagy megszakítások küldéséhez.
Jó ötlet, hogy megelőzze az első küldeményt egy folyamathoz egy elvárás szerint . várni fogja a folyamat megkezdését, míg a küldés nem lehetséges. Különösen, ha az első küldés befejeződik, mielőtt a folyamat elindulna, fennáll annak a kockázata, hogy az adatokat figyelmen kívül hagyja. Olyan esetekben, amikor az interaktív programok nem tartalmaznak kezdeti felszólítást, a későbbiekben a későbbiekben a következőket teheti meg:
# Annak elkerülése érdekében, hogy a hackerek rámutassanak a behatolásra, # ez a rendszer nem kéri a külső jelszót. # Várjon 5 másodpercet a végrehajtónak, hogy töltse ki a spawn telnet-t very.secure.gov sleep 5 jelszó küldéseA exp_send alias a küldéshez. Ha az Expectk-t vagy az Expect egy másik változatát használja a Tk környezetben, akkor a küldetet Tk határozza meg teljesen más célra. A exp_send a környezetek kompatibilitására szolgál. Hasonló aliasok is rendelkezésre állnak más Expect többi küldési parancsára.
send_error [-flags] string
mint a küldés , kivéve, hogy a kimenetet az aktuális folyamat helyett a stderr-re továbbítjuk.
send_log [-] karakterlánc
mint a küldés , kivéve, hogy a karakterlánc csak a naplófájlba kerül (lásd: log_file .) Az argumentumokat figyelmen kívül hagyja, ha nincs naplófájl.
send_tty [-flags] string
olyan, mint a küldés , kivéve, hogy a kimenetet a jelenlegi eljárás helyett a / dev / tty-nek küldtük.
send_user [-flags] karakterláncot
olyan, mint a küldés , kivéve, hogy a kimenetet a jelenlegi folyamat helyett a stdoutra küldi.
alvás másodperc
a parancsfájl a megadott számú másodpercig alszik . A másodperc lehet egy decimális szám. Megszakítások (és Tk események, ha az Expectk-t használják) feldolgozásra kerülnek, amíg az Alvás elképzelhető.
spawn [args] program [args]
létrehoz egy új folyamatot, amely a "program args" -t futtatja. A stdin, a stdout és az stderr kapcsolódnak az Expecthez, hogy más elvárható parancsok olvashassanak és írhassanak . A kapcsolat megszakad, vagy a folyamat maga zárja le a fájlazonosítót.
Amikor egy folyamatot a spawn elindít , a spawn_id változó egy leíróra van állítva, amely erre a folyamatra vonatkozik . A spawn_id által leírt folyamat az "aktuális folyamat ". A spawn_id olvasható vagy írható, hatásosan a munka ellenőrzésére.
A user_spawn_id egy olyan globális változó, amely leírja a felhasználónak szóló leírást. Ha például a spawn_id értéke erre az értékre van beállítva, úgy számíthat arra , hogy úgy viselkedik, mint a expect_user .
A hiba_spawn_id egy olyan globális változó, amely egy leírót tartalmaz, amely a standard hibára utal. Például, ha a spawn_id értéke erre az értékre van állítva, a küldés viselkedik mint send_error .
A tty_spawn_id olyan globális változó, amely leírást tartalmaz, amely a / dev / tty kifejezésre utal. Ha a / dev / tty nem létezik (például cron, at vagy batch script), akkor a tty_spawn_id nincs definiálva. Ez a következőképpen tesztelhető:
ha {[info vars tty_spawn_id]} {# / dev / tty létezik} máshol {# / dev / tty nem létezik # valószínűleg cron, batch vagy script esetén}spawn visszaadja a UNIX folyamatazonosítót . Ha semmilyen folyamatot nem generálunk, akkor 0 visszaküldésre kerül. A spawn_out változó (slave, name) a pty slave eszköz nevére van állítva.
Alapértelmezés szerint a spawn visszhangozza a parancsnevet és az argumentumokat. A -noecho zászló megakadályozza a spawnot .
A -konzol zászló a konzol kimenetét átirányítja a létrehozott folyamatba . Ez nem minden rendszeren támogatott.
Belsőleg, a spawn egy pty-t használ, amelyet ugyanúgy inicializál, mint a felhasználó tty. Ezt további inicializálással végezzük, így minden beállítás "jó" (stty (1) szerint). Ha a stty_init változó definiálva van, az stty argumentumok stílusában értelmezik további konfigurációként. Például, a "set stty_init raw" a további termelt folyamatok termináljait nyers üzemmódban kezdheti. A -nottycopy átugrik az inicializálást a felhasználó tty alapján. -nottyinit kihagyja a "jó" inicializálást.
Általában a spawn kevés időt vesz igénybe a végrehajtáshoz. Ha észreveszi, hogy a spawn jelentős mennyiségű időt vesz igénybe, akkor valószínűleg találkozik azokkal, amelyek ékek vannak. Számos tesztet futtatnak a ptys-en, hogy elkerüljék a téves folyamatokkal való összefonódásokat. (Ez 10 másodpercet vesz igénybe egy szálas pty-enként.) A -d opcióval való futás megmutatja, hogy az Expect több ptyt érint-e páratlan állapotban. Ha nem tudod megölni azokat a folyamatokat, amelyekhez ezeket a fájlokat csatolják, akkor csak újraindulhat.
Ha a programot nem lehet sikeresen elindítani, mert a végrehajtás (2) sikertelen (pl. Ha a program nem létezik), a következő interakció vagy a parancs elvárása esetén hibaüzenet jelenik meg, mintha a program futna volna és a hibaüzenetet kimenetként állította volna elő. Ez a viselkedés természetes következménye a spawn megvalósításának. Belülről, spawn villákat, amelyek után az elevenített folyamat nem tud kommunikálni az eredeti Expect eljárással, kivéve ha a spawn_id keresztül kommunikál.
A -open zászló azt eredményezi, hogy a következő argumentum Tcl fájl azonosítóként értelmezhető (azaz nyitott .) A spawn id ezt követően fel lehet használni, mintha egy létrehozott folyamat lenne . (A fájlazonosítót már nem kell használni.) Ezzel nyers eszközöket, fájlokat és csővezetékeket kezelhet, mint létrehozott folyamatokat a pty használata nélkül. 0 visszakerül annak jelzésére, hogy nincs kapcsolódó folyamat . Amikor a kapcsolatot a létrehozott eljárással lezárták, akkor a Tcl fájl azonosítója is. A -leaveopen zászló hasonló a -open- hoz, azzal a különbséggel, hogy a -leaveopen a fájl azonosítóját nyitva hagyja még a spawn id bezárása után is.
Az üres zászló megnyitja a pty-t, de nem keletkezik folyamat . 0 visszakerül annak jelzésére, hogy nincs kapcsolódó folyamat . A Spawn_id szokásos módon van beállítva.
A spawn_out (slave, fd) változó a pty slave-nek megfelelő fájlazonosítóra van állítva. Zárt lehet zárni "szeles" segítségével.
A -ignore zászló olyan jelet jelöl , amelyet figyelmen kívül kell hagyni a létrehozott folyamat során . Ellenkező esetben a jelek megkapják az alapértelmezett viselkedést. A jelek neve a csapdaparanccsal azonos , kivéve, hogy minden jel külön zászlót igényel.
strace szint
a következő állításokat nyomtatja ki a végrehajtás előtt. (Tcl nyomkövetési parancs nyomon követi a változókat.) Szint azt jelzi, hogy milyen messze van a hívási verem nyomon követéséhez. Például, a következő parancs fut az Expect-et, miközben nyomon követi az első 4 hívásszintet, de az alatt sem.
Az -info zászló okozza a strace-ot, hogy visszaadja a legfrissebb nem-info-érvek leírását.
stty args
a külső stty parancshoz hasonlóan megváltoztatja a terminál módokat.
Alapértelmezés szerint a vezérlő terminál elérhető. Az egyéb terminálok elérése a "Request for status return" paranccsal történik, ha nincs szükség állapotra, és a vezérlő terminál elérhető, akkor a nyers és echo attribútumok előző állapotát egy olyan formában adják vissza, amely később amelyet a parancs használ.
Például a nyers vagy éppen felkínált érvek a terminált nyers üzemmódba helyezték. A -raw vagy főzött argumentumok a terminált főzött módba helyezték. Az echo és -echo argumentumok a terminált echo és noecho módba helyezték.
A következő példa bemutatja a visszhang visszavonásának ideiglenes letiltását. Ez másképp használható automatikus szkriptekben, így elkerülhető a jelszavak beágyazása. (Lásd az alábbiakban VIZSGÁLATI HÍRKÉNT.).
stty -echo send_user "Jelszó:" expect_user -re "(. *) \ n" jelszó megadása $ expect_out (1, string) stty echo rendszer args
a sh (1) bemenetként argumentumot ad, mint akkor, ha parancsot kaptunk termináltól. Várjon, amíg a héj meg nem szűnik. A sh visszatérési állapotát ugyanúgy kell kezelni, hogy az exec kezeli a visszatérési állapotát.
Ezzel ellentétben a végrehajtó, amely átirányítja a stdin és a stdout parancsot a rendszerhez , a rendszer nem végez átirányítást (kivéve azt, amit maga a karakterlánc jelez). Így lehetséges olyan programokat használni, amelyeknek közvetlenül a / dev / tty-vel kell beszélniük. Ugyanezen okból a rendszer eredményei nem szerepelnek a naplóban.
időbélyeg [args]
egy időbélyeget ad vissza. Bármelyik argumentum nélkül az időponthoz tartozó másodpercek száma visszaadható.
Az -format zászló bemutatja a visszaadott karakterláncot, de a POSEX szabályai szerint készített rétegek helyett. Például a% a helyett egy rövidített hétköznapi név (pl. Szo). Mások:
% egy rövid hétköznapi név% egy teljes napi név% b rövidített hónap neve% B teljes hónév% c dátum-idő, mint: Wed Okt 6 11:45:56 1993% d nap a hónapban (01-31% H óra (00-61)% óra (01-12)% j nap (001-366)% m hónap (01-12)% M perc (00-59)% p am vagy pm% S másodperc (00-61) % u nap (1-7, hétfő a hét első napja)% U hét (00-53, első vasárnap az első hét első napja)% V hét (01-53, ISO 8601 stílus)% w nap (0- 6)% W hét (00-53, első hétfő az első hét első napja)% x dátum-idő, mint: Wed Okt 6 1993% X ideje, mint: 23:59:59% y év (00-99) % Y éve, mint: 1993% Z időzóna (vagy semmi, ha nem határozható meg) %% meztelen százalék jelA többi% előírás nem definiált. Más karakterek áthaladnak érintetlenül. Csak a C locale támogatott.
A -seconds zászló számos másodpercet mutat be, mivel a korszak formátumként felhasználható forrásként használható. Ellenkező esetben az aktuális időt használják.
A -gmt flag erõsíti az idõbélyeg kimenetet a GMT idõzónának használatához. Jelző nélkül a helyi időzóna használatban van.
csapda [[parancs] jelek]
az adott parancsot a megadott jelek jövőbeli beérkezésének időpontjáig hajtja végre. A parancs végrehajtása a globális hatókörben történik. Ha a parancs hiányzik, akkor a jelzést visszaadják. Ha a parancs a SIG_IGN karakterlánc, akkor a jelek figyelmen kívül maradnak. Ha a parancs a SIG_DFL karakterlánc, akkor a jelek a rendszer alapértelmezéséhez vezetnek. a jelek egy jel vagy egy jelek listája. A jelek numerikusan vagy szimbolikusan megadhatók jelként (3). A "SIG" előtag elhagyható.
Ha nincs argumentum (vagy az argumentum-szám), a csapda visszaadja a pillanatnyilag végrehajtott csapásparancs jelét.
A -code jelző a parancs visszatérési kódját használja annak a kódnak a helyett, amelyre a Tcl vissza akar térni, amikor a parancs eredetileg futott.
A -interp zászló azt eredményezi, hogy a parancsot a beolvasás idején aktív parancsértelmező használatával kell értékelni, nem pedig a csapda deklarálásakor.
A -name flag a csapdaparancsot visszaadja az éppen futó csapda parancs nevének.
A -max zászló okozza a csapó parancsot, hogy visszaállítsa a beállítható legnagyobb jelszámot .
Például a "trap {send_user" Ouch! "} SIGINT parancs a" Ouch! " minden alkalommal, amikor a felhasználó megnyomja a ^ C billentyűt.
Alapértelmezés szerint a SIGINT (amely általában a ^ C) és a SIGTERM gomb megnyomásával generálható, az Expect kilépését eredményezi. Ez a következő csapdának köszönhető, amelyet alapértelmezés szerint hoztak létre, amikor az Expect elindul.
csapda kilépés {SIGINT SIGTERM}Ha a -D flag-ot használja a debugger indításához, a SIGINT újra definiálódik az interaktív hibakereső indításához. Ez a következő csapdának köszönhető:
trap {exp_debug 1} SIGINTA hibakereső csapda megváltoztatható az EXPECT_DEBUG_INIT környezeti változó beállításával egy új csapda parancsra.
Természetesen felülbírálhatja mindkettőt csak a parancsfájl parancsára. Különösen, ha saját "csapdás kilépési SIGINT" van, ez felülbírálja a hibakereső csapdát. Ez akkor hasznos, ha meg szeretné akadályozni a felhasználókat, hogy egyáltalán eljussanak a hibakeresőhöz.
Ha saját csapdáját szeretné meg definiálni a SIGINT-on, de továbbra is csapdába esik a hibakeresőhöz, akkor használja:
ha {! [exp_debug]} {trap mystuff SIGINT}Alternatív megoldásként a hibakeresőt másik jel segítségével is megteheti.
a csapda nem engedheti meg, hogy felülírja a SIGALRM műveletét, mivel ezt belsőleg használja az Expect . A disconnect parancs a SIGALRM beállítást SIG_IGN (ignore) értékre állítja. Ezeket mindaddig visszaállíthatja, amíg letiltja azt a következő spawn parancsok alatt.
További információért lásd a (3) jelet.
várjon [args]
késlelteti, amíg egy kivágott folyamat (vagy az aktuális folyamat, ha egyiket sem nevezik) megszűnik.
várakozás általában négy egész számot ad vissza. Az első egész szám az a folyamat , amelyet vártak. A második egész szám a megfelelő spawn id. A harmadik egész szám -1, ha operációs rendszer hiba történt, vagy 0 egyébként. Ha a harmadik egész szám 0, akkor a negyedik egész szám az elválasztott folyamat által visszaküldött állapot. Ha a harmadik egész szám -1, akkor a negyedik egész az operációs rendszer által beállított errno értéke. A globális változó errorCode is meg van adva.
További elemek jelenhetnek meg a visszatérési érték végén a várakozástól . Az opcionális ötödik elem azonosítja az információosztályt. Jelenleg az elem egyetlen lehetséges értéke CHILDKILLED, mely esetben a következő két érték a C-típusú jel neve és rövid szöveges leírása.
A -i flag deklarálja a folyamatot, hogy várjon a megnevezett spawn_id (NEM a folyamat azonosítója). A SIGCHLD-kezelőn belül bármely ikrázott folyamat várakozási ideje meg lehet várni a spawn id -1 használatával.
A -nowait zászló azt eredményezi, hogy a várakozás azonnal visszatér a sikeres várakozás jelzésével. Amikor a folyamat kilép (később), akkor automatikusan megszűnik anélkül, hogy kifejezett várakozásra lenne szüksége.
A várakoztatás parancsot is használhatjuk a "-i -1" argumentumok használatával. A létrehozott folyamatokkal szemben ez a parancs bármikor végrehajtható. Nincs ellenõrzés arra, hogy melyik folyamatot érik el. A folyamatazonosító azonban ellenőrizhető a visszatérési értéken.
KÖNYVTÁRAK
Expect automatikusan ismeri két beépített könyvtárat az Expect szkriptekhez. Ezeket a exp_library és exp_exec_library változókban megadott könyvtárak határozzák meg. Mindkettő olyan parancsfájlokat tartalmaz, amelyeket más szkriptek használhatnak.
A exp_library architektúrával nem rendelkező fájlokat tartalmaz. A exp_exec_library architektusfüggő fájlokat tartalmaz. A rendszerétől függően mindkét könyvtár teljesen üres lehet. A $ exp_exec_library / cat-buffer fájl létezése írja le, hogy a / bin / cat pufferek alapértelmezés szerint.
PRETTY nyomtatás
A vgrind definíció elérhető a szép nyomtatási Expect szkriptekhez. Feltételezve, hogy a vgrind definíciója az Expect eloszlással megfelelően lett telepítve, használhatja ezt:
vgrind -lexpect fájlPÉLDÁK
Sokan nem lehetnek nyilvánvalóak, hogyan kell mindent összeszedni, amit a man oldal leír. Bízom benne, hogy olvassa el és próbálja ki a példákat az Expect eloszlás példakézikönyvében . Néhány közülük valódi programok. Mások egyszerűen illusztrálják bizonyos technikákat, és természetesen egy pár csak gyors hack. Az INSTALL fájl gyors áttekintést nyújt ezekről a programokról.
Az Expect papírok (lásd LÁSD MÉG) szintén hasznosak. Miközben egyes papírok az Expect korábbi verzióinak megfelelő szintaxist használják, a kísérő okok még mindig érvényesek és sokkal részletesebbek lesznek, mint a man oldalon.
FENNTARTÁSOK
A kiterjesztések ütköznek az Expect parancsneveivel. Például a küldetet Tk határozza meg teljesen más célra. Emiatt az Expect parancsok többsége "exp_XXXX" -ként is elérhető. A "exp", "inter", "spawn" és "timeout" -al kezdődő parancsok és változók nem tartalmaznak álneveket. Használja a kiterjesztett parancsneveket, ha ez a kompatibilitás a környezetek között.
A várakozás meglehetősen liberális nézetet képvisel. Különösen az Expect programhoz tartozó parancsok által olvasott változókat keresik először a helyi hatókörből, és ha nem találják meg, a globális hatókörben. Ez például elkerüli a "globális időtúllépés" helyét minden olyan eljárásban, amelyet a várakozások szerint ír. Másrészt az írott változók mindig a helyi hatókörben vannak (kivéve, ha "globális" parancsot adtak ki). A leggyakoribb probléma az, amikor az ív létrehozása folyamatban van. Az eljáráson kívül a spawn_id már nem létezik, így az elterjedt folyamat már nem hozzáférhető egyszerűen a körforgás miatt. Adjon hozzá egy "globális spawn_id" -et egy ilyen eljáráshoz.
Ha nem tudja engedélyezni a multispawning képességet (pl. A rendszer nem támogatja sem a szelektált (BSD *. *), A poll (SVR> 2), sem az egyenértékű kifejezést), az Expect csak egyszerre képes egyetlen folyamat vezérlésére. Ebben az esetben ne próbálkozzon meg a spawn_id beállításával, és ne hajtsa végre a folyamatokat végrehajtás közben, amikor egy létrehozott folyamat fut. Ezenkívül egyszerre több folyamatból (beleértve a felhasználót is) nem fog számolni .
A terminálparaméterek nagy hatással lehetnek a szkriptekre. Például, ha egy szkriptet írt, hogy visszhangot keresjen, a visszhang visszavonásakor rosszul fog működni. Emiatt az Expect az alapértelmezés szerint hangos terminálparamétereket tartalmaz. Sajnos ez a dolgokat kellemetlenné teheti a többi program számára. Például az emacs héja megváltoztatja a "szokásos" leképezést: az újvonalak az újvonalakra vannak leképezve a kocsi-visszatérő újvonalak helyett, és a visszhang visszahúzódik. Ez lehetővé teszi az emacs használatát a bemeneti sor szerkesztéséhez. Sajnos, az Expect ezt nem tudja kitalálni.
Megkérheti, hogy az Expect not felülírja a terminál paramétereinek alapértelmezett beállítását, de akkor nagyon óvatosnak kell lennie, amikor írásokat írsz ilyen környezetekhez. Az emacs esetében elkerülje a visszhangot és a végső sorrendi leképezést.
Azok a parancsok, amelyek elfogadták az argumentumokat egyetlen listára (az elvárt változatok és a kölcsönhatás ), heurisztikusan használják annak eldöntését, hogy a lista tényleg egy argumentum vagy sok. A heurisztika csak abban az esetben sikertelen, ha a lista ténylegesen egyetlen olyan argumentumot képvisel, amely több beágyazott \ n-et tartalmaz nem-fehérek közötti karakterekkel közöttük. Ez eléggé valószínűtlennek tűnik, azonban az "nobrace" érv arra használható, hogy egy érvet egyetlen érvként kezeljünk. Ezt elképzelhetően a gép által generált Expect kóddal lehet használni. Hasonlóképpen, a -brace egy olyan érvet kényszerít, amelyet több mintázatnak és műveletnek kell kezelnie.
HIBÁK
Igazán csábító volt a "szex" program megnevezése ("Smart EXEC" vagy "Send-EXpect"), de jó értelemben (vagy talán csak puritánizmusban) uralkodott.
Egyes rendszereknél, amikor egy héj elszívódik, azt panaszolja, hogy nem fér hozzá a tty-hez, de egyébként is működik. Ez azt jelenti, hogy a rendszernek van mechanizmusa arra, hogy megszerezzük az ellenőrző tty-t, amelyet az Expect nem tud. Kérem, derítse ki, mi az, és küldje vissza nekem ezt az információt.
Az Ultrix 4.1-es verziója (legalább a legfrissebb verziók itt) a 1000000-nél több időtúllépésnél 0-nak felel meg.
A Digital UNIX 4.0A (és valószínűleg más verziók) megtagadja a ptys hozzárendelését, ha egy SIGCHLD kezelőt definiál. További információért lásd a támogatott oldalt.
Az IRIX 6.0 nem kezeli helyesen a pty-engedélyeket, így ha az Expect egy másik felhasználó által korábban használt pty lefoglalására törekszik, akkor nem sikerül. Frissítés az IRIX 6.1-re.
A Telnet (csak a SunOS 4.1.2 alatt ellenőrzött) lefagy, ha a TERM nincs beállítva. Ez egy probléma a cron, cgi és cgi parancsfájlok alatt, amelyek nem definiálják a TERM-et. Így egyértelműen be kell állítania - hogy milyen típusú általában nem releváns. Csak be kell állítani valamit! A következő esetekben a legtöbb esetben elegendő.
set env (TERM) vt100Tipp (csak a BSDI BSD / OS 3.1 i386 alatt ellenőrzött), ha a SHELL és a HOME nincs beállítva. Ez egy probléma a cron , cgi és cgi parancsfájlok alatt, amelyek nem definiálják ezeket a környezeti változókat. Így kifejezetten meg kell határoznia őket - milyen típusú általában nem releváns. Csak be kell állítani valamit! A következő esetekben a legtöbb esetben elegendő.
set env (SHELL) / bin / sh beállít env (HOME) / usr / local / binNéhány ptys implementáció úgy van megtervezve, hogy a rendszermag elhagyja az olvasatlan kimenetet 10-15 másodperc elteltével (a tényleges szám a végrehajtás függvénye), miután a folyamat leállította a fájlleírást. Így várható programok, mint például
spawn dátum alvás 20 várhatóel fog bukni. Ennek elkerülése érdekében hívja meg a nem interaktív programokat a végrehajtó helyett az ívás helyett. Bár az ilyen helyzetek elképzelhetők, a gyakorlatban soha nem tapasztaltunk olyan helyzetet, amelyben a valóban interaktív program végső kimenete elveszne ilyen viselkedés miatt.
Másrészről, a Cray UNICOS elhagyja az olvasatlan kimenetet, miután a folyamat leállította a fájlleírást. Ezt jelentettem Cray-nek, és egy fixen dolgoznak.
Néha a prompt és a válasz között késés szükséges, például amikor egy tty interfész megváltoztatja az UART beállításokat vagy a megfelelő átviteli sebességeket az induló / leállítandó bitek megkeresésével. Általában mindez megköveteli, hogy aludjon egy-két másodpercig. A robusztusabb technika az újrapróbálkozás, amíg a hardver készen áll a bemeneti adatok fogadására. A következő példa mindkét stratégiát használja:
küldés "9600 sebesség"; alvás 1 vár {timeout {küldés "\ r"; exp_continue} $ prompt}a trap-code nem működik olyan parancsokkal, amelyek a Tcl eseményhurokjában ülnek, például az alvás. A probléma az, hogy az esemény hurok esetén a Tcl visszavonja a visszatérési kódokat az async eseménykezelőktől. A megoldás egy zászló beállítása a csapda kódjában. Ezután ellenőrizze a zászlót közvetlenül a parancs után (pl. Alvás).
A expect_background parancs figyelmen kívül hagyja az argumentumokat, és általában nincs ideje az időtúllépésekre.
& # 34; EXPECT HINTS & # 34;
Vannak olyan dolgok, amelyek lehetnek nem intuitívek. Ez a rész néhány javaslattal próbál foglalkozni néhány ilyen dologgal.
A közös problémát váró probléma az, hogy hogyan lehet felismerni a parancsértelmezőket. Mivel ezeket különböző módon személyre szabják különböző emberek és különböző kagylók, a rlogin hordozható automatizálása nehéz lehet anélkül, hogy tudná a promptot. Az ésszerű konvenció az, hogy a felhasználók az EXPECT_PROMPT környezeti változóban a rendszeres kifejezést (különösen annak végét) írják le. Az alábbiakhoz hasonló kódot lehet használni. Ha az EXPECT_PROMPT nem létezik, a kód még mindig jó eséllyel működik megfelelően.
set prompt "(% | # | \\ $) $"; # alapértelmezett prompt fogása {set prompt $ env (EXPECT_PROMPT)} expect -re $ promptBízom benne, hogy írjon olyan elvárásokat, amelyek magukban foglalják a végeit, amire számíthat. Ezzel elkerülhető a kérdés megválaszolásának lehetősége, mielőtt az egészet meglátja. Továbbá, bár a kérdések megválaszolása előtt teljesen megválaszolhatja a kérdéseket, ha korán válaszol, akkor a válasz a kérdés közepén visszhangként jelenhet meg. Más szavakkal, az így létrejövő párbeszéd helyes lesz, de megdőlt.
A legtöbb utasítás tartalmaz egy szóköz karaktert a végén. Például az ftp parancs kérdése: 'f', 't', 'p', '>' és. Ennek a lekérdezésnek a megfeleléséhez figyelembe kell venni az egyes karaktereket. Általános hiba, hogy ne tegye bele a vakut. Tegye egyértelműen az üresen.
Ha az X * formanyomtatvány mintáját használja, akkor a * a X végétől kapott összes kimenetet a kapott utolsó dologhoz igazítja. Ez intuitívnek tűnik, de kissé zavaró lehet, mert a "legutoljára megkapott" kifejezés a számítógép sebességétől és az I / O feldolgozásától függően változhat a rendszermag és az eszközillesztő között.
Különösen az emberek hajlamosak arra, hogy a program kimenetét óriási darabokra (atomikusan) érje el, amikor a valóságban a legtöbb program egy sorban kimeneti teljesítményt termel. Feltételezve, hogy ez az eset áll fenn, az előző bekezdésben szereplő * * csak az aktuális vonal végéhez érhet, annak ellenére, hogy úgy tűnik, hogy több van, mert a meccs idején a teljes kimenet volt.
nem számíthat arra, hogy további kimenet jön, hacsak a mintája kifejezetten nem számol.
Még a line-orientált puffereléstől is függõen. Nem csak a programok ritkán teszik ígéretüket arról, hogy milyen pufferelést végeznek, de a rendszer emésztési zavarai megszakíthatják a kimeneti vonalat úgy, hogy a vonalak elváltak a látszólag véletlenszerű helyeken. Így, ha írásmóddal írhatod meg az utolsó néhány karaktert, akkor bölcs dolog ezt megtenni.
Ha egy program legutóbbi kimenetén egy minta várakozik, és a program emiatt valami másat bocsát ki, akkor nem fogja tudni észlelni azt a timeout kulcsszóval. Ennek az az oka, hogy az elvárás nem lesz időtúllépés - hanem eof- jelzést kap. Használd helyett. Még jobb, használj mindkettőt. Így ha ez a vonal soha nem mozog, akkor nem kell szerkesztenie a sort.
Az új vonalak általában átalakulnak kocsi vissza, linefeed szekvenciák, amikor a terminál meghajtó. Így ha olyan mintát szeretne, amely kifejezetten illeszkedik a két sorhoz, például printf ("foo \ nbar"), akkor használja a "foo \ r \ nbar" mintát.
Hasonló fordítás fordul elő, ha a felhasználótól a expect_user segítségével olvas . Ebben az esetben, ha megnyomja a visszatérést, akkor lefordítódik egy új sorra. Ha az Expect ezt követően átmegy egy olyan programra, amely a terminált nyers üzemmódba állítja (mint például a telnet), akkor probléma merül fel, mivel a program elvárja a tényleges visszatérést. (Egyes programok valóban megbocsátanak, mert automatikusan lefordítják az újvonalakat a visszatérésekre, de a legtöbb nem.) Sajnos nincs mód annak megállapítására, hogy egy program a terminált nyers üzemmódba helyezte.
Ahelyett, hogy manuálisan helyettesítené az újvonalakat visszatéréssel, a megoldás a "stty raw" parancs használata, amely leállítja a fordítást. Ne feledje azonban, hogy ez azt jelenti, hogy már nem kapja meg a főzött vonalszerkesztési funkciókat.
interakció implicit módon beállítja a terminált nyers üzemmódba, így ez a probléma nem fog felmerülni.
Gyakran hasznos a jelszavak (vagy más személyes adatok) tárolása az Expect szkriptekben. Ez nem ajánlott, mivel bármi, ami a számítógépen tárolódik, bárki hozzáférhet. Így a szkriptből érkező jelszavak interaktív módon történő ösztönzése okosabb ötlet, mint szó szerinti beágyazás. Mindazonáltal néha az ilyen beágyazás az egyetlen lehetőség.
Sajnos a UNIX fájlrendszernek nincs közvetlen módja a parancsfájlok létrehozására, amelyek végrehajthatóak, de olvashatatlanok. A setgid shell parancsfájlokat támogató rendszerek közvetve ezt a következőképpen szimulálhatják:
Hozzon létre az Expect szkriptet (ami a titkos adatokat tartalmazza), mint rendesen. Engedélyezze az engedélyeket 750 (-rwxr-x ---) és egy megbízható csoport tulajdonosa, vagyis egy olyan csoport, amely el tudja olvasni. Szükség esetén hozzon létre egy új csoportot erre a célra. Ezután készítsen egy / bin / sh parancsfájlt a 2751 (-rwxr-s - x) engedélyekkel, amelyek ugyanazt a csoportot kapják, mint korábban.
Az eredmény egy szkript, amelyet bárki végrehajthat (és olvas). Visszahíváskor az Expect szkript fut.
& # 34; LÁSD MÉG: & # 34;
Tcl (3), libexpect (3)
"Expecting Expect: A Tcl alapú eszköztár az interaktív programok automatizálására" , Don Libes, 602. oldal, ISBN 1-56592-090-2, O'Reilly és munkatársai, 1995.
"várják: az interaktivitás kontrollálhatatlan illeszkedését" Don Libes, az 1990-es nyári 1990-es kiadvány, Anaheim, Kalifornia, 1990. június 11-15.
"A Rendszerfelügyeleti feladatok automatizálásának várakozásai" című kiadványban Don Libes, az 1990-es USENIX Nagy Telepítési Rendszerigazgatási Konferencia, Colorado Springs, Colorado, 1990. október 17-19.
"Tcl: a beágyazható parancsnyelv", John Ousterhout, a Téli 1990-es kiadványai, USENIX konferencia, Washington, DC, 1990. január 22-26. "Don Abbes, számítástechnikai rendszerek" elvárása: Scripts Interactive Programs vezérléséhez " , Vol. 4, 2. szám, a Kaliforniai Egyetemi folyóiratok folyóirata, 1991. november. "A regressziós tesztelés és a megfelelőség tesztelés interaktív programjai", Don Libes, az 1992. nyári USENIX konferencia, 135-144. Oldal, San Antonio, TX, 1992. június 12-15. "Kibitz - Több interaktív program összekapcsolása", Don Libes, Software - Practice & Experience, John Wiley & Sons, West Sussex, Anglia, v.
Az 1993-as Tcl / Tk Workshop, Berkeley, CA, 1993. június 10-11., Kiadta: Don Libes, "A Debugger for Tcl Applications".
SZERZŐ
Don Libes, Nemzeti Szabványügyi és Technológiai Intézet
KÖSZÖNETNYILVÁNÍTÁS
Köszönet John Ousterhout számára a Tcl-nek és Scott Paisley-nek inspirációért. Köszönjük Rob Savoye for Expect autokonfigurációs kódját.
A HISTORY fájl dokumentálja az elvárások fejlődésének nagy részét. Érdekes olvasást tesz lehetővé, és további betekintést nyújthat ehhez a szoftverhez. Köszönöm a benne említetteket, akik hibajavításokat küldtek és más segítséget nyújtottak.
Az Expect megtervezése és végrehajtása részben az amerikai kormány részéről fizetett, ezért közkinccsé vált. Azonban a szerző és a NIST szeretne, ha ezt a programot és dokumentációt vagy részeit felhasználják.