ожидать - онлайн в облаке

ПРОГРАММА:

ИМЯ

ожидать - запрограммированный диалог с интерактивными программами, Версия 5

СИНТАКСИС

ожидать [ -дДинН ] [ -c команд ] [[ -[f|b]] командный файл ] [ арг ]

ВВЕДЕНИЕ

Ожидать это программа, которая «разговаривает» с другими интерактивными программами согласно сценарию.
Следуя сценарию, Ожидать знает, чего можно ожидать от программы и что
правильный ответ должен быть. Интерпретируемый язык обеспечивает ветвление и высокоуровневый
управляющие структуры для управления диалогом. Кроме того, пользователь может взять на себя управление и
при желании взаимодействовать напрямую, а затем возвращать управление скрипту.

Ожидать это смесь Ожидать и Tk. Он ведет себя так же, как Ожидать и Tk's желание. Ожидать
также может использоваться непосредственно в C или C ++ (то есть без Tcl). Видеть libexpect(3).

Название «Ожидайте» происходит от идеи отправить / ожидать последовательности, популяризированные uucp, kermit
и другие программы управления модемом. Однако в отличие от uucp, Ожидать обобщается так, что
может быть запущен как команда пользовательского уровня с учетом любой программы и задачи. Ожидать действительно может
разговаривать с несколькими программами одновременно.

Например, вот некоторые вещи Ожидать сможет сделать:

· Заставить ваш компьютер перезвонить вам, чтобы вы могли войти в систему, не платя за
звонок.

· Запустите игру (например, мошенник), и если оптимальная конфигурация не появится,
перезапускайте его (снова и снова), пока он не произойдет, затем передайте управление вам.

· Запустить fsck и в ответ на его вопросы ответить «да», «нет» или передать управление
вернуться к вам на основе заранее определенных критериев.

· Подключитесь к другой сети или BBS (например, MCI Mail, CompuServe) и
автоматически получать вашу почту, чтобы она выглядела так, как если бы она была изначально
отправлено в вашу локальную систему.

· Перенести переменные среды, текущий каталог или любую информацию
через rlogin, telnet, tip, su, chgrp и т. д.

Оболочка не может выполнять эти задачи по разным причинам. (Попробуй, ты
см.) Все возможно с Ожидать.

В общем, Ожидать полезен для запуска любой программы, которая требует взаимодействия между
программа и пользователь. Все, что необходимо, - это то, что взаимодействие может быть
охарактеризован программно. Ожидать также может вернуть пользователю контроль (без
остановка управляемой программы) при желании. Точно так же пользователь может вернуть управление
к сценарию в любое время.

ИСПОЛЬЗОВАНИЕ

Ожидать читает командный файл для списка команд для выполнения. Ожидать также может быть вызван
неявно в системах, поддерживающих #! обозначение исполняемого файла сценария, и
сделав первую строку в вашем скрипте:

#! / usr / bin / expect -f

Конечно, путь должен точно описывать, где Ожидать живет. / USR / бен это просто
пример.

The -c flag предваряет команду, которая должна быть выполнена перед любой в сценарии. Команда
следует указывать во избежание разрушения оболочкой. Эта опция может быть использована
многократно. Несколько команд могут быть выполнены с помощью одного -c разделив их
с точкой с запятой. Команды выполняются в порядке их появления. (При использовании Expectk,
эта опция указана как -команда.)

The -d флаг включает некоторый диагностический вывод, который в первую очередь сообщает о внутренней активности
такие команды, как ожидать и взаимодействовать. Этот флаг имеет тот же эффект, что и "exp_internal 1".
в начале сценария Expect плюс версия Ожидать печатается. (В Трассирование
команда полезна для отслеживания операторов, а прослеживать команда полезна для трассировки
присвоения переменных.) (При использовании Expectk этот параметр указывается как -диаг.)

The -D flag включает интерактивный отладчик. За ним должно следовать целочисленное значение. В
отладчик возьмет на себя управление перед следующей процедурой Tcl, если значение не равно нулю или если
^ C нажата (или достигнута точка останова, или другая соответствующая команда отладчика появляется в
сценарий). См. Файл README или СМОТРИ ТАКЖЕ (ниже) для получения дополнительной информации о
отладчик. (При использовании Expectk этот параметр указывается как -Отлаживать.)

The -f flag является предисловием к файлу, из которого следует читать команды. Сам флаг не обязателен
поскольку это полезно только при использовании #! обозначение (см. выше), так что другие аргументы могут
поставляться в командной строке. (При использовании Expectk этот параметр указывается как -файл.)

По умолчанию командный файл считывается в память и выполняется полностью. это
иногда желательно читать файлы по одной строке за раз. Например, stdin читается так
способ. Чтобы принудительно обрабатывать произвольные файлы таким образом, используйте -b флаг. (Когда
используя Expectk, этот параметр указывается как -буфер.)Вниманиекотораястдио-
буферизациимайвсе ещевзятьместооднакоэтой не должно вызывать проблем при чтении с FIFO или
стандартный ввод.

Если в качестве имени файла указана строка «-», вместо нее читается стандартный ввод. (Использовать "./-"
для чтения из файла с именем "-".)

The -i флаг причины Ожидать интерактивно запрашивать команды вместо их чтения
из файла. Подсказка прекращается через выход команда или по EOF. Видеть переводчик
(ниже) для получения дополнительной информации. -i предполагается, если ни командный файл, ни -c используется.
(При использовании Expectk этот параметр указывается как -интерактивный.)

-- может использоваться для ограничения конца опций. Это полезно, если вы хотите передать
аргумент вашего сценария, подобный параметру, без его интерпретации Ожидать, Это может
полезно поместить в #! строка, чтобы предотвратить любую подобную флагу интерпретацию со стороны Expect. За
пример, следующее оставит исходные аргументы (включая имя сценария) в
переменная ARGV.

#! / usr / bin / expect -

Обратите внимание, что обычный Getopt(3) и Execve(2) при добавлении
аргументы #! линия.

Файл $ exp_library / expect.rc загружается автоматически, если он присутствует, если только -N флаг
использовал. (При использовании Expectk этот параметр указывается как -НОРК.) Сразу после этого
файла ~ / .expect.rc загружается автоматически, если только -n флаг используется. Если
переменная окружения DOTDIR определена, она рассматривается как каталог, а .expect.rc - это
читать оттуда. (При использовании Expectk этот параметр указывается как -норк.) Этот источник
происходит только после выполнения любого -c флаги.

-v заставляет Expect напечатать номер своей версии и выйти. (Соответствующий флаг в
Expectk, использующий длинные имена флагов, - это -версия.)

По желанию арг составляются в список и хранятся в переменной с именем ARGV. ARGC is
инициализируется длиной argv.

argv0 определяется как имя сценария (или двоичный файл, если сценарий не используется). За
Например, следующее выводит имя сценария и первые три аргумента:

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

КОМАНДЫ

Ожидать использования Tcl (Инструментальный командный язык). Tcl обеспечивает поток управления (например, если для
break), оценка выражения и несколько других функций, таких как рекурсия, процедура
определение и т. д. Команды, используемые здесь, но не определенные (например, набор, if, Exec) являются Tcl
команды (см. TCL(3 г.)). Ожидать поддерживает дополнительные команды, описанные ниже. Пока не
в противном случае команды возвращают пустую строку.

Команды перечислены в алфавитном порядке, чтобы их можно было быстро найти. Однако новые
пользователям может быть проще начать с чтения описания порождать, Отправить, ожидать и
взаимодействовать, в этой последовательности.

Обратите внимание, что лучшее введение в язык (как Expect, так и Tcl) представлено в
книга "Exploring Expect" (см. ТАКЖЕ ниже). Примеры включены в эту справочную страницу, но
они очень ограничены, так как эта страница руководства предназначена в первую очередь как справочный материал.

Обратите внимание, что в тексте этой справочной страницы «Expect» с заглавной буквой «E» относится к
Ожидать программа, в то время как "ожидать" со строчной буквой "е" относится к ожидать команда в
Ожидать программа.)

Закрыть [-раб] [-онэкзек 0 | 1] [-я spawn_id]
закрывает соединение с текущим процессом. Большинство интерактивных программ обнаруживают
EOF на их стандартном вводе и выходе; таким образом Закрыть обычно достаточно, чтобы убить процесс, так как
Что ж. -i flag объявляет закрытие процесса в соответствии с указанным
spawn_id.

Оба формата ожидать и взаимодействовать обнаружит, когда текущий процесс завершится, и неявно
сделать Закрыть. Но если вы завершите процесс, скажем, "exec kill $ pid", вам нужно будет
явно называть Закрыть.

