Очаквайте програма, която разговаря с други интерактивни програми според сценария. Следвайки сценария, Expect знае какво може да се очаква от програмата и какъв трябва да бъде правилният отговор. Тълкуваният език осигурява структури за разклоняване и контрол на високо ниво, за да насочва диалога. В допълнение, потребителят може да поеме контрола и да взаимодейства директно при желание, след което да върне контрола върху скрипта.
Expectk е смес от Expect и Tk. Тя се държи точно като желанието на Expect и Tk. Очаквайте може да се използва директно в C или C ++ без Tcl.
Името "Очаквайте" идва от идеята за изпращане / очакване на последователности, популяризирани от uucp, kermit и други програми за контрол на модема. Въпреки това, за разлика от uucp, Expect се генерализира, така че да може да се изпълнява като команда на ниво потребител с всяка програма и задача в ума. Очаквайте да говорите с няколко програми по едно и също време.
Какво очаквате да направите
Например, тук са някои неща, които може да направи командата:
- Причината е, че компютърът ви набира обратно, за да можете да влезете, без да плащате за обаждането.
- Започнете да играете и ако оптималната конфигурация не се появи, рестартирайте я отново и отново), докато го направите, и след това предайте контрола си на вас.
- Изпълнете fsck и в отговор на неговите въпроси отговорете "да" или "не" или дайте контрол върху вас въз основа на предварително определени критерии.
- Свържете се с друга мрежа и автоматично извличайте вашата поща така, че да изглежда така, сякаш първоначално е била изпратена на вашата локална система.
- Носете променливи на средата, текущата директория или всякакъв вид информация в rlogin, telnet, tip, su или chgrp
Има различни причини, поради които черупката не може да изпълни тези задачи. Всички са възможни с Expect.
Обикновено, Expect е полезно за стартиране на всяка програма, която изисква взаимодействие между програмата и потребителя. Всичко, което е необходимо, е, че взаимодействието може да се характеризира програмно. Очаквайте също така да дадете обратно контрол на потребителя, без да спирате контролираната програма. По същия начин, потребителят може да върне контрол на скрипта по всяко време.
употреба
Очаквайте да прочетете cmdfile за списък с команди, които да изпълните. Очаквайте, че може да се извиква имплицитно на системи, които поддържат #! нотация чрез маркиране на скрипта като изпълним и правене на първия ред в скрипта:
#! / usr / local / bin / очаквайте-еРазбира се, пътеката трябва точно да опише къде живеят. / usr / local / bin е само пример.
Знакът -c предупреждава команда да бъде изпълнена преди всяка от скрипта. Командата трябва да бъде цитирана, за да не бъде разбита от обвивката. Тази опция може да се използва няколко пъти. Множество команди могат да се изпълнят с единичен -c, като се разделят с точка и запетая. Командите се изпълняват в реда, в който се показват. Когато използвате Expectk, тази опция е зададена като -command.
Знакът -d дава възможност за извеждане на диагностика, което главно отчита вътрешната активност на командите, като например очакване и взаимодействие. Този флаг има същия ефект като "exp_internal 1" в началото на скрипта Expect, плюс версията на Expect се отпечатва.
Знакът -D позволява интерактивен дебъгер. Трябва да следва цяла стойност. Дебъгорът ще поеме контрола преди следващата процедура Tcl, ако стойността не е нула или ако се натисне ^ C или се удари точка на прекъсване или се появи друга подходяща команда за дебъгер в скрипта. Когато използвате Expectk, тази опция е посочена като - Debug.
Флаговението -f префиксира файл, от който да се четат команди. Самият флаг е незадължителен, тъй като е полезен само при използване на #! така че да могат да бъдат предоставени и други аргументи на командния ред. Когато използвате Expectk, тази опция е посочена като "файл".
По подразбиране командният файл се чете в паметта и се изпълнява изцяло. Понякога е желателно да четете файлове един ред наведнъж. За да принудите произволни файлове да се обработват по този начин, използвайте знака -b. Когато използвате Expectk, тази опция е зададена като -buffer.
Ако низът "-" се доставя като име на файл, вместо това се чете стандартния вход. Използвайте "./-", за да четете от файл, който действително е "-".
Факторът -i причинява да очаквате интерактивно показване на команди, вместо да ги четете от файл. Показването се прекратява чрез командата за излизане или при EOF. Знакът -i се приема, ако нито команден файл, нито -c се използват. Когато използвате Expectk, тази опция е посочена като "интерактивна".
- може да се използва за ограничаване на края на опциите. Това е полезно, ако искате да предавате на вашия скрипт подобен на опция аргумент, без да се интерпретира от Expect. Това полезно може да бъде поставено в #! за да предотвратите подобно тълкуване от страна на Expect. Например следното ще остави оригиналните аргументи, включително името на скрипта в променливата argv .
#! / usr / local / bin / очаквайте -Обърнете внимание, че при добавяне на аргументи към #! Трябва да се спазват обичайните conventions getopt (3) и execve (2)! линия.
Файлът $ exp_library / expect.rc се получава автоматично, ако е налице, освен ако не се използва знакът -N. (Когато използвате Expectk, тази опция е посочена като -NORC.) Веднага след това файлът ~ / .expect.rc се получава автоматично, освен ако не се използва флагът -n. Ако променливата на средата DOTDIR е дефинирана, тя се третира като директория и от там се чете .expect.rc. Когато използвате Expectk, тази опция е посочена като -norc. Това извличане се извършва само след като се изпълнят всички знаци -c.
-v причини Expect да отпечата своя номер на версията и да излезе. Съответният флаг в Expectk, който използва дълги имена на флаговете, е -version.
Допълнителните аргументи се изграждат в списък и се съхраняват в променливата named argv and. argc се инициализира до дължината на argv.
Argv0 се дефинира като името на скрипта или двоичен, ако не се използва скрипт. Например, следното отпечатва името на скрипта и първите три аргумента:
send_user "$ argv0 [преход $ argv 0 2] \ n"команди
Очаквайте използването на инструмента Command Language. Tcl осигурява контролен поток (ако за счупване), оценка на експресията и няколко други характеристики като рекурсия и процедура за дефиниране. Командите, използвани тук, но не са дефинирани (set, if, exec) са Tcl команди. Очаквайте допълнителни команди. Освен ако не е посочено друго, командите връщат празния низ.
Командите са изброени по азбучен ред, така че да могат бързо да бъдат намерени. Но новите потребители може да установят, че е по-лесно да започнат, като прочетат описанията на хайвер, изпращат, очакват и взаимодействат в тази последователност.
close [-slave] [-onexec 0 | 1] [-i spawn_id]Затваря връзката с текущия процес . Повечето интерактивни програми ще открият EOF на своя стадион и изход; като по този начин обикновено е достатъчно да убие и процеса . Знакът -i декларира процеса за затваряне, съответстващ на имената spawn_id.
Очакванията и взаимодействията ще открият, когато текущият процес напусне и имплицитно приключи, но ако убиете процеса , да речем "exec kill killpid", трябва да извикате изрично .
Знакът "-onexec" определя дали идентификационният номер на хайвера е затворен при всякакви нови начини на заразяване или ако процесът е насложен. За да оставите id idle отворен, използвайте стойността 0. Ненулева стойност на цялото число принуждава хайвера да се затвори във всички нови процеси.
Флагът "slave" затваря робота, свързан с идентификатора на хайвера. Когато връзката е затворена, робът автоматично се затваря, ако все още е отворен.
Независимо дали връзката е затворена имплицитно или изрично, трябва да изчакате да изчакате да изчистите съответното слот за процес на ядро. Командата за затваряне не изчаква чакане, тъй като няма гаранция, че затварянето на връзка с процеса ще я доведе до излизане.
debug [[-now] 0 | 1]контролира Tcl debugger, който ви позволява да преминете към изявления и да зададете прекъсвачи.
Без аргументи, връща се 1, ако дебъгерът не се изпълнява, в противен случай се връща 0.
С 1 аргумент, дебъгерът се стартира. С аргумент 0 дебъгерът е спрян. Ако аргументът 1 се предхожда от флага -now, дебъгерът се стартира незабавно. В противен случай, дебъгерът се стартира със следващия инструмент Tcl.
Командата за отстраняване на грешки не променя всички капани. Сравнете това с стартиране Очаквайте с флага "-D".
Командата за прекъсване на връзката прекъсва връзката с вилката от терминала . Той продължава да работи във фонов режим. На процеса се дава собствена група от процеси. Стандартните I / O се пренасочват към / dev / null .
Следният фрагмент използва прекъсване, за да продължите да изпълнявате скрипта във фонов режим.
ако {[fork]! = 0} излезете от връзката. , ,Следният скрипт чете парола и след това изпълнява програма на всеки час, която изисква парола всеки път, когато се изпълнява. Скриптът доставя паролата, така че трябва само да я въведете веднъж.
"{} {} {} {} {if {} {} {} {} 1, низ) \ r ". , , изход}Предимство при използване на прекъсване на връзката върху черупката на асинхронния процес (&) е, че Expect може да запази параметрите на терминала преди прекъсване и след това да ги приложи към новите ptys. С &, Expect няма шанс да прочете параметрите на терминала, тъй като терминалът вече е изключен от времето, когато Expect получава контрол.
изход [-opts] [статус]причини Очаквайте да излезете или да се подготвите по друг начин за това.
Флагът -onexit причинява следващия аргумент да бъде използван като изходен манипулатор. Без аргумент се връща текущият изходен манипулатор.
Знакът " -noexit" причинява " Очаквайте" да се подготви за излизане, но не спира действителното връщане на контрола към операционната система. Изпълнява се потребителски дефиниращ изходен манипулатор, както и вътрешните манипулатори на Expect. Не трябва да се изпълняват допълнителни команди. Това е полезно, ако използвате Expect с други разширения Tcl. Текущият преводач (и главният прозорец, ако е в средата Tk) остават така, че другите Tcl разширения да могат да се почистват. Ако отново се извика излизането на Expect (но това може да се случи), операторите не се повторяват.
При излизане всички връзки към процесите на зареждане са затворени. Затварянето ще бъде открито като EOF чрез заразени процеси. изходът не предприема други действия, освен това, което прави нормалната процедура _exit (2). По този начин процесите на заразяване, които не проверяват за EOF, могат да продължат да текат. (Различни условия са важни за определяне например на това, което ще бъде изпратено, но ще зависи от системата, което обикновено се документира под изход (3).) Процесите, които продължават да се изпълняват, ще бъдат наследени от init.
състоянието (или 0, ако не е посочено) се връща като изходно състояние на Expect . изходът се изпълнява имплицитно, ако се достигне краят на скрипта.
exp_continue [-continue_timer]
Командата exp_continue позволява да се очаква да продължи да изпълнява, вместо да се връща, както обикновено. По подразбиране exp_continue нулира таймера за изчакване. Флагът -continue_timer предотвратява рестартирането на таймера. (Вижте очакване за повече информация.)
exp_internal [-f файл] стойност
причинява допълнителни команди за изпращане на диагностична информация вътрешна към " Очаквайте" до " stderr", ако стойността не е нула. Този изход е деактивиран, ако стойността е 0. Диагностичната информация включва всеки получен знак и всеки опит за съпоставяне на текущия изход с моделите.
Ако е предоставен незадължителен файл , всички нормални и отстранени грешки се записват в този файл (независимо от стойността на стойността ). Всеки предишен диагностичен изходен файл е затворен.
Флагът -info причинява exp_internal да върне описание на най-новите неанализирани аргументи.
exp_open [args] [-i spawn_id]
връща идентификатор на файла Tcl, който съответства на оригиналния идентификационен номер на хартия. Идентификаторът на файла може да се използва, ако е бил отворен от отворената команда на Tcl. (Идентификационният номер на хайвера не трябва да се използва повече.) Чакането не трябва да се изпълнява.
Флагът -олейопен закача отворената идентификация на хайвера за достъп чрез команди Expect. Чакането трябва да бъде изпълнено на идентификатора на хайвера.
exp_pid [-i spawn_id]
връща идентификационния номер на процеса, съответстващ на процеса, който е създаден понастоящем. Ако се използва знакът -i , връщането на pid съответства на това на дадения идентификатор.
exp_send
е псевдоним за изпращане .
exp_send_error
е псевдоним за send_error .
exp_send_log
е псевдоним за send_log .
exp_send_tty
е псевдоним за send_tty .
exp_send_user
е псевдоним на send_user .
exp_version [[-exit] version]
е полезно да се гарантира, че скриптът е съвместим с текущата версия на Expect.
Без аргументи се връща текущата версия на Expect . Тази версия може да бъде кодирана в скрипта ви. Ако наистина знаете, че не използвате функциите на последните версии, можете да посочите по-ранна версия.
Версиите се състоят от три номера, разделени с точки. Първият е основният номер. Сценариите, написани за версии на Expect с различен голям брой, със сигурност няма да работят. exp_version връща грешка, ако главните номера не съвпадат.
Втората е незначителният номер. Скриптовете, написани за версия с по-голямо незначително число от текущата версия, може да зависят от нова функция и да не се изпълняват. exp_version връща грешка, ако големите числа съвпадат, но малкият брой на скрипта е по-голям от този на текущия Очаквайте .
Трето е число, което няма значение за сравнението на версията. Въпреки това, той се увеличава, когато софтуерното разпространение Expect се променя по какъвто и да е начин, например чрез допълнителна документация или оптимизация. Той се нулира на 0 при всяка нова второстепенна версия.
С флага " Exit " Expect отпечатва грешка и излиза, ако версията е остаряла.
очакват [[-opts] pat1 body1] ... [-opts] patn [bodyn]
чака, докато един от шаблоните не съвпадне с изхода на възникналия процес, изтече определен период от време или се види край на файла. Ако окончателното тяло е празно, то може да бъде пропуснато.
Моделите от последната expect_before команда са имплицитно използвани преди всякакви други модели. Моделите от последната команда expect_after са имплицитно използвани след всякакви други модели.
Ако аргументите за цялото очакване изискват повече от един ред, всички аргументи могат да бъдат "подравнени" в едно, за да се избегне прекратяването на всеки ред с обратна наклонена черта. В този случай, обичайните Tcl замени ще се появят въпреки скобите.
Ако моделът е ключовата дума eof , съответното тяло се изпълнява след края на файла. Ако даден шаблон е времето за изчакване на ключовата дума, съответното тяло се изпълнява след изтичане на срока. Ако не се използва ключова дума с изчакване, при изтичане на времето се изпълнява имплицитно нищожно действие. Периодът на изчакване по подразбиране е 10 секунди, но може да бъде зададен, например до 30, с командата "set timeout 30". Неограниченото изчакване може да бъде означено със стойност -1. Ако шаблонът е по подразбиране за ключовата дума, съответното тяло се изпълнява при изтичане на срока или края на файла.
Ако моделът съвпадне, тогава съответното тяло се изпълнява. Очаква се връща резултата от тялото (или празния низ, ако не съответства на шаблона). В случай, че се съчетаят няколко модела, първата, която се показва, се използва за избор на тяло.
Всеки път, когато пристигне нов изход, той се сравнява с всеки модел в реда, в който са изброени. По този начин можете да тествате за отсъствие на мач, като направите последния шаблон с нещо, гарантирано, че ще се появи, например подкана. В ситуации, в които няма подкана, трябва да използвате изчакване (точно както бихте направили, ако ръчно взаимодействахте).
Моделите са посочени по три начина. По подразбиране шаблоните се задават както при командата за съвпадение на низовете на Tcl. (Такива модели също са подобни на обикновените изрази на С-черупки, обикновено наричани "глобус" модели). Флагът -gl може да бъде използван за защита на шаблони, които иначе биха могли да съответстват на очакването на флагове. Всеки модел, започващ с "-", трябва да бъде защитен по този начин. (Всички низове, започващи с "-", са запазени за бъдещи опции.)
Например, следният фрагмент търси успешно влизане. (Обърнете внимание, че анулирането се приема за процедура, определена другаде в сценария.)
очаквам {зает {пуска зает \ n; exp_continue} не успя да прекрати "невалидна парола" прекратяване на изчакването прекратяване на връзката}Цитатите са необходими на четвъртия модел, тъй като тя съдържа пространство, което иначе би отделило шаблона от действието. Моделите със същото действие (например 3-то и 4-то) изискват отново да бъдат описани действията. Това може да се избегне, използвайки модели в стил regexp (вижте по-долу). Повече информация за моделирането на стил в стил "глобус" може да намерите в ръководството на Tcl.
Моделите в стил Regexp следват синтаксиса, дефиниран от командата Tcl's regexp (кратко за "регулярния израз"). моделите regexp се въвеждат с флага -re . Предишният пример може да бъде пренаписан с помощта на regexp като:
очаквам {зает {пуска зает \ n; exp_continue} -re "неуспешна | невалидна парола" abort timeout abort connected}И двата вида модели са "неподдържани". Това означава, че шаблоните не трябва да съответстват на целия низ, но могат да започнат и да завършват мача навсякъде в низа (стига всичко друго да съвпадне). Използвайте ^, за да съответствате на началото на низ и $, за да съответства на края. Имайте предвид, че ако не изчакате края на низа, отговорите ви лесно могат да завършат в средата на низа, тъй като те се повтарят от процеса на зареждане. Докато все още се получават правилни резултати, продукцията може да изглежда неестествена. По този начин използването на $ се насърчава, ако можете да опишете точно знаците в края на низа.
Имайте предвид, че в много редактори, ^ и $ съвпадат съответно с началото и края на линиите. Обаче, тъй като очакването не е линейно ориентирано, тези знаци съвпадат с началото и края на данните (за разлика от линиите), които понастоящем се намират в очаквания буфер за съвпадение. (Също така, вижте бележката по-долу относно "Системата за лошо храносмилане".)
Знакът -ex причинява съответствието на шаблона като "точен" низ. Не се прави тълкуване на *, ^, и т.н. (въпреки че все пак трябва да се спазват обичайните конвенции Tcl). Точните шаблони винаги са непотвърдени.
Знакът -nocase причинява главни букви на изхода, за да ги сравни, сякаш са малки букви. Моделът не е засегнат.
Докато чете продукцията, повече от 2000 байта могат да принудят по-ранните байтове да бъдат "забравени". Това може да се промени с функцията match_max . (Забележете, че прекомерно големи стойности могат да забавят матрицата на шаблона.) Ако патичният списък е full_buffer , съответното тяло се изпълнява, ако са получени максимум максимум максимуми и няма други съвпадения. Дали ключът full_buffer се използва или не, забравените знаци се записват в expect_out (буфер).
Ако патлистът е ключова дума нула и нулеви са разрешени (чрез командата remove_nulls ), съответното тяло се изпълнява, ако се съчетае една ASCII 0. Не е възможно да се сравняват 0 байта чрез шаблони на glob или regexp.
След съгласуване на шаблон (или eof или full_buffer), всяка съвпадаща и преди несравнима продукция се записва в променливата expect_out (буфер) . До максимум 9 съвпадения на съвпадения в regexp се запазват в променливите expect_out (1, string) чрез expect_out (9, string) . Ако знакът "индикации" се използва преди образец, началните и крайните индекси (във форма, подходяща за преливане ) на 10-те струни се съхраняват в променливите expect_out (X, start) и expect_out (X, end) цифра, съответства на позицията на подзадача в буфера. 0 се отнася за струни, които съвпадат с целия модел и се генерират за шаблони, както и за модели на regexp. Например, ако даден процес е произвел продукция от "abcdefgh \ n", резултатът от:
очаквайте "cd"е като че са изпълнени следните твърдения:
задайте expect_out (0, низ) cd задаване expect_out (буфер) abcdи "efgh \ n" остават в изходния буфер. Ако процесът е произвел изхода "abbbcabkkkka \ n", резултатът от:
Очаквайте - индикации -re "b (b *). * (k +)"е като че са изпълнени следните твърдения:
(1, начало) 2 задаване expect_out (0, начало) 1 set expect_out (0, начало) 1 set expect_out (0, края) (2, начало) 10 задаване expect_out (2, край) 10 set expect_out (2, string) k набор expect_out (буфер) abbbcabkkkkи "a \ n" остава в изходния буфер. Шаблонът "*" (и -re ". *") Ще изчисти изходния буфер, без да чете повече изход от процеса.
Обикновено съответстващата продукция се изхвърля от вътрешните буфери на Expect. Това може да бъде предотвратено чрез префиксиране на шаблон с знака -transfer . Това знаме е особено полезно при експериментиране (и може да бъде съкратено до "-not" за удобство при експериментиране).
Идентификационният номер на хороскоп, свързан със съответстващия изход (или eof или full_buffer) се съхранява в expect_out (spawn_id) .
Флагът -timeout причинява командата текуща очаква да използва следната стойност като timeout, вместо да използва стойността на променливата за изчакване.
По подразбиране шаблоните съответстват на изхода от текущия процес, но флагът -i декларира, че изходът от списъка с имена spawn_id е съпоставен с всички следващи модели (до следващата -i ). Списъкът на spawn_id трябва да бъде или отделен от whitespace списък с spawn_ids, или променлива, която се отнася за такъв списък с spawn_ids.
Например, следният пример чака за "свързан" от текущия процес, или "зает", "неуспешен" или "невалидна парола" от spawn_id, наречен от $ proc2.
очаквайте {-i $ proc2 зает {пуска зает \ n; exp_continue} -re "неуспешна | невалидна парола" abort timeout abort connected}Стойността на глобалната променлива any_spawn_id може да бъде използвана, за да съответства на шаблоните на всякакви spawn_ids, които са именувани с всички други -i флагове в текущата команда Очаквайте . Разпространението на мишката от флага -i без свързан шаблон (т.е. последвано веднага от друг) е достъпно за всички други шаблони в същата команда, очаквана, свързана с any_spawn_id.
Знакът -i може също така да назове глобална променлива, в който случай се прочита променливата за списък с идентификатори на хайвер. Променливата се преглежда отново, когато се промени. Това осигурява начин за промяна на източника на I / O, докато командата се изпълнява. Идентичностите на Спана, които по този начин се наричат "индиректни" идентификатори на хайвер.
Действия като прекъсване и продължаване на създаването на контролни структури (т.е. за proc ) да се държат по обичайния начин. Командата exp_continue позволява да се очаква да продължи да изпълнява, вместо да се връща, както обикновено.
Това е полезно за избягване на изрични цикли или повтарящи се очакване на изявления. Следващият пример е част от фрагмента за автоматизиране на rlogin. Exp_continue избягва да напише втора очакване изявление (да потърси отново подкана), ако rlogin подканя за парола.
Очаквайте {Password: {stty -echo send_user "парола за $ user) на $ host:" expect_user -re "(. *) \ n" send_user "\ n" изпрати "$ expect_out (1, string) echo exp_continue} неправилно {send_user "невалидна парола или сметка \ n" изход} timeout {send_user "връзка към $ host изтекъл \ n" изход} eof {send_user \ re $ prompt}Например, следващият фрагмент може да помогне на потребителското ръководство за взаимодействие, което вече е изцяло автоматизирано. В този случай терминалът се поставя в режим "суров". Ако потребителят натисне "+", променливата се увеличава. Ако се натисне "p", няколко процеса се връщат на процеса, може би, за да се изясни по някакъв начин и "i" позволява на потребителя да взаимодейства с процеса, като ефективно открадва контрола от скрипта. Във всеки случай exp_continue позволява на текущия да очакват продължаване на съвпадението на шаблоните след изпълнение на текущото действие.
stty raw - очаквате_поточка {-i $ user_spawn_id "p" {send "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "излизане" изход}По подразбиране exp_continue нулира таймера за изчакване. Таймерът не се рестартира, ако exp_continue се извиква с флага -continue_timer .
expect_after [expect_args]
работи по същия начин , както очакваме преди, освен, че ако шаблоните от очакване и expect_after могат да съвпадат, се използва моделът на очакване . Вижте командата expect_before за повече информация.
expect_background [expect_args]
има същите аргументи, както се очаква , но се връща незабавно. Моделите се тестват всеки път, когато пристигнат нови данни. Времето за изчакване на шаблона и по подразбиране са безсмислени да се очакват обратно и мълчаливо се отхвърлят. В противен случай командата expect_background използва ориентири expectations_before и expect_after , точно както очакват .
Когато се очакват действия на expect_background , обработката на фона за един и същ идентификатор за зареждане е блокирана. Обработката на фона се отблокира, когато действието завърши. Докато обработката на заден поток е блокирана, е възможно да се направи очакване (на преден план) на един и същ идентификатор.
Не е възможно да се изпълни очакванията, докато wait_background е отблокиран. expect_background за конкретен id на заразяване се изтрива, като се обявява нов expect_background със същия идентификационен номер. Обявяването на expect_background без шаблон премахва даден id spawn от способността да съответства на шаблоните във фонов режим.
очаквайте преди [expect_args]
има същите аргументи, както се очаква , но се връща незабавно. Възможно е да се добавят комбинации от двойки от последната expect_before със същия идентификатор на зарибяване към всички следващи команди за очакване . Ако моделът съвпадне, той се третира като описан в самата очаквана команда и свързаното тяло се изпълнява в контекста на очакваната команда. Ако шаблони от двете expect_before и очакване могат да съвпадат, очаква се before_before модел.
Ако не е зададен шаблон, идентификационният номер на хартия не се проверява за никакви шаблони.
Освен ако не е заведен от флаг -i , очаквайте преди да се съчетаят с идентификационния номер на хартията, определен по времето, когато командата expect_before е изпълнена (а не когато моделът е съвпадащ).
Флаго знанието -info причинява очакване преди да се върнат текущите спецификации за това какви модели ще съответстват. По подразбиране той отчита текущия идентификационен номер на хартия. За информация относно идентификационния номер на хайвера може да бъде дадена незадължителна спецификация за идент. Например
expect_before -info -i $ procМогат да бъдат дадени най-много една спецификация за хайвера. Знакът - индиректно подтиска директните идентификатори на хайвер, които идват само от непреки спецификации.
Вместо спецификацията на id spawn, флагът "-all" ще предизвика "-info" да докладва за всички идентификатори на хайвер.
Резултатът от флага "-info" може да бъде използван отново като аргумент за очакване преди.
expect_tty [expect_args]
е като очакване, но чете символи от / dev / tty (т.е. натискания на клавиши от потребителя). По подразбиране четенето се извършва в готвения режим. По този начин линиите трябва да завършват с връщане, за да очакват да ги видят. Това може да се промени чрез stty (вижте командата stty по-долу).
expect_user [expect_args]
е като очакване, но чете символи от stdin (т.е. натискания на клавиши от потребителя). По подразбиране четенето се извършва в готвения режим. По този начин линиите трябва да завършват с връщане, за да очакват да ги видят. Това може да се промени чрез stty (вижте командата stty по-долу).
вилица
създава нов процес . Новият процес е точно копие на текущия процес Expect . При успех, вилицата връща 0 към новия (детски) процес и връща идентификационния процес на подчинените процес в родителския процес . При неизправност (неизменно поради липса на ресурси, например, суап пространство, памет), вилицата връща -1 към родителския процес и не се създава детешки процес .
Завършените процеси излизат от командата за излизане , точно като оригиналния процес . Записите в процесите могат да се записват в дневниците. Ако не деактивирате отстраняването на грешки или се регистрирате в повечето от процесите, резултатът може да бъде объркващ.
Някои pty реализации могат да бъдат объркани от няколко читатели и писатели, дори и за момент. По този начин, най-безопасно е да се раздават вилици преди процесите на хвърляне на хайвера.
взаимодействат [string1 body1] ... [stringn [bodyn]]
дава контрол на текущия процес на потребителя, така че клавишните комбинации се изпращат към текущия процес и се връщат stdout и stderr на текущия процес .
Двойките на струнни тела могат да бъдат определени като аргументи, в който случай тялото се изпълнява, когато се въведе съответният низ. (По подразбиране низът не се изпраща към текущия процес .) Командата на интерпретатора се приема, ако липсва окончателното тяло.
Ако аргументите за цялата операция за взаимодействие изискват повече от един ред, всички аргументи могат да бъдат "подравнени" в едно, за да се избегне прекратяването на всяка линия с обратна наклонена черта. В този случай, обичайните Tcl замени ще се появят въпреки скобите.
Например, следната команда работи, взаимодейства със следните двойки стринг-тяло: Когато се натисне ^ Z, Expect е спряно. ( Флагът " Reset" възстановява терминалните режими.) Когато се натисне ^ A, потребителят вижда "сте въвели контрола-А" и процесът е изпратен a ^ A. Когато се натисне $, потребителят вижда датата. Когато се натисне ^ C, очаквайте изходи. Ако се въведе "foo", потребителят вижда "bar". При натискането на ~~, интерпретаторът Expect се изпълнява интерактивно.
set CTRLZ \ 032 взаимодействие {-уреда $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "въведете контрола-A \ n"; изпрати "\ 001"} $ {send_user "Датата е [часов формат [часовник секунди]]"} \ 003 exit foo {send_user "bar"} ~~}В двойки струнен-телесен, низовете се съгласуват в реда, в който са изброени като аргументи. Срещите, които частично съвпадат, не се изпращат към текущия процес в очакване на останалата част. Ако след това се въведат знаци, така че вече не може да има съвпадение, само част от низа ще бъде изпратена до процеса, който не може да започне друго съвпадение. По този начин струните, които са подзаредения на частични съвпадения, могат да се сравняват по-късно, ако оригиналните струни, които се опитват да бъдат съвпадащи, в крайна сметка не успеят.
По подразбиране съвпадението на низовете е точна без диви карти . (За разлика от това, командата " очаква" използва по подразбиране шаблони в стил "глобус".) Флагът -ex може да се използва за защита на шаблони, които иначе биха могли да съвпаднат с флаговете от взаимодействие . Всеки модел, започващ с "-", трябва да бъде защитен по този начин. (Всички низове, започващи с "-", са запазени за бъдещи опции.)
Знакът -re принуждава низът да се интерпретира като шаблон в стил regexp. В този случай съответстващите подзаписи се съхраняват в променливата interact_out, подобно на начина, по който се очаква да се съхранява продукцията му в променливата expect_out . Знакът " индикации" се поддържа подобно.
Моделът eof въвежда действие, което се изпълнява след края на файла. Отделен модел eof може да следва и флаг-изхода, в който случай тя се съчетава, ако eof е открит, докато записвате изход. Действието по подразбиране eof е "връщане", така че взаимодействието просто се връща на всеки EOF.
Времето на шаблона въвежда времево изчакване (в секунди) и действие, което се изпълнява, след като не са прочетени за определен период от време знаци. Схемата за изчакване се прилага за последно определения процес . Няма изчакване по подразбиране. Специалната променлива "timeout" (използвана от командата expect) няма влияние върху това време.
Например, следното изявление може да бъде използвано за автологизиране на потребители, които не са въвели нищо за един час, но все още получават чести системни съобщения:
взаимодействайте - въведете $ user_spawn_id timeout 3600 връщане-изход \ $ spawn_idАко шаблонът е ключова дума нула и nulls са разрешени (чрез командата remove_nulls ), съответното тяло се изпълнява, ако се съчетае една ASCII 0. Не е възможно да се сравняват 0 байта чрез шаблони на glob или regexp.
Представянето на шаблон с флага -write води до това, че променливата interact_out (spawn_id) ще бъде зададена като spawn_id, която съответства на шаблона (или eof).
Действия като прекъсване и продължаване на създаването на контролни структури (т.е. за proc ) да се държат по обичайния начин. Въпреки това причините за връщане взаимодействат, за да се върнат на повикващия, докато inter_return причинява взаимодействие, за да предизвика връщане на повикващия. Например, ако "proc foo" се нарича взаимодействие, което след това изпълни действието inter_return , proc foo ще се върне. (Това означава, че ако взаимодействате с обажданията, интерпретаторът натиска връщането, което ще доведе до продължаване на взаимодействието, докато inter_return ще предизвика взаимодействието да се върне на повикващия.)
По време на взаимодействие се използва груб режим, така че всички знаци да могат да бъдат предавани на текущия процес . Ако настоящият процес не улови сигнали за управление на заданието, той ще спре, ако бъде изпратен сигнал за спиране (по подразбиране ^ Z). За да го рестартирате, изпратете сигнал за продължаване (например чрез "kill-CONT"). Ако наистина искате да изпратите SIGSTOP на такъв процес (от ^ Z), помислете първо за пускане на csh и първо да стартирате програмата си. От друга страна, ако искате да изпратите SIGSTOP да се очаква , първо се обадете на преводача (може би с помощта на евакуационен символ), след което натиснете ^ Z.
Срещите на струнни тела могат да се използват като стенография за избягване на навлизането в интерпретатора и изпълнение на команди интерактивно. Предишният терминален режим се използва, докато тялото на двойка низ-тяло се изпълнява.
За скорост действията се изпълняват в режим "суров" по подразбиране. Флагът -резистентност възстановява терминала в режима, който е имал, преди да е бил изпълнен (неизменно, готвения режим). Имайте предвид, че знаците, въведени при превключване на режима, могат да бъдат загубени (една неприятна черта на драйвера на терминала на някои системи). Единствената причина да използвате reset е, ако действието ви зависи от пускането в режим на готвене.
Знакът -echo изпраща знаци, които съответстват на следния шаблон, обратно към процеса, който ги е генерирал при четене на всеки знак. Това може да е полезно, когато потребителят трябва да види обратна връзка от частично напечатани модели.
Ако моделът се повтаря, но евентуално не съвпада, героите се изпращат в процеса на заснемане. Ако процесът, в който се зароди , след това ги отразява, потребителят ще види знаците два пъти. -echo вероятно е подходящ само в ситуации, при които е малко вероятно потребителят да не завърши модела. Например, следният откъс е от rftp, рекурсивния-ftp скрипт, където потребителят е подканен да въведе ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Те са толкова далеч от нормалните команди на ftp, че потребителят е малко вероятно да въведе ~ последвано от нещо друго, освен погрешно, в който случай те вероятно просто игнорират резултата все пак.
взаимодействайте {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}Флагът -nobuffer изпраща знаци, които съответстват на следния шаблон на изходния процес, докато се четат знаците.
Това е полезно, когато искате да позволите на програма да отразява модела. Например, може да се използва следното, за да се следи къде се набира човек (модем стил Hayes). Всеки път, когато се вижда "atd", скриптът регистрира останалата част от линията.
proc lognumber {} {interact -nobuffer -re "(. *) \ r" връщане поставя $ log "[часов формат [часовник секунди]]: набрани $ interact_out (1, string)" interact -nobuffer "atd"По време на взаимодействие , предишната употреба на log_user се игнорира. По-специално, взаимодействието ще принуди изхода му да бъде регистриран (изпращан към стандартния изход), тъй като се предполага, че потребителят не желае да си взаимодейства сляпо.
Знакът -o причинява следните двойки ключ-тяло, които се прилагат към изхода на текущия процес . Това може да бъде полезно, например, когато се занимавате с хостове, които изпращат нежелани знаци по време на телнет сесия.
По подразбиране, взаимодействието се очаква потребителят да пише stdin и да чете stdout на самия процес Expect . Флагът -u (за "потребител") прави взаимодействие на потребителя като процес, наречен от неговия аргумент (който трябва да е идентификатор за зареждане).
Това позволява две несвързани процеси да бъдат свързани заедно без да се използва изрична линия. За да помогнете за отстраняването на грешки, очаквайте диагностика винаги да отидете на stderr (или stdout за определена информация за логване и отстраняване на грешки). По същата причина командата на преводача ще се чете интерактивно от stdin.
Например, следният фрагмент създава процес на вход. След това той набира потребителя (не е показан) и накрая свързва двата заедно. Разбира се, всеки процес може да бъде заменен от вход. Черупка, например, би позволила на потребителя да работи без да доставя профил и парола.
зареждане с вход за настройка вход $ spawn_id spawn tip modem # набиране обратно към потребител # свързване на потребител за вход interact -u $ loginЗа да изпратите изход на няколко процеса, избройте всеки списък с идентификатори на хайвера, предшестван от флаг- изход . Въвеждането на група от идентификационни данни за изходните хакове може да бъде определено от списък с идентификатори на хайвер, предшестван от флаг за въвеждане. (И двата -input и -output могат да приемат списъци в същата форма като флага -i в очакваната команда, с изключение на това, че any_spawn_id няма смисъл да взаимодейства .) Всички последващи флагове и низове (или шаблони) вмъкване на флага. Ако не се покаже "-input", -output означава "-input $ user_spawn_id -output". (По същия начин, с шаблони, които нямат въвеждане.) Ако е зададена една -индукция , тя заменя $ user_spawn_id. Ако е зададена втора -интервала , тя заменя $ spawn_id. Могат да бъдат посочени допълнителни флагове за въвеждане.
Двете имплицитни процеси на въвеждане по подразбиране имат своите изходи, определени като $ spawn_id и $ user_spawn_id (на обратната страна). Ако се покаже флаг за въвеждане с флага без изход , символите от този процес се отхвърлят.
Флагът -i въвежда заместващ елемент за текущия спасителен номер, когато не се използват други знаци за въвеждане или за излизане. Знакът "-i" предполага знак -o.
Възможно е да се променят процесите, с които се работи, като се използват косвени идентификатори на хайвер. (Непосредствените идентификатори на хайвера са описани в раздела на командата "Очаквайте".) Непосредствените идентификатори на хайвера могат да бъдат определени с флаговете -i, -u, -input или -output.
тълкувател [аргументи]
причинява на потребителя да бъде подканен интерактивно за команди Expect и Tcl. Резултатът от всяка команда се отпечатва.
Действия като прекъсване и продължаване на създаването на контролни структури (т.е. за proc ) да се държат по обичайния начин. Връщането обаче води до връщане на интервюиращия на обаждащия се, докато inter_return кара преводача да се върне в обаждащия се. Например, ако "proc foo" се нарича тълкувател, който след това изпълни действието inter_return , proc foo ще се върне. Всяка друга команда причинява тълкувателя да продължи да подканва за нови команди.
По подразбиране подкана съдържа две числа. Първото цяло число описва дълбочината на колоната за оценка (т.е. колко пъти е наречена Tcl_Eval). Второто цяло число е идентификаторът на историята на Tcl. Проблемът може да бъде зададен чрез дефиниране на процедура наречена "prompt1", чиято връщаща се стойност се превръща в следващата подкана. Ако в изявление има отворени котировки, пароли, скоби или скоби, се изписва втори ред (по подразбиране "+>") при нов ред. Вторичният ред може да бъде зададен чрез дефиниране на процедура, наречена "prompt2".
По време на интерпретатора се използва режим на готвене, дори когато повикващият използва суров режим.
Ако stdin е затворен, преводачът ще се върне, освен ако не се използва флага- eof , в който случай се използва следващият аргумент.
log_file [args] [[-a] файл]
Ако е предоставено име на файл, log_file ще записва препис от сесията (започващ от тази точка) във файла. log_file ще спре да записва, ако няма даден аргумент. Всеки предишен регистрационен файл е затворен.
Вместо име на файл, може да бъде предоставен идентификатор на файла Tcl, използвайки фрагментите "open" или " open" . Това е подобно на командата за хвърляне на хайвера . (За повече информация вижте загадката .)
Силите на флаг -a се извеждат, за да бъдат записани, подтиснати от командата log_user .
По подразбиране командата log_file се прибавя към стари файлове, а не към съкращаването им, за да може да се изключи и да се изключва няколко пъти в една сесия. За да съкратите файловете, използвайте флага -notappend .
Флагът -info причинява log_file, за да върне описание на най-новите неанализирани аргументи.
log_user -инфо | 0 | 1
По подразбиране диалоговият прозорец за изпращане / очакване се записва в stdout (и в лог файл, ако е отворен). Записването в стоп е деактивирано от командата "log_user 0" и се активира отново от "log_user 1". Влизането в регистрационния файл е непроменено.
Флагът -info причинява log_user да върне описание на най-новите неанализирани аргументи.
match_max [-d] [-i spawn_id] [размер]
дефинира размера на буфера (в байтове), използван вътрешно от очакванията . Без аргумент за размера се връща текущият размер.
С флага -d е зададен стандартният размер. (Първоначалната стойност по подразбиране е 2000.) С флага -i , размерът е зададен за името на идент. Икона, в противен случай е зададен за текущия процес .
overlay [- # spawn_id] [- # spawn_id] [...] програма [арги]
изпълнява "програмни аргументи" вместо текущата програма Expect , която се прекратява. Горещият аргумент на тирето принуждава тире преди името на командата, сякаш е входна черупка. Всички зони_серии са затворени, с изключение на тези, които са посочени като аргументи. Те се нанасят върху идентифицираните идентификатори на файлове.
Spawn_ids са означени с идентификатори на файлове, които новата програма да наследи. Например, следната линия изпълнява шахмат и позволява да бъде контролирана от текущия процес - да речем, шахмат.
наслагване -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id шахТова е по-ефективно от "взаимодействие-u", но той жертва способността да извършва програмирано взаимодействие, тъй като процесът Expect вече не се контролира.
Имайте предвид, че няма контролен терминал. По този начин, ако прекъсвате или преопаковате стандартен вход, програми, които правят контрол на работата (черупки, вход и т.н.) няма да функционират правилно.
паритет [-d] [-i spawn_id] [стойност]
дефинира дали паритетът трябва да се запази или да се отстрани от изхода на потопените процеси. Ако стойността е нула, паритетът се премахва, в противен случай не се премахва. Без аргумент за стойността , текущата стойност се връща.
С флага -d е зададена стойността по подразбиране за паритет. (Първоначалната стойност по подразбиране е 1, т.е. паритетът не се премахва.) С флага -i , стойността на паритета е зададена за името на идентификационния номер на иначе, в противен случай е зададен за текущия процес .
remove_nulls [-d] [-i spawn_id] [стойност]
дефинира дали нулите се задържат или отстраняват от изхода на потопените процеси, преди да съответстват на шаблона или да се съхраняват в променливата expect_out или interact_out . Ако стойността е 1, нулите се премахват. Ако стойността е 0, nulls не се премахват. Без аргумент за стойността , текущата стойност се връща.
С флага -d е зададена стойността по подразбиране. (Първоначалната стойност по подразбиране е 1, т.е. нулите се премахват.) С флаг -i стойността е зададена за именувания id spawn, в противен случай тя е зададена за текущия процес .
Независимо дали се премахват nulls, Expect ще записва нулеви байтове в дневника и stdout.
изпращане на [-флагис] низ
Изпраща низ на текущия процес . Например командата
изпраща знаците, helloworld към текущия процес . (Tcl включва команда printf (наречена формат ), която може да изгражда произволно сложни струни.)
Символите се изпращат незабавно, въпреки че програмите с буфериран входен вход няма да четат символите, докато не бъде изпратен обратен знак. Завръщащият се символ е обозначен "\ r".
Флагът принуждава следващият аргумент да се интерпретира като низ, а не като флаг. Всеки низ може да бъде предхождан от "-", независимо дали всъщност изглежда като знаме. Това осигурява надежден механизъм за определяне на променливи струни, без да се заплюват от тези, които случайно изглеждат като флагове. (Всички низове, започващи с "-", са запазени за бъдещи опции.)
Знакът -i декларира, че низът ще бъде изпратен до имената spawn_id. Ако spawn_id е user_spawn_id и терминалът е в необработен режим, новите линии в низа се преобразуват в последователност на връщане в нов ред, така че те да изглеждат така, сякаш терминалът е в режим на готвене. Флагове -raw деактивира този превод.
Знакът -null изпраща нулеви знаци (0 байта). По подразбиране се изпраща един нула. Цялото число може да следва нула, за да покаже колко нула да изпратите.
Флаговеният знак генерира състояние на прекъсване. Това има смисъл само ако id spawn се отнася до устройство tty, което е отворено чрез "spawn-open". Ако сте създали процес като върха, трябва да използвате конвенцията на върха за генериране на почивка.
Сигналите на сигналите -s се изпращат "бавно", като по този начин се избягва общата ситуация, при която компютърът излиза от буфер за въвеждане, предназначен за човек, който никога не би изпреварил същия буфер . Този изход се контролира от стойността на променливата "send_slow", която съдържа списък с два елемента. Първият елемент е цяло число, което описва броя на байтовете, които се изпращат атомно. Вторият елемент е реалният номер, който описва броя секунди, през които трябва да се отделят атомните. Например "set send_slow {10 .001}" ще накара "send -s" да изпрати струни с 1 милисекунда между всеки 10 изпратени символа.
Силата на флаговете -h излиза да бъде изпратена (донякъде) като човек, който всъщност пише. Между героите се появяват човешки закъснения. (Алгоритъмът се основава на Weibull разпределение, с модификации, които да отговарят на това конкретно приложение.) Този изход се контролира от стойността на променливата "send_human", която приема списък с пет елемента. Първите два елемента са средно време за прехвърляне на знаците в секунди. Първият се използва по подразбиране. Вторият се използва при крайни думи, за да се симулират фините паузи, които понякога се случват при такива преходи. Третият параметър е мярка за вариация, където .1 е доста променлива, 1 е разумно променлива, а 10 е съвсем неизменна. Последните са 0 до безкрайност. Последните два параметъра са, съответно, минимално и максимално време за изчакване. Минималният и максималният се използват последно и "clip" на последното време. Крайната средна стойност може да бъде съвсем различна от дадената средна стойност, ако минималната и максималната стойност на клипа са достатъчни.
Като пример, следната команда емулира бърз и последователен машинописец:
set send_human {.1 .3 1 .05 2} изпрати -h "Гладен съм. Да направим обяд."докато след махмурлук може да сте по-подходящи:
задайте send_human {.4 .4 .2 .5 100} изпрати -h "Goodd party вечер!"Обърнете внимание, че грешките не са симулирани, въпреки че можете сами да настроите ситуации за коригиране на грешки, като вградите грешки и корекции в аргумента за изпращане.
Флаговете за изпращане на нулеви знаци, за изпращане на прекъсвания, за принуждаване на бавен изход и за изход в човешки стил се изключват взаимно. Ще се използва само последната, посочена последно. Освен това не може да бъде посочен низ от аргументи с флагове за изпращане на нулеви знаци или прекъсвания.
Добра идея е да се предхожда първото изпращане на процес по очакване . Очаквайте, че ще изчака процесът да започне, докато изпращането не може. По-конкретно, ако първото изпращане завърши преди процесът да започне да се изпълнява, рискувате да пренебрегнете данните си. В ситуации, при които интерактивните програми не предлагат първоначален подкана, можете да предхождате изпращането със закъснение, както в:
# За да избегнете как хакерите да намерят намек за това как да се счупят, # тази система не подканя за външна парола. # Изчакайте 5 секунди за exec, за да завършите пускане telnet много. Secure.gov сън 5 изпрати парола \ rexp_send е псевдоним за изпращане. Ако използвате Expectk или друг вариант на Expect в средата Tk, изпращането е дефинирано от Tk за съвсем различна цел. exp_send се осигурява за съвместимост между среди. Подобни псевдоними са предоставени и за другите команди за изпращане на Expect.
send_error [-flags] низ
е като изпраща , с изключение на това, че продукцията се изпраща на stderr, а не на текущия процес .
send_log [-] низ
е като изпращане , с изключение на това, че низът се изпраща само в журналния файл (вж. log_file .) Аргументите се игнорират, ако няма отворен регистрационен файл.
send_tty [-flags] низ
е като изпращане , с изключение на това, че продукцията се изпраща на / dev / tty вместо текущия процес .
send_user [-flags] низ
е като изпращане , с изключение на това, че продукцията се изпраща на stdout, а не на текущия процес .
спи секунди
причинява скрипта за определен брой секунди. Секундите могат да бъдат десетично число. Прекъсванията (и Tk събитията, ако използвате Expectk) се обработват, докато Expect спи.
програма [args] [args]
създава нов процес, изпълняващ "програмни аргументи". Неговите стан, 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, in или batch), тогава tty_spawn_id не е дефиниран. Това може да бъде тествано като:
ако {{vars tty_spawn_id]} {# / dev / tty съществува} друго {# / dev / tty не съществува # вероятно в cron, batch или script}spawn връща идентификационния номер на процеса UNIX. Ако не се появи никакъв процес , 0 се връща. Променливата spawn_out (роб, име) е зададена на името на устройството pty slave.
По подразбиране, хвърлянето на хайвера отразява името на командата и аргументите. Флагът -noecho спира да прави това.
Флагът -console предизвиква пренасочването на конзолния изход към процеса на възпроизвеждане. Това не се поддържа на всички системи.
Вътрешно, хвърлянето на хайвера използва pty, инициализирано по същия начин като tty на потребителя. Това допълнително се инициализира, така че всички настройки да са "нормални" (според stty (1)). Ако променливата stty_init е дефинирана, тя се интерпретира в стила на stty аргументите като допълнителна конфигурация. Например, "set stty_init raw" ще предизвика терминалите на по-нататъшните хартиени процеси, които да започнат в суров режим. -nottycopy прескача инициализацията въз основа на tty на потребителя. -nottyinit прескача "нормалната" инициализация.
Обикновено хвърлянето на храсти изисква малко време за изпълнение. Ако забележите хайвер, който отнема значително време, вероятно се натъкват на ptys, които са заклещени. Редица тестове се провеждат на ptys, за да се избегнат заплитания с нарушени процеси. (Те отнемат 10 секунди на закръглено pty.) Изпълнението Expect с опцията -d ще покаже дали Expect среща много ptys в нечетни състояния. Ако не можете да убивате процесите, към които са прикачени тези ptys, единственото ви решение може да бъде рестартирането.
Ако програмата не може да бъде пусната успешно, защото exec (2) не успее (например когато програмата не съществува), следващото съобщение ще бъде върнато от следващата операция за взаимодействие или очаквайте, както ако програмата е стартирала и изведе съобщението за грешка като изход. Това поведение е естествена последица от прилагането на хайвер . Вътрешно, пукнатините за хвърляне на хайвера, след което процесът на заснемане няма начин да комуникира с оригиналния процес Expect , освен чрез комуникация чрез spawn_id.
Флагът " отворен" прави следващия аргумент да бъде интерпретиран като идентификатор на файла Tcl (т.е. върнат от отворен .) Идентификационният номер на хартия може да бъде използван, сякаш е процес на зареждане. (Идентификаторът на файла вече не трябва да се използва.) Това ви позволява да третирате сурови устройства, файлове и тръбопроводи като процеси на изчакване, без да използвате pty. 0 се връща, за да покаже, че няма свързан процес . Когато връзката със заредения процес е затворена, то също така е идентификаторът на файла Tcl. Флагът -лелеопен е подобен на -отварян, с изключение на това, че -отдалечът задейства идентификатора на файла да остане отворен дори и след като идолът за хартия е затворен.
Флагът -pty причинява отваряне на pty, но не се появява никакъв процес . 0 се връща, за да покаже, че няма свързан процес . Spawn_id е зададено както обикновено.
Променливата spawn_out (slave, fd) е настроена на идентификатор на файл, съответстващ на pty slave. Тя може да бъде затворена с помощта на "close-slave".
Знакът " -ignore" подава сигнал, който трябва да бъде пренебрегнат в процеса на зареждане. В противен случай сигналите получават по подразбиране поведение. Сигналите се наименуват като в командата на капака , с изключение на това, че всеки сигнал изисква отделен флаг.
ниско ниво
причинява следното отпечатване, преди да бъде изпълнено. (Командата за проследяване на Tcl проследява променливите.) Нивото показва колко далече в колоната за повиквания може да се проследи. Например, следващата команда работи " Очаквайте", докато проследявате първите 4 нива на повиквания, но никой от тях.
Флаго знанието -info предизвиква връщане на описание на най-новите неанализирани аргументи.
stty args
сменя терминални режими подобно на командата за външен stty.
По подразбиране се осъществява достъп до контролния терминал. Други терминали могат да бъдат достъпни чрез добавяне на "Заявки за статус връщат се в резултат на командата.Ако не се изисква статус и контролният терминал е достъпен, предишното състояние на необработените и ехо атрибути се връща във форма, която по-късно може да бъде използван от командата.
Например, аргументите сурови или изсъхнали поставят терминала в суров режим. Аргументите - рано или варени, поставят терминала в режим на готвене. Аргументите отразяват и - така че терминалът е в ехо и noecho режим съответно.
Следният пример илюстрира как да деактивирате временно ехото. Това може да се използва в иначе автоматични скриптове, за да се избегне вграждането на пароли в тях. (Вижте още дискусии по това по EXPECT HINTS по-долу.)
stty -echo send_user "Парола:" expect_user -re "(. *) \ n" задаване на парола $ expect_out (1, string) stty ехо системни аргументи
дава аргументи на sh (1) като вход, сякаш е въведен като команда от терминал. Очаквайте чака, докато черупката завърши. Състоянието на връщане от sh се обработва по същия начин, по който exec изпълнява статуса си на връщане.
За разлика от exec, който пренасочва stdin и stdout към скрипта, системата не извършва пренасочване (различно от това, посочено от самия низ). По този начин е възможно да се използват програми, които трябва да говорят директно с / dev / tty. По същата причина резултатите от системата не се записват в дневника.
timestamp [args]
връща времева марка. Без аргументи броят секунди след връщането на епохата.
Флагът " формат" въвежда низ, който се връща, но с замествания, направени съгласно правилата POSIX за strftime. Например% a е заменен със съкратено име на седмицата (т.е., събота). Другите са:
% a съкратено име на седмицата% Пълно име на седмицата% b съкратено име на месец% B пълно име на месец% c дата на време, както в: Wed Oct 6 11:45:56 1993% d ден на месеца (01-31% H час (00-23)% I час (01-12)% j ден (001-366)% m месец (01-12)% M минута (00-59)% p am или pm% S second (00-61) % u ден (1-7, понеделник е първият ден от седмицата)% U седмица (00-53, първата неделя е първият ден от седмицата)% V седмица (01-53, стил ISO 8601) 6)% W седмица (00-53, първият понеделник е първият ден от седмицата една)% x дата-време, както в: Wed 6 октомври 1993% X време като в: 23:59:59% y година (00-99) % Y година, както и в: 1993% Z часова зона (или нищо, ако не е определимо) %% знак за голи процентиДругите спецификации% не са дефинирани. Другите знаци ще бъдат преминали през недокосната. Поддържа се само локалът на C.
Знакът " -секунди" въвежда няколко секунди, тъй като епохата се използва като източник, от който да форматирате. В противен случай се използва текущото време.
Флагогътнието -gmt сигнализира извеждането на времевата марка за използване на часовата зона GMT . Без флаг се използва местната часова зона.
капан [[команда] сигнали]
причинява дадената команда да бъде изпълнена при бъдещо получаване на някой от дадените сигнали. Командата се изпълнява в глобален обхват. Ако липсва команда , сигналното действие се връща. Ако командата е низ SIG_IGN, сигналите се игнорират. Ако командата е низ SIG_DFL, сигналите са резултат от системата по подразбиране. Сигналите са или един сигнал, или списък от сигнали. Сигналите могат да бъдат посочени цифрово или символно по сигнал (3). Префиксът "SIG" може да бъде пропуснат.
Без аргументи (или аргумент -number), trap връща номера на сигнала на командата trap, която се изпълнява понастоящем.
Кодът на кода използва кода за връщане на командата вместо кода Tcl, който щеше да се върне, когато командата първоначално стартира.
Флагът -interp причинява командата да бъде оценена с помощта на устен преводач, действащ по време на започване на командата, а не когато е обявен капакът.
Флагът-име причинява командата на капака да върне името на сигнала на командата на капака, която се изпълнява понастоящем.
Знакът -макс кара командата на капака да върне най-големия номер на сигнала, който може да бъде зададен.
Например, командата "trap {send_user" Ouch! "} SIGINT" ще отпечата "Ouch!" всеки път, когато потребителят натисне ^ C.
По подразбиране SIGINT (което обикновено може да се генерира чрез натискане на клавиша ^ C) и SIGTERM причиняват изчакване Expect. Това се дължи на следващия капан, създаден по подразбиране, когато Expect започва.
излизане на капака {SIGINT SIGTERM}Ако използвате знака -D за стартиране на дебъгера, SIGINT е предефинирано, за да стартирате интерактивния дебъгер. Това се дължи на следния капан:
капак {exp_debug 1} SIGINTКапанът за отстраняване на грешки може да бъде променен чрез задаване на променливата на средата EXPECT_DEBUG_INIT на нова команда за превключване.
Можете, разбира се, да заобиколите и двете, само като добавите команди за прихващане към вашия скрипт. По-конкретно, ако имате свой собствен "изход SIGINT", това ще замени дефектоскоп. Това е полезно, ако искате да предотвратите навлизането на потребителите в дебъгера изобщо.
Ако искате да дефинирате свой собствен капан на SIGINT, но все пак да прихванете към дебъгера, когато той работи, използвайте:
ако {! [exp_debug]} {trap mystuff SIGINT}Като алтернатива можете да превключите към дебъгера, като използвате друг сигнал.
капакът няма да ви позволи да отмените действието за SIGALRM, тъй като това се използва вътрешно, за да очаквате . Командата за изключване задава SIGALRM на SIG_IGN (игнорира). Можете да активирате отново тази функция, докато я деактивирате по време на следващите команди.
Вижте сигнал (3) за повече информация.
чакай [арг]
забавя процеса, докато процесът на зареждане (или текущият процес, ако никой не е кръстен) приключва.
изчакване обикновено връща списък с четири числа. Първото цяло число е пика на процеса, който беше изчакан. Второто цяло число е съответният идентификатор на хартията. Третото цяло число е -1, ако възникне грешка в операционната система, или 0 в противен случай. Ако третото цяло число е 0, четвъртото цяло число е състоянието, върнато от процеса на зареждане. Ако третото цяло число е -1, четвъртото число е стойността на грешката, зададена от операционната система. Променена е и глобалната променлива ErrorCode.
Допълнителни елементи могат да се появят в края на връщащата стойност от изчакване . Незадължителният пети елемент идентифицира клас информация. Понастоящем единствената възможна стойност за този елемент е CHILDKILLED, в който случай следващите две стойности са името на сигнала в Стил и кратко текстово описание.
Знакът -i декларира процеса да изчака, съответстващ на името на spawn_id (НЕ е идентификационният номер на процеса ). Вътре в SIGCHLD манипулатор е възможно да се изчака всеки произхождащ от завода процес, като се използва идентификационният номер -1.
Знакът " знак" означава, че чакането се връща незабавно с индикация за успешно изчакване. Когато процесът изтече (по-късно), той автоматично ще изчезне, без да е необходимо изрично чакане.
Командата за изчакване също може да бъде използвана, за да изчакате задействания процес, като използвате аргументите "-i -1". За разлика от използването й с процеси на заразяване, тази команда може да бъде изпълнена по всяко време. Няма контрол върху кой процес се събират. Въпреки това, връщаната стойност може да бъде проверена за id на процеса .
БИБЛИОТЕКИ
Очаквайте автоматично да знаете за две вградени библиотеки за Expect scripts. Те се дефинират от директории, посочени в променливите exp_library и exp_exec_library. И двете са предназначени да съдържат полезност файлове, които могат да бъдат използвани от други скриптове.
exp_library съдържа файлове, независими от архитектурата. exp_exec_library съдържа файлове, зависими от архитектурата. В зависимост от системата си и двете директории може да са напълно празни. Съществуването на файла $ exp_exec_library / cat-buffers описва дали буферите ви / bin / cat по подразбиране.
Хубава-ПЕЧАТ
Налице е дефиниция за грешка за доста печат Очаквайте скриптове. Ако приемем, че дефиницията на vgrind, доставена с разпределението Expect, е правилно инсталирана, можете да я използвате като:
vgrind -lexpectpect файлПРИМЕРИ
Много хора не са ясни как да обединяват всичко, което описва страницата на човека . Препоръчвам ви да прочетете и изпробвате примерите в примерната директория на разпределението на Expect . Някои от тях са истински програми. Другите са само илюстративни за някои техники и, разбира се, двойката е просто бърз хак. Файлът INSTALL има бърз преглед на тези програми.
Очакват се и документи " Очаквайте" (вижте също "Виж също"). Докато някои статии използват синтаксис, съответстващ на по-ранните версии на Expect, придружаващите ги разсъждения са все още валидни и са по-подробни от тази страница.
уговорки
Разширенията може да се сблъскат с командите на Expect. Например, изпращането се определя от Tk за съвсем различна цел. Поради тази причина повечето от командите Expect също са на разположение като "exp_XXXX". Командите и променливите, започващи с "exp", "inter", "spawn" и "timeout" нямат псевдоними. Използвайте разширените команди, ако имате нужда от тази съвместимост между среди.
Очаквайте по-скоро либерален поглед върху обхвата. По-специално, променливите, прочетени от командите, специфични за програмата Expect , ще бъдат търсени първо от локалния обхват и ако не бъдат намерени в глобалния обхват. Например, това премахва необходимостта от поставяне на "глобално изчакване" във всяка процедура, която пишете, която използва очакванията . От друга страна, написаните променливи винаги са в местния обхват (освен ако не е издадена "глобална" команда). Най-честият проблем, който причинява това, е когато се създава хайвер в процедура. Извън процедурата, spawn_id вече не съществува, така че процесът на заразяване вече не е достъпен само заради обхвата. Добавете "global spawn_id" към такава процедура.
Ако не можете да активирате функцията за многократно натоварване (т.е. системата ви не поддържа избиране (BSD *. *), Анкета (SVR> 2), нито нещо еквивалентно), очаквайте само да контролирате отделен процес наведнъж. В този случай, не се опитвайте да зададете spawn_id , нито пък трябва да изпълнявате процеси чрез exec, докато се изпълнява процес на зареждане . Освен това няма да можете да очаквате от множество процеси (включително потребителя като едно) по едно и също време.
Параметрите на терминала могат да имат голям ефект върху скриптовете. Например, ако е написан сценарий, който да търси ехо, той ще се побърка, ако ехото е изключено. Поради тази причина, по подразбиране очаквайте параметрите на терминалите на терминала. За съжаление, това може да направи нещата неприятни за други програми. Като пример, корпусът на emacs иска да промени "обичайните" картографиране: новите линии се описват на нови линии вместо нови редове за връщане на каретата и ехото е забранено. Това позволява да се използва emacs, за да се редактира входната линия. За съжаление, очаквайте това не може да се досетите.
Можете да заявите, че Expect не пренебрегва настройката по подразбиране на параметрите на терминала, но трябва да бъдете много внимателни при писането на скриптове за такива среди. В случай на emacs, избягвайте в зависимост от неща като echoing и end-of-line mappings.
Командите, които приемат аргументи, подредени в един списък ( очакваните варианти и взаимодействат ) използват евристика, за да решат дали списъкът всъщност е един аргумент или много. Евривизмът може да се провали само в случаите, когато списъкът всъщност представлява един аргумент, който има множество вградени \ n с символи, които не са между тях. Това изглежда достатъчно невероятно, но аргументът "-образия" може да се използва, за да принуди един аргумент да се разглежда като един аргумент. Това би могло да се използва с машинно генериран код Expect. По подобен начин, бравата налага един аргумент, който да се разглежда като множество модели / действия.
ГРЕШКИ
Наистина беше примамливо да се посочи програмата "секс" (за "Smart EXec" или "Send-Expect"), но доброто усещане (или може би просто пуританизмът) надделя.
На някои системи, когато се появява черупка, тя се оплаква, че не е в състояние да има достъп до tty, но работи така или иначе. Това означава, че вашата система има механизъм за придобиване на контрола, който Expect не знае. Моля, разберете какво е и изпратете тази информация обратно на мен.
Ultrix 4.1 (най-малко най-новите версии тук) счита, че изтеченията от време над 1000000 са еквивалентни на 0.
Цифров UNIX 4.0A (и вероятно други версии) отказва да разпредели ptys, ако дефинирате SIGCHLD манипулатор. Вижте страницата за кандидатстване за повече информация.
IRIX 6.0 не обработва Pty разрешения правилно, така че ако Очаквайте опитите да заделите pty, използвано преди това от някой друг, той се проваля. Надстройване до IRIX 6.1.
Telnet (проверен само под SunOS 4.1.2) виси, ако TERM не е зададен. Това е проблем по cron, in и cgi скриптове, които не определят TERM. По този начин трябва да го зададете изрично - към какъв тип обикновено няма значение. Просто трябва да бъде настроен на нещо! По-долу вероятно е достатъчно в повечето случаи.
настроен env (TERM) vt100Съветът (проверен само при BSDI BSD / OS 3.1 i386) виси, ако SHELL и HOME не са зададени. Това е проблем при cron , in и cgi скриптове, които не дефинират тези променливи на средата. По този начин трябва да ги зададете изрично - към какъв тип обикновено няма отношение. Просто трябва да бъде настроен на нещо! По-долу вероятно е достатъчно в повечето случаи.
задайте env (SHELL) / bin / sh настройка env (HOME) / usr / local / binНякои реализации на ptys са проектирани така, че ядрото да отхвърля всяка непрочетена продукция след 10 до 15 секунди (действителното число зависи от внедряването), след като процесът е приключил файловия дескриптор. По този начин очаквайте програми като
Спящата дата сън 20 очакватще се провали. За да избегнете това, извикайте не-интерактивни програми с exec, а не с хайвер . Макар че такива ситуации са възможни, на практика никога не съм срещал ситуация, при която крайното продуциране на истинска интерактивна програма ще бъде загубено поради това поведение.
От друга страна, Cray UNICOS ptys изхвърля всяка непрочетена продукция веднага след като процесът е затворил файловия дескриптор. Съобщих за това на Крей и те работят върху ремонт.
Понякога се изисква забавяне между подкана и отговора, като например когато интерфейс tty променя настройките на UART или съответстващите скорости на преноса чрез търсене на битове за старт / стоп. Обикновено всичко това е изискване е да спиш за секунда или две. По-надеждна техника е да опитате отново, докато хардуерът е готов да приеме вход. Следният пример използва двете стратегии:
изпраща "скорост 9600 \ r"; сън 1 очакват {timeout {изпращане "\ r"; exp_continue} $ prompt}капакът код няма да работи с команда, която седи в цикъл на събитието на Tcl, като например сън. Проблемът е, че в цикъла за събития Tcl изхвърля кодовете за връщане от манипулатори на събития, които са съвместими с Async. Заобиколно решение е да зададете флаг в кода на капана. След това проверете знамето веднага след командата (т.е. заспиване).
Командата expect_background пренебрегва аргументите за време и няма понятие за timeouts като цяло.
ОЧАКВАЙТЕ ОЧАКВАНЕ & # 34;
Има няколко неща за Очаквайте, че може да не са интуитивни. Тази секция се опитва да разгледа някои от тези неща с няколко предложения.
Обикновен проблем при очакване е как да разпознаете подсказките на shell. Тъй като те са персонализирани по различен начин от различни хора и различни черупки, портативно автоматизиране на rlogin може да бъде трудно, без да знаете кога да поискате. Разумна конвенция е потребителят да съхранява регулярен израз, описващ свой ред (по-специално края му) в променливата на средата EXPECT_PROMPT. Може да се използва код като следния. Ако EXPECT_PROMPT не съществува, кодът все още има добри шансове да функционира правилно.
(% ## \\ $) $ "; # по подразбиране подкана за затваряне {set prompt $ env (EXPECT_PROMPT)} expect -re $ promptАз ви насърчавам да напишете очаквате модели, които включват края на всичко, което очаквате да видите. Това избягва възможността да се отговори на въпрос, преди да видите цялото нещо. Освен това, въпреки че може да сте в състояние да отговорите на въпроси, преди да ги видите изцяло, ако отговорите по-рано, отговорът ви може да се появи отново в средата на въпроса. С други думи, резултатът от диалога ще бъде правилен, но изглежда бъркат.
Повечето подсказвания съдържат знак за интервал в края. Например, подканата от ftp е 'f', 't', 'p', '>' и. За да съответствате на тази подканя, трябва да отчитате всеки от тези знаци. Често срещана е грешката да не включвате празното място. Поставете празното място изрично.
Ако използвате образец от формуляра X *, * ще съответства на всички получени резултати от края на X до последното получено нещо. Това звучи интуитивно, но може да бъде малко объркващо, защото фразата "последното нещо, което сте получили" може да варира в зависимост от скоростта на компютъра и обработката на I / O както от ядрото, така и от драйвера на устройството.
По-специално, хората са склонни да видят продукцията на програмата, пристигаща в огромни парчета (атомно), когато в действителност повечето програми продуцират продукция по един ред наведнъж. Ако се приеме, че това е така, * в модела на предишния абзац може да съвпада само с края на текущия ред, въпреки че изглежда, че има повече, защото по време на мача, който е бил цялата получена продукция.
Очаквайте, че няма начин да знаете, че ще дойде по-нататъшна продукция, освен ако моделът ви не отговаря специално на него.
Дори в зависимост от линейно ориентираното буфериране не е разумно. Не само, че програмите рядко правят обещания за типа на буферирането, които правят, но системното храносмилане може да наруши изходните линии, така че линиите да се разпаднат на привидно случайни места. По този начин, ако можете да изразявате последните няколко символа на подкана, когато пишете модели, е разумно да направите това.
Ако чакате модел в последния изход на програма и програмата излъчва нещо друго, няма да можете да го откриете с ключовата дума за изчакване . Причината е, че очакваме , че няма да изтече времето - вместо това ще получи указание eof . Използвайте го вместо това. Още по-добре, използвайте и двете. По този начин, ако тази линия някога се движи наоколо, няма да е необходимо да редактирате самата линия.
Новите линии обикновено се преобразуват в връщане на каретата, последователности, когато се извеждат от терминалния драйвер. По този начин, ако искате модел, който изрично да съвпада с двата реда, от, да речем, printf ("foo \ nbar"), трябва да използвате шаблона "foo \ r \ nbar".
Подобен превод възниква при четене от потребителя, чрез expect_user . В този случай, когато натиснете бутона за връщане, той ще бъде преведен на нов ред. Ако Expect го предава на програма, която поставя своя терминал в суров режим (като telnet), ще има проблем, тъй като програмата очаква истинска възвращаемост. (Някои програми всъщност прощават в това, че автоматично ще превеждат нови линии до връщания, но повечето не го правят.) За съжаление, няма начин да разберете, че дадена програма поставя своя терминал в суров режим.
Вместо да заменяте ръчно нови редове с връщане, решението е да използвате командата "stty raw", която ще спре прехода. Имайте предвид обаче, че това означава, че вече няма да получите функциите за редактиране на линия.
interact implicit установява терминала ви в суров режим, така че този проблем няма да възникне след това.
Често е полезно да съхранявате пароли (или друга частна информация) в скрипта Expect . Това не се препоръчва, тъй като всичко, което се съхранява на компютър, е достъпно за всеки. По този начин интерактивно подканянето на пароли от сценария е по-умна идея, отколкото да ги вградите буквално. Независимо от това, понякога такова вграждане е единствената възможност.
За съжаление файловата система на UNIX няма директен начин за създаване на скриптове, които са изпълними, но не могат да се четат. Системите, които поддържат скриптовете на setgid shell, могат индиректно да симулират това, както следва:
Създайте скрипта Expect (който съдържа тайните данни), както обикновено. Направете разрешенията му 750 (-rwxr-x ---) и притежавани от доверена група, т.е. група, която има право да я прочете. Ако е необходимо, създайте нова група за тази цел. След това създайте скрипт / bin / sh с разрешения 2751 (-rwxr-s - x), притежавани от същата група, както преди.
Резултатът е скрипт, който може да бъде изпълнен (и четен) от всеки. Когато се извиква, той изпълнява скрипта Expect .
"ВИЖ СЪЩО"
Tcl (3), libexpect (3)
"Exploring Expect: Tcl базиран набор от инструменти за автоматизиране на интерактивни програми" от Don Libes, стр. 602, ISBN 1-56592-090-2, O'Reilly and Associates, 1995.
"очакват: оздравяване на тези неконтролируеми прилики на интерактивност" от Дон Либес, Сборник на лятото 1990 USENIX конференция, Анахайм, Калифорния, 11-15 юни 1990 г.
.I "Използване на очакване за автоматизиране на задачите за администриране на системата" от Дон Либес, Сборник на Конференцията за администрацията на големите инсталационни системи USENIX 1990, Колорадо Спрингс, Колорадо, 17-19 октомври 1990 г.
. "Tcl: Вграден команден език" от Джон Оустърхоут, Сборници на зимата 1990 USENIX конференция, Вашингтон, Дъблин, 22-26 януари 1990 г. "Очаквам: Скриптове за контролиране на интерактивни програми" от Дон Либес, , Vol. 4, № 2, Калифорнийски пресконференции, ноември 1991 г. I "Ретроспективно тестване и провеждане на интерактивни програми за тестване на съответствие" от Дон Либес, Сборник на конференцията USENIX от лятото на 1992 г., стр. 135-144, Сан Антонио, 12-15 юни 1992 г. I "Kibitz - Свързване на множество интерактивни програми заедно", от Дон Либес, Софтуер - Практика и опит, John Wiley & Sons, West Sussex, England, vol.
23, No. 5, May, 1993 .. I "Debugger for Tcl Applications", by Don Libes, Proceedings of the 1993 Tcl / Tk Workshop, Berkeley, CA, June 10-11, 1993.
АВТОР
Дон Либес, Национален институт за стандарти и технологии
БЛАГОДАРНОСТИ
Благодарение на Джон Ousterhout за Tcl и Скот Paisley за вдъхновение. Благодарение на Роб Савой за кода за автоконфигурация на Expect.
Файлът ИСТОРИЯ документира голяма част от еволюцията на очакванията . Това прави интересно четене и може да ви даде допълнителна представа за този софтуер. Благодарение на споменатите в него хора, които ми изпратиха корекции на бъгове и дадох друга помощ.
Проектирането и внедряването на Expect е било платено отчасти от американското правителство и следователно е обществено достояние. Въпреки това авторът и NIST биха искали кредит, ако тази програма и документация или части от тях се използват.