Очекуваат е програма која разговара со други интерактивни програми според сценариото. Следејќи го сценариото, Очекувајте да знаат што може да се очекува од некоја програма и што треба да биде точниот одговор. Интерпретиран јазик обезбедува разгранување и структури на контрола на високо ниво за да го насочи дијалогот. Покрај тоа, корисникот може да ја преземе контролата и да комуницира директно по желба, потоа да се врати контролата на сценариото.
Expectk е мешавина од Expect и Tk. Се однесува како желбата на Очек и Тк. Очекуваат, исто така, може да се користи директно во C или C + + без Tcl.
Името "Очекување" доаѓа од идејата за испраќање / очекување на секвенци кои се популаризирани од uucp, kermit и други програми за контрола на модемот. Сепак, за разлика од uucp, Expect е генерализирана така што може да се изврши како корисник на ниво на команда со која било програма и задача во умот. Очекувајте да разговарате со неколку програми во исто време.
Што очекува да направи
На пример, тука се и некои работи што може да ги направи командата очекуваат:
- Предизвикајте го компјутерот да ве повика назад, за да можете да се најавите без да плаќате за повикот.
- Започнете игра и ако оптималната конфигурација не се појави, рестартирајте го одново и одново) додека не го стори тоа, а потоа ја предаде контролата на вас.
- Стартувај fsck , и како одговор на своите прашања, одговорете "да" или "не" или да му дадете контрола врз вас, врз основа на предодредени критериуми.
- Поврзете се со друга мрежа и автоматски ја добивате вашата пошта, така што ќе се појави како да е првично испратена до вашиот локален систем.
- Носете променливи на околината, тековниот директориум или било каков вид на информации преку rlogin, telnet, tip, su , или chgrp
Постојат различни причини зошто школка не може да ги извршува овие задачи. Сите се можни со Очекуваат.
Во принцип, Expect е корисно за извршување на било која програма која бара интеракција помеѓу програмата и корисникот. Сè што е потребно е дека интеракцијата може да се карактеризира како програмски. Очекуваат, исто така, може да ја врати контролата на корисникот без да ја запре програмата што се контролира. Слично на тоа, корисникот може да ја врати контролата во сценариото во секое време.
Употреба
Очекуваат чита cmdfile за листа на команди за извршување. Очекуваме може да се повика имплицитно на системи кои го поддржуваат #! нотација со означување на сценариото како извршна и правење на првата линија во сценариото:
#! / usr / local / bin / expect -fСе разбира, патеката мора точно да опише каде Оживот живее. / usr / local / bin е само пример.
Знамето -c претпоставува команда која треба да се изврши пред било кој од сценариото. Командата треба да се цитира за да се спречи растурање од страна на школка. Оваа опција може да се користи повеќе пати. Повеќекратни команди може да се извршат со еден -c со нивно раздвојување со точка-запирка. Командите се извршуваат по редоследот по кој се појавуваат. Кога користите Expectk, оваа опција е наведена како -command.
Знакот -d овозможува извесен дијагностички излез, кој првенствено ја пријавува внатрешната активност на командите како што се очекува и комуницирате. Ова знаме го има истиот ефект како "exp_internal 1" на почетокот на сценариото Expect, плус верзијата на Expect е испечатена.
Знакот -D овозможува интерактивен дебагер. Треба да се следи целобројна вредност. Дебагерот ќе ја преземе контролата пред следната постапка Tcl ако вредноста е не-нула или ако е притиснато ^ C или е прекината точка на прекин, или во скриптата се појавува друга соодветна команда за дебагерот. Кога користите Expectk, оваа опција е наведен како - Debug.
Знамето -f претпочита датотека од која може да чита команди. Самиот знаме е опционален бидејќи е корисен само при користење на #! нотација, така што другите аргументи може да бидат доставени на командната линија. Кога користите Expectk, оваа опција е наведена како-датотека.
По дифолт, командната датотека се чита во меморијата и се извршува во целост. Повремено е пожелно да се читаат датотеките една линија одеднаш. Со цел да се присили арбитрарните датотеки да се управуваат на овој начин, користете го знакот -b. Кога се користи Expectk, оваа опција е наведена како-буфер.
Ако низата "-" се доставува како име на датотека, наместо стандардниот влез се чита. Користете "./-" за да прочитате од датотеката која е всушност наречена "-".
Знамето -i предизвикува Очекуваме интерактивно да прашува за команди, наместо да ги чита од датотеката. Прашањето се прекинува преку командата за излез или по EOF. Знакот -i се претпоставува ако не се користи командна датотека ниту -c. Кога користите Expectk, оваа опција е наведена како-интерактивна.
- може да се користи за разграничување на крајот на опциите. Ова е корисно ако сакате да го пренесете аргументот како опција во вашата скрипта без да биде толкувана од Expect. Ова може полесно да се стави во #! линија за да се спречи каква било транспарентна интерпретација од Очекувајте. На пример, следниве ќе ги остават оригиналните аргументи, вклучувајќи го и името на сценариото во променливата argv .
#! / usr / local / bin / expect -Забележете дека вообичаените усвојувања getopt (3) и execve (2) мора да се набљудуваат при додавање аргументи на #! линија.
Датотеката $ exp_library / expect.rc се добива автоматски ако е присутна, освен ако не се користи знакот -N. (Кога се користи Expectk, оваа опција е назначена како -NORC.) Веднаш по ова, датотеката ~ / .expect.rc се добива автоматски, освен ако не се користи знакот -n. Ако е дефинирана променливата на околината DOTDIR, таа се третира како директориум и од таму се чита .expect.rc. Кога користите Expectk, оваа опција е наведена како -norc. Овој извор се појавува само по извршување на било-знамиња -c.
-v причини Очекувајте да го испечатите бројот на верзијата и да излезете. Соодветното знаме во Expectk, кое користи имиња со долги знамиња, е -верзија.
Изборните аргументи се конструирани во листа и се зачувуваат во променливата наречена argv и. argc е иницијализиран на должината на argv.
Argv0 е дефиниран како име на сценариото или бинарно ако не се користи скрипта. На пример, следново го испишува името на сценариото и првите три аргументи:
send_user "$ argv0 [langage $ argv 0 2] \ n"Команди
Очекуваат користи команден јазик на алатката. Tcl обезбедува контролен проток (ако, за, скрши), проценка на изразот и неколку други функции, како што е рекурзијата и дефиниција на постапката. Командите што се користат тука, но не се дефинирани (поставени, ако, exec) се Tcl команди. Очекуваат поддржува дополнителни команди. Освен ако не е поинаку наведено, командите ја враќаат празен стринг.
Командите се наведени по азбучен ред, за да можат брзо да се лоцираат. Сепак, на новите корисници може да им биде полесно да почнат со читање на описите на потомство, испраќање, очекување и интеракција, во тој редослед.
close [-slave] [-onexec 0 | 1] [-i spawn_id]ја затвора врската со тековниот процес . Повеќето интерактивни програми ќе го откријат EOF на нивниот стандард и излез; Така блиску обично е доволно да го убие процесот, исто така. Знакот -i го декларира процесот да се затвори што одговара на именуваниот spawn_id.
Очекувањата и интеракцијата ќе детектираат кога тековниот процес ќе излезе и имплицитно ќе се затвори, но ако го убиете процесот со, на пример, "exec kill killer", треба експлицитно да се јавите во близина .
Знамето -onexec одредува дали ID на замрзнување е затворен во било какви нови добиени процеси или ако процесот е преклопен. За да се остави отворен идентификатор, употребете ја вредноста 0. Целокупната вредност што не е нула го присилува замрзнувањето затворено во сите нови процеси.
Знамето -слој го затвора роботот поврзан со идентитетот. Кога врската е затворена, робовот автоматски се затвора, ако е сè уште отворен.
Без разлика дали врската е затворена имплицитно или експлицитно, треба да повикате чекаат да го исчистат соодветниот слот за процесорот на јадрото. Командата за затворање не повикува чека, бидејќи нема гаранција дека затворањето на конекцијата ќе предизвика да излезе.
debug [[-now] 0 | 1]го контролира дебагерот Tcl што ви овозможува да ги чекорите изјавите и да поставите гранични точки.
Без аргументи, 1 се враќа ако дебагерот не работи, инаку се враќа 0.
Со 1 аргумент, дебагерот се стартува. Со аргумент 0, дебагерот се прекинува. Ако на 1 аргумент му претходи знамето -now, дебагерот започнува веднаш. Во спротивно, дебагерот започнува со следната изјава Tcl.
Командата за дебагирање не менува никакви стапици. Споредете го ова за да го стартувате Expect со знакот -D.
Командата за исклучување го исклучува процесот на раздвојување од терминалот . Таа продолжува да работи во позадина. Процесот е даден со сопствената процесна група. Стандардниот I / O се пренасочува кон / dev / null .
Следниот фрагмент користи исклучување за да продолжите со работа на сценариото во позадина.
ако {[вилушка]! = 0} излез исклучите. . .Следниот скрипт чита лозинка, а потоа ја извршува програмата секој час што бара лозинка секогаш кога се работи. Скриптата ја снабдува лозинката, така што само еднаш мора да ја напишете.
Испратете "send_user" лозинка? "expect_user -re" (. *) \ n "за {} 1 {} {ако {[fork]! = 0} {спиење 3600; 1, низа) \ r ". . . излез}Предност за користење на исклучување преку функцијата за асинхрони процес на школка (&) е дека Очекувањата можат да ги зачуваат терминалните параметри пред да се исклучат, а потоа да ги применат на нови ptys. Со &, Expect нема шанса да ги прочита параметрите на терминалот бидејќи терминалот веќе е исклучен од времето кога Expect добива контрола.
излез [-opts] [статус]причини Очекуваме да излезете или на друг начин да се подготвите за тоа.
Знамето -несетото предизвикува следниот аргумент да се користи како излез управувач. Без аргумент, се враќа тековниот управувач за излез.
Знамето кое не е експлицитно предизвикува Очекува да се подготви за излез, но не успее да ја врати контролата на оперативниот систем. Се извршува кориснички дефиниран управувач за излез, како и сопствени внатрешни ракувачи на Expect. Не треба да се извршуваат други очекувани команди. Ова е корисно ако користите Expect со други Tcl екстензии. Тековниот преведувач (и главниот прозорец ако во околината Tk) остануваат така што другите Tcl екстензии можат да се исчистат. Ако излезот на Expect се повика повторно (но ова може да се случи), ракувачите не се повторуваат.
По излегување, сите врски со создадените процеси се затворени. Затворањето ќе се открие како EOF од страна на создадените процеси. излезот не презема други дејства надвор од она што нормалната процедура _exit (2) ја прави. Така, подигнатите процеси кои не проверуваат за EOF може да продолжат да работат. (Различни услови се важни за да се утврдат, на пример, какви сигнали ќе бидат испратени, но тие се системски зависни, обично документирани под излез (3).) Поставените процеси што продолжуваат да се извршуваат ќе бидат наследени од init.
статусот (или 0 ако не е наведен) се враќа како статус на излез на Очекуваат . излезот е имплицитно извршен ако се достигне крајот на сценариото.
exp_continue [-continue_timer]
Командата exp_continue овозможува да се очекува да продолжи да извршува, а не да се враќа како што нормално би го сториле. Стандардно exp_continue го обновува тајмерот за истекување. Знамето -continue_timer го спречува рестартирањето на тајмерот. (Види ги очекувањата за повеќе информации.)
exp_internal [-f датотека] вредност
предизвикува понатамошни команди за испраќање на внатрешна дијагностичка информација за Одете на stderr ако вредноста не е нула. Овој излез е оневозможен ако вредноста е 0. Дијагностичките информации го вклучуваат секој применат карактер, и секој обид е направен да одговара на тековниот излез во однос на шаблоните.
Доколку се испорачува опционалната датотека , сите нормални и дебагирачки резултати се запишани во таа датотека (без оглед на вредноста на вредноста ). Секоја претходна дијагностичка излезна датотека е затворена.
Знамето -инфо предизвикува exp_internal да врати опис на најновите аргументи за не-информации.
exp_open [args] [-i spawn_id]
враќа идентификатор на Tcl-датотека што одговара на оригиналниот идентификатор на spawn. Идентификаторот на датотеката потоа може да се користи како да е отворен со отворена команда на Tcl. (Идентификацијата за потомство не треба повеќе да се користи. Не треба да се изврши чекање .
Знамето- слепило го остава отворениот id за отворен пристап преку командите Expect . Чекањето мора да се изврши на идентитетот.
exp_pid [-i spawn_id]
го враќа идентификацијата на процесот што одговара на тековниот процес. Ако се користи знакот -i , вратениот pid одговара на оној на дадениот id.
exp_send
е алијас за испраќање .
exp_send_error
е алијас за send_error .
exp_send_log
е алијас за send_log .
exp_send_tty
е алијас за send_tty .
exp_send_user
е алијас за send_user .
exp_version [[-exit] верзија]
е корисно за да се осигура дека сценариото е компатибилно со моменталната верзија на Expect.
Без аргументи, тековната верзија на Expect се враќа. Оваа верзија потоа може да биде кодирана во вашата скрипта. Ако всушност знаете дека не користите функции од последните верзии, можете да наведете претходна верзија.
Верзиите се состојат од три броја разделени со точки. Прво е главен број. Скриптите напишани за верзии на Очекуваат со друг голем број практично сигурно нема да функционираат. exp_version враќа грешка ако главните броеви не се совпаѓаат.
Второто е помалиот број. Скриптите напишани за верзија со поголем помал број од тековната верзија може да зависат од некоја нова функција и може да не работат. exp_version враќа грешка ако главните броеви се совпаѓаат, но малиот скрипт е поголем од сценариото на Очекуваниот .
Трето е број кој не учествува во споредба со верзијата. Меѓутоа, таа се зголемува кога дистрибуцијата на софтвер Expect се менува на кој било начин, како на пример преку дополнителна документација или оптимизација. Се ресетира на 0 по секоја нова помала верзија.
Со знакот -exit , Expect отпечатоци грешка и ќе излезе ако верзијата е застарена.
се очекува [[-opts] pat1 body1] ... [-opts] patn [bodyn]
чека додека еден од шаблоните не се совпаѓа со излезот на создаден процес, поминал одреден временски период или се гледа крај-на-датотека. Ако финалното тело е празно, може да биде испуштено.
Моделите од најновата команда expect_before се имплицитно користени пред сите други шаблони. Моделите од најновата очекувана_последна команда се имплицитно користени по било која друга шема.
Ако аргументите за целата очекувана изјава бараат повеќе од една линија, сите аргументи можат да бидат "заглавени" во една, за да не се прекине секоја линија со обратна коса црта. Во овој случај, вообичаените Tcl замени ќе се појават и покрај загради.
Ако модел е клучен збор eof , соодветното тело се извршува по крајот на датотеката. Ако модел е времетраењето на клучен збор, соодветното тело се извршува по истекот на времето. Ако не се користи клучен збор за истек на време, имплицитна нулта акција се извршува по истекот на времето. Стандардниот временски период е 10 секунди, но може да се постави, на пример, до 30, со командата "Постари времетраење 30". Бесконечното истекување може да се означи со вредност -1. Ако модел е стандардна клучен збор, соодветното тело се извршува по тајминг или крај на датотеката.
Ако некој образец се совпадне, тогаш соодветното тело се извршува. се очекува да го враќа резултатот од телото (или празна низа ако не се совпаѓа со моделот). Во случај да се совпаѓаат повеќекратни обрасци, оној што се појавува прво се користи за избор на тело.
Секој пат кога ќе пристигне нов излез, тој се споредува со секоја шема во редоследот на кој тие се наведени. Така, може да пробате за отсуство на натпревар со тоа што ќе направите последна шема што ќе гарантира нешто што ќе се појави, како што е најава. Во ситуации каде што нема напредок, мора да го користите истек на време (исто како што би сакал ако сте интеракција рачно).
Моделите се специфицирани на три начини. По дифолт, шаблоните се специфицирани како со командата за стрингот на Tcl. (Таквите обрасци се слични на регуларните изрази на Ц-школка, кои вообичаено се нарекуваат "шаблони"). Знакот -gl може да се користи за заштита на обрасци кои инаку би можеле да одговараат на очекуваните знамиња од тоа. Секоја шема која започнува со "-" треба да биде заштитена на овој начин. (Сите стрингови почнувајќи од "-" се резервирани за идните опции.)
На пример, следниов фрагмент бара успешна најава. (Забележете дека прекинот се претпоставува дека е процедура дефинирана на друго место во сценариото.)
очекува {зафатено {става зафатено \ n; exp_continue} не успеа да прекине "неважечка лозинка" прекине прекин на прекин поврзан}Цитатите се потребни на четвртиот модел, бидејќи содржи простор, кој инаку би го одвоил моделот од дејството. Моделите со иста акција (како што се 3 и 4) бараат повторно да ги наведат дејствата. Ова може да се избегне со користење на обрасци на стил на регексп (види подолу). Повеќе информации за формирање на глоб-стил модели може да се најде во прирачникот Tcl.
Обрасците на образец во Regexp ја следат синтаксата дефинирана со regexp на Tcl (кратка за "регуларен израз") команда. обрасните обрасци се воведуваат со знаме -ре . Претходниот пример може да се препишува повторно со користење на regexp како:
очекува {зафатено {става зафатено \ n; exp_continue} -re "не успеа | невалидна лозинка" прекине прекин на прекин поврзан}Двата вида на модели се "ненасочени". Ова значи дека шаблоните не мора да се совпаѓаат со целата низа, но може да започне и да го завршува натпреварот било каде во низата (се додека се друго се совпаѓа). Користете ^ за да одговараат на почетокот на низата, а $ да се совпаѓа со крајот. Забележете дека ако не чекате крај на стрингот, вашите одговори лесно можат да завршат во средината на низата, бидејќи тие се повторуваат од процесот што се појави. Додека сеуште произведуваат точни резултати, излезот може да изгледа неприроден. Така, употребата на $ се поттикнува ако можете точно да ги опишете ликовите на крајот на стрингот.
Забележете дека во многу уредници, ^ и $ се совпаѓаат со почетокот и крајот на линиите соодветно. Меѓутоа, бидејќи очекуваме дека не е ориентирана кон линија, овие знаци се совпаѓаат со почетокот и крајот на податоците (за разлика од линиите) што се во моментов во баферот што го очекува појавување. (Исто така, видете ја белешката подолу за "системско варење").
Знакот -ex го предизвикува примерот да се совпаѓа како "точна" стринг. Не се прави интерпретација на *, ^, итн. (Иако вообичаените Tcl конвенции се уште мора да се почитуваат). Точните модели се секогаш неоштетени.
Знакот -nocase предизвикува големи букви од излезот да се споредат како да се мали букви. Моделот не е засегнат.
Додека го чита излезот, повеќе од 2000 бајти може да ги принуди претходно бајтите да бидат "заборавени". Ова може да се промени со функцијата match_max . (Забележете дека прекумерно големи вредности можат да го забават примерокот за усогласување.) Ако патливата е full_buffer , соодветното тело се извршува ако се примени match_max бајти и не се совпаѓаат други шаблони. Без разлика дали се користи клучниот збор full_buffer или не, заборавените знаци се пишуваат за да очекуваат (buffer).
Ако патливата е клучен збор нула , а нулти се дозволени (преку команда remove_nulls ), соодветното тело се извршува ако се совпаѓа еден единствен ASCII 0. Не е можно да се совпаѓаат 0 бајти преку шаблони за глоб или регексп.
По појавување на шема (или eof или full_buffer), секој соодветен и претходно неспоредлив излез се зачувува во променливата expect_out (тампон) . До 9 натпревари на подредување на regexp се зачувуваат во променливите expect_out (1, стринг) преку expect_out (9, стринг) . Ако знакот -indices се користи пред шема, почетните и завршните индекси (во форма погодна за lrange ) од 10 стрингови се зачувани во променливите wait_out (X, start) и expect_out (X, end), каде што X е цифра, одговара на позицијата на подниз во тампон. 0 се однесува на стрингови кои се исти со целата шема и се генерираат за шаблони, како и за обрасните обрасци. На пример, ако еден процес произведе излез од "abcdefgh \ n", резултатот е:
очекуваат "cd"е како да се извршуваат следните изјави:
set expect_out (0, стринг) cd set expect_out (buffer) abcdи "efgh \ n" е оставена во излезниот тампон. Ако еден процес го произведе излезот "abbbcabkkkka \ n", резултатот е:
очекуваат -индиции -re "b (b *). * (k +)"е како да се извршуваат следните изјави:
(1, почеток) 1 set expect_out (0, end) 1 set expect_out (0, end) 10 set expect_out (0, string) bbbcabkkkk set expect_out (1, start) 2 set expect_out (2, почеток) 10 сет expect_out (2, крај) 10 сет expect_out (2, стринг) k сет expect_out (тампон) abbbcabkkkkи "a \ n" е оставена во излезниот тампон. Образецот "*" (и -re ". *") Ќе го исфрли излезниот тампон без да чита повеќе резултати од процесот.
Нормално, истиот излез е отфрлен од внатрешните бафери на Expect. Ова може да се спречи со префиксирање на образец со знамето -notransfer . Ова знаме е особено корисно во експериментирањето (и може да се скрати на "-not" за погодност додека експериментира).
Идентификацијата што се поврзува со совпаѓачкиот излез (или eof или full_buffer) се чува во expect_out (spawn_id) .
Знакот -timeout предизвикува тековната очекува команда да ја користи следната вредност како временски период, наместо да ја користи вредноста на временската променлива.
По дифолт, шаблоните се исти со излезот од тековниот процес, но -и знамето го декларира излезот од наведената листа на spawn_id да се совпаѓа со сите следни шаблони (до следниот -i ). Списокот со spawn_id треба да биде листа со spawn_ids или со променлива која се однесува на таква листа на spawn_ids.
На пример, следниот пример чека "поврзан" од тековниот процес, или "зафатен", "не успеа" или "неважечка лозинка" од spawn_id именуван од $ proc2.
се очекува {-i $ proc2 зафатен {става зафатен \ n; exp_continue} -re "не успеа | невалидна лозинка" прекине прекин на прекин поврзан}Вредноста на глобалната променлива any_spawn_id може да се користи за да се поклопуваат обрасци на било кој spawn_ids кои се именувани со сите други -i знамиња во тековната очекуваат команда. Spawn_id од знаме -i без поврзан образец (т.е. веднаш следен од друг -i ) е ставен на располагање на сите други шаблони во истата очекуваат команда поврзана со any_spawn_id.
Знакот -i исто така може да именува глобална променлива, во кој случај променливата е прочитана за листа на идентификациски точки. Променливата повторно се чита кога се менува. Ова обезбедува начин за промена на изворот на I / O додека командата е во извршување. Идентификациите на мешавините под услов на овој начин се нарекуваат "индиректни" потомци.
Акциите како што се прекинуваат и продолжуваат да предизвикаат структурни контроли (т.е. за , proc ) да се однесуваат на вообичаен начин. Командата exp_continue овозможува да се очекува да продолжи да извршува, а не да се враќа како што нормално би го сториле.
Ова е корисно за избегнување на експлицитни циклуси или повторување на очекуваните изјави. Следниот пример е дел од фрагментот за автоматизирање на rlogin. Exp_continue избегнува да напише втора изјава за очекување (повторно да бара побарување ) ако rlogin бара лозинка.
очекувајте {лозинка: {stty -echo send_user "лозинка (за $ user) на $ host:" expect_user -re "(. *) \ n" send_user "\ n" испрати "$ expect_out (1, стринг) echo exp_continue} неправилна лозинка или сметка \ n "exit} timeout {send_user" за време на хостинг \ n "exit} eof {send_user" врската со домаќинот не успеа: $ expect_out (buffer) "exit} повторно $ брзо}На пример, следниов фрагмент може да му помогне на корисникот да води интеракција што веќе е целосно автоматизирана. Во овој случај, терминалот се става во режим на суровини. Ако корисникот притисне "+", променливата се зголемува. Ако е притиснато "p", во процесот се испраќаат неколку повратни информации, можеби да се појави на некој начин, а "i" му овозможува на корисникот да комуницира со процесот, ефикасно крадејќи ја контролата од сценариото. Во секој случај, exp_continue дозволува тековната да очекува да продолжи со појавување на моделот по извршувањето на тековното дејство.
stty raw -echo expect_after {-i $ user_spawn_id "p" {испрати "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "излез" излез}Стандардно, exp_continue го ресетира тајмерот за истекување. Тајмерот не се рестартира, ако се јави exp_continue со знамето -continue_timer .
очекуваат_од [очекувам_групи]
работи идентично со очекуваме, освен ако шаблоните од очекуваните и очекуваните_од можат да се совпаднат, се користи шаблонот што се очекува . Погледнете ја командата expect_before за повеќе информации.
expect_background [expect_args]
ги зема истите аргументи како што се очекува , но се враќа веднаш. Моделите се тестираат секогаш кога ќе пристигне нов влез. Времето на истекот на моделот и стандардната вредност се бесмислени за да очекуваат опсег и се тивко отфрлени. Инаку, командата expect_background користи очекувај и претпоставувај по моделот исто како што очекува .
Кога се очекува да се оценат очекуваните опциите на дејството, обработката на позадина за истиот идентификациски број за замрзнување е блокирана. Обработката на позадина се деблокира кога дејството ќе заврши. Додека обработката на позадината е блокирана, можно е да се направи (преден план) да се очекува на истиот идентификатор.
Не е возможно да се изврши очекување, додека очекуваниот_background е деблокиран. expect_background за одреден идентификационен id е избришан со прогласување на ново expect_background со ист идентитет. Изјаснување expect_background без шаблон го отстранува зададениот id од способноста да се совпаѓаат со обрасци во позадина.
expect_before [expect_args]
ги зема истите аргументи како што се очекува , но се враќа веднаш. Парите за акција-дејства од најновата очекувана_пред со ист идентитет се додаваат имплицитно на следните очекувани команди. Ако некој образец се совпадне, се третира како да е назначен во самата команда за очекување , а поврзаното тело се извршува во контекст на очекуваната команда. Ако шаблоните од двете expect_before и очекуваме може да се совпаднат, се користи шаблонот expect_before .
Ако ниеден шаблон не е наведен, идентификаторот за потомство не е проверен за никакви шеми.
Освен ако не е преоптоварено со знаме -i , очекувајте_пред моделите се совпаѓаат со идентитетот за потомство дефиниран во времето кога командата expect_before беше извршена (не кога нејзиниот модел е совпаднат).
Знамето -инфо предизвикува_пред да ги врати моменталните спецификации за тоа кои обрасци ќе се совпаднат. Стандардно, тој известува за тековниот id. Може да се даде опционална спецификација на идентитетот на идентитет за информации за тој идентификациски број. На пример
expect_before -info-i $ procМоже да се даде најмногу една спецификација на идентитетот. Знамето-индиректно потиснува директни идентификациски икони кои доаѓаат само од индиректни спецификации.
Наместо идентификација на идентитетот на идентитетот, знакот "-all" ќе предизвика "-инфо" да известува за сите икони за идентитет.
Излезот на знамето -инфо може да се користи како аргумент што треба да очекуваме.
expect_tty [expect_args]
е како да се очекува, но чита букви од / dev / tty (т.е. тастатурата од корисникот). По дифолт, читањето се врши во готвење. Така, линиите мора да завршат со враќање за да очекуваат да ги видат. Ова може да се смени преку stty (видете ја командата stty подолу).
expect_user [expect_args]
е како да се очекува, но ги чита карактери од stdin (т.е. тастатурата од корисникот). По дифолт, читањето се врши во готвење. Така, линиите мора да завршат со враќање за да очекуваат да ги видат. Ова може да се смени преку stty (видете ја командата stty подолу).
вилушка
создава нов процес . Новиот процес е точна копија од тековниот процес Очекување . За успехот, вилушка враќа 0 во новиот процес (дете) и го враќа процесот на идентификација на дете процесот на родителскиот процес . На неуспех (секогаш поради недостиг на ресурси, на пример, swap простор, меморија), вилушка се враќа -1 до родителскиот процес , и ниеден дете процес не е создаден.
Излезни процеси излегуваат преку командата за излез , исто како и оригиналниот процес . Дозволените процеси на процесирање се запишуваат во датотеките на лог. Ако не оневозможите дебагирање или логирање во повеќето процеси, резултатот може да биде збунувачки.
Некои Pty имплементации може да бидат збунети од повеќе читатели и писатели, дури и моментално. Така, најбезбедно е да се раздели пред процесите на мрестење.
комуницирате [string1 body1] ... [стринг [bodyn]]
дава контрола на тековниот процес на корисникот, така што тастатурата се испраќа до тековниот процес , и се враќаат stdout и stderr на тековниот процес .
Пари со низа од телото може да се специфицираат како аргументи, во кој случај телото се извршува кога се внесува соодветната низа. (Стандардно, стрингот не е испратен до тековниот процес .) Препознаена е командата на преведувачот , ако не е пронајдено конечниот орган.
Ако аргументите за целата изјава за интеракција бараат повеќе од една линија, сите аргументи може да бидат "заглавени" во една, за да не се прекине секоја линија со обратна коса црта. Во овој случај, вообичаените Tcl замени ќе се појават и покрај загради.
На пример, следнава команда работи во интеракција со дефинираните парови на стринг-телото: Кога притиснете ^ Z е притиснато, Expect е суспендиран. (Знакот -reset ги враќа терминалните режими.) Кога притиснете ^ A, корисникот ќе види "ти ја внеси контролата-А" и процесот е испратен ^ ^. Кога $ е притиснато, корисникот го гледа датумот. Кога притиснете ^ C, Очекувајте да излезат. Ако е внесено "foo", корисникот гледа "бар". Кога е притиснато ~~, интерпретаторот Expect работи интерактивно.
во собата CTRLZ \ 032 комуницирате {-резирате $ CTRLZ {exec убиете -STOP [pid]} \ 001 {send_user "внесете контрола-A \ n"; испрати "\ 001"} $ {send_user "Датумот е [формат на часовник [часовник секунди]]."} \ 003 излез foo {send_user "bar"}} ~}Во парови од низа-тело, стрингови се исти со редоследот на кој се наведени како аргументи. Стрингови кои делумно се совпаѓаат не се испраќаат до тековниот процес во пресрет на остатокот што доаѓа. Ако знаците се внесуваат така што повеќе не може да биде совпаѓање, само дел од стрингот ќе биде испратен во процесот што не може да започне друг натпревар. Така, низите што се подлоги на делумни совпаѓања можат да се совпаѓаат подоцна, ако оригиналните стрингови кои се обидувале да бидат совпаѓање во крајна линија не успеваат.
Стандардно, појавување на низа е точно без диви картички . (Спротивно на тоа, командата " очекуваат" стандардно користи шаблони за глоп -стил.) Знамето -ex може да се користи за да се заштитат обрасците кои инаку би можеле да ги совпаднат интерактивните знамиња од тоа. Секоја шема која започнува со "-" треба да биде заштитена на овој начин. (Сите стрингови почнувајќи од "-" се резервирани за идните опции.)
Знакот " -re" ја присилува низата да се толкува како образец на стил на регексп. Во овој случај, соодветните суптинки се зачувани во променливата interact_out слично на начинот на кој се очекува да го зачува својот излез во променливата expect_out . Слично е поддржано и знамето -индикации.
Шаблонот eof воведува акција што се извршува по крајот на датотеката. Посебен образец на eof исто така може да го следи знакот -output, во кој случај се совпаѓа ако се открие eof додека пишува излез. Стандардната акција eof е "враќање", така што интеракцијата едноставно се враќа на било кој EOF.
Временскиот распоред на моделот воведува истек на време (во секунди) и дејство што се извршува откако не се прочитани знаци за одредено време. Шаблонот на истекување се применува на најново утврдениот процес . Нема стандарден тајмаут. Специјалната променлива "timeout" (што се користи од очекуваната команда) нема никакво влијание врз овој временски период.
На пример, следната изјава може да се користи за autologout корисници кои немаат напишано ништо за еден час, но кои се уште добиваат чести системски пораки:
interact -input $ user_spawn_id timeout 3600 return -output \ $ spawn_idАко шаблонот е клучен збор null , и нулите се дозволени (преку команда remove_nulls ), соодветното тело се извршува ако се совпаѓа еден ASCII 0. Не е можно да се совпаѓаат 0 бајти преку шаблони за глоб или регексп.
Префрлањето на образецот со знаме -иритиране предизвикува променливата interact_out (spawn_id) да биде поставена на spawn_id кој одговараше на моделот (или eof).
Акциите како што се прекинуваат и продолжуваат да предизвикаат структурни контроли (т.е. за , proc ) да се однесуваат на вообичаен начин. Меѓутоа, причините за враќање комуницираат за да се вратат на повикувачот, додека inter_return предизвикува интеракција за да предизвика поврат на повикувачот. На пример, ако "proc foo" наречен интеракција, а потоа изврши дејство inter_return , proc foo ќе се врати. (Ова значи дека ако interactact повици преведувач интерактивно пишување враќање ќе предизвика интеракцијата да продолжи, додека inter_return ќе предизвика интеракцијата да се врати на својот повикувач.)
За време на интеракцијата се користи суров режим, така што сите карактери можат да бидат предадени на тековниот процес . Ако тековниот процес не ги фаќа сигналите за контрола на работното место, тој ќе престане ако испрати сигнал за застанување (по правило ^ Z). За да го рестартирате, испратете го сигналот за продолжување (како на пример со "kill -ONT"). Ако навистина сакате да го испратите SIGSTOP на таков процес (од ^ Z), прво размислете за стартување на csh, а потоа да ја стартувате вашата програма. Од друга страна, ако сакате да испратите SIGSTOP да Обиди се себеси, прво јавете се на преведувач (можеби со помош на знак за избегнување), а потоа притиснете ^ Z.
Парот со низа од телото може да се користи како стенографија за избегнување на потребата да влезат во преведувачот и интерактивно да ги извршуваат командите. Претходниот терминален режим се користи додека се извршува телото на пар на низа.
За брзина, дејствата се извршуваат во суровински режим по дифолт. Знакот -reset го ресетира терминалот на модот што го имал пред извршување на интеракцијата (секогаш, варен режим). Забележете дека карактери што се внесуваат кога се вклучи режимот може да се изгубат (несреќна карактеристика на терминалниот драјвер на некои системи). Единствената причина што треба да се употреби -ресе е ако вашата акција зависи од трчање во режим на готвење.
Знакот -echo испраќа знаци кои се совпаѓаат со следниов образец назад кон процесот што ги генерира како што се чита секој карактер. Ова може да биде корисно кога корисникот треба да ги види повратните информации од делумно внесените обрасци.
Ако модел се повторува, но на крајот не успее да се совпадне, ликовите се испраќаат до процесот што се појавил. Ако предизвиканиот процес потоа ги одекнува, корисникот ќе ги види ликовите два пати. -еко е веројатно само соодветно во ситуации каде што корисникот веројатно нема да ја заврши шаблоната . На пример, следниов извадок е од rftp, рекурзивен-ftp сценариото, каде што на корисникот му е потребно да влезат ~ g, ~ p, или ~ l, за рециклирање, редење или листа на тековниот директориум. Овие се толку далеку од нормалните ftp команди, дека корисникот е малку веројатно да напише ~ проследено со нешто друго, освен погрешно, во кој случај, веројатно ќе го игнорираат резултатот во секој случај.
комуницирате {-еко ~ g {getcurdirectory 1} -ееко-l {getcurdirectory 0} -ичо-p {putcurdirectory}}Знамето -буфер испраќа знаци кои се совпаѓаат со следниов модел на излезниот процес, додека знаците се читаат.
Ова е корисно кога сакате да дозволите некоја програма да ја повтори образецот. На пример, следново може да се користи за следење на местото каде што некој бира (модем во стил Хејс). Секој пат кога се гледа "atd", сценариото го најавува остатокот од линијата.
proc lognumber {} {interact -nobuffer -re "(. *)" враќање става $ дневник "[формат на часовникот [часовни секунди]]: повикани $ interact_out (1, стринг)"} интеракција -буфер "atd" lognumberЗа време на интеракцијата , претходната употреба на log_user е игнорирана. Особено, интеракцијата ќе го присили излезот да биде најавен (испратен до стандардниот излез), бидејќи се претпоставува дека корисникот не сака слепо да комуницира.
Знамето -o предизвикува следното следно пар на клучните тела да се примени на излезот од тековниот процес . Ова може да биде корисно, на пример, кога се работи за компјутери кои испраќаат несакани знаци за време на телнет сесија.
Стандардно, интеракцијата очекува корисникот да пишува статичен и читање stdout од самиот процес на Expect. Знамето -u (за "корисник") прави интерактивен изглед за корисникот како процес именуван според неговиот аргумент (кој мора да биде именуван id).
Ова им овозможува на два неповрзани процеси да се здружат без употреба на експлицитен циклус. За да помогне во дебагирањето, Очекувајте дијагностика секогаш оди на stderr (или stdout за одредени информации за најавување и дебагирање). Од истата причина, командата на преведувачот интерактивно ќе се чита од stdin.
На пример, следниов фрагмент создава процес на најавување. Потоа го бира корисникот (не е прикажано), и конечно ги поврзува двете заедно. Се разбира, секој процес може да биде заменет за најава. Школка, на пример, ќе му дозволи на корисникот да работи без да обезбеди сметка и лозинка.
spawn најава во собата најава $ spawn_id spawn врвот модем # dial назад до корисникот # поврзете корисник да се најавите комуницирате -u $ ВлезотЗа да испратите излез на повеќе процеси, наведете ја секоја листа со иницијали за итни случаи претходно поставени со -output знаме. Влезот за група излезни идентификатори за идентификација може да се определи со листа на иницијали за итни случаи претходно поставени со знак -input . (И двете -input и -output може да земаат листи во иста форма како и знамето -i во очекуваната команда, освен што any_spawn_id не е значајно во интеракција .) Сите следни знамиња и низи (или обрасци) се однесуваат на овој влез до друг - се појавува знак за внесување. Ако не се појавува -input , -output имплицира "-input $ user_spawn_id -output". (Слично на тоа, со обрасци кои немаат- влез .) Ако е назначен еден- input , тој го прекорува $ user_spawn_id. Ако е наведен втор влез, тој го прекорува $ spawn_id. Можат да се наведат дополнителни -инвестирачки знамиња.
Двата имплицирани влезни процеси се стандардно да ги имаат нивните резултати издвоени како $ spawn_id и $ user_spawn_id (обратно). Ако знамето -input се појавува без знаме -output , знаците од тој процес се отфрлаат.
Знакот -i воведува замена за тековната spawn_id кога нема други знаци на влез или излез . Знамето A -i подразбира знаме -о.
Можно е да се променат процесите со кои се остварува интеракција со користење на индиректни иницијали за потомци. (Индиректните идентификатори за подигнување се опишани во делот за командата што се очекува.) Индиректните ID-ии на имотот може да се специфицираат со -i, -u, -input или -output знамињата.
преведувач [args]
предизвикува корисникот да биде интерактивно поттикнат за Expect и Tcl командите. Резултатот од секоја команда е отпечатен.
Акциите како што се прекинуваат и продолжуваат да предизвикаат структурни контроли (т.е. за , proc ) да се однесуваат на вообичаен начин. Меѓутоа, враќањето предизвикува преведувач да се врати на повикувачот, додека inter_return предизвикува преведувач да предизвика поврат на повикувачот. На пример, ако "proc foo" наречен преведувач кој потоа го извршил дејството inter_return , proc foo ќе се врати. Секоја друга команда предизвикува преведувач да продолжи да бара нови команди.
По дифолт, линијата содржи два цели броја. Првиот цел број ја опишува длабочината на стек на евалуација (т.е., колку пати е повикан Tcl_Eval). Вториот цел број е идентификаторот на историјата на Tcl. Појавата може да се постави со дефинирање на процедура наречена "prompt1", чија повратна вредност станува следното барање. Ако изјавата има отворени цитати, паразити, загради или загради, секундарното барање (по правило "+>") се издава по нова линија. Второто барање може да се постави со дефинирање на процедура наречена "prompt2".
За време на преведувачот , се користи готвениот режим, дури и ако повикувачот користел суровини.
Ако стен е затворен, преведувачот ќе се врати, освен ако знамето -eof се користи, во кој случај се повикува следниот аргумент.
log_file [args] [[-a] датотека]
Ако е дадено име на датотека, log_file ќе сними транскрипт од сесијата (почнувајќи од таа точка) во датотеката. log_file ќе престане да снима ако нема аргумент. Секоја претходна дневник е затворена.
Наместо име на датотека, идентификатор на датотека со Tcl може да се обезбеди со користење на знаците -open или -leaveopen . Ова е слично на командата за потомство . (Види потомство за повеќе информации.)
Знамето -а го присилува излезот да биде најавен, кој беше потиснат од командата log_user .
Стандардно, командата log_file се додава на стари датотеки, наместо да ги скратува, за погодност да можат да го исклучат одјавувањето и повеќекратно во една сесија. За да ги скратите датотеките, користете го знакот -noappend .
Знамето -инфо предизвикува log_file да врати опис на најновите аргументи за не-информации.
log_user -info | 0 | 1
По дифолт, дијалогот за испраќање / очекување е најавен до stdout (и лог датотека ако е отворена). Логирањето кон stdout е оневозможено со командата "log_user 0" и повторно е овозможено од "log_user 1". Пријавувањето на лог датотеката е непроменето.
Знамето -инфо предизвикува log_user да врати опис на најновите аргументи за не-информации.
match_max [-d] [-i spawn_id] [големина]
ја дефинира големината на тампон (во бајти) што се користи внатрешно од очекуваното . Без аргумент за големина , моменталната големина се враќа.
Со знамето -d , се поставува основната големина. (Почетната вредност е 2000.) Со знаме -i , големината е поставена за именскиот иденски ID, инаку е поставена за тековниот процес .
преклопување [- # spawn_id] [- # spawn_id] [...] програма [args]
извршува "програма args" на местото на тековната Expect програма, која завршува. Голиот аргумент за цртички предизвикува цртичка пред името на командата како да е школка за најавување. Сите spawn_ids се затворени, освен оние кои се именувани како аргументи. Овие се мапирани врз идентификуваните датотечни идентификатори.
Spawn_ids се одбележани на датотечни идентификатори за новата програма за наследување. На пример, следната линија работи шах и дозволува да биде контролирана од тековниот процес - на пример, шаховски господар.
преклопување -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id шахОва е поефикасно од "interact -u", меѓутоа, таа ја жртвува способноста да се програмира интеракцијата бидејќи процесот на Очекување веќе не е во контрола.
Забележете дека не е обезбеден контролен терминал. Така, ако го исклучите или преместите стандардниот влез, програмите што вршат контрола на работното место (школки, најава и слично) нема да функционираат правилно.
паритет [-d] [-i spawn_id] [вредност]
дефинира дали паритет треба да се задржи или да се одземе од излезот на создадените процеси. Ако вредноста е нула, паритетот е одземен, инаку не е одземен. Без аргумент за вредност , моменталната вредност се враќа.
Со знамето -d , стандардната вредност за паритет е поставена. (Првичната вредност е 1, т.е. паритетот не е одземен.) Со знаме -i , вредноста на паритетот е поставена за именскиот именски id, инаку е поставена за тековниот процес .
remove_nulls [-d] [-i spawn_id] [вредност]
дефинира дали nulls се задржуваат или се отстрануваат од излезот на создадените процеси пред да се совпаѓаат или складираат шаблони во променливата wait_out или interact_out . Ако вредноста е 1, nulls се отстранети. Ако вредноста е 0, nulls не се отстранети. Без аргумент за вредност , моменталната вредност се враќа.
Со знамето -d , се постави основната вредност. (Првичната вредност е 1, односно се отстрануваат nulls.) Со знаме -i , вредноста е поставена за именскиот spawn id, инаку таа е поставена за тековниот процес .
Дали се отстрануваат или не се отстрануваат нули, Очекувајте ќе сними нулти бајти во дневникот и stdout.
испрати низа [-flags]
Испраќа стринг на тековниот процес . На пример, командата
ги испраќа ликовите, helloworld на тековниот процес . (Tcl вклучува команда слична на printf (наречена формат ) која може да изгради произволно сложени низи.)
Карактерите се испраќаат веднаш, иако програмите со влезен влез во линија нема да ги читаат знаците додека не се испрати знак за враќање. Карактерот за враќање е означен со "\ r".
Знамето го принудува следниот аргумент да се толкува како стринг, а не знаме. Секое низа може да претходи со "-" без разлика дали всушност изгледа како знаме. Ова обезбедува сигурен механизам за да ги наведете променливите жици без да бидат заглавени од оние кои случајно изгледаат како знамиња. (Сите стрингови почнувајќи од "-" се резервирани за идните опции.)
Знакот -i изјавува дека низата ќе биде испратена до именуваниот spawn_id. Ако spawn_id е user_spawn_id , а терминалот е во raw mode, новите линии во стрингот се преведени во секвенци за return-newline, така што ќе се појават како терминалот да е во режим на готвење. Знакот -ра го оневозможува овој превод.
-Новото знаменце испраќа нула карактери (0 бајти). Стандардно е испратена една нула. Цел број може да го следи -null за да укаже колку нули да испратат.
Знамето- појава генерира состојба на пауза. Ова има смисол само ако идентот на spawn се однесува на tty уред кој се отвора преку "spawn -open". Ако сте го предизвикале процесот како врв, треба да користите конвенција на врвот за генерирање пауза.
Знакот " -s" го присилува излезот да се испраќа "полека", со што се избегнува вообичаена ситуација кога компјутерот го оформува влезниот тампон кој е дизајниран за човекот кој никогаш нема да го одвои истиот тампон . Овој излез е контролиран од вредноста на променливата "send_slow" која ги зема двете елементи на елементот. Првиот елемент е цел број кој го опишува бројот на бајти кои се испраќаат атомично. Вториот елемент е вистински број кој го опишува бројот на секунди со кои атомските пратки мора да се одделат. На пример, "постави send_slow {10 .001}" ќе ги принуди "испратите-и" да испраќаат низи со 1 милисекунда меѓу секои 10 карактери.
Знамето -H го присилува излезот да биде испратен (нешто) како човечко пишување. Меѓу ликовите се појавуваат одложувања слични на човекот. (Алгоритмот се базира на распределбата на Weibull, со модификации кои одговараат на оваа конкретна апликација.) Овој излез е контролиран од вредноста на променливата "send_human" која ја зема листата на пет елементи. Првите два елементи се просечно време на интервалот на карактери во секунди. Првиот се користи стандардно. Вториот се користи при завршување на зборовите, за да се симулираат суптилните паузи кои понекогаш се случуваат при такви транзиции. Третиот параметар е мерка на варијабилност, каде што 1 е прилично варијабилен, 1 е разумно променлив, а 10 е сосема непроменлив. Екстремитетите се 0 до бесконечност. Последните два параметри се, односно, минимално и максимално време на интервалот. Минимално и максимално се користат последните и "клип" на последното време. Крајниот просек може да биде сосема различен од дадениот просек, ако минималните и максималните клипови доволно вредни.
Како пример, следнава команда емитира брза и конзистентна таписерија:
set send_human {.1 .3 1 .05 2} испрати-ж "Јас сум гладен. Ајде да ручаме".додека следново може да биде посоодветно по мамурлак:
во собата send_human {.4 .4 .2 .5 100} испрати-ж "Goodd партија камшик ноќ!"Забележете дека грешките не се симулирани, иако можете сами да поставите ситуации за корекција на грешки со вметнување грешки и корекции во аргументот за испраќање.
Знамењата за испраќање нула карактери, за испраќање одмори, за принудување на бавно излез и за излез во човечки стил се меѓусебно исклучени. Ќе се користи само оној што е одреден последен. Понатаму, не може да се специфицира низа аргументи со знамињата за испраќање нула карактери или паузи.
Добра идеја е да се претпостави првото испраќање до некој процес со очекувано . Очекувам ќе почека процесот да почне, а испраќањето не може. Особено, ако првото испраќање заврши пред да започне процесот , ризикувате да ги игнорирате вашите податоци. Во ситуации кога интерактивните програми не нудат почетна пратка, може да му претходите на испраќање со одложување како во:
# За да се избегне давање на хакери навестувања за тоа како да се пробие, # овој систем не бара надворешна лозинка. # Чекај 5 секунди за извршување за да се заврши spawn telnet very.secure.gov спиење 5 испрати лозинка \ rexp_send е алијас за испраќање. Ако користите Expectk или некоја друга варијанта на Очекуваат во околината Tk, испраќањето е дефинирано од страна на Tk за сосема друга цел. exp_send е обезбедена за компатибилност помеѓу средини. Слични псевдоними се даваат и за други команди за испраќање на Expect.
send_error [-flags] стринг
е како испрати , освен што излезот е испратен до stderr, а не од сегашниот процес .
send_log [-] стринг
е како испрати , освен што низата е испратена само до датотеката за евиденција (видете log_file .) Аргументите се игнорираат ако ниедна датотека не е отворена.
send_tty [-flags] стринг
е како испрати , освен што излезот е испратен до / dev / tty наместо тековниот процес .
send_user [-flags] стринг
е како испрати , освен што излезот е испратен до stdout, а не од сегашниот процес .
спиење секунди
предизвикува сценариото да спие за даден број на секунди. Секунди може да бидат децимален број. Прекините (и Tk настани ако користите Expectk) се обработуваат додека Очекувајте спие.
spawn [args] програма [args]
создава нов процес со "програма args". Неговите stdin, stdout и stderr се поврзани со Expect, така што тие може да бидат прочитани и напишани од други Expect команди. Врската е скршена одблизу или ако самиот процес затвора некој од идентификаторите на датотеките.
Кога еден процес се започнува од потомство , променливата spawn_id е поставена на дескриптор кој се однесува на тој процес . Процесот опишан од spawn_id се смета за "тековен процес ". spawn_id може да биде прочитан или напишан, што всушност обезбедува контрола на работата.
user_spawn_id е глобална променлива која содржи дескриптор кој се однесува на корисникот. На пример, кога spawn_id е поставен на оваа вредност, очекувајте да се однесува како expect_user .
.I error_spawn_id е глобална променлива која содржи дескриптор кој се однесува на стандардна грешка. На пример, кога spawn_id е поставен на оваа вредност, испратете се однесува како send_error .
tty_spawn_id е глобална променлива која содржи дескриптор кој се однесува на / dev / tty. Ако / dev / tty не постои (како на пример во cron, at, или серија скрипта), тогаш tty_spawn_id не е дефиниран. Ова може да се тестира како:
ако {[info vars tty_spawn_id]} {# / dev / tty exists} друго {# / dev / tty не постои # најверојатно во cron, серија или скрипта}spawn го враќа идентификациониот процес на UNIX. Ако не се појави процес , се враќа 0. Променливата spawn_out (роб, име) е поставена на името на уредот pty-slave.
По дифолт, потомството го одекнува името на командата и аргументите. Знамето -noecho престанува да создава од ова.
Знамето -конзол предизвикува конзолниот излез да биде пренасочен кон процесот што се појавил. Ова не е поддржано на сите системи.
Внатрешно, spawn користи pty, иницијализиран на ист начин како и tty на корисникот. Ова е дополнително иницијализирано, така што сите поставки се "нормални" (според stty (1)). Ако променливата stty_init е дефинирана, таа се толкува во стилот на stty аргументите како понатамошна конфигурација. На пример, "поставените stty_init raw" ќе предизвикаат терминалите на поштенските процеси да започнат во суровински режим. -nottycopy ја прескокнува иницијализацијата врз основа на tty на корисникот. -нетонит ја прескокнува "нормалната" иницијализација.
Нормално, потомството трае малку време за извршување. Ако забележите потомство земајќи значителен дел од времето, најверојатно се сретнува со ptys кои се заглавени. Голем број на тестови се извршуваат на Ptys за да се избегнат заплетувања со грешни процеси. (Овие се 10 секунди за заглавени pty.) Running Expect со опцијата -d ќе покаже дали Expect наидува на многу ptys во чудни состојби. Ако не можете да ги убиете процесите на кои се прикачени овие ptys, единствено може да се рестартира.
Ако програмата не може да се постави успешно бидејќи exec (2) не успее (на пример, кога програмата не постои), пораката за грешка ќе биде вратена од следната команда за интеракција или очекувајте како програмата да се изврши и да ја добие пораката за грешка како излез. Ова однесување е природна последица на спроведувањето на потомството . Внатрешно, подигнува вилушки, по што создадениот процес нема начин да комуницира со оригиналниот Expect процес, освен преку комуникација преку spawn_id.
Знамето -основа го предизвикува следниот аргумент да се толкува како идентификатор на Tcl-датотека (т.е., вратен по отворен .) Идентификацијата за потомство тогаш може да се користи како да е процес кој е создаден. (Идентификаторот на датотеката повеќе не треба да се користи.) Ова ви овозможува да ги третирате суровите уреди, датотеки и цевководи како создадени процеси без користење на pty. 0 се враќа за да се покаже дека не постои поврзан процес . Кога поврзувањето со создадениот процес е затворен, исто така е идентификаторот на датотеката Tcl. Знамето -Laveopen е слично на -open освен дека- ливеопен предизвикува идентификаторот на датотеката да биде оставена отворена дури и откако ќе се затвори id-от.
Знакот " празно" предизвикува PTY да се отвори, но не се појави процес . 0 се враќа за да се покаже дека не постои поврзан процес . Spawn_id е поставен како и обично.
Променливата spawn_out (slave, fd) е поставена на идентификатор на датотека што одговара на pty-робот. Може да се затвори со помош на "затворање".
Знамето -познавање означува сигнал кој треба да се игнорира во процесот што се создава. Во спротивно, сигналите го добиваат стандардното однесување. Сигналите се именуваат како во командата за стапица , освен што секој сигнал бара посебно знаме.
ниво на strace
предизвикува следните изјави да бидат испечатени пред да бидат извршени. (Tcl командата за следење на трагите променливи.) Ниво покажува колку долу во оградата на повикот е да се следи. На пример, следнава команда работи Очекувај додека ги следи првите 4 нивоа на повици, но ништо под тоа.
Знамето -инфо предизвикува страв да се врати опис на најновите аргументи за не-информации.
stty args
ги менува терминалните модови слично на надворешната команда на stty.
Стандардно, се пристапува до контролниот терминал. До други терминали може да се пристапи со додавање "Барањата за статус го враќаат како резултат на командата. Доколку не се бара статус и се пристапува кон контролниот терминал, претходниот статус на атрибутите на суровини и ехо се враќаат во форма која подоцна може да биде што се користи од командата.
На пример, аргументите сурови или сфатени , терминалот го ставаат во суров режим. Аргументите -видови или варени го ставаат терминалот во варен режим. Аргументите ехо и -ее го стават терминалот во echo и noecho режим, соодветно.
Следниот пример покажува како привремено да се оневозможи ехо. Ова може да се користи во инаку-автоматски скрипти за да се избегне вградување на лозинки во нив. (Види повеќе дискусија за ова под EXPECT HINTS подолу.)
stty -echo send_user "Лозинка:" expect_user -re "(. *) \ n" поставете ја лозинката $ expect_out (1, стринг) со echo системски аргументи
дава аргументи на sh (1) како влез, исто како да беше напишан како команда од терминал. Очекуваат чека додека не заврши школка. Статусот за враќање од sh се ракува на ист начин како што exec се справува со својот статус на враќање.
За разлика од exec кој пренасочува Stdin и stdout во сценариото, системот не извршува пренасочување (освен оној што го покажува самиот стринг). Така, можно е да се користат програми кои мора да зборуваат директно на / dev / tty. Од истата причина, резултатите на системот не се запишуваат во дневникот.
временска ознака [args]
враќа временска ознака. Без аргументи, бројот на секунди од епохата се враќа.
Знамето -формат воведува низа што се враќа, но со замена направена според POSIX-правилата за strftime. На пример,% a се заменува со скратено име на денот во неделата (т.е. Sat). Другите се:
% скратено име на денот на неделата% Цело име за денот на денот% b Скратено име на месец% B Целосно име на месецот% c Датум-време како во: Сре. 6 11:45:56 1993% d ден од месецот (01-31% H час (00-12)% I час (01-12)% j ден (001-366)% m месец (01-12)% М минута (00-59)% п ама или pm% секунда (00-61) % u ден (1-7, понеделник е првиот ден од неделата)% U недела (00-53, првата недела е првиот ден од неделата еден)% V недела (01-53, ISO 8601 стил)% w ден (0- 6)% W недела (00-53, прв понеделник е првиот ден од неделата еден)% x датум време како во: ср 6 октомври 1993% X време како во: 23:59:59% y година (00-99) % Y година како во: 1993% Z временска зона (или ништо ако не е определено) %% знак за голи процентиДруги% спецификации се недефинирани. Другите знаци ќе бидат пренесени преку недопрени. Поддржана е само локацијата на C.
Знамето-секунди го воведува бројот на секунди откако епохата ќе се користи како извор за да се форматира. Во спротивно, се користи тековното време.
Знамето -gmt го присилува излезот на временската ознака за да ја користи временската зона во зоната GMT . Без знаме, се користи локалната временска зона.
стапици [[команда] сигнали]
предизвикува дадената команда да биде извршена по иден прием на некој од дадените сигнали. Командата е извршена во глобалниот опсег. Ако командата е отсутна, акцијата на сигналот се враќа. Ако командата е стринг SIG_IGN, сигналите се игнорираат. Ако командата е стринг SIG_DFL, сигналите се резултат на стандардниот систем. сигнали е или еден сигнал или листа на сигнали. Сигналите може да се наведат нумеричко или симболично според сигналот (3). Префиксот "SIG" може да биде испуштен.
Без аргументи (или аргумент -број), стапицата го враќа бројот на сигналот на командата за стапица што моментално се извршува.
Знамето -code го користи кодот за враќање на командата наместо она што кодот Tcl требаше да се врати кога командата првично почна да работи.
Знамето -interp предизвикува командата да се евалуира со помош на преведувачот активен во времето кога командата почна да работи, а не кога стапицата беше прогласена.
Знамето -name предизвикува командата за стапица да го врати името на сигналот на командата за стапица која моментално се извршува.
Знамето -макс ја предизвикува командата за стапица да го врати најголемиот број на сигнали што може да се постави.
На пример, командата "trap {send_user" Ouch! "} SIGINT" ќе отпечати "Ouch!" секојпат кога корисникот ќе притисне ^ C.
Стандардно, SIGINT (што обично може да се генерира со притискање на ^ C) и SIGTERM предизвика Очекуваме да излезете. Ова се должи на следната стапица, креирана од стандардно кога ќе започне Expect.
излез од стапица {SIGINT SIGTERM}Ако го користите знакот -D за да го стартувате дебагерот, SIGINT е редефиниран за да го стартува интерактивниот дебагер. Ова се должи на следната замка:
стапица {exp_debug 1} SIGINTЗамката на дебагерот може да се смени со поставување на променливата на околината EXPECT_DEBUG_INIT во нова команда за стапици.
Можете, се разбира, да ги пребришете двата од овие само со додавање на команди за стапици во вашата скрипта. Особено, ако имате свој "излез од стапица SIGINT", ова ќе ја преоптовари стапицата на дебагерот. Ова е корисно ако сакате да спречите корисниците да влезат во дебагерот.
Ако сакате да ја дефинирате сопствената стапица на SIGINT, но сеуште стапицата на дебагерот кога работи, користете:
ако {! [exp_debug]} {mystuff mystuff SIGINT}Алтернативно, може да се фатите за дебагерот користејќи некој друг сигнал.
стапицата нема да ви дозволи да го отфрлите дејството за SIGALRM бидејќи ова се користи внатрешно да Очекувајте . Командата за исклучување го поставува SIGALRM до SIG_IGN (игнорира). Можете да го вратите ова сè додека го оневозможите за време на последователните команди за поток.
Видете сигнал (3) за повеќе информации.
почекај [args]
одложувања се додека не се појави процес (или сегашниот процес, ако никој не е именуван) завршува.
почекајте нормално враќа листа од четири цели броеви. Првиот цел број е pid на процесот на кој се чека. Вториот цел број е соодветниот идентификатор. Третиот цел број е -1 ако се случи грешка на оперативниот систем, или 0 на друг начин. Ако третиот цел број е 0, четвртиот цел број е статусот вратен од процесот што се појави. Ако третиот цел број е -1, четвртиот цел број е вредноста на errno поставена од оперативниот систем. Исто така е поставена глобалната променлива errorCode.
Дополнителните елементи може да се појават на крајот од повратната вредност од чекање . Опционален петти елемент идентификува класа на информации. Во моментов, единствената можна вредност за овој елемент е CHILDKILLED, во кој случај следните две вредности се името на сигналот на C и краток текстуален опис.
Знамето -i го декларира процесот да почека одговара на именуваниот spawn_id (НЕ идентификацијата на процесот ). Во внатрешноста на SIGCHLD управувачот, можно е да се почека за кој било предизвикан процес со користење на id-1.
Неочекуваното знаме предизвикува чекање веднаш да се врати со наведување на успешен почеток. Кога процесот ќе излезе (подоцна), тој автоматски ќе исчезне без потреба од експлицитно чекање.
Наредбата за чекање, исто така, може да се користи за чекање за разговор со користење на аргументите "-i -1". За разлика од неговата употреба со создадените процеси, оваа команда може да се изврши во секое време. Нема контрола врз кој процес е пожелен. Сепак, вредноста на поврат може да се провери за идентификацијата на процесот .
БИБЛИОТЕКИ
Очекуваме автоматски да знае за две вградени библиотеки за Expect скрипти. Овие се дефинирани од директориумите именувани во променливите exp_library и exp_exec_library. Двете се наменети да содржат кориснички датотеки кои можат да се користат од други скрипти.
exp_library содржи архиви независни од архитектурата. exp_exec_library содржи датотеки што зависат од архитектурата. Во зависност од вашиот систем, обете директориуми може да бидат целосно празни. Постоењето на датотеката $ exp_exec_library / cat-buffers опишува дали вашата / bin / cat бафери по правило.
ПЕТТИ ПЕЧАТЕЊЕ
Дефиниција за грешка е достапна за прилично печатење Очекувајте скрипти. Претпоставувајќи дека дефиницијата за грешка која се испорачува со дистрибуцијата Оцени е правилно инсталирана, можете да ја користите како:
vgrind -селективна датотекаПРИМЕРИ
Многумина не се очигледни како да се стави сè заедно што опишува човечката страница. Ги охрабрувам да ги прочитате и да ги испробате примерите во примерокот од листата на Оцени дистрибуција. Некои од нив се вистински програми. Другите се едноставно илустративни за одредени техники, и, се разбира, неколку се само брзи хакове. Фајлот INSTALL има брз преглед на овие програми.
Исто така се корисни и Очекуваните документи (видете ЈИЕ ИСТО). Додека некои трудови користат синтакса што одговара на претходните верзии на Expect, придружните објаснувања се сеуште валидни и одат во многу повеќе детали од оваа страница на човекот.
ПРЕПАРАТИ
Екстензии може да се судираат со командните имиња на Expect. На пример, испраќањето е дефинирано од страна на Tk за сосема друга цел. Поради оваа причина, повеќето од командите Expect се исто така достапни како "exp_XXXX". Командите и променливите кои почнуваат со "exp", "inter", "spawn" и "timeout" немаат псевдоними. Користете ги проширените командни имиња ако ви треба оваа компатибилност помеѓу средините.
Очекуваме да има прилично либерален поглед на опсегот. Особено, променливите прочитани од командите специфични за програмата Expect ќе се бараат прво од локалниот опсег, а ако не се најдат, во глобалниот опсег. На пример, ова ја спречува потребата да се постави "глобален тајмаут" во секоја постапка што ја пишувате која што се користи. Од друга страна, променливите напишани се секогаш во локалниот опсег (освен ако не е издадена "глобална" команда). Најчестиот проблем што ова го предизвикува е кога потомството се извршува во постапка. Надвор од постапката, spawn_id повеќе не постои, така што процесот што потекнува веќе не е достапен само поради опсегот. Додајте "глобален spawn_id" во таква постапка.
Ако не можете да ја овозможите мултиспиналната способност (т.е. вашиот систем не поддржува ниту да одбере (BSD *. *), Анкета (SVR> 2), ниту нешто еквивалентно), Expect ќе може само да контролира еден процес одеднаш. Во овој случај, не обидувајте се да го поставите spawn_id , ниту пак да ги извршувате процесите преку exec додека се стартува процесот . Покрај тоа, нема да можете да очекувате од повеќе процеси (вклучувајќи го и корисникот како еден) во исто време.
Терминалните параметри можат да имаат голем ефект врз скриптите. На пример, ако сценариото е напишано за да бара ехо, тоа ќе се погреши ако ехо се исклучи. Поради оваа причина, очекувајте стандардните параметри за нормални термини. За жал, ова може да ги направи работите непријатни за други програми. Како пример, школка на емаците сака да ги смени "вообичаените" мапи: новите линии се пресликуваат на нови линии, наместо на нови линии за враќање на превозот, а повторувањето е оневозможено. Ова им овозможува на еден човек да користи emacs за уредување на влезната линија. За жал, Очекуваме, не може да го погоди ова.
Можете да побарате Очекувате да не го пребрише своето основно поставување на терминални параметри, но тогаш мора да бидете внимателни кога пишувате скрипти за такви средини. Во случај на emacs, избегнувајте во зависност од нештата како ехо и мапирање на крајни линии.
Командите што ги прифаќаа аргументите собрани во една листа ( очекуваните варијанти и интеракција ) користат хеуристички да одлучат дали листата е всушност еден аргумент или многу. Хеуристичкиот може да пропадне само во случај кога листата всушност претставува еден аргумент кој има повеќе вградени \ n со не-празни букви меѓу нив. Ова се чини дека е доволно неверојатно, но аргументот "-nobrace" може да се користи за да се принуди еден аргумент да се ракува како единствен аргумент. Ова веројатно би можело да се искористи со машински-очекуваниот код. Слично на тоа, бракот ги присилува единствените аргументи кои треба да се справуваат како повеќе шеми / акции.
БУГИ
Навистина беше примамливо да се именува програмата "секс" (или за "Smart EXec" или "Send-Expect"), но добра смисла (или можеби само пуританизам) преовладуваше.
Во некои системи, кога ќе се појави школка, се жали дека не може да пристапи до tty, но сепак работи. Ова значи дека Вашиот систем има механизам за стекнување на контролната единица за која Очекувате не знаат. Ве молиме да дознаете што е, и испратете ги овие информации назад кон мене.
Ultrix 4.1 (барем најновите верзии овде) разгледува времетраење од над 1000000 за да биде еквивалентно на 0.
Дигиталниот UNIX 4.0A (и најверојатно други верзии) одбива да ги распредели Ptys ако дефинирате SIGCHLD управувач. Погледнете страница за грант за повеќе информации.
IRIX 6.0 не ги обработува правилните Pty дозволи така што ако Expect се обидува да одвои pty претходно користен од некој друг, тоа не успее. Надградба на IRIX 6.1.
Телнет (заверен само под SunOS 4.1.2) виси ако не е поставена TERM. Ова е проблем под cron, на и во cgi скрипти, кои не дефинираат TERM. Така, мора да го поставите експлицитно - до кој тип е обично ирелевантен. Тоа само треба да биде поставено на нешто! Следните веројатно се доволни за повеќето случаи.
set env (TERM) vt100Совет (потврден само под BSDI BSD / OS 3.1 i386) виси ако SHELL и HOME не се поставени. Ова е проблем под cron , на и во cgi скрипти, кои не ги дефинираат овие променливи на околина. Така, мора да ги поставите експлицитно - до кој тип е обично ирелевантен. Тоа само треба да биде поставено на нешто! Следните веројатно се доволни за повеќето случаи.
поставете env (SHELL) / bin / sh set env (почеток) / usr / local / binНекои имплементации на ptys се дизајнирани така што кернелот го фрла секој непрочитан излез по 10 до 15 секунди (вистинскиот број е зависен од имплементацијата) откако процесот го затвори дескрипторот на датотеката. Така Очекувајте програми како што се
Спин датум спиење 20 се очекуваќе пропадне. За да се избегне ова, се повикуваат не-интерактивни програми со exec, а не со потомство . Иако такви ситуации се разбирливи, во пракса никогаш не наидов на ситуација во која конечниот резултат на вистински интерактивна програма ќе биде изгубен поради ова однесување.
Од друга страна, Cray UNICOS ptys фрлаат непрочитан излез веднаш откако процесот го затвори дескрипторот на датотеката. Јас го пријавив ова на Креј и тие работат на фикс.
Понекогаш се бара одложување помеѓу повикот и одговорот, како на пример кога tty интерфејсот ги менува поставките на UART или соодветните стапки на бајт, барајќи старт / стоп битови. Обично, сето ова е потребно е да спиеме за една секунда или две. Поцврста техника е да се обидете се додека хардверот не е подготвен да добие влез. Следниот пример ги користи двете стратегии:
испрати "брзина 9600 \ r"; спиење 1 очекува {timeout {испрати "\ r"; exp_continue} $ прашува}trap -code нема да работи со било која команда која се наоѓа во циклусот на настани на Tcl, како што е спиењето. Проблемот е во тоа што во циклусот на настанот, Tcl ги отфрла кодовите за враќање од обработувачите на настани на асинхрони. Заобиколи е да поставите знаме во кодот за стапици. Потоа проверете го знамето веднаш по командата (т.е. спиење).
Командата expect_background игнорира -времени аргументи и нема концепт за тајминг воопшто.
& EXPECT HINTS & # 34;
Постојат неколку работи за Очекувајте дека може да бидат неинтуитивни. Овој дел се обидува да одговори на некои од овие работи со неколку предлози.
Чест очекуван проблем е како да препознаете инструкции за школка. Бидејќи тие се прилагодени поинаку од различни луѓе и различни школки, преносливо автоматизирање на rlogin може да биде тешко без да се знае брзата. Разумна конвенција е корисниците да зачуваат редовно изразување со опишување на нивната пратка (особено, крај на тоа) во променливата на околината EXPECT_PROMPT. Може да се користи код како следново. Ако EXPECT_PROMPT не постои, кодот сè уште има добри шанси да функционира правилно.
постави го прашањето "(% | # | \\ $) $"; #Јас ве охрабрувам да пишувате модели на очекување што го вклучуваат крајот на она што го очекувате да го видите. Ова ја избегнува можноста за одговарање на прашање пред да се види целата работа. Дополнително, додека можеби ќе можете да одговорите на прашањата пред да ги видите целосно, ако одговорите рано, вашиот одговор може да се појави повторно во средината на прашањето. Со други зборови, резултирачкиот дијалог ќе биде точен, но ќе биде измешан.
Повеќето инструкции вклучуваат просторен карактер на крајот. На пример, известувањето од ftp е 'f', 't', 'p', '>' и. За да одговарате на оваа пратка, мора да го наведете секој од овие знаци. Честа грешка е да не се вклучи празно. Ставете го празно во експлицитно.
Ако користите образец на образец X *, * ќе се совпадне со целиот излез добиен од крајот на X до последното нешто што ќе се прими. Ова звучи интуитивно, но може да биде малку збунувачки, бидејќи фразата "последното добивање" може да варира во зависност од брзината на компјутерот и обработката на I / O и од кернелот и од двигателот на уредот.
Особено, луѓето имаат тенденција да го видат програмскиот излез кој пристигнува во големи делови (атомски) кога во реалноста повеќето програми произведуваат излез една линија во исто време. Претпоставувајќи дека ова е случај, * во моделот од претходниот став може да се совпаѓа само со крајот на тековната линија, иако се чини дека има повеќе, бидејќи во времето на натпреварот беше целиот резултат што беше примена.
очекуваме дека нема начин да знаеме дека доаѓа до излез, освен ако вашиот образец посебно одговара за тоа.
Дури и во зависност од линиско-ориентираното буферизирање е неразумно. Не само што програмите ретко даваат ветувања за визуелниот тип на буферизација, но системното варење може да ги прекине излезните линии, така што линиите ќе се скршат на навидум случајни места. Така, ако можете да ги изразат последните неколку знаци на писмо кога пишувате обрасци, тоа е мудро да го сторите тоа.
Ако чекате шема во последниот излез на програмата и програмата емитира нешто друго, наместо тоа, нема да можете да го откриете тоа со клучен збор за истек на време . Причината е во тоа што очекуваме дека нема да истекува време - наместо тоа ќе добие индикатор eof . Користете го тоа. Уште подобро, користете и двете. На тој начин, ако таа линија некогаш се премести, нема да мора да ја уредувате самата линија.
Новите линии обично се претвораат во враќање на превозот, секвенци со линеарен пренос при излез од терминалниот возач. Така, ако сакате шема која експлицитно се совпаѓа со двете редови, од, да речеме, printf ("foo \ nbar"), треба да го користите моделот "foo \ r \ nbar".
Сличен превод се појавува кога читате од корисникот, преку expect_user . Во овој случај, кога ќе притиснете за враќање, тој ќе биде преведен на нова линија. Ако Expect потоа го помине тоа во програма која го поставува својот терминал на raw mode (како telnet), ќе има проблем, бидејќи програмата очекува вистинско враќање. (Некои програми всушност простуваат со тоа што автоматски ќе преведуваат нови линии за враќање, но повеќето не.) За жал, не постои начин да се открие дека програмата го става својот терминал во суров режим.
Наместо рачно да се заменат нови линии со поврат, решението е да се користи командата "stty raw", која ќе го запре преводот. Забележете, сепак, дека ова значи дека повеќе нема да ги добиете функциите за уредување на линии за готвење.
комуницирате имплицитно го поставува вашиот терминал на raw режим, па овој проблем нема да се појави тогаш.
Често е корисно да се зачуваат лозинките (или други приватни информации) во Оцени скрипти. Ова не е препорачливо, бидејќи нешто што е зачувано на компјутер е подложно на пристапот од никого. Така, интерактивно поттикнување на лозинките од сценариото е попаметна идеја отколку буквално да ги вметнете. Сепак, понекогаш таквото вградување е единствената можност.
За жал, датотечниот систем UNIX нема директен начин да создава скрипти кои се извршуваат, но се нечитливи. Системите кои ги поддржуваат поставените скрипти на школка може индиректно да симулираат ова на следниов начин:
Креирајте скрипта Expect (која ги содржи тајните податоци) како и обично. Дајте дозволи да бидат 750 (-rwxr-x ---) и во сопственост на доверлива група, односно група која може да ја прочита. Доколку е потребно, креирајте нова група за оваа намена. Следно, креирајте скрипта / bin / sh со дозволи 2751 (-rwxr-s - x) во сопственост на истата група како и порано.
Резултатот е скрипта која може да се изврши (и прочита) од никого. Кога ќе се повика, таа го води сценариото Expect.
& # 34; Видете исто & # 34;
Tcl (3), libexpect (3)
"Истражување на очекувањата: алатки за автоматизирање интерактивни програми" на Дон Либс, стр. 602, ISBN 1-56592-090-2, О'Рајли и соработници, 1995.
"Очекувајте: лекување на оние кои не се контролираат од интерактивноста" од Дон Либес, трудови на летото 1990 USENIX Conference, Anaheim, California, 11-15 јуни 1990.
. "Користејќи ги очекувањата да ги автоматизирам задачите на администрацијата на системот" од Дон Либес, трудови од конференцијата за администрација на големи системи за инсталација на системи USENIX, Колорадо Спрингс, Колорадо, 17-19 октомври 1990 година.
. I "Tcl: Вграден команден јазик" од Џон Оустерхут, Зборник на трудови од Зимски 1990 УСЕНИНС конференција, Вашингтон, 22-26 јануари, 1990.И "Очекувам: скрипти за контролирање на интерактивни програми" од Дон Либес, компјутерски системи , Vol. 4, бр. 2, Прилози за новинарство на Универзитетот во Калифорнија, ноември 1991..И "Тест за регресија и тестирање на интерактивни програми за усогласување", Дон Либес, Зборник на трудови од летото 1992 USENIX Conference, pp. 135-144, Сан Антонио, 12-15 јуни 1992 година. I "Kibitz - поврзување на повеќе интерактивни програми заедно", од Дон Либес, Софтвер - пракса и искуство, Џон Вајли и синови, Западен Сасекс, Англија, том.
23, бр. 5, мај, 1993 година. "Дебагер за апликации за", Дон Либес, Зборник на трудовата работилница 1993, Беркли, Калифорнија, 10-11 јуни 1993 година.
АВТОР
Дон Либес, Национален институт за стандарди и технологија
ПРИЗНАНИЈА
Благодарение на John Ousterhout за Tcl, и Скот Paisley за инспирација. Благодарение на Роб Савој за кодот за автоконфигурација на Expect.
Датотеката ИСТОРИЈА документира голем дел од еволуцијата на очекувањата . Тоа го прави интересно читање и може да ви даде дополнителен увид во овој софтвер. Благодарение на луѓето споменати во него, кои ме испратија поправки на бубачки и дадоа друга помош.
Дизајн и имплементација на Expect беше делумно платен од американската влада и затоа е во јавен домен. Меѓутоа, авторот и NIST би сакале да добијат кредит ако се користат оваа програма и документација или делови од нив.