Expect – это программа, которая общается с другими интерактивными программами по сценарию. Следуя сценарию, Expect знает, чего можно ожидать от программы и каков должен быть правильный ответ. Интерпретированный язык предоставляет ветвящиеся и высокоуровневые структуры управления для управления диалогом. Кроме того, пользователь может взять на себя управление и взаимодействовать напрямую при желании, а затем вернуть управление сценарию.
Expectk представляет собой смесь Expect и Tk. Он ведет себя так же, как Expect и желание Tk. Expect также может быть использован непосредственно в C или C ++ без Tcl.
Название «Expect» происходит от идеи последовательностей отправки/ожидания, популяризируемых uucp, kermit и другими программами управления модемами. Однако, в отличие от uucp, Expect обобщен, поэтому его можно запускать как команду пользовательского уровня с учетом любых программ и задач. Expect может разговаривать с несколькими программами одновременно.
Что ожидать можно сделать
Например, вот некоторые вещи, которые может выполнять команда ожидающих:
- Заставьте ваш компьютер перезвонить вам, чтобы вы могли войти в систему, не оплачивая звонок.
- Запустите игру и, если оптимальная конфигурация не появится, перезапустите ее снова и снова), пока она не появится, а затем передайте управление вам.
- Запустите fsck и, отвечая на его вопросы, ответьте «да» или «нет» или верните контроль, основываясь на заранее определенных критериях.
- Подключитесь к другой сети и автоматически получите свою почту, чтобы она выглядела так, как если бы она была первоначально отправлена в вашу локальную систему.
- Перенос переменных среды, текущего каталога или любой другой информации через rlogin, telnet, tip, su или chgrp
Существует множество причин, по которым оболочка не может выполнять эти задачи. Все возможно с Expect.
В общем, Expect полезен для запуска любой программы, которая требует взаимодействия между программой и пользователем. Все, что необходимо, – это то, что взаимодействие можно охарактеризовать программно. Expect также может вернуть контроль пользователю, не останавливая контролируемую программу. Точно так же пользователь может вернуть управление скрипту в любое время.
использование
Ожидайте чтения cmdfile для получения списка команд для выполнения. Expect может быть вызван неявно в системах, которые поддерживают #! обозначение, помечая скрипт как исполняемый и делая первую строку в скрипте:
#!/usr/local/bin/wait -f
Конечно, путь должен точно описывать, где ожидает Expect./usr/local/bin это просто пример.
Флаг -c предшествует команде, которая будет выполнена перед любой в сценарии. Команда должна быть заключена в кавычки, чтобы предотвратить ее разрушение оболочкой. Эта опция может использоваться несколько раз. Несколько команд могут быть выполнены с одним -c, разделяя их точкой с запятой. Команды выполняются в порядке их появления. При использовании Expectk эта опция указывается как -команда.
Флаг -d включает некоторые диагностические данные, которые в первую очередь сообщают о внутренней активности команд, таких как ожидают и взаимодействуют. Этот флаг имеет тот же эффект, что и «exp_internal 1» в начале сценария Expect, плюс печатается версия Expect.
Флаг -D включает интерактивный отладчик. Целочисленное значение должно следовать. Отладчик получит управление перед следующей процедурой Tcl, если значение не равно нулю, или если нажата ^ C, или достигнута точка останова, или в сценарии появляется другая соответствующая команда отладчика. При использовании Expectk этот параметр указывается как – Debug.
Флаг -f предшествует файлу, из которого читаются команды. Сам флаг является необязательным, поскольку он полезен только при использовании #! нотации, так что другие аргументы могут быть предоставлены в командной строке. При использовании Expectk эта опция указывается как -file.
По умолчанию командный файл считывается в память и выполняется полностью. Иногда желательно читать файлы по одной строке за раз. Чтобы принудительно обрабатывать произвольные файлы, используйте флаг -b. При использовании Expectk эта опция указывается как -buffer.
Если в качестве имени файла указана строка «-», вместо него читается стандартный ввод. Используйте «./-» для чтения из файла с именем «-».
Флаг -i заставляет Expect интерактивно запрашивать команды вместо чтения их из файла. Подсказка прекращается с помощью команды выхода или после EOF. Флаг -i предполагается, если не используется ни командный файл, ни -c. При использовании Expectk эта опция указывается как -interactive.
– может использоваться для определения конца параметров. Это полезно, если вы хотите передать опциональный аргумент в ваш скрипт без интерпретации Expect. Это можно с пользой поместить в #! строка, чтобы предотвратить любую флагоподобную интерпретацию Expect. Например, следующее оставит исходные аргументы, включая имя скрипта, в переменной argv .
#!/ usr/local/bin/Ожидается -
Обратите внимание, что обычные соглашения getopt (3) и execve (2) должны соблюдаться при добавлении аргументов в #! линия.
Файл $ exp_library/wait.rc автоматически создается при его наличии, если не используется флаг -N. (При использовании Expectk этот параметр указывается как -NORC.) Сразу после этого файл ~/.expect.rc поступает автоматически, если не используется флаг -n. Если переменная окружения DOTDIR определена, она обрабатывается как каталог и оттуда читается .expect.rc. При использовании Expectk эта опция указывается как -norc. Этот источник происходит только после выполнения любых флагов -c.
-v приводит к тому, что Expect печатает номер своей версии и завершает работу. Соответствующий флаг в Expectk, который использует длинные имена флагов, это -version.
Необязательные аргументы составляются в виде списка и хранятся в переменной с именем argv и. argc инициализируется до длины argv.
Argv0 определяется как имя сценария или двоичный файл, если сценарий не используется. Например, следующий текст выводит имя скрипта и первые три аргумента:
send_user "$ argv0 [lrange $ argv 0 2] \ n"
команды
Expect использует Tool Command Language. Tcl обеспечивает поток управления (если, для, разрыв), оценку выражения и ряд других функций, таких как рекурсия и определение процедуры. Команды, используемые здесь, но не определенные (set, if, exec), являются командами Tcl. Expect поддерживает дополнительные команды. Если не указано иное, команды возвращают пустую строку.
Команды перечислены в алфавитном порядке, чтобы их можно было быстро найти. Тем не менее, новым пользователям может быть легче начать с чтения описаний порождения, отправки, ожидания и взаимодействия в указанном порядке.
закрыть [-slave] [-onexec 0 | 1] [-i spawn_id]
закрывает соединение с текущим процессом. Большинство интерактивных программ обнаруживают EOF на своем стандартном входе и выходят; таким образом, close обычно достаточно, чтобы убить процесс. Флаг -i объявляет процесс закрытия в соответствии с именованным spawn_id.
И ожидают, и взаимодействуют, обнаружат, когда текущий процесс завершает работу, и неявно закрывают его, но если вы убьете процесс, скажем, «exec kill $ pid», вам нужно явно вызвать close .
Флаг -onexec определяет, закрыт ли идентификатор появления в каких-либо новых порожденных процессах или процесс перекрывается. Чтобы оставить идентификатор спавна открытым, используйте значение 0. Ненулевое целочисленное значение приводит к закрытию спавна в любых новых процессах.
Флаг -slave закрывает подчиненное устройство, связанное с идентификатором появления. Когда соединение закрыто, ведомое устройство также автоматически закрывается, если оно все еще открыто.
Независимо от того, закрыто ли соединение неявно или явно, вы должны вызвать wait, чтобы очистить соответствующий слот процесса ядра. Команда close не вызывает wait, поскольку нет гарантии, что закрытие соединения с процессом приведет к его выходу.
debug [[-now] 0 | 1]
управляет отладчиком Tcl, позволяя вам проходить через операторы и устанавливать точки останова.
Без аргументов возвращается 1, если отладчик не запущен, в противном случае возвращается 0.
С 1 аргументом отладчик запускается. С аргументом 0 отладчик останавливается. Если аргументу 1 предшествует флаг -now, отладчик запускается немедленно. В противном случае отладчик запускается со следующей инструкцией Tcl.
Команда отладки не меняет никаких ловушек. Сравните это с запуском Expect с флагом -D.
Команда отсоединения отключает разветвленный процесс от терминала. Он продолжает работать в фоновом режиме. Процесс имеет свою собственную группу процессов. Стандартный ввод/вывод перенаправляется в/dev/null.
Следующий фрагмент использует отключение для продолжения работы сценария в фоновом режиме.
if {[fork]! = 0} выйти
отключить
. , .
Следующий скрипт читает пароль и затем запускает программу каждый час, которая требует пароль каждый раз, когда он запускается. Сценарий предоставляет пароль, поэтому вам нужно будет ввести его только один раз.
send_user "пароль? \"
Expect_user -re "(. *) \ n"
для {} 1 {} {
if {[fork]! = 0} {sleep 3600; продолжить}
отключить
spawn priv_prog
ожидать пароль:
отправить "$ Ожидаем (1, строка) \ r"
. , .
выход
}
Преимущество использования отключения по сравнению с функцией асинхронного процесса оболочки (&) заключается в том, что Expect может сохранять параметры терминала перед отключением, а затем применять их к новым ptys. С & Expect не имеет возможности прочитать параметры терминала, так как терминал уже отключен к тому времени, когда Expect получает управление.
exit [-opts] [status]
Причины Ожидать, чтобы выйти или иным образом подготовиться к этому.
Флаг -onexit приводит к использованию следующего аргумента в качестве обработчика выхода. Без аргумента текущий обработчик выхода возвращается.
Флаг -noexit заставляет Expect подготовиться к выходу, но не может фактически вернуть управление операционной системе. Определяемый пользователем обработчик выхода запускается так же, как и собственные внутренние обработчики Expect. Дальнейшие команды Expect не должны выполняться. Это полезно, если вы используете Expect с другими расширениями Tcl. Текущий интерпретатор (и главное окно, если оно находится в среде Tk) остается таким образом, что другие расширения Tcl могут очищаться. Если Expect exit вызывается снова (однако это может произойти), обработчики не запускаются повторно.
При выходе все соединения с порожденными процессами закрываются. Закрытие будет обнаружено как EOF порожденными процессами. exit не выполняет никаких других действий, кроме обычной процедуры _exit (2). Таким образом, порожденные процессы, которые не проверяют EOF, могут продолжать работать. (Различные условия важны для определения, например, сигналов, которые будут отправлены порожденные процессы, но они зависят от системы, как правило, документированы в exit (3).) Порожденные процессы, которые продолжают выполняться, будут наследоваться init.
status (или 0, если не указан) возвращается в качестве состояния выхода Expect . выход выполняется неявно, если достигнут конец сценария.
exp_continue [-continue_timer]
Команда exp_continue позволяет самому ожидать продолжать выполнение, а не возвращаться, как обычно. По умолчанию exp_continue сбрасывает таймер тайм-аута. Флаг -continue_timer предотвращает перезапуск таймера. (См. ожидание для получения дополнительной информации.)
exp_internal [-f file] value
заставляет дальнейшие команды отправлять диагностическую информацию внутри Expect в stderr, если значение не равно нулю. Этот вывод отключается, если value равно 0. Диагностическая информация включает в себя каждый полученный символ и каждую попытку, сделанную для сопоставления текущего вывода с шаблонами.
Если указан необязательный файл , все обычные и отладочные выходные данные записываются в этот файл (независимо от значения value ). Любой предыдущий диагностический выходной файл закрыт.
Флаг -info заставляет exp_internal возвращать описание самых последних приведенных неинформационных аргументов.
exp_open [аргументы] [-i spawn_id]
возвращает идентификатор файла Tcl, который соответствует исходному идентификатору spawn. Затем идентификатор файла можно использовать так, как если бы он был открыт командой Tcl open . (Идентификатор spawn больше не должен использоваться. wait не должен выполняться.
Флаг -leaveopen оставляет идентификатор spawn открытым для доступа через команды Expect. wait должно быть выполнено для идентификатора spawn.
exp_pid [-i spawn_id]
возвращает идентификатор процесса, соответствующий текущему процессу. Если используется флаг -i , возвращаемый pid соответствует идентификатору данного идентификатора spawn.
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 . Эта версия может быть закодирована в вашем скрипте. Если вы действительно знаете, что не используете функции последних версий, вы можете указать более раннюю версию.
Версии состоят из трех чисел, разделенных точками. Во-первых, это основной номер. Сценарии, написанные для версий Expect с другим основным номером, почти наверняка не будут работать. exp_version возвращает ошибку, если основные числа не совпадают.
Второе – младший номер. Сценарии, написанные для версии с большим младшим номером, чем текущая версия, могут зависеть от какой-либо новой функции и могут не работать. exp_version возвращает ошибку, если основные номера совпадают, но младший номер сценария больше, чем у Expect .
Третье – число, которое не играет никакой роли в сравнении версий. Однако он увеличивается, когда распространение программного обеспечения Expect изменяется каким-либо образом, например, путем дополнительной документации или оптимизации. Он сбрасывается в 0 при каждой новой минорной версии.
С флагом -exit Expect выдает ошибку и завершает работу, если версия устарела.
ожидайте [[-opts] pat1 body1] … [-opts] patn [bodyn]
ожидает, пока один из шаблонов не совпадет с выводом порожденного процесса, пройдет указанный период времени или не будет обнаружен конец файла. Если окончательное тело пусто, оно может быть опущено.
Шаблоны из самой последней команды hope_before неявно используются перед любыми другими шаблонами. Шаблоны из самой последней команды hope_after неявно используются после любых других шаблонов.
Если для аргументов всего оператора ожидаем требуется более одной строки, все аргументы могут быть «заключены» в одну, чтобы избежать завершения каждой строки обратной косой чертой. В этом одном случае обычные замены Tcl будут происходить, несмотря на скобки.
Если шаблон является ключевым словом eof , соответствующее тело выполняется в конце файла. Если шаблон является ключевым словом время ожидания , соответствующее тело выполняется по истечении времени ожидания. Если ключевое слово timeout не используется, по истечении времени ожидания выполняется неявное нулевое действие. Период ожидания по умолчанию составляет 10 секунд, но его можно установить, например, 30, командой «установить время ожидания 30». Бесконечное время ожидания может быть обозначено значением -1. Если шаблон является ключевым словом default , соответствующее тело выполняется по истечении времени ожидания или окончания файла.
Если шаблон соответствует, то выполняется соответствующее тело. ожидаемо возвращает результат тела (или пустую строку, если не найдено ни одного шаблона). В случае совпадения нескольких шаблонов один, который появляется первым, используется для выбора тела.
Каждый раз, когда поступает новый вывод, он сравнивается с каждым шаблоном в порядке их перечисления. Таким образом, вы можете проверить отсутствие совпадения, сделав последний шаблон таким, который гарантированно появится, например, приглашение. В ситуациях, когда нет приглашения, вы должны использовать тайм-аут (так же, как если бы вы взаимодействовали вручную).
Шаблоны указываются тремя способами. По умолчанию шаблоны указываются с помощью команды Соответствие строки в Tcl. (Такие шаблоны также похожи на регулярные выражения C-shell, обычно называемые шаблонами «glob»). Флаг -gl может использоваться для защиты шаблонов, которые в противном случае могли бы соответствовать флаги ожидают от этого. Любой шаблон, начинающийся с “-“, должен быть защищен таким образом. (Все строки, начинающиеся с «-», зарезервированы для будущих опций.)
Например, следующий фрагмент ищет успешный вход в систему. (Обратите внимание, что abort считается процедурой, определенной в другом месте скрипта.)
ожидайте {
занято {ставит занято \ n; exp_continue}
не удалось прервать
«неверный пароль» прервать
тайм-аут прервать
подключено
}
Кавычки необходимы для четвертого шаблона, поскольку он содержит пробел, который в противном случае отделил бы шаблон от действия. Шаблоны с одинаковым действием (например, 3-е и 4-е) требуют повторного перечисления действий. Этого можно избежать, используя шаблоны в стиле регулярных выражений (см. Ниже). Более подробную информацию о формировании шаблонов в стиле glob можно найти в руководстве по Tcl.
Шаблоны в стиле регулярных выражений следуют синтаксису, определенному командой Tcl regexp (сокращение от «регулярное выражение»). Шаблоны регулярных выражений вводятся с флагом -re . Предыдущий пример можно переписать с помощью регулярного выражения:
ожидайте {
занято {ставит занято \ n; exp_continue}
-re «сбой | неверный пароль» прервать
тайм-аут прервать
подключено
}
Оба типа паттернов являются «незанятыми». Это означает, что шаблоны не должны совпадать со всей строкой, но могут начинать и заканчивать сопоставление в любом месте строки (при условии, что все остальное совпадает). Используйте ^, чтобы соответствовать началу строки, и $, чтобы соответствовать концу. Обратите внимание, что если вы не дождетесь конца строки, ваши ответы могут легко оказаться в середине строки, поскольку они отражаются в порожденном процессе. Несмотря на то, что результаты все еще дают правильные результаты, результат может выглядеть неестественным. Таким образом, использование $ рекомендуется, если вы можете точно описать символы в конце строки.
Обратите внимание, что во многих редакторах ^ и $ соответствуют началу и концу строк соответственно. Тем не менее, так как ожидание не ориентировано на строки, эти символы соответствуют началу и концу данных (в отличие от строк), которые в настоящее время находятся в буфере ожидаемого соответствия. (Также см. Примечание ниже о «расстройстве желудка».)
Флаг -ex позволяет сопоставить шаблон как «точную» строку. Интерпретация *, ^ и т. Д. Не производится (хотя обычные соглашения Tcl все еще должны соблюдаться). Точные шаблоны всегда остаются без внимания.
Флаг -nocase приводит к тому, что символы вывода в верхнем регистре сравниваются так, как если бы они были символами нижнего регистра. На шаблон это не влияет.
При чтении выходных данных более 2000 байтов могут заставить «забытые» ранние байты. Это можно изменить с помощью функции match_max . (Обратите внимание, что чрезмерно большие значения могут замедлить сопоставление шаблонов.) Если patlist равен full_buffer , соответствующее тело будет выполнено, если были match_max байты получил, и никакие другие образцы не совпали. Независимо от того, используется ключевое слово full_buffer или нет, забытые символы записываются в функцию ожидаемого_отвода (буфер).
Если patlist является ключевым словом null , и допустимы нулевые значения (с помощью команды remove_nulls ), то выполняется соответствующее тело, если один ASCII 0 равен соответствует. Невозможно сопоставить 0 байтов с помощью шаблонов glob или regexp.
После сопоставления с шаблоном (или eof или full_buffer) все совпадающие и ранее несопоставленные выходные данные сохраняются в переменной hope_out (buffer) . До 9 совпадений подстрок регулярного выражения сохраняются в переменных от hope_out (1, строка) до Ожидаемый_out (9, строка) . Если перед шаблоном используется флаг -indices , начальные и конечные индексы (в форме, подходящей для lrange ) из 10 строк сохраняются в переменных wait_out (X, start) и hope_out (X, end) , где X – это цифра, соответствует позиции подстроки в буфере. 0 относится к строкам, которые соответствуют всему шаблону и генерируются для шаблонов глобуса, а также шаблонов регулярных выражений. Например, если процесс выдал вывод «abcdefgh \ n», результат:
ожидайте "cd"
это как если бы следующие операторы выполнили:
установить функцию wait_out (0, строка) cd
установить функцию ожидающего_бука (буфер) abcd
и “efgh \ n” остается в буфере вывода. Если процесс выдает вывод «abbbcabkkkka \ n», результат:
ожидают -indices -re "b (b *). * (k +)"
это как если бы следующие операторы выполнили:
установить функцию ожидаемого выхода (0, начало) 1
установить ожидаемую величину (0, конец) 10
установить ожидаемый результат (0, строка) bbbcabkkkk
установить ожидаемый результат (1, начало) 2
установить функцию wait_out (1, конец) 3
установить ожидаемую величину (1, строка) bb
установить ожидаемую величину (2, начало) 10
установить ожидаемую величину (2, конец) 10
установить wait_out (2, строка) k
установить wait_out (буфер) abbbcabkkkk
и “a \ n” остается в буфере вывода. Шаблон “*” (и -re “. *”) Очистит выходной буфер, не считывая больше выходных данных процесса.
Обычно согласованный вывод отбрасывается из внутренних буферов Expect. Это может быть предотвращено путем добавления префикса к шаблону с флагом -notransfer . Этот флаг особенно полезен при экспериментировании (и может быть сокращен до «-не» для удобства при экспериментировании).
Идентификатор порождения, связанный с совпадающим выводом (или eof или full_buffer), хранится в hope_out (spawn_id) .
Флаг -timeout заставляет текущую команду ожидаемого использовать следующее значение в качестве тайм-аута вместо использования значения переменной тайм-аута.
По умолчанию шаблоны сопоставляются с выходными данными текущего процесса, однако флаг -i объявляет выходные данные из именованного списка spawn_id сопоставленными с любыми следующими шаблонами (до следующего -i ). Список spawn_id должен быть либо списком spawn_ids, разделенным пробелами, либо переменной, ссылающейся на такой список spawn_ids.
Например, в следующем примере ожидается «подключено» из текущего процесса или «занято», «не удалось» или «неверный пароль» из spawn_id, названного $ proc2.
ожидают {
-i $ proc2 busy {ставит занят \ n; exp_continue}
-re «сбой | неверный пароль» прервать
тайм-аут прервать
подключено
}
Значение глобальной переменной any_spawn_id можно использовать для сопоставления шаблонов с любыми spawn_id, имена которых соответствуют всем другим флагам -i в текущем ожидаемом . команда. Spawn_id из флага -i без ассоциированного шаблона (т. Е. Сразу после другого -i ) становится доступным для любых других шаблонов с таким же ожиданием < Команда/strong>, связанная с any_spawn_id.
Флаг -i также может называть глобальную переменную, и в этом случае переменная считывается для списка идентификаторов появления. Переменная перечитывается всякий раз, когда она изменяется. Это позволяет изменить источник ввода-вывода во время выполнения команды. Идентификаторы появления, предоставляемые таким способом, называются «косвенными» идентификаторами появления.
Такие действия, как break и continue , заставляют структуры управления (т. Е. for , proc ) вести себя обычным образом. ,Команда exp_continue позволяет самому ожидать продолжать выполнение, а не возвращаться, как обычно.
Это полезно для избежания явных циклов или повторных ожиданий. Следующий пример является частью фрагмента для автоматизации rlogin. exp_continue избавляет от необходимости писать второй оператор ожидаем (чтобы снова искать подсказку), если rlogin запрашивает пароль.
ожидаемый {
пароль: {
stty -echo
send_user "пароль (для $ user) на $ host:"
hope_user -re "(. *) \ n "
send_user" \ n "
отправить" $ hope_out (1, string) \ r "
stty echo
exp_continue
} неверный {
send_user" неверный пароль или учетная запись \ n "
выход
} тайм-аут {
send_user" истекло время ожидания соединения с $ host \ n "
exit
} eof {
send_user \
"Не удалось установить соединение с хостом: $ hope_out (buffer)"
exit
} -re $ prompt
}
Например, следующий фрагмент может помочь пользователю управлять взаимодействием, которое уже полностью автоматизировано. В этом случае терминал переводится в сырой режим. Если пользователь нажимает «+», переменная увеличивается. Если нажать «p», в процесс будет отправлено несколько возвратов, возможно, чтобы каким-то образом ткнуть его, а «i» позволяет пользователю взаимодействовать с процессом, эффективно скрывая контроль над сценарием. В каждом случае exp_continue позволяет текущему ожидать продолжить сопоставление с образцом после выполнения текущего действия.
stty raw -echo
Outlook_after {
-i $ user_spawn_id
"p" {send "\ r \ r \ r"; exp_continue}
"+" {incr foo; exp_continue}
"i" {взаимодействовать; exp_continue}
выход "quit"
}
По умолчанию exp_continue сбрасывает таймер тайм-аута. Таймер не перезапускается, если exp_continue вызывается с флагом -continue_timer .
hope_after [Ожидаемые_арги]
работает идентично hope_before , за исключением того, что если паттерны как из hope , так и hope_after могут совпадать, то используется шаблон hope , Для получения дополнительной информации см. Команду hope_before .
hope_background [Ожидаемые_арги]
принимает те же аргументы, что и ожидают , однако возвращает сразу. Шаблоны проверяются всякий раз, когда поступает новый ввод. Шаблон timeout и default не имеет смысла для hope_background и молча отбрасывается. В противном случае команда hope_background использует шаблоны hope_before и hope_after так же, как это делает hope .
Когда оцениваются действия hope_background , фоновая обработка для того же идентификатора появления блокируется. Фоновая обработка разблокируется после завершения действия. В то время как фоновая обработка заблокирована, можно сделать (на переднем плане) ожидание с тем же идентификатором появления.
Невозможно выполнить ожидание , пока ожидаемое поле разблокировано. Ожидаемый_бэкграунд для определенного идентификатора спавна удаляется объявлением нового ожидаемого фонового поля с тем же идентификатором спавна. Объявление Ожидаемый_бэк без шаблона удаляет данный идентификатор появления из способности сопоставлять шаблоны на заднем плане.
hope_before [Ожидаемые_арги]
принимает те же аргументы, что и ожидаемый, , однако возвращает немедленно. Пары «паттерн-действие» из самых последних hope_before с тем же идентификатором spawn неявно добавляются к любым последующим командам wait . Если шаблон соответствует, он обрабатывается так, как если бы он был указан в самой команде ожидаем , а соответствующее тело выполняется в контексте команды ожидаем . Если паттерны как из hope_before , так и из ожидаемого могут совпадать, используется шаблон hope_before .
Если шаблон не указан, идентификатор spawn не проверяется на наличие шаблонов.
Если не переопределено флагом -i , шаблоны hope_before сопоставляются с идентификатором spawn, определенным во время выполнения команды hope_before (а не когда образец соответствует).
Флаг -info заставляет Ожидаемое_предшество возвращать текущие спецификации того, с какими шаблонами он будет соответствовать. По умолчанию он сообщает о текущем spawn id. Необязательная спецификация spawn id может быть предоставлена для информации об этом spawn id. Например
wait_before -info -i $ proc
Можно указать не более одной спецификации идентификатора вызова.Флаг -indirect подавляет идентификаторы прямого появления, которые приходят только из косвенных спецификаций.
Вместо спецификации идентификатора порождения флаг “-all” заставит “-info” сообщать обо всех идентификаторах порождения.
Вывод флага -info может быть повторно использован в качестве аргумента для ожидаемого_переда.
hope_tty [Ожидаемые_арги]
похоже на ожидаемо , но читает символы из/dev/tty (то есть нажатия клавиш пользователем). По умолчанию чтение выполняется в готовом режиме. Таким образом, строки должны заканчиваться возвратом, чтобы ожидали их увидеть. Это можно изменить с помощью stty (см. Ниже команду stty ).
hope_user [Ожидаемые_арги]
похоже на ожидание , но читает символы из стандартного ввода (т. е. нажатия клавиш пользователем). По умолчанию чтение выполняется в готовом режиме. Таким образом, строки должны заканчиваться возвратом, чтобы ожидали их увидеть. Это можно изменить с помощью stty (см. Ниже команду stty ).
вилка
создает новый процесс. Новый процесс является точной копией текущего процесса Expect . В случае успеха fork возвращает 0 новому (дочернему) процессу и возвращает идентификатор процесса дочернего процесса в родительский процесс. В случае сбоя (неизменно из-за недостатка ресурсов, например, пространства подкачки, памяти), fork возвращает -1 родительскому процессу, и дочерний процесс не создается.
Завершенные процессы завершаются с помощью команды exit , как и исходный процесс. Разветвленным процессам разрешено записывать в файлы журнала. Если вы не отключите отладку или регистрацию в большинстве процессов, результат может привести к путанице.
Некоторые реализации pty могут быть сбиты с толку множеством читателей и авторов даже на мгновение. Таким образом, разветвляться безопаснее, чем создавать процессы.
взаимодействовать [string1 body1] … [stringn [bodyn]]
дает контроль над текущим процессом пользователю, чтобы нажатия клавиш отправлялись текущему процессу, а возвращались stdout и stderr текущего процесса.
В качестве аргументов могут быть заданы пары строка-тело, и в этом случае тело выполняется при вводе соответствующей строки. (По умолчанию строка не отправляется текущему процессу.) Команда интерпретатор принимается, если окончательное тело отсутствует.
Если для аргументов всего оператора взаимодействовать требуется более одной строки, все аргументы могут быть «заключены» в одну, чтобы избежать завершения каждой строки обратной косой чертой. В этом одном случае обычные замены Tcl будут происходить, несмотря на скобки.
Например, следующие запуски команд взаимодействуют со следующими определенными парами строка-тело: при нажатии ^ Z приостановка Expect . (Флаг -reset восстанавливает режимы терминала.) Когда нажимается ^ A, пользователь видит «вы набрали управляющий элемент A», и процесс отправляет ^ A. Когда $ нажата, пользователь видит дату. При нажатии ^ C Ожидать завершается. Если введено «foo», пользователь видит «bar». При нажатии ~~ интерпретатор Expect запускается в интерактивном режиме.
set CTRLZ \ 032 взаимодействовать {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "вы ввели элемент управления-A \ n"; send "\ 001"} $ {send_user "Дата: [формат часов [часы в секундах]]."} \ 003 exit foo {send_user "bar"} ~~}
В парах строка-тело строки сопоставляются в порядке их перечисления в качестве аргументов. Частично совпадающие строки не отправляются текущему процессу в ожидании прихода остатка. Если символы вводятся таким образом, что совпадение больше не может быть, только часть строки будет отправлена процессу, который не может начать другое совпадение. Таким образом, строки, являющиеся подстроками частичных совпадений, могут совпадать позже, если исходные строки, которые пытались найти совпадения, в конечном итоге терпят неудачу.
По умолчанию сопоставление строк является точным без подстановочных знаков. (В отличие от этого, команда ожидаем по умолчанию использует шаблоны в стиле glob.) Флаг -ex может использоваться для защиты шаблонов, которые в противном случае могли бы соответствовать взаимодействию флаги от этого. Любой шаблон, начинающийся с “-“, должен быть защищен таким образом. (Все строки, начинающиеся с «-», зарезервированы для будущих опций.)
Флаг -re заставляет строку интерпретироваться как шаблон в стиле регулярного выражения. В этом случае совпадающие подстроки сохраняются в переменной interactive_out аналогично тому, как Ожидает , сохраняет свои выходные данные в переменной hope_out . Флаг -indices поддерживается аналогичным образом.
Шаблон eof представляет действие, выполняемое в конце файла.Отдельный шаблон eof может также следовать за флагом -output , и в этом случае он сопоставляется, если eof обнаружен во время записи вывода. Действие eof по умолчанию – «возврат», поэтому взаимодействовать просто возвращает любой EOF.
Шаблон время ожидания вводит время ожидания (в секундах) и действие, которое выполняется после того, как в течение определенного времени не было прочитано ни одного символа. Шаблон timeout применяется к последнему указанному процессу. Тайм-аут по умолчанию отсутствует. Специальная переменная “timeout” (используемая командой ожидаем ) не влияет на это время ожидания.
Например, следующий оператор может быть использован для автозапуска пользователей, которые ничего не печатали в течение часа, но которые все еще получают частые системные сообщения:
взаимодействовать -вход $ user_spawn_id timeout 3600 return -output \ $ spawn_id
Если в качестве шаблона используется ключевое слово null , а значения NULL допускаются (с помощью команды remove_nulls ), то выполняется соответствующее тело, если сопоставляется один ASCII 0. Невозможно сопоставить 0 байтов с помощью шаблонов glob или regexp.
Предварительный поиск шаблона с флагом -iwrite приводит к тому, что для переменной interactive_out (spawn_id) устанавливается значение spawn_id, которое соответствует шаблону (или eof).
Такие действия, как break и continue , заставляют структуры управления (т. Е. for , proc ) вести себя обычным образом. , Однако return заставляет Interactive возвращаться к своему вызывающему, в то время как inter_return заставляет взаимодействия вызывать возврат к своему вызывающему. Например, если “proc foo” с именем взаимодействовать , который затем выполнил действие inter_return , вернется proc foo . (Это означает, что если взаимодействовать вызывает интерпретатор , введя в интерактивном режиме return , взаимодействие продолжится, а inter_return вызовет взаимодействовать, чтобы вернуться к своему абоненту.)
Во время взаимодействия используется необработанный режим, чтобы все символы могли быть переданы в текущий процесс. Если текущий процесс не улавливает сигналы управления заданиями, он остановится, если будет отправлен сигнал остановки (по умолчанию ^ Z). Чтобы перезапустить его, отправьте сигнал продолжения (например, «kill -CONT»). Если вы действительно хотите отправить SIGSTOP в такой процесс (с помощью ^ Z), попробуйте сначала запустить csh, а затем запустить вашу программу. С другой стороны, если вы хотите отправить SIGSTOP самому Expect , сначала вызовите интерпретатор (возможно, с помощью escape-символа), а затем нажмите ^ Z.
Пары «строка-тело» можно использовать как сокращение, чтобы избежать необходимости вводить интерпретатор и выполнять команды в интерактивном режиме. Предыдущий режим терминала используется во время выполнения тела пары строка-тело.
Для скорости действия выполняются в необработанном режиме по умолчанию. Флаг -reset сбрасывает терминал в режим, в котором он находился до выполнения взаимодействия (неизменно готовый режим). Обратите внимание, что символы, введенные при переключении режима, могут быть потеряны (неудачная функция драйвера терминала в некоторых системах). Единственная причина использовать -reset , если ваши действия зависят от запуска в готовом режиме.
Флаг -echo отправляет символы, соответствующие следующему шаблону, обратно в процесс, который их сгенерировал, при чтении каждого символа. Это может быть полезно, когда пользователь должен видеть обратную связь от частично типизированных шаблонов.
Если шаблон отражается, но в конечном итоге не совпадает, символы отправляются в порожденный процесс. Если порожденный процесс затем повторяет их, пользователь увидит символы дважды. -echo , вероятно, подходит только в ситуациях, когда пользователь вряд ли завершит шаблон. Например, следующий фрагмент взят из rftp, сценария рекурсивного ftp, где пользователю предлагается ввести ~ g, ~ p или ~ l, чтобы рекурсивно получить, поместить или вывести список текущего каталога. Они настолько далеки от обычных команд ftp, что пользователь вряд ли наберет ~, а затем что-нибудь еще, кроме по ошибке, и в этом случае они, скорее всего, просто проигнорируют результат.
взаимодействовать {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}
Флаг -nobuffer отправляет символы, соответствующие следующему шаблону, в процесс вывода при чтении символов.
Это полезно, когда вы хотите, чтобы программа повторила шаблон. Например, следующее может использоваться для отслеживания того, где набирает человек (модем в стиле Хейса). Каждый раз, когда “atd” виден, скрипт регистрирует остаток строки.
proc lognumber {} {взаимодействовать -nobuffer -re "(.*) \ r "возвращение ставит $ log" [формат часов [часы в секундах]]: набранный $ взаимодействовать_ут (1, строка) "} взаимодействовать -nobuffer" atd "номер журнала
Во время взаимодействия предыдущее использование log_user игнорируется. В частности, взаимодействовать принудительно зарегистрирует свой вывод (отправленный на стандартный вывод), поскольку предполагается, что пользователь не хочет взаимодействовать вслепую.
Флаг -o приводит к тому, что любые следующие пары клавиш и тела применяются к выходным данным текущего процесса. Это может быть полезно, например, при работе с хостами, которые отправляют нежелательные символы во время сеанса telnet.
По умолчанию взаимодействовать ожидает, что пользователь будет писать стандартный ввод и читать стандартный вывод самого процесса Expect . Флаг -u (для «пользователя») заставляет взаимодействовать искать пользователя как процесс, названный его аргументом (который должен быть порожденным идентификатором).
Это позволяет объединять два несвязанных процесса без использования явного цикла. Чтобы помочь в отладке, диагностическая программа Expect всегда идет в stderr (или stdout для получения определенной информации о протоколировании и отладке). По той же причине команда интерпретатор будет читать в интерактивном режиме из стандартного ввода.
Например, следующий фрагмент создает процесс входа в систему. Затем он набирает пользователя (не показан) и, наконец, соединяет их вместе. Конечно, любой процесс может заменить логин. Оболочка, например, позволит пользователю работать без указания учетной записи и пароля.
spawn login set login $ spawn_id spawn tip modem # дозвониться до пользователя # подключить пользователя для входа взаимодействовать -u $ login
Чтобы отправить вывод нескольким процессам, перечислите каждый список идентификаторов спавна с предваряющим флагом -output . Входные данные для группы выходных идентификаторов порождения могут быть определены списком идентификаторов порождения, которому предшествует флаг -input . (И -input , и -output могут принимать списки в той же форме, что и флаг -i в ожидаемом . команда, за исключением того, что any_spawn_id не имеет смысла в взаимодействии .) Все следующие флаги и строки (или шаблоны) применяются к этому входу, пока не появится другой флаг -input. Если -input не отображается, то -output означает «-input $ user_spawn_id -output». (Аналогично, для шаблонов, которые не имеют -input .) Если указан один -input , он переопределяет $ user_spawn_id. Если указан второй -input , он переопределяет $ spawn_id. Могут быть указаны дополнительные флаги -input .
По умолчанию для двух подразумеваемых процессов ввода их выходные данные определены как $ spawn_id и $ user_spawn_id (в обратном порядке). Если флаг -input отображается без флага -output , символы этого процесса отбрасываются.
Флаг -i вводит замену текущего spawn_id, когда другие флаги -input или -output не используются. Флаг -i подразумевает флаг -o.
Можно изменить процессы, с которыми взаимодействуют, используя косвенные идентификаторы порождения. (Идентификаторы косвенного вызова описаны в разделе о команде ожидаемого.) Идентификаторы косвенного вызова могут быть указаны с помощью флагов -i, -u, -input или -output.
переводчик [аргументы]
вызывает интерактивное приглашение пользователя для команд Expect и Tcl. Результат каждой команды печатается.
Такие действия, как break и continue , заставляют структуры управления (т. Е. for , proc ) вести себя обычным образом. , Однако return приводит к тому, что интерпретатор возвращается к своему вызывающему, а inter_return заставляет интерпретатор вызывать возвращение к своему вызывающему. Например, если «proc foo» вызвал интерпретатор , который затем выполнил действие inter_return , proc foo вернется. Любая другая команда заставляет интерпретатор продолжать запрашивать новые команды.
По умолчанию подсказка содержит два целых числа. Первое целое число описывает глубину стека оценки (т. Е. Сколько раз был вызван Tcl_Eval). Второе целое число – идентификатор истории Tcl. Подсказка может быть установлена путем определения процедуры с именем «prompt1», возвращаемое значение которой становится следующей подсказкой. Если в операторе есть открытые кавычки, скобки, скобки или скобки, при переводе строки выдается дополнительная подсказка (по умолчанию «+>»). Вторичный запрос может быть установлен путем определения процедуры, называемой «prompt2».
Во время интерпретатора используется готовый режим, даже если вызывающий абонент использовал необработанный режим.
Если stdin закрыт, интерпретатор вернется, если не используется флаг -eof , и в этом случае вызывается последующий аргумент.
log_file [args] [[-a] файл]
Если указано имя файла, файл_файла запишет в файл стенограмму сеанса (начиная с этого момента). log_file прекратит запись, если аргумент не указан. Любой предыдущий файл журнала закрыт.
Вместо имени файла идентификатор файла Tcl может быть предоставлен с использованием флагов -open или -leaveopen . Это похоже на команду spawn . (Для получения дополнительной информации см. spawn .)
Флаг -a принудительно регистрирует вывод, который был подавлен командой log_user .
По умолчанию команда log_file добавляет к старым файлам, а не обрезает их, для удобства отключения и повторного входа в систему в течение одного сеанса. Чтобы обрезать файлы, используйте флаг -noappend .
Флаг -info приводит к тому, что log_file возвращает описание самых последних приведенных неинформационных аргументов.
log_user -info | 0 | 1
По умолчанию диалог отправки/ожидания записывается в стандартный вывод (и файл журнала, если он открыт). Запись в stdout отключена командой «log_user 0» и повторно включена «log_user 1». Запись в лог-файл не изменилась.
Флаг -info заставляет log_user возвращать описание самых последних приведенных неинформационных аргументов.
match_max [-d] [-i spawn_id] [размер]
определяет размер буфера (в байтах), используемого внутренне ожидаем . Без аргумента size возвращается текущий размер.
С флагом -d устанавливается размер по умолчанию. (Исходное значение по умолчанию – 2000.) С флагом -i размер устанавливается для именованного идентификатора появления, в противном случае он устанавливается для текущего процесса.
наложение [- # spawn_id] [- # spawn_id] […] программа [аргументы]
выполняет “program args” вместо текущей программы Expect , которая завершается. Пустой аргумент дефиса ставит дефис перед именем команды, как если бы это была оболочка входа в систему. Все spawn_ids закрыты, за исключением тех, которые названы в качестве аргументов. Они отображаются на именованные идентификаторы файлов.
Spawn_ids отображаются в идентификаторы файлов для новой программы для наследования. Например, следующая строка запускает шахматы и позволяет им управлять текущим процессом – скажем, мастером по шахматам.
overlay -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id chess
Это более эффективно, чем «взаимодействовать -u», однако оно жертвует возможностью выполнять программируемое взаимодействие, поскольку процесс Expect больше не контролируется.
Обратите внимание, что управляющий терминал не предоставляется. Таким образом, если вы отключите или переназначите стандартный ввод, программы, которые выполняют управление заданиями (оболочки, логин и т. Д.), Не будут работать должным образом.
четность [-d] [-i spawn_id] [значение]
определяет, должен ли паритет сохраняться или удаляться из результатов порожденных процессов. Если значение равно нулю, четность удаляется, в противном случае она не удаляется. Без аргумента value возвращается текущее значение.
С флагом -d устанавливается значение четности по умолчанию. (Исходное значение по умолчанию – 1, то есть четность не удаляется.) С флагом -i значение четности устанавливается для именованного идентификатора появления, в противном случае оно устанавливается для текущего процесса.
remove_nulls [-d] [-i spawn_id] [значение]
определяет, будут ли нулевые значения сохраняться или удаляться из вывода порожденных процессов перед сопоставлением с образцом или сохранением в переменной hope_out или interactive_out . Если значение равно 1, нули удаляются. Если значение равно 0, нули не удаляются. Без аргумента value возвращается текущее значение.
С флагом -d устанавливается значение по умолчанию. (Исходное значение по умолчанию – 1, т. Е. Нулевые значения удаляются.) С флагом -i устанавливается значение для именованного идентификатора появления, в противном случае оно устанавливается для текущего процесса.
Независимо от того, были ли удалены нулевые значения, Ожидайте запишет нулевые байты в журнал и стандартный вывод.
отправить [-flags] строку
Отправляет строку в текущий процесс. Например, команда
отправьте "hello world \ r"
отправляет символы, которые будут отображаться в текущем процессе. (Tcl содержит команду, похожую на printf (называемую формат ), которая может создавать произвольно сложные строки.)
Символы отправляются немедленно, хотя программы с входным буферизованным вводом не будут читать символы, пока не будет отправлен символ возврата. Возвращаемый символ обозначается как “\ r”.
Флаг – заставляет следующий аргумент интерпретироваться как строку, а не как флаг.Любой строке может предшествовать «-», независимо от того, действительно ли она выглядит как флаг. Это обеспечивает надежный механизм для указания переменных строк без отключения тех, которые случайно выглядят как флаги. (Все строки, начинающиеся с «-», зарезервированы для будущих опций.)
Флаг -i объявляет, что строка отправлена по имени spawn_id. Если spawn_id равен user_spawn_id и терминал находится в необработанном режиме, новые строки в строке преобразуются в последовательности return-newline, так что они выглядят так, как если бы терминал находился в готовом режиме. Флаг -raw отключает этот перевод.
Флаг -null отправляет нулевые символы (0 байт). По умолчанию отправляется один ноль. Целое число может следовать за -null , чтобы указать, сколько нулей нужно отправить.
Флаг -break создает условие разрыва. Это имеет смысл, только если идентификатор spawn относится к tty устройству, открытому через «spawn -open». Если вы породили такой процесс, как tip, вы должны использовать соглашение tip для генерации перерыва.
Флаг -s заставляет вывод отправляться «медленно», что позволяет избежать распространенной ситуации, когда компьютер набирает тип входного буфера, который был разработан для человека, который никогда не будет вытеснять тот же буфер. Эти выходные данные контролируются значением переменной “send_slow”, которая принимает список из двух элементов. Первый элемент – это целое число, которое описывает количество байтов, отправляемых атомарно. Второй элемент – это действительное число, которое описывает количество секунд, на которые атомные отправления должны быть разделены. Например, «set send_slow {10 .001}» заставит «send -s» отправлять строки с интервалом в 1 миллисекунду между каждыми 10 отправленными символами.
Флаг -h вынуждает отправлять вывод (что-то вроде) человека, который на самом деле печатает. Человеческие задержки появляются между персонажами. (Алгоритм основан на распределении Вейбулла с модификациями, подходящими для данного конкретного приложения.) Эти выходные данные контролируются значением переменной “send_human”, которая принимает список из пяти элементов. Первые два элемента – это среднее время прохождения символов в секундах. Первый используется по умолчанию. Второй используется в конце слов, чтобы имитировать тонкие паузы, которые иногда возникают при таких переходах. Третий параметр представляет собой меру изменчивости, где .1 является достаточно переменным, 1 является достаточно переменным, а 10 является совершенно неизменным. Крайности от 0 до бесконечности. Последние два параметра – это, соответственно, минимальное и максимальное время взаимодействия. Минимум и максимум используются последним и «обрезают» последний раз. Конечное среднее значение может сильно отличаться от заданного среднего, если для минимального и максимального значения клипа достаточно.
Например, следующая команда эмулирует быструю и последовательную машинистку:
set send_human {.1 .3 1 .05 2} send -h "Я голоден. Давай пообедаем."
в то время как следующее может быть более подходящим после похмелья:
set send_human {.4 .4 .2 .5 100} send -h "Хорошая вечеринка!"
Обратите внимание, что ошибки не моделируются, хотя вы можете сами настроить ситуации с исправлением ошибок, встраивая ошибки и исправления в аргумент отправки.
Флаги для отправки нулевых символов, для отправки разрывов, для принудительного медленного вывода и для вывода в человеческом стиле являются взаимоисключающими. Будет использоваться только последний указанный. Кроме того, аргумент string не может быть указан с флагами для отправки нулевых символов или разрывов.
Хорошая идея – предшествовать первой отправке процессу ожидаемым . ожидайте дождитесь начала процесса, а отправить – нет. В частности, если первая отправка завершится до запуска процесса, вы рискуете игнорировать ваши данные. В тех случаях, когда интерактивные программы не предлагают первоначального приглашения, перед отправкой может быть задержка, например:
# Чтобы не давать хакерам подсказок о том, как взломать, # эта система не запрашивает внешний пароль. # Подождите 5 секунд, пока exec завершит вызов spel. Telnet very.secure.gov sleep 5 send password \ r
exp_send – это псевдоним send. . Если вы используете Expectk или какой-либо другой вариант Expect в среде Tk, send определяется Tk для совершенно другой цели. exp_send предоставляется для совместимости между средами. Подобные псевдонимы предоставляются для других команд отправки Expect.
send_error [-flags] строка
похоже на отправить , за исключением того, что выходные данные отправляются в stderr, а не в текущий процесс.
send_log [-] string
похоже на отправить , за исключением того, что строка отправляется только в файл журнала (см. файл_файла .) Аргументы игнорируются, если файл журнала не открыт.
send_tty [-flags] string
похоже на отправить , за исключением того, что вывод отправляется в/dev/tty, а не в текущий процесс.
send_user [-flags] string
похоже на отправить , за исключением того, что вывод отправляется на стандартный вывод, а не на текущий процесс.
секунд сна
заставляет скрипт спать в течение заданного количества секунд. Секунды могут быть десятичным числом. Прерывания (и события Tk, если вы используете Expectk) обрабатываются во время ожидания Expect.
spawn [args] программа [args]
создает новый процесс, выполняющий “program args”. Его stdin, stdout и stderr связаны с Expect, так что они могут быть прочитаны и записаны другими командами Expect . Соединение разрывается из-за закрытия или если сам процесс закрывает какой-либо из идентификаторов файла.
Когда процесс запускается spawn , переменная spawn_id устанавливается в дескриптор, ссылающийся на этот процесс. Процесс, описанный spawn_id , считается «текущим процессом». spawn_id может быть прочитан или записан, фактически обеспечивая контроль работы.
user_spawn_id – это глобальная переменная, содержащая дескриптор, который ссылается на пользователя. Например, когда для spawn_id задано это значение, Ожидает ведет себя как Ожидаемый_user .
.I error_spawn_id – глобальная переменная, содержащая дескриптор, который ссылается на стандартную ошибку. Например, когда для spawn_id установлено это значение, send ведет себя как send_error .
tty_spawn_id – глобальная переменная, содержащая дескриптор, который ссылается на/dev/tty. Если/dev/tty не существует (например, в cron, at или batch-скрипте), то tty_spawn_id не определено. Это может быть проверено как:
if {[info vars tty_spawn_id]} {#/dev/tty существует} иначе {#/dev/tty не существует # возможно в cron, batch или at script}
spawn возвращает идентификатор процесса UNIX. Если процесс не запущен, возвращается 0. Переменная spawn_out (slave, name) установлена на имя pty подчиненного устройства.
По умолчанию spawn отображает имя команды и аргументы. Флаг -noecho не позволяет spawn сделать это.
Флаг -console приводит к тому, что вывод консоли перенаправляется в порожденный процесс. Это поддерживается не во всех системах.
Внутри spawn использует pty, инициализированный так же, как и tty пользователя. Это далее инициализируется так, чтобы все настройки были “нормальными” (согласно stty (1)). Если переменная stty_init определена, она интерпретируется в стиле аргументов stty как дальнейшая конфигурация. Например, «set stty_init raw» приведет к запуску терминалов других порождаемых процессов в необработанном режиме. -nottycopy пропускает инициализацию на основе tty пользователя. -nottyinit пропускает “нормальную” инициализацию.
Обычно spawn занимает мало времени для выполнения. Если вы заметили, что спавн занимает значительное время, он, вероятно, сталкивается с клиньями. Ряд тестов выполняется на ptys, чтобы избежать путаницы с ошибочными процессами. (Это занимает 10 секунд на каждый pty.) Запуск Expect с опцией -d покажет, если Expect встречает много ptys в нечетных состояниях. Если вы не можете уничтожить процессы, к которым подключены эти ptys, единственным выходом может быть перезагрузка.
Если программа не может быть успешно создана из-за сбоя exec (2) (например, когда программа не существует), сообщение об ошибке будет возвращено при следующем взаимодействии < Команда/strong> или ожидайте , как если бы программа запустилась и выдавала сообщение об ошибке в качестве вывода. Такое поведение является естественным следствием реализации spawn . Внутри, порожденные порождения, после которых порожденный процесс не может связаться с исходным процессом Expect , кроме как через spawn_id.
Флаг -open приводит к тому, что следующий аргумент интерпретируется как идентификатор файла Tcl (т. Е. Возвращается open .) Идентификатор spawn можно затем использовать так, как если бы он был породил процесс. (Идентификатор файла больше не должен использоваться.) Это позволяет вам рассматривать необработанные устройства, файлы и конвейеры как порожденные процессы без использования pty. 0 возвращается, чтобы указать, что нет никакого связанного процесса. Когда соединение с порожденным процессом закрыто, то и идентификатор файла Tcl.Флаг -leaveopen аналогичен флагу -open , за исключением того, что -leaveopen оставляет идентификатор файла открытым, даже после закрытия идентификатора спавна.
Флаг -pty вызывает открытие pty, но процесс не запускается. 0 возвращается, чтобы указать, что нет никакого связанного процесса. Spawn_id устанавливается как обычно.
Переменная spawn_out (slave, fd) устанавливается на идентификатор файла, соответствующий pty-ведомому. Его можно закрыть с помощью «close -slave».
Флаг -ignore указывает на сигнал, который следует игнорировать в порожденном процессе. В противном случае сигналы получают поведение по умолчанию. Сигналы именуются как в команде trap , за исключением того, что для каждого сигнала требуется отдельный флаг.
уровень strace
приводит к тому, что следующие операторы будут напечатаны перед выполнением. (Команда трассировки Tcl отслеживает переменные.) level указывает, как далеко в стеке вызовов требуется выполнить трассировку. Например, следующая команда запускает Expect , отслеживая первые 4 уровня вызовов, но ни один из них не ниже.
Ожидается -c "strace 4" script.exp
Флаг -info заставляет strace возвращать описание самых последних неинформационных аргументов.
stty args
изменяет режимы терминала аналогично внешней команде stty.
По умолчанию доступ к управляющему терминалу Доступ к другим терминалам можно получить, добавив «Запросы на статус, которые возвращаются в результате выполнения команды. Если статус не запрашивается и к управляющему терминалу обращаются, предыдущее состояние атрибутов raw и echo возвращается в форме, которая может быть позже используется командой.
Например, аргументы raw или -cooked переводят терминал в режим raw. Аргументы -raw или cooked переводят терминал в готовый режим. Аргументы echo и -echo переводят терминал в режим echo и noecho соответственно.
В следующем примере показано, как временно отключить эхо. Это может быть использовано в автоматических сценариях, чтобы избежать встраивания в них паролей. (Подробнее об этом см. В разделе «ОЖИДАЕМЫЕ СОВЕТЫ» ниже.)
stty -echo send_user "Пароль:" wait_user -re "(. *) \ n" установить пароль $ Ожидаем (1, строка) stty echo
системные аргументы
дает args для sh (1) в качестве ввода, как если бы оно было набрано как команда из терминала. Ожидайте , пока не завершится работа оболочки. Статус возврата из sh обрабатывается так же, как exec обрабатывает его статус возврата.
В отличие от exec , который перенаправляет stdin и stdout в сценарий, system не выполняет перенаправление (кроме указанного в самой строке). Таким образом, можно использовать программы, которые должны напрямую взаимодействовать с/dev/tty. По той же причине результаты системы не записываются в журнал.
отметка времени [args]
возвращает метку времени Без аргументов – количество секунд с начала эпохи.
Флаг -format вводит строку, которая возвращается, но с заменами, сделанными в соответствии с правилами POSIX для strftime. Например,% a заменяется сокращенным названием дня недели (т. Е. Суббота). Другие являются:
% a сокращенное название дня недели% A полное название дня недели% b сокращенное название месяца% B полное имя месяца% c дата-время, как в: ср 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 секунда (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
Флаг -seconds вводит количество секунд с начала эпохи, которое будет использоваться в качестве источника для форматирования. В противном случае используется текущее время.
Флаг -gmt заставляет выходные метки времени использовать часовой пояс GMT. Без флага используется местный часовой пояс.
trap [[команда] сигналы]
заставляет данную команду выполняться при получении в будущем любого из указанных сигналов. Команда выполняется в глобальной области видимости. Если команда отсутствует, возвращается действие сигнала. Если команда является строкой SIG_IGN, сигналы игнорируются.Если команда является строкой SIG_DFL, сигналы являются результатом по умолчанию системы. сигналы – это либо отдельный сигнал, либо список сигналов. Сигналы могут быть указаны численно или символически согласно сигналу (3). Префикс «SIG» может быть опущен.
Без аргументов (или аргумента -number) trap возвращает номер сигнала выполняемой в данный момент команды trap.
Флаг -code использует код возврата команды вместо любого кода, который Tcl собирался вернуть, когда команда начала выполняться.
Флаг -interp приводит к тому, что команда оценивается с использованием интерпретатора, активного во время запуска команды, а не после объявления прерывания.
Флаг -name заставляет команду trap возвращать имя сигнала команды trap, выполняемой в данный момент.
Флаг -max заставляет команду trap возвращать наибольший номер сигнала, который можно установить.
Например, команда “trap {send_user” Ouch! “} SIGINT” выведет “Ouch!” каждый раз, когда пользователь нажимает ^ C.
По умолчанию SIGINT (который обычно генерируется нажатием ^ C) и SIGTERM вызывают Expect для выхода. Это связано со следующей ловушкой, созданной по умолчанию при запуске Expect.
выход ловушки {SIGINT SIGTERM}
Если вы используете флаг -D для запуска отладчика, SIGINT переопределяется для запуска интерактивного отладчика. Это связано со следующей ловушкой:
trap {exp_debug 1} SIGINT
Ловушка отладчика может быть изменена путем установки переменной среды EXPECT_DEBUG_INIT новой команды прерывания.
Конечно, вы можете переопределить оба этих параметра, просто добавив команды trap в ваш скрипт. В частности, если у вас есть собственный «выход ловушки SIGINT», это отменит ловушку отладчика. Это полезно, если вы хотите вообще запретить пользователям доступ к отладчику.
Если вы хотите определить свою собственную ловушку в SIGINT, но все еще ловите ее в отладчике, когда он работает, используйте:
if {! [exp_debug]} {trap mystuff SIGINT}
Кроме того, вы можете перехватить отладчик, используя другой сигнал.
trap не позволит вам переопределить действие для SIGALRM, так как оно используется внутри для Expect . Команда отсоединения устанавливает SIGALRM в SIG_IGN (игнорировать). Вы можете включить это, если отключите его во время последующих команд появления.
Смотрите сигнал (3) для получения дополнительной информации.
wait [args]
задерживается до тех пор, пока не завершится созданный процесс (или текущий процесс, если ни один из них не назван).
wait обычно возвращает список из четырех целых чисел. Первое целое число – это pid процесса, который ожидался. Второе целое число – соответствующий идентификатор появления. Третье целое число равно -1, если произошла ошибка операционной системы, или 0 в противном случае. Если третье целое число было 0, четвертое целое число – это состояние, возвращаемое порожденным процессом. Если третье целое число было -1, четвертое целое число является значением errno, установленным операционной системой. Глобальная переменная errorCode также установлена.
Дополнительные элементы могут появляться в конце возвращаемого значения из wait . Необязательный пятый элемент идентифицирует класс информации. В настоящее время единственным возможным значением для этого элемента является CHILDKILLED, в этом случае следующие два значения – это имя сигнала в стиле C и краткое текстовое описание.
Флаг -i объявляет процесс ожидания, соответствующий названному spawn_id (НЕ идентификатор процесса). Внутри обработчика SIGCHLD можно ожидать любого порожденного процесса, используя идентификатор порождения -1.
Флаг -nowait приводит к немедленному возвращению ожидания с указанием успешного ожидания. Когда процесс завершается (позже), он автоматически исчезает без необходимости явного ожидания.
Команда wait также может использоваться для ожидания разветвленного процесса с использованием аргументов “-i -1”. В отличие от использования с порожденными процессами, эта команда может быть выполнена в любое время. Нет контроля над тем, какой процесс происходит. Однако возвращаемое значение может быть проверено на идентификатор процесса.
Библиотеки
Expect автоматически знает о двух встроенных библиотеках для сценариев Expect. Они определяются каталогами, названными в переменных exp_library и exp_exec_library. Оба должны содержать служебные файлы, которые могут использоваться другими сценариями.
exp_library содержит независимые от архитектуры файлы. exp_exec_library содержит архитектурно-зависимые файлы. В зависимости от вашей системы оба каталога могут быть совершенно пустыми. Существование файла $ exp_exec_library/cat-buffers описывает, буферизует ли ваш/bin/cat по умолчанию.
Довольно-печать
Определение vgrind доступно для красивых печатающих Expect сценариев.Предполагая, что определение vgrind, поставляемое с дистрибутивом Expect , установлено правильно, вы можете использовать его как:
vgrind -lexpect файл
Примеры
Многим не очевидно, как собрать все вместе, что описывает страница руководства. Рекомендуется прочитать и опробовать примеры в каталоге примеров дистрибутива Expect . Некоторые из них являются настоящими программами. Другие просто иллюстрируют определенные методы, и, конечно, пара – это просто быстрые взломы. Файл INSTALL содержит краткий обзор этих программ.
Документы Expect (см. Также см.) Также полезны. Хотя в некоторых статьях используется синтаксис, соответствующий более ранним версиям Expect, сопутствующие обоснования по-прежнему действительны и содержат гораздо больше подробностей, чем справочная страница.
Предостережения
Расширения могут конфликтовать с именами команд Expect. Например, отправить определяется Tk для совершенно другой цели. По этой причине большинство команд Expect также доступны как «exp_XXXX». Команды и переменные, начинающиеся с «exp», «inter», «spawn» и «timeout», не имеют псевдонимов. Используйте расширенные имена команд, если вам нужна совместимость между средами.
Ожидайте довольно либерально. В частности, переменные, считываемые командами, специфичными для программы Expect , будут сначала искать в локальной области, а если не найдены, в глобальной области. Например, это избавляет от необходимости помещать «глобальное время ожидания» в каждую написанную вами процедуру, использующую ожидаемо . С другой стороны, записанные переменные всегда находятся в локальной области (если не была введена «глобальная» команда). Наиболее распространенная проблема, которую это вызывает, – когда в процедуре выполняется spawn. Вне процедуры spawn_id больше не существует, поэтому порожденный процесс больше не доступен просто из-за области видимости. Добавьте “глобальный spawn_id” к такой процедуре.
Если вы не можете включить функцию мультиспавнования (т. Е. Ваша система не поддерживает ни select (BSD *. *), Poll (SVR> 2), ни что-либо эквивалентное), Expect сможет управлять только одним процесс за один раз. В этом случае не пытайтесь установить spawn_id , а также не запускайте процессы через exec, когда запущенный процесс запущен. Кроме того, вы не сможете ожидать от нескольких процессов (включая пользователя как один) одновременно.
Параметры терминала могут оказать большое влияние на сценарии. Например, если сценарий написан для поиска эха, он будет работать неправильно, если эхо отключено. По этой причине Expect по умолчанию принудительно устанавливает параметры терминала. К сожалению, это может сделать вещи неприятными для других программ. Например, оболочка emacs хочет изменить «обычные» отображения: новые строки отображаются на новые строки вместо новых строк с возвратом каретки, и эхо отключено. Это позволяет использовать emacs для редактирования строки ввода. К сожалению, Expect не может догадаться об этом.
Вы можете попросить Expect не переопределять настройки по умолчанию для параметров терминала, но вы должны быть очень осторожны при написании сценариев для таких сред. В случае с emacs, избегайте зависимости от таких вещей, как эхо и отображение конца строки.
Команды, принимающие аргументы, объединены в один список (варианты ожидают и взаимодействуют ), чтобы определить, является ли список одним или несколькими аргументами, с помощью эвристики. Эвристика может потерпеть неудачу только в том случае, если список фактически представляет один аргумент, который имеет несколько встроенных \ n с непробельными символами между ними. Это кажется маловероятным, однако аргумент “-nobrace” может использоваться для принудительной обработки одного аргумента в качестве одного аргумента. Возможно, это можно использовать с машинным кодом Expect. Точно так же -brace заставляет один аргумент обрабатываться как множество шаблонов/действий.
ошибки
Было действительно заманчиво назвать программу «секс» (для «Smart EXec» или «Send-EXpect»), но здравый смысл (или, может быть, просто пуританство) преобладал.
В некоторых системах, когда запускается оболочка, она жалуется на невозможность доступа к tty, но все равно запускается. Это означает, что в вашей системе есть механизм получения контрольного tty, о котором Expect не знает. Пожалуйста, выясните, что это, и отправьте мне эту информацию.
Ultrix 4.1 (по крайней мере, последние версии здесь) считает превышение времени ожидания более 1000000 равным 0.
Digital UNIX 4.0A (и, возможно, другие версии) отказывается выделять ptys, если вы определяете обработчик SIGCHLD. Для получения дополнительной информации см. Страницу grantpt.
IRIX 6.0 неправильно обрабатывает разрешения pty, поэтому если Expect попытается выделить pty, ранее использованный кем-то другим, произойдет сбой. Обновление до IRIX 6.1.
Telnet (проверено только под SunOS 4.1.2) зависает, если не установлен TERM. Это проблема в сценариях cron, at и cgi, которые не определяют TERM. Таким образом, вы должны установить его явно – к какому типу обычно не имеет отношения. Это просто должно быть настроено на что-то! Следующего, вероятно, достаточно для большинства случаев.
set env (TERM) vt100
Совет (проверено только в BSDI BSD/OS 3.1 i386) зависает, если SHELL и HOME не установлены. Это проблема в сценариях cron, at и cgi, которые не определяют эти переменные среды. Таким образом, вы должны установить их явно – к какому типу обычно не имеет отношения. Это просто должно быть настроено на что-то! Следующего, вероятно, достаточно для большинства случаев.
установить env (SHELL)/bin/sh установить env (HOME)/usr/local/bin
Некоторые реализации ptys спроектированы так, что ядро выбрасывает любые непрочитанные выходные данные через 10-15 секунд (фактическое число зависит от реализации) после того, как процесс закрыл дескриптор файла. Таким образом, ожидайте программы, такие как
дата появления sleep sleep 20 ожидаем
не удастся. Чтобы избежать этого, вызывайте неинтерактивные программы с помощью exec , а не spawn . Хотя такие ситуации возможны, на практике я никогда не сталкивался с ситуацией, в которой конечный результат действительно интерактивной программы был бы потерян из-за такого поведения.
С другой стороны, Cray UNICOS ptys отбрасывает любые непрочитанные выходные данные сразу после того, как процесс закрыл дескриптор файла. Я сообщил об этом Крэй, и они работают над исправлением.
Иногда требуется задержка между приглашением и ответом, например, когда интерфейс tty изменяет настройки UART или соответствует скорости передачи данных в поисках битов пуска/останова. Обычно все, что для этого требуется – это поспать секунду или две. Более надежный метод – повторять попытки до тех пор, пока оборудование не будет готово к получению ввода. В следующем примере используются обе стратегии:
отправить "скорость 9600 \ r"; сон 1 ожидаем {timeout {send "\ r"; exp_continue} $ prompt}
trap-код не будет работать ни с какой командой, которая находится в цикле событий Tcl, например сном. Проблема состоит в том, что в цикле событий Tcl отбрасывает коды возврата от асинхронных обработчиков событий. Обходной путь должен установить флаг в коде ловушки. Затем проверьте флаг сразу после команды (то есть, спать).
Команда wait_background игнорирует аргументы -timeout и вообще не имеет понятия о тайм-аутах.
Ожидайте подсказки
В Expect есть несколько вещей, которые могут быть не интуитивными. В этом разделе предпринята попытка решить некоторые из этих вопросов с помощью нескольких предложений.
Общая ожидаемая проблема заключается в том, как распознать приглашения оболочки. Так как они настраиваются по-разному разными людьми и разными оболочками, переносимая автоматизация rlogin может быть затруднена без знания подсказки. Разумное соглашение заключается в том, чтобы пользователи хранили регулярное выражение, описывающее их приглашение (в частности, его конец), в переменной окружения EXPECT_PROMPT. Можно использовать код, подобный следующему. Если EXPECT_PROMPT не существует, у кода все еще есть хорошие шансы на правильное функционирование.
установить приглашение "(% | # | \\ $) $"; # задание приглашения по умолчанию {установить приглашение $ env (EXPECT_PROMPT)} ожидают -re $ приглашение
Напишите шаблоны ожидайте , которые включают конец всего, что вы ожидаете увидеть. Это исключает возможность ответить на вопрос, прежде чем увидеть все это. Кроме того, хотя вы вполне можете отвечать на вопросы до того, как полностью их увидеть, если вы ответите рано, ваш ответ может оказаться отраженным в середине вопроса. Другими словами, итоговый диалог будет правильным, но выглядит зашифрованным.
Большинство подсказок содержат пробел в конце. Например, приглашение от ftp это ‘f’, ‘t’, ‘p’, ‘>’ и. Чтобы соответствовать этому приглашению, вы должны учитывать каждый из этих символов. Это распространенная ошибка – не включать пробел. Вставьте пробел явно.
Если вы используете шаблон формы X *, * будет сопоставлять все выходные данные, полученные с конца X, с последней полученной вещью. Это звучит интуитивно, но может быть несколько запутанным, потому что фраза «последняя полученная вещь» может варьироваться в зависимости от скорости компьютера и обработки ввода-вывода как ядром, так и драйвером устройства.
В частности, люди склонны видеть, что программный результат поступает огромными порциями (атомарно), когда в действительности большинство программ выдают выходные данные по одной строке за раз. Если предположить, что это так, то * в шаблоне предыдущего абзаца может совпадать только с концом текущей строки, даже если кажется, что их больше, потому что во время совпадения были все выходные данные, которые были получены.
ожидаемо не может знать, что последует дальнейший вывод, если только ваш шаблон не учитывает его.
Даже в зависимости от строковой буферизации неразумно.Мало того, что программы редко дают обещания о типе буферизации, которую они делают, но несварение системы может разбить выходные строки так, что строки ломаются в, казалось бы, случайных местах. Таким образом, если вы можете выразить последние несколько символов приглашения при написании шаблонов, это целесообразно сделать.
Если вы ожидаете шаблон в последнем выводе программы, и вместо этого программа выдает что-то еще, вы не сможете обнаружить это с помощью ключевого слова timeout . Причина в том, что ожидаем не истечет время ожидания – вместо этого он получит указание eof . Используйте это вместо этого. Еще лучше, используйте оба. Таким образом, если эта строка будет перемещена, вам не придется редактировать саму строку.
Новые строки обычно преобразуются в возврат каретки, последовательности перевода строки при выводе драйвером терминала. Таким образом, если вы хотите шаблон, который явно соответствует двум строкам, скажем, printf (“foo \ nbar”), вам следует использовать шаблон “foo \ r \ nbar”.
Аналогичный перевод происходит при чтении от пользователя через hope_user . В этом случае, когда вы нажмете возврат, он будет переведен на новую строку. Если Expect затем передает это программе, которая переводит свой терминал в режим raw (например, telnet), возникнет проблема, так как программа ожидает истинного возврата. (Некоторые программы на самом деле прощают то, что они автоматически переводят переводы строк в возвраты, но большинство этого не делают.) К сожалению, нет никакого способа узнать, что программа переводит свой терминал в режим raw.
Вместо того, чтобы вручную заменять символы новой строки на возвраты, решение состоит в том, чтобы использовать команду “stty raw”, которая остановит перевод. Обратите внимание, однако, что это означает, что вы больше не получите готовые функции редактирования строки.
взаимодействовать неявно переводит ваш терминал в необработанный режим, поэтому проблема не возникнет.
Часто полезно хранить пароли (или другую личную информацию) в скриптах Expect . Это не рекомендуется, поскольку все, что хранится на компьютере, может быть доступно любому. Таким образом, интерактивное запрашивание паролей из сценария является более разумной идеей, чем встраивание их буквально. Тем не менее, иногда такое вложение является единственной возможностью.
К сожалению, файловая система UNIX не имеет прямого способа создания сценариев, которые выполняются, но не читаются. Системы, которые поддерживают сценарии оболочки setgid, могут косвенно моделировать это следующим образом:
Создайте скрипт Expect (содержащий секретные данные) как обычно. Сделайте его разрешения 750 (-rwxr-x —) и принадлежать доверенной группе, то есть группе, которой разрешено читать. При необходимости создайте новую группу для этой цели. Затем создайте сценарий/bin/sh с разрешениями 2751 (-rwxr-s – x), принадлежащими той же группе, что и раньше.
Результатом является скрипт, который может быть выполнен (и прочитан) кем угодно. При запуске он запускает скрипт Expect .
Ссылки
Tcl (3) , libexpect (3)
“ Исследование Expect: основанный на Tcl инструментарий для автоматизации интерактивных программ ” Дона Либеса, с. 602, ISBN 1-56592-090-2, O’Reilly and Associates 1995
“ ожидаемо: вылечить те неконтролируемые проявления интерактивности ” Дона Либеса, Материалы конференции USENIX летом 1990 года, Анахайм, Калифорния, 11-15 июня 1990 года.
.I “Использование ожидаемого для автоматизации задач системного администрирования”, Дон Либес, Материалы конференции по администрированию больших систем установки USENIX 1990 г., Колорадо-Спрингс, Колорадо, 17-19 октября 1990 г.
.I «Tcl: встраиваемый командный язык» Джона Оустерхаута, Материалы конференции USENIX зимой 1990 г., Вашингтон, округ Колумбия, 22–26 января 1990 г. Я ожидаю: сценарии для управления интерактивными программами. Автор Don Libes, Computing Systems. Вып. 4, № 2, Журналы Калифорнийского университета для прессы, ноябрь 1991 года. I «Интерактивные программы регрессионного тестирования и проверки соответствия», Дон Либес, Труды летней конференции USENIX 1992 года, стр. 135-144, Сан-Антонио, Техас 12-15 июня 1992 г. Я “Kibitz – Соединение нескольких интерактивных программ”, автор Don Libes, Software – Practice & Experience, John Wiley & Sons, Западный Суссекс, Англия, Vol. 23, № 5, май 1993 г. I “Отладчик для приложений Tcl”, Дон Либес, Труды семинара Tcl/Tk 1993 г., Беркли, Калифорния, 10-11 июня 1993 г.
Автор – Дон Либес, Национальный институт стандартов и технологий
Подтверждения
Спасибо Джону Оустерхауту за Tcl и Скотту Пейсли за вдохновение. Спасибо Робу Савойю за код автоконфигурации Expect.
Файл HISTORY описывает большую часть эволюции ожидаемого . Это делает интересное чтение и может дать вам дальнейшее понимание этого программного обеспечения. Спасибо людям, упомянутым в нем, которые прислали мне исправления ошибок и оказали другую помощь.
Разработка и реализация Expect была частично оплачена правительством США и, следовательно, находится в открытом доступе. Однако автор и NIST хотели бы получить кредит, если эта программа и документация или их части используются.