The -онэкзек флаг определяет, будет ли закрыт идентификатор спауна в любом новом порожденном
процессы или если процесс наложен. Чтобы оставить идентификатор спауна открытым, используйте значение
0. Ненулевое целочисленное значение приведет к закрытию респауна (по умолчанию) в любом новом
процессов.

The -раб flag закрывает подчиненное устройство, связанное с идентификатором спауна. (См. "Spawn -pty".)
Когда соединение закрывается, ведомое устройство также автоматически закрывается, если
открыть.

Независимо от того, закрыто ли соединение явно или неявно, вы должны вызвать
ждать чтобы очистить соответствующий слот процесса ядра. Закрыть не звонит ждать
поскольку нет гарантии, что закрытие технологического соединения приведет к его завершению.
Посмотреть ждать ниже для получения дополнительной информации.

отлаживать [[-в настоящее время] 0 | 1]
управляет отладчиком Tcl, позволяя выполнять инструкции, устанавливать точки останова,
и так далее

Без аргументов возвращается 1, если отладчик не запущен, в противном случае - 0.
вернулся.

С аргументом 1 запускается отладчик. С аргументом 0 отладчик
остановился. Если аргументу 1 предшествует -сейчас флаг, отладчик запущен
сразу (т. е. в середине отлаживать сама команда). В противном случае
отладчик запускается следующим оператором Tcl.

The отлаживать команда не меняет ловушек. Сравните это с запуском Expect с
-D флаг (см. выше).

См. Файл README или СМОТРИ ТАКЖЕ (ниже) для получения дополнительной информации об отладчике.

отключать
отключает разветвленный процесс от терминала. Он продолжает работать в
задний план. Процессу дается собственная группа процессов (если это возможно). Стандартный ввод / вывод
перенаправляется на / dev / null.

В следующем фрагменте используется отключать чтобы продолжить выполнение сценария в
фон.

если {[fork]! = 0} выход
отключать
. . .

Следующий сценарий считывает пароль, а затем каждый час запускает программу, которая
требует пароль при каждом запуске. Сценарий предоставляет пароль, чтобы
вам нужно набрать его только один раз. (См. стти команда, которая демонстрирует, как повернуть
выкл. повторение пароля.)

send_user "пароль? \"
ожидать_пользователь -re "(. *) \ п"
для {} 1 {} {
если {[fork]! = 0} {sleep 3600; continue}
отключать
создать priv_prog
ожидайте Пароль:
отправить "$ expect_out (1, строка) \ r"
. . .
выход
}

Преимущество использования отключать над функцией асинхронного процесса оболочки (&)
которая Ожидать может сохранять параметры терминала до отключения, а затем позже
применить их к новым ptys. С участием &, Ожидать не имеет возможности прочитать
параметры терминала, так как терминал уже отключен к моменту Ожидать
получает контроль.

выход [-опции] [положение дел]
Причины Ожидать выйти или иным образом подготовиться к этому.

The -один выход flag заставляет следующий аргумент использоваться как обработчик выхода. Без
аргумент, возвращается текущий обработчик выхода.

The -нет выхода флаг причины Ожидать подготовиться к выходу, но на самом деле остановиться
возвращение управления операционной системе. Пользовательский обработчик выхода запускается как
а также собственные внутренние обработчики Expect. Никаких дальнейших команд Expect не должно быть
выполнен. Это полезно, если вы используете Expect с другими расширениями Tcl. В
текущий интерпретатор (и главное окно, если в среде Tk) остаются так, чтобы другие
Расширения Tcl могут очищать. Если ожидать выход вызывается снова (однако это может
происходят), обработчики не запускаются повторно.

При выходе все подключения к порожденным процессам закрываются. Закрытие будет
определяется как EOF порожденными процессами. выход не предпринимает никаких других действий, кроме того, что
нормальная _выход(2) процедура. Таким образом, порожденные процессы, которые не проверяют
EOF может продолжать работать. (Для определения важны различные условия:
Например, какие сигналы будут отправлены порожденному процессу, но это системные
зависимый, обычно документируемый в выход(3).) Порожденные процессы, которые продолжают
run будет унаследован init.

статус (или 0, если не указано) возвращается как статус выхода Ожидать. выход is
неявно выполняется, если достигнут конец скрипта.

exp_continue [-continue_timer]
Команда exp_continue позволяет ожидать сам, чтобы продолжить выполнение, а не
возвращается, как обычно. По умолчанию exp_continue сбрасывает таймер тайм-аута.
The -continue_timer флаг предотвращает перезапуск таймера. (Видеть ожидать для большего
Информация.)

exp_internal [-ф файл] ценностное
заставляет дальнейшие команды посылать внутреннюю диагностическую информацию Ожидать к stderr
if ценностное не равно нулю. Этот выход отключен, если ценностное равно 0. Диагностика
информация включает в себя каждый полученный символ и каждую попытку сопоставить
текущий вывод по шаблонам.

Если необязательный файл поставляется, весь нормальный и отладочный вывод записывается в этот
файл (независимо от значения ценностное ). Любой предыдущий диагностический выходной файл
закрыты.

The -Информация флаг заставляет exp_internal возвращать описание самого последнего не-
данные аргументы приведены.

exp_open [аргументы] [-я spawn_id]
возвращает идентификатор файла Tcl, соответствующий исходному идентификатору порождения. Файл
идентификатор может затем использоваться, как если бы он был открыт Tcl открытый команда. (Спаун
id больше не следует использовать. А ждать не должны выполняться.

The -оставьте открытым флаг оставляет идентификатор спауна открытым для доступа через команды Expect. А
ждать должен выполняться по идентификатору спауна.

exp_pid [-я 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 [[-выход] версия]
полезен для проверки совместимости сценария с текущей версией
Ожидать.

Без аргументов текущая версия Ожидать возвращается. Эта версия может затем
быть закодированным в вашем сценарии. Если вы действительно знаете, что не используете функции
последние версии, вы можете указать более раннюю версию.

Версии состоят из трех цифр, разделенных точками. Во-первых, главное число.
Скрипты написаны для версий Ожидать с другим основным номером будет почти
конечно не получится. exp_version возвращает ошибку, если основные числа не совпадают.

Второй - второстепенный номер. Скрипты, написанные для версии с младшим младшим
число, чем текущая версия, может зависеть от какой-либо новой функции и может не работать.
exp_version возвращает ошибку, если основные числа совпадают, но младший номер скрипта
больше, чем у бега Ожидать.

В-третьих, это число, которое не играет никакой роли при сравнении версий. Однако это
увеличивается, когда Ожидать распространение программного обеспечения было изменено любым способом, например
дополнительная документация или оптимизация. Сбрасывается до 0 при каждом новом несовершеннолетнем
версия.

Достаточно воспользоваться ИИ-ассистентом презентера -выход флаг, Ожидать выводит сообщение об ошибке и завершает работу, если версия устарела.

ожидать [[-опции] pat1 тело1] ... [-опции] Патн [тело]
ожидает, пока один из шаблонов не совпадет с выводом порожденного процесса, указанного
истек период времени или виден конец файла. Если последнее тело пусто, оно
может быть опущено.

Выкройки из самых последних ожидать_перед неявно используются перед любыми
другие узоры. Выкройки из самых последних ожидаем_после команда неявно
используется после любых других шаблонов.

Если аргументы ко всему ожидать оператор требует более одной строки, все
аргументы могут быть объединены в один, чтобы не заканчивать каждую строку
обратная косая черта. В этом одном случае обычные замены Tcl будут происходить, несмотря на
подтяжки.

Если шаблон является ключевым словом ВФ, соответствующий орган исполняется по окончании работы.
файл. Если шаблон является ключевым словом Тайм-аут, соответствующий орган исполняется по
тайм-аут. Если ключевое слово тайм-аута не используется, неявное нулевое действие выполняется при
тайм-аут. По умолчанию период ожидания составляет 10 секунд, но его можно установить, например, на
30, командой «установить тайм-аут 30». Бесконечный тайм-аут может быть обозначен
значение -1. Если шаблон является ключевым словом по умолчанию, соответствующий орган выполняется
либо по таймауту, либо по окончании файла.

Если шаблон совпадает, выполняется соответствующее тело. ожидать возвращает
результат тела (или пустая строка, если шаблон не найден). В случае, если
совпадение нескольких шаблонов, тот, который появляется первым, используется для выбора тела.

Каждый раз, когда поступает новый результат, он сравнивается с каждым шаблоном в том порядке, в котором они находятся.
перечисленные. Таким образом, вы можете проверить отсутствие совпадения, составив последний шаблон
что-то обязательно появится, например, подсказка. В ситуациях, когда нет
Подскажите, вы должны использовать Тайм-аут (как если бы вы взаимодействовали вручную).

Узоры задаются тремя способами. По умолчанию шаблоны указаны как с
Tcl's string совпадение команда. (Такие шаблоны также похожи на обычные C-shell
выражения, обычно называемые "глобальными" шаблонами). В -гл флаг может быть использован
для защиты шаблонов, которые в противном случае могли бы совпадать ожидать флаги от этого. Любой
шаблон, начинающийся с "-", должен быть защищен таким образом. (Все строки начинаются
с "-" зарезервированы для будущих опций.)

Например, следующий фрагмент ищет успешный вход в систему. (Обратите внимание, что преждевременное прекращение
предполагается, что это процедура, определенная в другом месте сценария.)

ожидать {
занято {ставит занято \ п; exp_continue}
неудачное прерывание
"неверный пароль" отмена
прерывание тайм-аута
подключенный
}

В четвертом шаблоне кавычки необходимы, так как он содержит пробел, который
в противном случае отделите узор от действия. Выкройки с одинаковым действием (например,
как 3-й и 4-й) требуют повторного перечисления действий. Этого можно избежать, используя
шаблоны в стиле регулярных выражений (см. ниже). Дополнительная информация о формировании паттернов в виде глобусов
можно найти в руководстве по Tcl.

Шаблоны в стиле регулярных выражений следуют синтаксису, определенному Tcl RegExp (сокращение от «обычный
выражение ") команда. шаблоны регулярных выражений вводятся с помощью флага -re,
предыдущий пример можно переписать с использованием регулярного выражения как:

ожидать {
занято {ставит занято \ п; exp_continue}
-re "сбой | неверный пароль" отменить
прерывание тайм-аута
подключенный
}

Оба типа паттернов являются «незакрепленными». Это означает, что шаблоны не обязательно
соответствует всей строке, но может начинать и заканчивать сопоставление в любом месте строки (как
пока все остальное совпадает). Используйте ^ для соответствия началу строки и $
чтобы соответствовать концу. Обратите внимание: если вы не дожидаетесь конца строки, ваш
ответы могут легко оказаться в середине строки, поскольку они отражаются от
порожденный процесс. Несмотря на то, что результаты по-прежнему верны, результат может выглядеть
неестественно. Таким образом, рекомендуется использовать $, если вы можете точно описать символы
в конце строки.

Обратите внимание, что во многих редакторах символы ^ и $ соответствуют началу и концу строк.
соответственно. Однако, поскольку ожидаемое значение не ориентировано на строку, эти символы соответствуют
начало и конец данных (в отличие от строк) в настоящее время в ожидаемом
соответствующий буфер. (Также см. Примечание ниже о «несварении желудка».)

The -бывший флаг заставляет шаблон быть сопоставленным как "точная" строка. Нет
выполняется интерпретация *, ^ и т. д. (хотя обычные соглашения Tcl по-прежнему должны
соблюдать). Точные шаблоны всегда не закреплены.

The -без чехла флаг заставляет символы верхнего регистра вывода сравниваться, как если бы они
были строчными буквами. На узор не влияет.

При чтении вывода более 2000 байтов могут заставить более ранние байты быть
«забыл». Это можно изменить с помощью функции match_max, (Обратите внимание, что
слишком большие значения могут замедлить сопоставление с образцом.) Если список is
полный_буфер, соответствующее тело выполняется, если match_max байты были
получено, и никакие другие образцы не совпадают. Независимо от того, полный_буфер ключевое слово
, забытые символы записываются в expect_out (буфер).

If список ключевое слово нуль, и допускаются значения NULL (через Remove_nulls
команда), соответствующее тело выполняется, если совпадает единственный ASCII 0. это
невозможно сопоставить 0 байтов с помощью шаблонов glob или regexp.

При сопоставлении с шаблоном (или eof или full_buffer) любое сопоставление и ранее
несогласованный вывод сохраняется в переменной ожидать_out (буфер). До 9 регулярных выражений
совпадения подстрок сохраняются в переменных ожидать_out (1, строка) через
ожидать_out (9, строка), Если -индексы флаг используется перед паттерном, начальный
и конечные индексы (в форме, подходящей для Lrange) из 10 строк хранятся в
переменные ожидать_out (X, начало) и ожидать_out (X, конец) где X - цифра,
соответствует позиции подстроки в буфере. 0 относится к строкам, которые
соответствует всему шаблону и создается для шаблонов глобуса, а также для регулярного выражения
узоры. Например, если процесс произвел вывод «abcdefgh \ n», результат
о:

ожидать "cd"

как если бы были выполнены следующие операторы:

установить expect_out (0, строка) cd
установить expect_out (буфер) abcd

и "efgh \ n" остается в буфере вывода. Если процесс произвел вывод
"abbbcabkkkka \ n", результат:

ожидать -indices -re "b (b *). * (k +)"

как если бы были выполнены следующие операторы:

установить expect_out (0, начало) 1
установить expect_out (0, конец) 10
установить expect_out (0, строка) bbbcabkkkk
установить expect_out (1, начало) 2
установить expect_out (1, конец) 3
установить expect_out (1, строка) bb
установить expect_out (2, начало) 10
установить expect_out (2, конец) 10
установить expect_out (2, строка) k
установить expect_out (буфер) abbbcabkkkk

и "a \ n" остается в буфере вывода. Шаблон "*" (и -re ". *") Будет сброшен
буфер вывода без чтения вывода из процесса.

Обычно совпадающий вывод удаляется из внутренних буферов Expect. Это может
можно предотвратить, добавив к шаблону префикс -нет трансфера флаг. Этот флаг
особенно полезен при экспериментировании (для удобства может быть сокращен до "-not"
пока экспериментирую).

Идентификатор спауна, связанный с совпадающим выводом (или eof, или full_buffer), сохраняется.
in ожидать_out (spawn_id).

The -тайм-аут флаг заставляет текущую команду ожидать использовать следующее значение в качестве
тайм-аут вместо использования значения переменной тайм-аута.

По умолчанию шаблоны сопоставляются с выходными данными текущего процесса, однако
-i flag объявляет, что результат из указанного списка spawn_id будет сопоставлен с любым
следующие шаблоны (до следующего -i). Список spawn_id должен быть либо
разделенный пробелами список spawn_ids или переменная, относящаяся к такому списку
spawn_id.

Например, в следующем примере ожидается "подключено" от текущего процесса,
или "занято", "не удалось" или "неверный пароль" из spawn_id, названного $ proc2.

ожидать {
-i $ proc2 занято {ставит занято \ n; exp_continue}
-re "сбой | неверный пароль" отменить
прерывание тайм-аута
подключенный
}

Значение глобальной переменной любой_spawn_id может использоваться для сопоставления шаблонов с любым
spawn_ids, названные вместе со всеми другими -i флаги в текущем ожидать команда.
spawn_id из -i флаг без связанного шаблона (т. е. сразу за которым следует
другой -i) доступен для любых других шаблонов в том же ожидать команду
связанные с любой_spawn_id.

The -i flag также может называть глобальную переменную, и в этом случае переменная читается для
список идентификаторов спавна. Переменная перечитывается при каждом изменении. Это дает возможность
изменения источника ввода-вывода во время выполнения команды. Предоставляются идентификаторы появления
таким образом называются «косвенными» идентификаторами появления.

Такие действия, как перерыв и продолжать вызывают управляющие структуры (т. е. для, процесс), Чтобы
вести себя как обычно. Команда exp_continue позволяет ожидать сам продолжать
выполняется, а не возвращается, как обычно.

Это полезно для избежания явных циклов или повторяющихся операторов ожидания. В
Следующий пример является частью фрагмента для автоматизации rlogin. В exp_continue позволяет избегать
приходится писать второй ожидать оператор (чтобы снова найти подсказку), если
rlogin запрашивает пароль.

ожидать {
Пароль: {
стти-эхо
send_user "пароль (для $ user) на $ host:"
ожидать_пользователь -re "(. *) \ п"
send_user "\ n"
отправить "$ expect_out (1, строка) \ r"
эхо
exp_continue
} неверный {
send_user "неверный пароль или учетная запись \ n"
выход
} время ожидания {
send_user "время ожидания соединения с $ host истекло \ n"
выход
} конец {
отправить_пользователь \
"соединение с хостом не удалось: $ expect_out (буфер)"
выход
} -re $ prompt
}

Например, следующий фрагмент может помочь руководству пользователя во взаимодействии, которое
уже полностью автоматизирован. В этом случае терминал переводится в необработанный режим. Если
пользователь нажимает «+», значение переменной увеличивается. Если нажать "p", будет выполнено несколько возвратов.
отправлено в процесс, возможно, чтобы каким-то образом проткнуть его, а "i" позволяет пользователю взаимодействовать
с процессом, эффективно отнимая контроль у сценария. В каждом случае,
exp_continue позволяет текущему ожидать продолжить сопоставление с образцом после
выполнение текущего действия.

stty сырой -эхо
ожидать_после {
-i $ user_spawn_id
"p" {send "\ r \ r \ r"; exp_continue}
"+" {incr foo; exp_continue}
"я" {взаимодействовать; exp_continue}
"выйти" выход
}

По умолчанию exp_continue сбрасывает таймер тайм-аута. Таймер не перезапускается, если
exp_continue называется с -continue_timer флаг.

ожидаем_после [ожидаемые_аргументы]
работает идентично ожидать_перед за исключением того, что если образцы из обоих ожидать и
ожидаем_после может соответствовать, ожидать узор используется. Увидеть ожидать_перед команду
чтобы получить больше информации.

ожидаемый_фон [ожидаемые_аргументы]
принимает те же аргументы, что и ожидать, однако он возвращается немедленно. Выкройки
проверяется всякий раз, когда поступает новый ввод. Шаблон Тайм-аут и по умолчанию бессмысленны
в ожидаемый_фон и молча отбрасываются. В противном случае ожидаемый_фон
команда использует ожидать_перед и ожидаем_после шаблоны точно так же, как ожидать делает.

После появления ожидаемый_фон действия оцениваются, фоновая обработка для
тот же идентификатор спауна заблокирован. Фоновая обработка разблокируется, когда действие
завершает. Пока фоновая обработка заблокирована, можно выполнить
(На переднем плане) ожидать на том же идентификаторе респауна.

Невозможно выполнить ожидать в то время как ожидаемый_фон разблокирован.
ожидаемый_фон для определенного идентификатора спауна удаляется путем объявления нового
expect_background с тем же идентификатором спауна. Объявление ожидаемый_фон без
шаблон удаляет указанный идентификатор спауна из возможности сопоставления шаблонов в
фон.

ожидать_перед [ожидаемые_аргументы]
принимает те же аргументы, что и ожидать, однако он возвращается немедленно. Паттерн-действие
пары из самых последних ожидать_перед с тем же идентификатором спауна неявно добавляются
любому последующему ожидать команды. Если шаблон совпадает, он обрабатывается так, как если бы он
было указано в ожидать сама команда, а связанное с ней тело выполняется в
контекст ожидать команда. Если шаблоны из обоих ожидать_перед и ожидать
может соответствовать, ожидать_перед узор используется.

Если шаблон не указан, идентификатор спауна не проверяется на наличие шаблонов.

Если не отменено -i флаг, ожидать_перед шаблоны совпадают с идентификатором спауна
определено в то время, когда ожидать_перед команда была выполнена (не когда ее
шаблон совпадает).

Флаг -info вызывает ожидать_перед чтобы вернуть текущие характеристики того, что
шаблоны, которые он будет соответствовать. По умолчанию он сообщает о текущем идентификаторе спауна. An
необязательная спецификация идентификатора спауна может быть дана для информации об этом идентификаторе порождения. За
пример

expect_before -info -i $ proc

Может быть указано не более одного идентификатора спауна. Флаг-косвенно подавляет
прямые идентификаторы появления, которые поступают только из косвенных спецификаций.

Вместо указания идентификатора спауна флаг "-all" заставит "-info" сообщать о
все идентификаторы спауна.

Вывод флага -info можно повторно использовать в качестве аргумента функции expect_before.

ожидаемый_tty [ожидаемые_аргументы]
, как ожидать но он читает символы из / dev / tty (т.е. нажатия клавиш из
Пользователь). По умолчанию чтение выполняется в готовом режиме. Таким образом, строки должны заканчиваться на
возврат для ожидать чтобы увидеть их. Это можно изменить с помощью стти (См
стти команду ниже).

ожидаемый_пользователь [ожидаемые_аргументы]
, как ожидать но он считывает символы из стандартного ввода (т. е. нажатия клавиш пользователем).
По умолчанию чтение выполняется в готовом режиме. Таким образом, строки должны заканчиваться возвратом
Для того чтобы ожидать чтобы увидеть их. Это можно изменить с помощью стти (См стти команду
ниже).

вилка создает новый процесс. Новый процесс является точной копией текущего Ожидать
процесс. При успехе вилка возвращает 0 новому (дочернему) процессу и возвращает
Идентификатор процесса дочернего процесса родительского процесса. В случае отказа (обязательно в связи с
к нехватке ресурсов (например, места подкачки, памяти), вилка возвращает -1 родителю
процесс, и дочерний процесс не создается.

Разветвленные процессы выходят через выход команда, как и в исходном процессе. Раздвоенный
процессам разрешено писать в файлы журналов. Если вы не отключите отладку или
входя в большинство процессов, результат может сбивать с толку.

Некоторые реализации pty могут быть запутаны несколькими читателями и авторами, даже
мгновенно. Таким образом, безопаснее всего вилка перед нерестовыми процессами.

взаимодействовать [строка1 тело1] ... [строка [тело]]
дает пользователю контроль над текущим процессом, так что нажатия клавиш отправляются
текущий процесс, и возвращаются stdout и stderr текущего процесса.

Пары строка-тело могут быть указаны в качестве аргументов, и в этом случае тело выполняется
при вводе соответствующей строки. (По умолчанию строка не отправляется в
текущий процесс.) переводчик команда предполагается, если окончательное тело
пропавшими без вести.

Если аргументы ко всему взаимодействовать оператор требует более одной строки, все
аргументы могут быть объединены в один, чтобы не заканчивать каждую строку символом
обратная косая черта. В этом одном случае обычные замены Tcl будут происходить, несмотря на
подтяжки.

Например, следующая команда запускает взаимодействие со следующей строкой-телом
определены пары: при нажатии ^ Z, Ожидать приостановлено. (В -сброс настроек флаг восстанавливает
режимы терминала.) При нажатии ^ A пользователь видит «вы набрали Ctrl-A» и
процессу отправляется ^ A. При нажатии $ пользователь видит дату. Когда ^ C
нажата, Ожидать выходы. Если введено «foo», пользователь видит «bar». Когда ~~
нажал, Ожидать интерпретатор работает в интерактивном режиме.

установить CTRLZ \ 032
взаимодействовать {
-reset $ CTRLZ {exec kill -STOP [pid]}
\ 001 {send_user "вы набрали Ctrl-A \ n";
отправить "\ 001"
}
$ {send_user "Дата [формат часов [часы в секундах]]."}
\ 003 выход
фу {send_user "bar"}
~~
}

В парах строка-тело строки сопоставляются в том порядке, в котором они указаны в качестве аргументов.
Частично совпадающие строки не отправляются в текущий процесс в ожидании
остальное идет. Если затем вводятся символы, которые больше не могут
возможно совпадение, только часть строки будет отправлена ​​процессу, который
не может начать другой матч. Таким образом, строки, которые являются подстроками частичного
совпадения могут быть сопоставлены позже, если исходные строки, которые пытались сопоставить
в конечном итоге терпит неудачу.

По умолчанию соответствие строк является точным, без подстановочных знаков. (Напротив, ожидать
по умолчанию команда использует шаблоны в стиле глобуса.) -бывший флаг может использоваться для защиты
шаблоны, которые в противном случае могли бы совпадать взаимодействовать флаги от этого. Любой узор
начинающиеся с "-" должны быть защищены таким образом. (Все строки, начинающиеся с "-"
зарезервированы для будущих опций.)

The -re flag заставляет строку интерпретироваться как шаблон в стиле регулярного выражения. В этом
случае совпадающие подстроки хранятся в переменной взаимодействовать_аут аналогично
путь ожидать сохраняет свой вывод в переменной ожидаемый_выход, -индексы флаг
аналогично поддерживается.

Шаблон ВФ вводит действие, которое выполняется при конце файла. Отдельный
ВФ шаблон может также следовать -выход флаг, и в этом случае он совпадает, если eof
обнаруживается при записи вывода. По умолчанию ВФ действие "возврат", так что
взаимодействовать просто возвращается при любом EOF.

Шаблон Тайм-аут вводит тайм-аут (в секундах) и действие, которое выполняется
после того, как ни один символ не был прочитан в течение заданного времени. В Тайм-аут шаблон применяется к
самый последний указанный процесс. Таймаута по умолчанию нет. Специальный
переменная "тайм-аут" (используется ожидать command) не влияет на этот тайм-аут.

Например, следующий оператор может использоваться для автоматического выхода пользователей, которые не
в течение часа набирал что угодно, но все равно получает частые системные сообщения:

interact -input $ user_spawn_id тайм-аут 3600 return -output \
$ spawn_id

Если шаблон является ключевым словом нуль, и допускаются значения NULL (через Remove_nulls
команда), соответствующее тело выполняется, если совпадает единственный ASCII 0. это
невозможно сопоставить 0 байтов с помощью шаблонов glob или regexp.

Предоставление выкройки с флагом -я пишу вызывает переменную interact_out (spawn_id)
должен быть установлен в spawn_id, который соответствует шаблону (или eof).

Такие действия, как перерыв и продолжать вызывают управляющие структуры (т. е. для, процесс), Чтобы
вести себя как обычно. тем не мение возвращают заставляет взаимодействовать, чтобы вернуться к его вызывающему,
в то время как интер_возврат Причины взаимодействовать чтобы вызвать возврат в вызывающей стороне. Например, если
"proc foo" называется взаимодействовать который затем выполнил действие интер_возврат, процесс Foo
вернется. (Это означает, что если взаимодействовать призывы переводчик интерактивный набор текста
возвращают вызовет продолжение взаимодействия, а интер_возврат приведет к тому,
взаимодействовать, чтобы вернуться к вызывающему.)

Во время взаимодействоватьиспользуется необработанный режим, поэтому все символы могут быть переданы в
текущий процесс. Если текущий процесс не улавливает сигналы управления заданиями, он
остановить, если отправлен сигнал остановки (по умолчанию ^ Z). Чтобы перезапустить его, отправьте сигнал продолжения
(например, "kill -CONT "). Если вы действительно хотите отправить сигнал SIGSTOP на такой
процесса (с помощью ^ Z), сначала рассмотрите возможность создания csh, а затем запуска вашей программы. На
с другой стороны, если вы хотите отправить сигнал SIGSTOP на Ожидать сам, первый вызов переводчика
(возможно, используя escape-символ), а затем нажмите ^ Z.

Пары строка-тело можно использовать как сокращение, чтобы избежать необходимости вводить
интерпретатор и интерактивно выполнять команды. Используется предыдущий режим терминала
пока выполняется тело пары струна-тело.

Для скорости действия по умолчанию выполняются в необработанном режиме. В -сброс настроек флаг сбрасывает
терминал в режим, который был раньше взаимодействовать был выполнен (всегда готовый режим).
Обратите внимание, что символы, введенные при переключении режима, могут быть потеряны (значок
досадная особенность драйвера терминала на некоторых системах). Единственная причина использовать
-сброс настроек если ваше действие зависит от работы в приготовленном режиме.

The -эхо flag отправляет символы, соответствующие следующему шаблону, обратно в процесс
которые генерировали их при чтении каждого символа. Это может быть полезно, когда пользователь
необходимо видеть обратную связь от частично типизированных шаблонов.

Если шаблон воспроизводится эхом, но в конечном итоге не соответствует, символы отправляются
порожденному процессу. Если порожденный процесс повторяет их, пользователь увидит
персонажи дважды. -эхо вероятно только уместно в ситуациях, когда
пользователь вряд ли завершит выкройку. Например, следующий отрывок
из rftp, сценарий рекурсивного ftp, в котором пользователю предлагается ввести ~ g, ~ p или
~ l, чтобы рекурсивно получить, поместить или перечислить текущий каталог. Это так далеко
из обычных команд ftp, пользователь вряд ли наберет ~ с последующим
что-нибудь еще, кроме ошибки, и в этом случае они, вероятно, просто проигнорируют
результат в любом случае.

взаимодействовать {
-echo ~ g {getcurdirectory 1}
-echo ~ l {getcurdirectory 0}
-echo ~ p {putcurdirectory}
}

The -нобуфер flag отправляет символы, соответствующие следующему шаблону, на
процесс вывода по мере чтения символов.

Это полезно, когда вы хотите, чтобы программа отображала шаблон. Например,
следующее может быть использовано для отслеживания того, куда набирает абонент (в стиле Хейса
модем). Каждый раз, когда отображается "atd", сценарий записывает оставшуюся часть строки.

номер журнала процедуры {} {
взаимодействовать -nobuffer -re "(. *) \ r" return
помещает $ log "[формат часов [часы в секундах]]: набранный $ interact_out (1, строка)"
}

взаимодействовать -nobuffer "atd" номер журнала

Во время взаимодействовать, предыдущее использование log_user игнорируется. Особенно, взаимодействовать предусматривает
принудительно регистрировать свой вывод (отправлять на стандартный вывод), поскольку предполагается, что
пользователь не желает взаимодействовать вслепую.

The -o флаг приводит к применению любых следующих пар ключ-тело к выходным данным
текущий процесс. Это может быть полезно, например, при работе с хостами, которые отправляют
нежелательные символы во время сеанса Telnet.

По умолчанию взаимодействовать ожидает, что пользователь будет писать stdin и читать stdout
Ожидать сам процесс. В -u флаг (для "пользователя") делает взаимодействовать ищите пользователя как
процесс, названный своим аргументом (который должен быть порожденным идентификатором).

Это позволяет объединить два несвязанных процесса без использования явного
петля. Чтобы помочь в отладке, диагностика Expect всегда отправляется на stderr (или stdout для
определенная информация для регистрации и отладки). По той же причине переводчик
команда будет читать в интерактивном режиме из стандартного ввода.

Например, следующий фрагмент создает процесс входа в систему. Затем он набирает пользователя
(не показано) и, наконец, соединяет их вместе. Конечно, любой процесс может быть
заменен на логин. Оболочка, например, позволит пользователю работать без
предоставление учетной записи и пароля.

создать логин
установить логин $ spawn_id
модем с подсказкой
# обратный вызов пользователю
# подключаем пользователя к логину
взаимодействовать -u $ войти

Чтобы отправить вывод нескольким процессам, перечислите каждый список идентификаторов респауна с префиксом -выход
флаг. Вход для группы выходных идентификаторов появления может быть определен списком идентификаторов появления.
предваряется -вход флаг. (Оба -вход и -выход может принимать списки в той же форме
как -i флаг в ожидать команда, за исключением того, что any_spawn_id не имеет смысла в
взаимодействовать.) Все следующие флаги и строки (или шаблоны) применяются к этому входу до тех пор, пока
появляется другой флаг -вход. Если нет -вход появляется, -выход подразумевает "-ввод
$ user_spawn_id -output ". (Точно так же с шаблонами, у которых нет -вход.) Если
one -вход указан, он переопределяет $ user_spawn_id. Если второй -вход is
указано, он переопределяет $ spawn_id. Дополнительный -вход могут быть указаны флаги.

Два подразумеваемых процесса ввода по умолчанию имеют выходные данные, указанные как
$ spawn_id и $ user_spawn_id (в обратном порядке). Если -вход флаг появляется без -выход
флаг, символы из этого процесса отбрасываются.

The -i flag вводит замену для текущего spawn_id, когда нет других -вход
or -выход используются флаги. Флаг -i подразумевает флаг -o.

Можно изменить процессы, с которыми происходит взаимодействие, используя
непрямые идентификаторы респауна. (Косвенные идентификаторы появления описаны в разделе, посвященном ожидаемому
Непрямые идентификаторы появления могут быть указаны с помощью -i, -u, -input или -output.
флаги.

переводчик [аргументы]
заставляет пользователя интерактивно запрашивать Ожидать и команды Tcl. В
печатается результат каждой команды.

Такие действия, как перерыв и продолжать вызывают управляющие структуры (т. е. для, процесс), Чтобы
вести себя как обычно. тем не мение возвращают заставляет интерпретатор возвращаться к вызывающему,
в то время как интер_возврат Причины переводчик чтобы вызвать возврат в вызывающей стороне. Например,
если вызывается "proc foo" переводчик который затем выполнил действие интер_возврат, процесс
Foo вернется. Любая другая команда вызывает переводчик продолжать запрашивать
новые команды.

По умолчанию приглашение содержит два целых числа. Первое целое число описывает глубину
оценочного стека (т.е. сколько раз был вызван Tcl_Eval). Секунда
целое число - идентификатор истории Tcl. Приглашение может быть установлено путем определения
процедура с именем «prompt1», возвращаемое значение которой становится следующим приглашением. Если
оператор имеет открытые кавычки, скобки, фигурные скобки или квадратные скобки, вторичное приглашение (по
по умолчанию "+>") выдается после перевода строки. Дополнительную подсказку можно установить, указав
процедура под названием «prompt2».

Во время переводчик, готовый режим используется, даже если его вызывающий абонент использовал необработанный режим.

Если stdin закрыт, переводчик вернется, если -еоф используется флаг, в котором
случае вызывается последующий аргумент.

журнальный файл [аргументы] [[-а] файл]
Если указано имя файла, журнальный файл запишет стенограмму сеанса
(начиная с этого места) в файле. журнальный файл прекратит запись, если нет аргументов
дано. Все предыдущие файлы журнала закрываются.

Вместо имени файла можно указать идентификатор файла Tcl, используя -открыть or
-оставьте открытым флаги. Это похоже на порождать команда. (Видеть порождать для получения дополнительной информации.)

The -a флаг заставляет регистрировать вывод, который был подавлен log_user команда.

По умолчанию, журнальный файл команду добавляет к старым файлам вместо их усечения,
для удобства включения и выключения выхода из системы несколько раз за один
сеанс. Чтобы обрезать файлы, используйте -нет добавления флаг.

The -Информация флаг заставляет log_file возвращать описание самого последнего неинформационного
приводятся аргументы.

log_user -info | 0 | 1
По умолчанию диалог отправки / ожидания регистрируется в stdout (и в файле журнала, если он открыт).
Запись в стандартный вывод отключена командой "log_user 0" и снова включена
"log_user 1". Запись в файл журнала не изменилась.

The -Информация флаг заставляет log_user возвращать описание самого последнего неинформационного
приводятся аргументы.

match_max [-д] [-я spawn_id] [размер]
определяет размер буфера (в байтах), используемого внутри ожидать. Без размер
аргумент, возвращается текущий размер.

Достаточно воспользоваться ИИ-ассистентом презентера -d флаг установлен размер по умолчанию. (Начальное значение по умолчанию - 2000.)
-i флаг, размер устанавливается для именованного идентификатора спауна, в противном случае он устанавливается для текущего
процесса.

наложение [- # spawn_id] [- # spawn_id] [...] программа [аргументы]
исполняет программа арг вместо нынешнего Ожидать программа, которая завершается. А
Аргумент голого дефиса заставляет ставить дефис перед именем команды, как если бы это был
оболочка входа в систему. Все spawn_id закрыты, кроме тех, которые указаны как аргументы. Эти
отображаются на именованные идентификаторы файлов.

Spawn_ids сопоставляются с идентификаторами файлов, которые должна наследовать новая программа. За
Например, следующая строка запускает шахматы и позволяет им управлять текущим
процесс - скажем, шахматный мастер.

оверлей -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id шахматы

Это более эффективно, чем "interact -u", однако приносит в жертву возможность делать
запрограммированное взаимодействие с Ожидать процесс больше не контролируется.

Обратите внимание, что управляющий терминал не предусмотрен. Таким образом, если вы отключите или переназначите
стандартный ввод, программы, которые управляют заданиями (оболочки, логин и т. д.), не будут работать
должным образом.

соотношение [-д] [-я spawn_id] [ценить]
определяет, должна ли четность сохраняться или удаляться из вывода порожденного
процессы. Если ценностное равен нулю, четность удаляется, в противном случае она не удаляется.
С нет ценностное аргумент, возвращается текущее значение.

Достаточно воспользоваться ИИ-ассистентом презентера -d флаг устанавливается значение четности по умолчанию. (Начальное значение по умолчанию - 1, т. Е.
паритет не урезан.) -i флаг, значение четности устанавливается для названного
id спауна, иначе он устанавливается для текущего процесса.

Remove_nulls [-д] [-я spawn_id] [ценить]
определяет, будут ли нули сохраняться или удаляться из вывода порожденных процессов
перед сопоставлением с образцом или сохранением в переменной ожидаемый_выход or взаимодействовать_аут. Если
ценностное равно 1, нули удаляются. Если ценностное равно 0, нули не удаляются. Без ценностное
аргумент, возвращается текущее значение.

Достаточно воспользоваться ИИ-ассистентом презентера -d флаг устанавливается значение по умолчанию. (Начальное значение по умолчанию - 1, т. Е. Нули
удалены.) -i флаг, значение устанавливается для именованного идентификатора спауна, в противном случае
он установлен для текущего процесса.

Независимо от того, удаляются ли нули, Ожидать будет записывать нулевые байты в журнал и
стандартный вывод.

Отправить [-флаги] string
Посылает string к текущему процессу. Например, команда

отправить "привет мир \ r"

отправляет персонажей, привет Мир к текущему процессу.
(Tcl включает команду, подобную printf (называемую формат) которые можно строить произвольно
сложные строки.)

Символы отправляются немедленно, хотя программы с строчной буферизацией ввода не будут
читать символы, пока не будет отправлен символ возврата. Обозначается символ возврата
"\р".

The -- флаг заставляет следующий аргумент интерпретироваться как строка, а не как
флаг. Любой строке может предшествовать знак "-" независимо от того, выглядит ли она на самом деле как
флаг. Это обеспечивает надежный механизм для указания переменных строк без необходимости
споткнулся о те, которые случайно выглядят как флаги. (Все строки, начинающиеся с
«-» зарезервированы для будущих опций.)

The -i flag объявляет, что строка будет отправлена ​​на указанный spawn_id. Если spawn_id
is user_spawn_id, а терминал находится в необработанном режиме, новые строки в строке
переведены в последовательности возврата-новой строки, чтобы они выглядели так, как если бы терминал находился в
приготовленный режим. В -сырой флаг отключает этот перевод.

The -нулевой flag отправляет нулевые символы (0 байт). По умолчанию отправляется один ноль. An
целое число может следовать за -нулевой чтобы указать, сколько нулей нужно отправить.

The -перерыв flag генерирует условие прерывания. Это имеет смысл, только если идентификатор спауна
относится к tty-устройству, открытому с помощью команды «spawn -open». Если вы породили такой процесс
в качестве подсказки вы должны использовать конвенцию подсказки для создания перерыва.

The -s флаг заставляет вывод отправляться "медленно", таким образом избегая общей ситуации, когда
компьютер превосходит входной буфер, который был разработан для человека, который никогда не
из того же буфера. Этот вывод контролируется значением переменной
send_slow, который принимает список из двух элементов. Первый элемент - это целое число, которое
описывает количество байтов для атомарной отправки. Второй элемент - настоящий
число, которое описывает количество секунд, на которое должны быть отправлены атомарные отправления.
разделены. Например, "set send_slow {10 .001}" заставит "send -s" отправить
строки с интервалом в 1 миллисекунду между каждыми 10 отправленными символами.

The -h flag заставляет вывод быть посланным (что-то вроде), как будто человек набирает текст.
Между персонажами появляются человеческие задержки. (Алгоритм основан на
Распределение Вейбулла с модификациями для этого конкретного приложения.)
вывод контролируется значением переменной send_human, которая принимает пять
список элементов. Первые два элемента - это среднее время прибытия персонажей в
секунд. По умолчанию используется первый. Второй используется в окончании слов, чтобы
имитируйте тонкие паузы, которые иногда возникают при таких переходах. Третий
параметр - это мера изменчивости, где .1 - довольно переменная, 1 - разумная
переменная, а 10 вполне неизменна. Крайние значения от 0 до бесконечности. Последние два
параметры - соответственно минимальное и максимальное время между прибытиями. Минимум
и максимальное используются в последний раз, а «клип» - в последний раз. Конечное среднее значение может быть
сильно отличается от заданного среднего, если минимального и максимального клипа достаточно
значения.

В качестве примера следующая команда имитирует работу быстрого и последовательного машинистки:

установить send_human {.1 .3 1 .05 2}
send -h «Я голоден. Давай пообедаем».

а после похмелья могут быть более подходящими:

установить send_human {.4 .4 .2 .5 100}
send -h "Хорошая вечеринка, ночь!"

Обратите внимание, что ошибки не моделируются, хотя вы можете настроить исправление ошибок.
ситуации сами, вставляя ошибки и исправления в аргумент отправки.

Флаги для отправки нулевых символов, для отправки пауз, для принудительного медленного вывода
и для вывода в человеческом стиле являются взаимоисключающими. Только один указанный последний будет
использоваться. Кроме того, нет string аргумент может быть указан с флагами для отправки
нулевые символы или разрывы.

Хорошая идея - предшествовать первому Отправить к процессу ожидать. ожидать предусматривает
дождитесь начала процесса, пока Отправить не может. В частности, если первый Отправить
завершается до запуска процесса, вы рискуете получить свои данные
игнорируется. В ситуациях, когда интерактивные программы не предлагают начального запроса, вы можете
предшествовать Отправить с задержкой, как в:

# Чтобы не давать хакерам подсказок о том, как взломать,
# эта система не запрашивает внешний пароль.
# Подождите 5 секунд, пока exec завершится
создать telnet very.secure.gov
спать 5
отправить пароль \ r

exp_send это псевдоним для Отправить. Если вы используете Expectk или другой вариант
Ожидайте в среде Tk, Отправить определяется Tk для совершенно другого
цель. exp_send предоставляется для совместимости между средами. Похожий
псевдонимы предоставляются для других команд отправки Expect.

send_error [-флаги] string
, как Отправить, за исключением того, что вывод отправляется на stderr, а не на текущий
процесса.

send_log [-] string
, как Отправить, за исключением того, что строка отправляется только в файл журнала (см. журнальный файл.)
Аргументы игнорируются, если файл журнала не открыт.

send_tty [-флаги] string
, как Отправить, за исключением того, что вывод отправляется в / dev / tty, а не в текущий
процесса.

send_user [-флаги] string
, как Отправить, за исключением того, что вывод отправляется на стандартный вывод, а не на текущий
процесса.

спать секунды
заставляет скрипт засыпать на заданное количество секунд. Секунды могут быть
десятичное число. Прерывания (и события Tk, если вы используете Expectk) обрабатываются
пока ожидаешь спит.

порождать [аргументы] программа [аргументы]
создает новый запущенный процесс программа арг. Его stdin, stdout и stderr:
связаны с Expect, так что они могут быть прочитаны и записаны другими Ожидать команды.
Связь разорвана Закрыть или если сам процесс закрывает какой-либо файл
идентификаторы.

Когда процесс запускается порождатьпеременная spawn_id устанавливается в дескриптор
ссылаясь на этот процесс. Процесс, описанный spawn_id считается
текущий процесс. spawn_id могут быть прочитаны или записаны, что фактически обеспечивает управление заданиями.

user_spawn_id - глобальная переменная, содержащая дескриптор, относящийся к пользователю.
Например, когда spawn_id установлено на это значение, ожидать ведет себя как ожидаемый_пользователь.

error_spawn_id - глобальная переменная, содержащая дескриптор, который относится к
стандартная ошибка. Например, когда spawn_id установлено на это значение, Отправить ведет себя как
send_error.

tty_spawn_id - глобальная переменная, содержащая дескриптор, относящийся к / dev / tty.
Если / dev / tty не существует (например, в cron, at или пакетном скрипте), тогда
tty_spawn_id не определено. Это можно проверить как:

если {[info vars tty_spawn_id]} {
# / dev / tty существует
} Еще {
# / dev / tty не существует
# возможно в cron, batch или в скрипте
}

порождать возвращает идентификатор процесса UNIX. Если процесс не порожден, возвращается 0. В
переменная spawn_out (раб, имя) устанавливается на имя ведомого устройства pty.

По умолчанию порождать повторяет имя команды и аргументы. В -ноэхо флаг останавливается
порождать от этого.

The -приставка Флаг перенаправляет вывод консоли на порожденный процесс.
Это поддерживается не во всех системах.

Внутри порождать использует pty, инициализированный так же, как и tty пользователя. Это
далее инициализируется так, чтобы все настройки были "вменяемыми" (согласно стти(1)). Если
переменная stty_init определен, он интерпретируется в стиле аргументов stty как
дальнейшая настройка. Например, "set stty_init raw" вызовет дальнейшее создание
терминалы процессов для запуска в необработанном режиме. -некопия пропускает инициализацию
на основе tty пользователя. -nottyinit пропускает "вменяемую" инициализацию.

Как правило, порождать требуется немного времени для выполнения. Если вы заметили, что спаун принимает
В течение значительного времени он, вероятно, сталкивается с заклиниванием ptys. А
количество тестов, запускаемых на ptys, чтобы избежать путаницы с ошибочными процессами.
(Это занимает 10 секунд на каждый клиновидный элемент). -d вариант покажет
if Ожидать сталкивается со многими пациентами в нечетных состояниях. Если вы не можете убить процессы
к которому прикреплены эти ptys, единственным выходом может быть перезагрузка.

If программа не может быть успешно порожден, потому что Exec(2) терпит неудачу (например, когда программа
не существует), сообщение об ошибке будет возвращено следующим взаимодействовать or ожидать
команда как будто программа был запущен и выдал сообщение об ошибке в качестве вывода. Этот
поведение является естественным следствием реализации порождать. Внутренне, нерест
вилки, после которых порожденный процесс не имеет возможности общаться с исходным
Ожидать процесс, кроме связи через spawn_id.

The -открыть флаг заставляет следующий аргумент интерпретироваться как идентификатор файла Tcl
(т. е. возвращено открытый.) Идентификатор спауна затем можно использовать, как если бы это был порожденный
процесс. (Идентификатор файла больше не должен использоваться.) Это позволяет обрабатывать необработанные
устройства, файлы и конвейеры как порожденные процессы без использования pty. 0 это
возвращается, чтобы указать, что связанный процесс отсутствует. Когда подключение к
порожденный процесс закрыт, как и идентификатор файла Tcl. В -оставьте открытым флаг
похож на -открыть Кроме этого -оставьте открытым заставляет идентификатор файла оставаться открытым
даже после закрытия идентификатора спауна.

The -пти flag вызывает открытие pty, но не порождает процесс. 0 возвращается в
указывают на отсутствие связанного процесса. Spawn_id устанавливается как обычно.

Переменная spawn_out (раб, fd) установлен на идентификатор файла, соответствующий
pty slave. Его можно закрыть с помощью "close -slave".

The -игнорировать flag называет сигнал, который нужно игнорировать в порожденном процессе. В противном случае,
сигналы получают поведение по умолчанию. Сигналы обозначаются как в ловушка команда, кроме
что каждый сигнал требует отдельного флага.

Трассирование уровень
заставляет напечатать следующие операторы перед выполнением. (След Tcl
команда отслеживает переменные.) уровень указывает, насколько глубоко в стеке вызовов нужно отслеживать.
Например, следующая команда запускается Ожидать при отслеживании первых 4 уровней
звонки, но ни одного ниже.

ожидать -c "strace 4" script.exp

The -Информация флаг заставляет strace возвращать описание самого последнего неинформационного
приводятся аргументы.

стти арг
изменяет режимы терминала аналогично внешней команде stty.

По умолчанию осуществляется доступ к управляющему терминалу. Доступны другие терминалы
добавив к команде "</ dev / tty ...". (Обратите внимание, что аргументы не должны быть
сгруппированы в один аргумент.)

Запросы статуса возвращают его как результат выполнения команды. Если нет статуса
запрашивается и осуществляется доступ к управляющему терминалу, предыдущий статус необработанного
и атрибуты эха возвращаются в форме, которая позже может быть использована командой.

Например, аргументы сырье or -приготовленный перевести терминал в необработанный режим. В
Аргументы -сырой or приготовленный перевести терминал в режим приготовления. Аргументы эхо и
-эхо перевести терминал в режим эха и без эха соответственно.

В следующем примере показано, как временно отключить эхо. Это должно быть
используется в автоматических скриптах, чтобы избежать встраивания в них паролей. (Узнать больше
обсуждение этого в разделе «ЖДИТЕ НАМЕТКИ» ниже.)

стти-эхо
send_user "Пароль:"
ожидать_пользователь -re "(. *) \ п"
установить пароль $ expect_out (1, строка)
эхо

система арг
дает арг в sh(1) в качестве ввода, как если бы он был набран как команда из
Терминал. Ожидать ждет, пока оболочка не завершится. Статус возврата из sh:
обрабатывается так же, как Exec обрабатывает свой статус возврата.

В отличие от Exec который перенаправляет stdin и stdout в скрипт, система выполняет
нет перенаправления (кроме указанного в самой строке). Таким образом, это
можно использовать программы, которые должны напрямую взаимодействовать с / dev / tty. По той же причине,
результат система не записываются в журнал.

отметка времени [аргументы]
возвращает отметку времени. Без аргументов количество секунд с начала эпохи равно
вернулся.

The -формат flag вводит строку, которая возвращается, но с выполненными заменами
согласно правилам POSIX для strftime. Например,% 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.

The -секунды флаг вводит количество секунд с начала эпохи, которое будет использоваться в качестве
источник, из которого нужно форматировать. В противном случае используется текущее время.

The -время по Гринвичу флаг заставляет вывод метки времени использовать часовой пояс GMT. Без флага
используется местный часовой пояс.

ловушка [[команда] сигналы]
вызывает данный команду должно быть выполнено при получении в будущем любого из указанных
сигналы. Команда выполняется в глобальном масштабе. Если команду отсутствует,
сигнальное действие возвращается. Если команду это строка SIG_IGN, сигналы
игнорируется. Если команду это строка SIG_DFL, сигналы передаются в систему
по умолчанию. сигналы либо одиночный сигнал, либо список сигналов. Сигналы могут быть
указано численно или символически согласно сигнал(3). Префикс "SIG" может быть
опущено.

Без аргументов (или аргумента -число), ловушка возвращает номер сигнала
команда trap, выполняемая в данный момент.

The -код flag использует код возврата команды вместо того кода, который был в Tcl.
собирается вернуться, когда команда изначально начала выполняться.

The -интерп флаг заставляет команду быть оцененной с использованием интерпретатора, активного в
время начала выполнения команды, а не время объявления прерывания.

The -имя флаг вызывает ловушка команда для возврата имени сигнала команды прерывания
в настоящее время выполняется.

The -Максимум флаг вызывает ловушка команда, чтобы вернуть наибольший номер сигнала, который может
быть установленным

Например, команда trap {send_user "Ой!"} SIGINT напечатает "Ой!" каждый
время, когда пользователь нажимает ^ C.

По умолчанию SIGINT (который обычно может быть сгенерирован нажатием ^ C) и SIGTERM вызывают
Ожидайте выхода. Это связано со следующей ловушкой, созданной по умолчанию, когда Expect
начинается.

выход из ловушки {SIGINT SIGTERM}

Если вы используете флаг -D для запуска отладчика, SIGINT переопределяется для запуска
интерактивный отладчик. Это связано со следующей ловушкой:

ловушка {exp_debug 1} SIGINT

Ловушку отладчика можно изменить, установив переменную среды
EXPECT_DEBUG_INIT на новую команду прерывания.

Вы можете, конечно, переопределить оба из них, просто добавив команды ловушки в свой
сценарий. В частности, если у вас есть собственный «сигнал выхода из ловушки», это переопределит
ловушка отладчика. Это полезно, если вы хотите, чтобы пользователи не попадали в
отладчик вообще.

Если вы хотите определить свою собственную ловушку для SIGINT, но по-прежнему перехватываете отладчик, когда он
работает, используйте:

если {! [exp_debug]} {trap mystuff SIGINT}

В качестве альтернативы вы можете перехватить отладчик с помощью другого сигнала.

ловушка не позволит вам переопределить действие для SIGALRM, поскольку это используется внутри для
Ожидать. Команда отключения устанавливает для SIGALRM значение SIG_IGN (игнорировать). Вы можете повторно включить
это до тех пор, пока вы отключите его во время последующих команд появления.

Посмотреть сигнал(3) для получения дополнительной информации.

ждать [аргументы]
задерживается до завершения порожденного процесса (или текущего процесса, если ни один не назван).

ждать обычно возвращает список из четырех целых чисел. Первое целое число - это идентификатор
процесс, которого ждали. Второе целое число - это соответствующий идентификатор спауна.
Третье целое число равно -1, если произошла ошибка операционной системы, или 0 в противном случае. Если
третье целое число было 0, четвертое целое число - это статус, возвращаемый порожденным
процесс. Если третье целое число было -1, четвертое целое число является значением установленной ошибки.
операционной системой. Также устанавливается глобальная переменная errorCode.

Дополнительные элементы могут появиться в конце возвращаемого значения из ждать.
необязательный пятый элемент определяет класс информации. В настоящее время единственный
возможное значение для этого элемента CHILDKILLED, и в этом случае следующие два значения
имя сигнала в стиле C и краткое текстовое описание.

The -i flag объявляет, что процесс ожидает, соответствующий названному spawn_id (НЕ
идентификатор процесса). Внутри обработчика SIGCHLD можно дождаться любого порожденного
процесс с использованием идентификатора спауна -1.

The -Нет, подождите флаг заставляет ожидание немедленно вернуться с указанием
Успешное ожидание. Когда процесс завершится (позже), он автоматически исчезнет
без необходимости явного ожидания.

The ждать команда также может использоваться для ожидания разветвленного процесса, используя аргументы "-i"
-1 ". В отличие от порожденных процессов, эта команда может быть выполнена в любом
время. Нет контроля над тем, какой процесс будет получен. Однако возвращаемое значение
можно проверить по идентификатору процесса.

БИБЛИОТЕКИ

Expect автоматически знает о двух встроенных библиотеках для сценариев Expect. Эти
определяется каталогами, указанными в переменных exp_library и exp_exec_library. Оба
предназначены для хранения служебных файлов, которые могут использоваться другими сценариями.

exp_library содержит файлы, не зависящие от архитектуры. exp_exec_library содержит
файлы, зависящие от архитектуры. В зависимости от вашей системы оба каталога могут быть полностью
пустой. Существование файла $ exp_exec_library / cat-buffers описывает, есть ли у вас
/ bin / cat буферы по умолчанию.

ПЕЧАТЬ

Для красивой печати доступно определение vgrind. Ожидать скрипты. Предполагая, что vgrind
определение, предоставленное с Ожидать дистрибутив установлен правильно, его можно использовать


vgrind -lexpect файл

ПРИМЕРЫ

Для многих не очевидно, как собрать все, что описано на странице руководства. я
рекомендую вам прочитать и опробовать примеры в каталоге примеров Ожидать
распределение. Некоторые из них - настоящие программы. Другие просто иллюстрируют определенные
техники и, конечно же, парочка быстрых приемов. Файл INSTALL имеет быстрое
обзор этих программ.

The Ожидать документы (см. ТАКЖЕ) также полезны. Хотя в некоторых статьях используется синтаксис
соответствующие более ранним версиям Expect, сопутствующие обоснования остаются в силе
и вдаваться в подробности, чем на этой странице руководства.

Пещеры

Расширения могут конфликтовать с именами команд Expect. Например, Отправить определяется как Tk
для совершенно другой цели. По этой причине большинство Ожидать команды также
доступно как «exp_XXXX». Команды и переменные, начинающиеся с "exp", "inter", "spawn",
и "тайм-аут" не имеют псевдонимов. Используйте расширенные имена команд, если вам это нужно
совместимость между средами.

Ожидать придерживается довольно либерального взгляда на определение объема работ. В частности, переменные, считываемые командами
специфичные для Ожидать программа будет искать сначала в локальной области, а если нет
найдено, в глобальной области. Например, это избавляет от необходимости размещать «глобальный тайм-аут»
в каждой написанной вами процедуре, которая использует ожидать. С другой стороны, записанные переменные
всегда в локальной области (если не была введена «глобальная» команда). Самый распространенный
Проблема, которая возникает, когда spawn выполняется в процедуре. Вне процедуры
spawn_id больше не существует, поэтому порожденный процесс больше не доступен просто потому, что
определения объема работ. Добавьте к такой процедуре "global spawn_id".

Если вы не можете включить возможность мультиспауна (т. Е. Ваша система не поддерживает ни
выберите (BSD *. *), опрос (SVR> 2) или что-то подобное), Ожидать сможет только
контролировать один процесс за раз. В этом случае не пытайтесь установить spawn_id, ни
если вы выполняете процессы через exec во время работы порожденного процесса. Более того,
ты не сможешь ожидать из нескольких процессов (включая пользователя как одного) на
то же время.

Параметры терминала могут иметь большое влияние на скрипты. Например, если сценарий написан
чтобы искать эхо, он будет вести себя неправильно, если эхо выключено. По этой причине ожидайте
по умолчанию устанавливает нормальные параметры терминала. К сожалению, это может сделать вещи
неприятно для других программ. Например, оболочка emacs хочет изменить "обычный"
сопоставления: символы новой строки сопоставляются с новой строкой вместо новой строки с возвратом каретки и повторением
выключен. Это позволяет использовать emacs для редактирования строки ввода. К сожалению, ожидайте
не могу догадаться об этом.

Вы можете запросить, чтобы Expect не отменял настройки параметров терминала по умолчанию, но
тогда вы должны быть очень осторожны при написании сценариев для таких сред. В случае
emacs, избегайте зависимости от таких вещей, как эхо и отображение конца строки.

Команды, принимающие аргументы, объединены в один список ( ожидать варианты и
взаимодействовать) используйте эвристику, чтобы решить, является ли список на самом деле одним аргументом или несколькими. В
эвристика может потерпеть неудачу только в том случае, если список действительно представляет собой единичный
аргумент, который имеет несколько встроенных \ n с непробельными символами между ними.
Это кажется достаточно маловероятным, однако аргумент «-nobrace» можно использовать, чтобы заставить
единственный аргумент, который должен обрабатываться как единственный аргумент. Это можно было бы использовать с
сгенерированный машиной ожидаемый код. Точно так же -brace заставляет обрабатывать один аргумент как
несколько шаблонов / действий.

Используйте Exit в Интернете с помощью сервисов onworks.net