esperar - Online en la nube

PROGRAMA:

NOMBRE

esperar - diálogo programado con programas interactivos, versión 5

SINOPSIS

esperar [ -dDinN ] [ -c cmds ] [[ -[f|b]] archivo cmd ] [ args ]

INTRODUCCIÓN

Esperar es un programa que "habla" con otros programas interactivos según un guión.
Siguiendo el guión, Esperar sabe lo que se puede esperar de un programa y lo que
la respuesta correcta debe ser. Un idioma interpretado proporciona ramificación y alto nivel
estructuras de control para dirigir el diálogo. Además, el usuario puede tomar el control y
interactuar directamente cuando lo desee, luego devolviendo el control al script.

Esperar es una mezcla de Esperar y Tk. Se comporta como Esperar y Tk's deseo. Esperar
también se puede usar directamente en C o C ++ (es decir, sin Tcl). Ver esperar(3).

El nombre "Esperar" proviene de la idea de enviar / esperar secuencias popularizadas por uucp, kermit
y otros programas de control de módem. Sin embargo, a diferencia de uucp, Esperar se generaliza para que
se puede ejecutar como un comando a nivel de usuario con cualquier programa y tarea en mente. Esperar realmente puede
hablar con varios programas al mismo tiempo.

Por ejemplo, aquí hay algunas cosas Esperar puede hacer:

· Haga que su computadora le marque para que pueda iniciar sesión sin pagar
la llamada.

· Inicie un juego (p. Ej., Pícaro) y si no aparece la configuración óptima,
reinícielo (una y otra vez) hasta que lo haga, luego entregue el control a usted.

· Ejecute fsck y, en respuesta a sus preguntas, responda "sí", "no" o ceda el control
de vuelta a usted, basado en criterios predeterminados.

· Conéctese a otra red o BBS (por ejemplo, MCI Mail, CompuServe) y
recuperar automáticamente su correo para que parezca como si fuera originalmente
enviado a su sistema local.

· Lleva variables de entorno, directorio actual o cualquier tipo de información
a través de rlogin, telnet, tip, su, chgrp, etc.

Hay una variedad de razones por las que el shell no puede realizar estas tareas. (Prueba, lo harás
ver.) Todo es posible con Esperar.

En general, un software de chat en vivo es ideal para todas las organizaciones, ya que permite conocer de cerca a la audiencia, identificar los problemas que están experimentando y resolverlos para aumentar la lealtad a la marca, la credibilidad y las valoraciones de satisfacción. Esperar es útil para ejecutar cualquier programa que requiera interacción entre
el programa y el usuario. Todo lo que se necesita es que la interacción pueda ser
caracterizado programáticamente. Esperar también puede devolver al usuario el control (sin
detener el programa que se está controlando) si lo desea. Del mismo modo, el usuario puede devolver el control
al guión en cualquier momento.

USO

Esperar lee archivo cmd para obtener una lista de comandos a ejecutar. Esperar también se puede invocar
implícitamente en sistemas que soportan el #! notación marcando el script como ejecutable, y
haciendo la primera línea en su script:

#! / usr / bin / esperan -f

Por supuesto, el camino debe describir con precisión dónde Esperar vidas. / usr / bin es solo un
ejemplo.

El -c flag precede a un comando que se ejecutará antes que cualquiera en el script. El comando
deben cotizarse para evitar que el caparazón lo rompa. Esta opción se puede utilizar
varias veces. Se pueden ejecutar varios comandos con un solo -c separándolos
con punto y coma. Los comandos se ejecutan en el orden en que aparecen. (Al usar Expectk,
esta opción se especifica como -mando.)

El -d El indicador habilita algunos resultados de diagnóstico, que informan principalmente sobre la actividad interna de
comandos como esperar y interactuar. Esta bandera tiene el mismo efecto que "exp_internal 1"
al comienzo de un script de Expect, más la versión de Esperar está impreso. (El rastro
El comando es útil para rastrear declaraciones, y el rastrear El comando es útil para rastrear
asignaciones de variables.) (Cuando se usa Expectk, esta opción se especifica como -diagnóstico.)

El -D flag habilita un depurador interactivo. Debe seguir un valor entero. El
depurador tomará el control antes del siguiente procedimiento Tcl si el valor es distinto de cero o si un
Se presiona ^ C (o se alcanza un punto de interrupción, o aparece otro comando de depuración apropiado en
la secuencia de comandos). Consulte el archivo README o CONSULTE TAMBIÉN (a continuación) para obtener más información sobre el
depurador. (Cuando se usa Expectk, esta opción se especifica como -Depurar.)

El -f flag precede a un archivo desde el que leer los comandos. La bandera en sí es opcional.
ya que solo es útil cuando se usa #! notación (ver arriba), de modo que otros argumentos puedan
suministrarse en la línea de comando. (Cuando se usa Expectk, esta opción se especifica como -expediente.)

De forma predeterminada, el archivo de comando se lee en la memoria y se ejecuta en su totalidad. Está
ocasionalmente es deseable leer archivos de una línea a la vez. Por ejemplo, stdin se lee esto
camino. Para forzar el manejo de archivos arbitrarios de esta manera, use el -b bandera. (Cuándo
usando Expectk, esta opción se especifica como -buffer.)Notaqueestudio-
bufferingpuedenauntakeplacesin embargoeste vídeo no debería causar problemas al leer de un quince o
entrada estándar

Si la cadena "-" se proporciona como un nombre de archivo, en su lugar se lee la entrada estándar. (Usar "./-"
para leer de un archivo realmente llamado "-".)

El -i causas de la bandera Esperar para solicitar comandos de forma interactiva en lugar de leerlos
desde un archivo. La solicitud finaliza a través del salida comando o en EOF. Ver Interprete
(abajo) para obtener más información. -i se asume si ni un archivo de comando ni -c se utiliza.
(Cuando se usa Expectk, esta opción se especifica como -interactivo.)

-- se puede utilizar para delimitar el final de las opciones. Esto es útil si desea pasar una
argumento similar a una opción para su script sin que sea interpretado por Esperar. Esto puede
Sería útil colocarlo en el #! línea para evitar cualquier interpretación similar a una bandera por parte de Expect. Para
ejemplo, lo siguiente dejará los argumentos originales (incluido el nombre del script) en
La variable argv.

#! / usr / bin / espera -

Tenga en cuenta que lo habitual conseguiroptar(3) y ejecutivo(2) deben observarse las convenciones al agregar
argumentos al #! línea.

El archivo $ exp_library / wait.rc se obtiene automáticamente si está presente, a menos que el -N bandera es
usado. (Cuando se usa Expectk, esta opción se especifica como -NORC.) Inmediatamente después de esto,
el archivo ~ / .expect.rc se obtiene automáticamente, a menos que el -n se utiliza la bandera. Si el
La variable de entorno DOTDIR está definida, se trata como un directorio y .expect.rc se
leer desde allí. (Cuando se usa Expectk, esta opción se especifica como -norc.) Este abastecimiento
ocurre solo después de ejecutar cualquier -c banderas.

-v hace que Expect imprima su número de versión y salga. (La bandera correspondiente en
Expectk, que usa nombres de bandera largos, es -version).

Opcional args se construyen en una lista y se almacenan en la variable denominada argv. argc is
inicializado a la longitud de argv.

argv0 se define como el nombre del script (o binario si no se utiliza ningún script). Para
Por ejemplo, lo siguiente imprime el nombre del script y los primeros tres argumentos:

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

COMANDOS

Esperar usos TCL (Lenguaje de comandos de herramientas). Tcl proporciona flujo de control (p. Ej., Si, para,
break), evaluación de expresiones y varias otras características como recursividad, procedimiento
definición, etc. Los comandos utilizados aquí pero no definidos (p. ej., para reinventar la industria logística y redefinir las soluciones ecológicas para reinventar la industria logística y redefinir las soluciones ecológicas., if, ejecutivo) son Tcl
comandos (ver TCL(3)). Esperar admite comandos adicionales, que se describen a continuación. A no ser que
de lo contrario, los comandos devuelven la cadena vacía.

Los comandos se enumeran alfabéticamente para que se puedan localizar rápidamente. Sin embargo, nuevo
los usuarios pueden encontrar más fácil comenzar por leer las descripciones de desovar, send, esperary
interactuar, en ese orden.

Tenga en cuenta que la mejor introducción al idioma (tanto Expect como Tcl) se proporciona en el
libro "Exploring Expect" (ver VEA TAMBIÉN a continuación). Se incluyen ejemplos en esta página de manual, pero
son muy limitados ya que esta página de manual está pensada principalmente como material de referencia.

Tenga en cuenta que en el texto de esta página de manual, "Esperar" con una "E" mayúscula se refiere a la
Esperar programa mientras que "esperar" con una "e" minúscula se refiere a la esperar comando dentro
los Esperar programa.)

Cerrar [-esclavo] [-onexec 0 | 1] [-I spawn_id]
cierra la conexión con el proceso actual. La mayoría de los programas interactivos detectarán
EOF en su stdin y salida; por lo tanto Cerrar por lo general, es suficiente para matar el proceso como
bien. los -i bandera declara el proceso a cerrar correspondiente al nombre
spawn_id.

Ambos esperar y interactuar detectará cuándo sale el proceso actual e implícitamente
hacer un Cerrar. Pero si mata el proceso, por ejemplo, "exec kill $ pid", necesitará
llamar explícitamente Cerrar.

El -onexec bandera determina si la identificación de generación se cerrará en cualquier nueva generación
procesos o si el proceso está superpuesto. Para dejar una ID de generación abierta, use el valor
0. Un valor entero distinto de cero forzará el cierre del spawn (predeterminado) en cualquier nuevo
de los empleados.

El -esclavo bandera cierra el esclavo asociado con el ID de generación. (Ver "spawn -pty".)
Cuando se cierra la conexión, el esclavo también se cierra automáticamente si todavía
abra.

No importa si la conexión se cierra implícita o explícitamente, debe llamar
esperar para limpiar la ranura de proceso del kernel correspondiente. Cerrar no llama esperar
ya que no hay garantía de que cerrar una conexión de proceso hará que se cierre.
See esperar a continuación para obtener más información.

depurar [[-ahora] 0 | 1]
controla un depurador de Tcl que le permite pasar por declaraciones, establecer puntos de interrupción,
etc.

Sin argumentos, se devuelve un 1 si el depurador no se está ejecutando; de lo contrario, se devuelve un 0
devuelto.

Con un argumento 1, se inicia el depurador. Con un argumento 0, el depurador es
detenido. Si un argumento 1 está precedido por el -ahora bandera, se inicia el depurador
inmediatamente (es decir, en medio de la depurar comando en sí mismo). De lo contrario, el
el depurador se inicia con la siguiente instrucción Tcl.

El depurar El comando no cambia ninguna trampa. Compare esto con comenzar Expect con
los -D bandera (ver arriba).

Consulte el archivo README o CONSULTE TAMBIÉN (a continuación) para obtener más información sobre el depurador.

desconectar
desconecta un proceso bifurcado de la terminal. Sigue funcionando en el
antecedentes. El proceso recibe su propio grupo de procesos (si es posible). E / S estándar
se redirige a / dev / null.

El siguiente fragmento utiliza desconectar para continuar ejecutando el script en el
fondo.

si {[fork]! = 0} sale
desconectar
. . .

El siguiente script lee una contraseña y luego ejecuta un programa cada hora que
exige una contraseña cada vez que se ejecuta. El script proporciona la contraseña para que
solo tienes que escribirlo una vez. (Ver el pocilga comando que demuestra cómo girar
apagado el eco de la contraseña.)

send_user "contraseña? \"
esperar_usuario -re "(. *) \ n"
para 1 {} {
if {[fork]! = 0} {sleep 3600; continue}
desconectar
generar priv_prog
esperar contraseña:
enviar "$ espera_salida (1, cadena) \ r"
. . .
salida
}

Una ventaja de usar desconectar sobre la característica de proceso asincrónico de shell (&) es
que Esperar puede guardar los parámetros del terminal antes de la desconexión, y luego más tarde
aplicarlos a nuevos ptys. Con &, Esperar no tiene la oportunidad de leer el
los parámetros del terminal ya que el terminal ya está desconectado en el momento Esperar
recibe el control.

salida [-opta] [estado]
causas Esperar para salir o prepararse para hacerlo.

El -una salida flag hace que el siguiente argumento se utilice como controlador de salida. Sin un
argumento, se devuelve el controlador de salida actual.

El -Sin salida causas de la bandera Esperar prepararse para salir, pero no llegar a
devolviendo el control al sistema operativo. El controlador de salida definido por el usuario se ejecuta como
así como los propios controladores internos de Expect. No se deben realizar más comandos Expect.
ejecutado. Esto es útil si está ejecutando Expect con otras extensiones de Tcl. El
intérprete actual (y la ventana principal si en el entorno Tk) permanecen para que otros
Las extensiones de Tcl pueden limpiar. Si espera salida se llama de nuevo (sin embargo, esto podría
ocurren), los controladores no se vuelven a ejecutar.

Al salir, se cierran todas las conexiones a los procesos generados. El cierre será
detectado como un EOF por procesos generados. salida no toma otras acciones más allá de lo que
la normal _Salida(2) el procedimiento lo hace. Por lo tanto, los procesos generados que no comprueban
EOF puede continuar ejecutándose. (Es importante determinar una variedad de condiciones, para
ejemplo, qué señales se enviará un proceso generado, pero estas son
dependiente, típicamente documentado bajo salida(3).) Procesos generados que continúan
run será heredado por init.

estado (o 0 si no se especifica) se devuelve como el estado de salida de Esperar. salida is
ejecutado implícitamente si se llega al final del script.

exp_continuar [-continue_timer]
El comando exp_continuar permite esperar sí mismo para continuar ejecutando en lugar de
regresando como lo haría normalmente. Por defecto exp_continuar restablece el temporizador de tiempo de espera.
El -continuar_temporizador La bandera evita que el temporizador se reinicie. (Ver esperar
información.)

exp_interno [-F expediente] propuesta de
hace que otros comandos envíen información de diagnóstico interna a Esperar a stderr
if propuesta de no es cero. Esta salida está deshabilitada si propuesta de es 0. El diagnóstico
La información incluye todos los caracteres recibidos y todos los intentos
salida actual contra los patrones.

Si el opcional presentar se suministra, toda la salida normal y de depuración se escribe en ese
archivo (independientemente del valor de propuesta de). Cualquier archivo de salida de diagnóstico anterior es
cerrado.

El -información La bandera hace que exp_internal devuelva una descripción de la no-
info argumentos dados.

exp_abierto [argumentos] [-I spawn_id]
devuelve un identificador de archivo Tcl que corresponde al ID de generación original. El archivo
El identificador se puede utilizar como si fuera abierto por Tcl. abierto mando. (El engendro
id ya no debe usarse. A esperar no debe ejecutarse.

El -dejar abierto flag deja la ID de generación abierta para el acceso a través de los comandos Expect. A
esperar debe ejecutarse en el ID de generación.

exp_pid [-I spawn_id]
devuelve el ID de proceso correspondiente al proceso generado actualmente. Si el -i
se usa la bandera, el pid devuelto corresponde al del ID de generación dado.

Exp_enviar
es un alias para send.

exp_enviar_error
es un alias para enviar error.

exp_enviar_log
es un alias para enviar_registro.

exp_enviar_tty
es un alias para enviar_tty.

exp_enviar_usuario
es un alias para enviar_usuario.

versión_exp [[-Salida] versión]
es útil para asegurar que el script sea compatible con la versión actual de
Suponer.

Sin argumentos, la versión actual de Esperar es regresado. Esta versión puede entonces
estar codificado en su secuencia de comandos. Si realmente sabe que no está utilizando las funciones de
versiones recientes, puede especificar una versión anterior.

Las versiones constan de tres números separados por puntos. Primero está el número mayor.
Scripts escritos para versiones de Esperar con un número mayor diferente casi
ciertamente no funciona. versión_exp devuelve un error si los números principales no coinciden.

El segundo es el número menor. Guiones escritos para una versión con menor mayor
número que la versión actual puede depender de alguna característica nueva y es posible que no se ejecute.
versión_exp devuelve un error si los números principales coinciden, pero el número menor del script
es mayor que el de la carrera Esperar.

El tercero es un número que no juega ningún papel en la comparación de versiones. Sin embargo lo és
incrementado cuando el Esperar La distribución de software se modifica de alguna manera, como por
documentación adicional u optimización. Se restablece a 0 con cada nuevo menor.
versión.

Con la -Salida bandera, Esperar imprime un error y sale si la versión no está actualizada.

esperar [[-opciones] pat1 cuerpo1] ... [-opta] patrón [cuerpo]
espera hasta que uno de los patrones coincida con la salida de un proceso generado, un
ha pasado el período de tiempo o se ve un final de archivo. Si el cuerpo final está vacío,
puede omitirse.

Patrones de los más recientes esperar_antes comando se utilizan implícitamente antes de cualquier
otros patrones. Patrones de los más recientes esperar_después comando son implícitamente
utilizado después de cualquier otro patrón.

Si los argumentos de la totalidad esperar declaración requiere más de una línea, todos los
Los argumentos se pueden "reforzar" en uno para evitar terminar cada línea con un
barra invertida. En este caso, las sustituciones habituales de Tcl ocurrirán a pesar de la
tirantes.

Si un patrón es la palabra clave eof, el cuerpo correspondiente se ejecuta al final de
Archivo. Si un patrón es la palabra clave tiempo de espera, el cuerpo correspondiente se ejecuta sobre
se acabó el tiempo. Si no se utiliza una palabra clave de tiempo de espera, se ejecuta una acción nula implícita
se acabó el tiempo. El período de tiempo de espera predeterminado es de 10 segundos, pero se puede configurar, por ejemplo, para
30, mediante el comando "set timeout 30". Un tiempo de espera infinito puede ser designado por el
valor -1. Si un patrón es la palabra clave tu préstamo estudiantil, se ejecuta el cuerpo correspondiente
ya sea al tiempo de espera o al final del archivo.

Si un patrón coincide, se ejecuta el cuerpo correspondiente. esperar devuelve el
resultado del cuerpo (o la cadena vacía si no coincide ningún patrón). En caso de que
varios patrones coinciden, el que aparece primero se utiliza para seleccionar un cuerpo.

Cada vez que llega una nueva salida, se compara con cada patrón en el orden en que se
enumerados. Por lo tanto, puede probar la ausencia de coincidencia haciendo el último patrón
algo garantizado que aparecerá, como un mensaje. En situaciones donde no hay
aviso, debe usar tiempo de espera (como lo haría si estuviera interactuando manualmente).

Los patrones se especifican de tres formas. De forma predeterminada, los patrones se especifican como con
Tcl's cadena partido mando. (Tales patrones también son similares a C-shell regular
expresiones usualmente referidas como patrones "glob"). El -gl se puede usar la bandera
para proteger patrones que de otro modo podrían coincidir esperar banderas de hacerlo. Ningún
el patrón que comienza con "-" debe protegerse de esta manera. (Todas las cadenas comienzan
con "-" están reservados para opciones futuras).

Por ejemplo, el siguiente fragmento busca un inicio de sesión exitoso. (Tenga en cuenta que abortar
se presume que es un procedimiento definido en otra parte del script).

suponer {
ocupado {pone ocupado \ n; exp_continue}
aborto fallido
abortar "contraseña inválida"
tiempo de espera abortar
conectado
}

Las comillas son necesarias en el cuarto patrón, ya que contiene un espacio, lo que
de lo contrario, separe el patrón de la acción. Patrones con la misma acción (como
como el 3 y el 4) requieren enumerar las acciones nuevamente. Esto se puede evitar usando
patrones de estilo regexp (ver más abajo). Más información sobre cómo formar patrones de estilo glob
se puede encontrar en el manual de Tcl.

Los patrones de estilo regexp siguen la sintaxis definida por Tcl's regexp (abreviatura de "regular
expresión ") comando. Los patrones de expresiones regulares se introducen con la bandera -re.
El ejemplo anterior se puede reescribir usando una expresión regular como:

suponer {
ocupado {pone ocupado \ n; exp_continue}
-re "falló | contraseña inválida" abortar
tiempo de espera abortar
conectado
}

Ambos tipos de patrones están "desanclados". Esto significa que los patrones no tienen por qué
coincidir con toda la cadena, pero puede comenzar y finalizar la coincidencia en cualquier lugar de la cadena (como
siempre que todo lo demás coincida). Use ^ para hacer coincidir el comienzo de una cadena y $
para que coincida con el final. Tenga en cuenta que si no espera el final de una cadena, su
Las respuestas pueden terminar fácilmente en el medio de la cadena, ya que se repiten desde el
proceso generado. Mientras sigue produciendo resultados correctos, la salida puede verse
antinatural. Por lo tanto, se recomienda el uso de $ si puede describir exactamente los caracteres
al final de una cadena.

Tenga en cuenta que en muchos editores, ^ y $ coinciden con el principio y el final de las líneas.
respectivamente. Sin embargo, debido a que esperar no está orientado a líneas, estos caracteres coinciden
el principio y el final de los datos (a diferencia de las líneas) actualmente en la expectativa
búfer coincidente. (Además, consulte la nota a continuación sobre "indigestión del sistema").

El -ej La bandera hace que el patrón coincida con una cadena "exacta". No
Se hace una interpretación de *, ^, etc. (aunque las convenciones habituales de Tcl deben
ser observado). Los patrones exactos siempre están desanclados.

El -no hay caso La bandera hace que los caracteres en mayúsculas de la salida se comparen como si
eran caracteres en minúscula. El patrón no se ve afectado.

Mientras se lee la salida, más de 2000 bytes pueden forzar que los bytes anteriores sean
"olvidado". Esto se puede cambiar con la función partido_max. (Tenga en cuenta que
valores excesivamente grandes pueden ralentizar el emparejamiento de patrones). lista de patines is
búfer_completo, el cuerpo correspondiente se ejecuta si partido_max bytes han sido
recibido y ningún otro patrón ha coincidido. Si el búfer_completo keyword
se utiliza, los caracteres olvidados se escriben en wait_out (búfer).

If lista de patines es la palabra clave nulo, y se permiten nulos (a través del eliminar_nulls
comando), el cuerpo correspondiente se ejecuta si un solo ASCII 0 coincide. Está
no es posible hacer coincidir 0 bytes a través de patrones glob o regexp.

Al hacer coincidir un patrón (o eof o full_buffer), cualquier coincidencia y previamente
la salida inigualable se guarda en la variable esperar_salida (búfer). Hasta 9 expresiones regulares
las coincidencias de subcadenas se guardan en las variables esperar_salida (1, cadena) atravesar
esperar_salida (9, cadena). Si el -índices La bandera se usa antes de un patrón, el inicio
e índices finales (en una forma adecuada para naranja) de las 10 cadenas se almacenan en
las variables esperar_salida (X, inicio) y esperar_salida (X, fin) donde X es un dígito,
corresponde a la posición de la subcadena en el búfer. 0 se refiere a cadenas que
coincidió con todo el patrón y se genera para patrones glob, así como regexp
patrones. Por ejemplo, si un proceso ha producido una salida de "abcdefgh \ n", el resultado
de:

esperar "cd"

es como si se hubieran ejecutado las siguientes declaraciones:

establecer esperar_salida (0, cadena) cd
establecer wait_out (búfer) abcd

y "efgh \ n" se deja en el búfer de salida. Si un proceso produjo la salida
"abbbcabkkkka \ n", el resultado de:

esperar -indices -re "b (b *). * (k +)"

es como si se hubieran ejecutado las siguientes declaraciones:

establecer esperar_salida (0, inicio) 1
establecer wait_out (0, end) 10
establecer esperar_salida (0, cadena) bbbcabkkkk
establecer esperar_salida (1, inicio) 2
establecer wait_out (1, end) 3
establecer esperar_salida (1, cadena) bb
establecer esperar_salida (2, inicio) 10
establecer wait_out (2, end) 10
establecer esperar_salida (2, cadena) k
establecer espera_salida (búfer) abbbcabkkkk

y "a \ n" se deja en el búfer de salida. El patrón "*" (y -re ". *") Se vaciará
el búfer de salida sin leer más salida del proceso.

Normalmente, la salida coincidente se descarta de los búferes internos de Expect. Esto puede
ser prevenido prefijando un patrón con el -no transferir bandera. Esta bandera es
especialmente útil para experimentar (y se puede abreviar como "-no" por conveniencia
mientras experimenta).

El ID de generación asociado con la salida coincidente (o eof o full_buffer) se almacena
in esperar_salida (spawn_id).

El -se acabó el tiempo marca hace que el comando de espera actual utilice el siguiente valor como un
timeout en lugar de utilizar el valor de la variable timeout.

De forma predeterminada, los patrones se comparan con la salida del proceso actual, sin embargo
los -i flag declara que la salida de la lista spawn_id nombrada se compara con cualquier
siguiendo patrones (hasta el siguiente -i). La lista spawn_id debe ser un
lista separada por espacios en blanco de spawn_ids o una variable que hace referencia a dicha lista de
spawn_ids.

Por ejemplo, el siguiente ejemplo espera "conectado" desde el proceso actual,
o "ocupado", "fallido" o "contraseña inválida" del spawn_id nombrado por $ proc2.

suponer {
-i $ proc2 ocupado {pone ocupado \ n; exp_continue}
-re "falló | contraseña inválida" abortar
tiempo de espera abortar
conectado
}

El valor de la variable global cualquier_spawn_id se puede utilizar para hacer coincidir patrones con cualquier
spawn_ids que se nombran con todos los demás -i banderas en la corriente esperar mando. los
spawn_id de un -i bandera sin patrón asociado (es decir, seguida inmediatamente por
una alternativa, -i) está disponible para cualquier otro patrón en el mismo esperar comando
asociado con cualquier_spawn_id.

El -i La bandera también puede nombrar una variable global, en cuyo caso la variable se lee para un
lista de identificadores de generación. La variable se vuelve a leer cada vez que cambia. Esto proporciona una forma
de cambiar la fuente de E / S mientras el comando está en ejecución. ID de generación proporcionados
de esta manera se denominan identificadores de generación "indirectos".

Acciones como break y continue causar estructuras de control (es decir, for, Proc) A
comportarse de la manera habitual. El comando exp_continuar permite esperar sí mismo para continuar
ejecutando en lugar de regresar como lo haría normalmente.

Esto es útil para evitar bucles explícitos o declaraciones de espera repetidas. El
El siguiente ejemplo es parte de un fragmento para automatizar rlogin. El exp_continuar evita
tener que escribir un segundo esperar declaración (para buscar el indicador de nuevo) si el
rlogin solicita una contraseña.

suponer {
Contraseña: {
stty-echo
send_user "contraseña (para $ usuario) en $ host:"
esperar_usuario -re "(. *) \ n"
send_user "\ n"
enviar "$ espera_salida (1, cadena) \ r"
eco stty
exp_continuar
} incorrecto {
send_user "contraseña o cuenta inválida \ n"
salida
} se acabó el tiempo {
send_user "se agotó el tiempo de espera de la conexión a $ host \ n"
salida
} e de {
enviar_usuario \
"Error de conexión con el host: $ espera_salida (búfer)"
salida
} -re $ prompt
}

Por ejemplo, el siguiente fragmento puede ayudar a un usuario a guiar una interacción que es
ya totalmente automatizado. En este caso, el terminal se pone en modo raw. Si el
el usuario presiona "+", se incrementa una variable. Si se presiona "p", varios retornos son
enviado al proceso, tal vez para pincharlo de alguna manera, y "i" permite que el usuario interactúe
con el proceso, robando efectivamente el control del guión. En cada caso,
los exp_continuar permite la corriente esperar para continuar la coincidencia de patrones después
ejecutando la acción actual.

stty crudo -echo
esperar_después {
-i $ user_spawn_id
"p" {enviar "\ r \ r \ r"; exp_continue}
"+" {incr foo; exp_continue}
"yo" {interactuar; exp_continue}
"salir" salir
}

De forma predeterminada, exp_continuar restablece el temporizador de tiempo de espera. El temporizador no se reinicia, si
exp_continuar se llama con el -continuar_temporizador bandera.

esperar_después [esperan_args]
funciona de manera idéntica a la esperar_antes excepto que si los patrones de ambos esperar y
esperar_después puede coincidir, el esperar se utiliza el patrón. Ver el esperar_antes comando
para obtener más información.

esperar_fondo [esperan_args]
toma los mismos argumentos que esperar, sin embargo, regresa inmediatamente. Los patrones son
probado cada vez que llega una nueva entrada. El patrón tiempo de espera y tu préstamo estudiantil no tienen sentido
a esperar_fondo y se descartan en silencio. De lo contrario, el esperar_fondo
usos del comando esperar_antes y esperar_después patrones como esperar hace.

Cuándo esperar_fondo acciones están siendo evaluadas, procesamiento en segundo plano para el
La misma identificación de generación está bloqueada. El procesamiento en segundo plano se desbloquea cuando la acción
completa. Mientras el procesamiento en segundo plano está bloqueado, es posible realizar una
(primer plano) esperar en el mismo ID de generación.

No es posible ejecutar una esperar mientras que un esperar_fondo está desbloqueado.
esperar_fondo para un ID de generación en particular se elimina declarando un nuevo
wait_background con el mismo ID de generación. Declarando esperar_fondo con ningún
patrón elimina la identificación de generación dada de la capacidad de hacer coincidir patrones en el
fondo.

esperar_antes [esperan_args]
toma los mismos argumentos que esperar, sin embargo, regresa inmediatamente. Patrón de acción
pares de los más recientes esperar_antes con el mismo ID de generación se agregan implícitamente
a cualquier siguiente esperar comandos. Si un patrón coincide, se trata como si tuviera
ha sido especificado en el esperar comando en sí, y el cuerpo asociado se ejecuta en
el contexto de la esperar mando. Si los patrones de ambos esperar_antes y esperar
puede coincidir, el esperar_antes se utiliza el patrón.

Si no se especifica ningún patrón, no se verifica ningún patrón en el ID de generación.

A menos que sea anulado por un -i bandera, esperar_antes los patrones coinciden con el ID de generación
definido en el momento en que el esperar_antes se ejecutó el comando (no cuando su
el patrón coincide).

El indicador -info provoca esperar_antes para devolver las especificaciones actuales de lo que
patrones que coincidirá. De forma predeterminada, informa sobre la identificación de generación actual. Un
Se puede dar una especificación de ID de generación opcional para obtener información sobre esa identificación de generación. Para
(aqui)

esperar_antes -info -i $ proc

Se puede dar como máximo una especificación de ID de generación. La bandera -indirecto suprime
ID de generación directa que provienen solo de especificaciones indirectas.

En lugar de una especificación de ID de generación, la bandera "-todos" hará que "-info" informe sobre
todos los identificadores de generación.

La salida del indicador -info se puede reutilizar como argumento para esperar_antes.

esperar_ta [esperan_args]
es como esperar pero lee caracteres de / dev / tty (es decir, pulsaciones de teclas del
usuario). Por defecto, la lectura se realiza en modo cocinado. Por lo tanto, las líneas deben terminar con
una devolución para esperar para verlos. Esto se puede cambiar a través de pocilga (Véase el
pocilga comando a continuación).

esperar_usuario [esperan_args]
es como esperar pero lee caracteres de stdin (es decir, pulsaciones de teclas del usuario).
Por defecto, la lectura se realiza en modo cocinado. Por lo tanto, las líneas deben terminar con un retorno.
para poder esperar para verlos. Esto se puede cambiar a través de pocilga (Véase el pocilga comando
abajo).

tenedor crea un nuevo proceso. El nuevo proceso es una copia exacta del actual Esperar
proceso. Sobre el éxito, tenedor devuelve 0 al nuevo proceso (hijo) y devuelve el
ID de proceso del proceso hijo al proceso padre. En caso de falla (invariablemente debido
a falta de recursos, por ejemplo, espacio de intercambio, memoria), tenedor devuelve -1 al padre
proceso y no se crea ningún proceso hijo.

Los procesos bifurcados salen a través del salida comando, al igual que el proceso original. Ahorquillado
Los procesos pueden escribir en los archivos de registro. Si no deshabilita la depuración o
al iniciar sesión en la mayoría de los procesos, el resultado puede ser confuso.

Algunas implementaciones de pty pueden ser confundidas por varios lectores y escritores, incluso
momentáneamente. Por lo tanto, es más seguro tenedor antes de los procesos de desove.

interactuar [cadena1 cuerpo1] ... [cadena [cuerpo]]
da el control del proceso actual al usuario, de modo que las pulsaciones de teclas se envían al
proceso actual, y se devuelven stdout y stderr del proceso actual.

Los pares cadena-cuerpo se pueden especificar como argumentos, en cuyo caso se ejecuta el cuerpo
cuando se ingresa la cadena correspondiente. (De forma predeterminada, la cadena no se envía a
el proceso actual). Interprete Se asume el comando, si el cuerpo final es
faltante.

Si los argumentos de la totalidad interactuar declaración requiere más de una línea, todos
los argumentos se pueden "reforzar" en uno para evitar terminar cada línea con un
barra invertida. En este caso, las sustituciones habituales de Tcl ocurrirán a pesar de la
tirantes.

Por ejemplo, el siguiente comando se ejecuta interactuando con el siguiente string-body
pares definidos: cuando se presiona ^ Z, Esperar está suspendido. (El -Reiniciar bandera restaura
los modos de terminal.) Cuando se presiona ^ A, el usuario ve "usted escribió un control-A" y
el proceso se envía a ^ A. Cuando se presiona $, el usuario ve la fecha. Cuando ^ C es
presionado, Esperar salidas. Si se ingresa "foo", el usuario ve "barra". Cuando ~~ es
presionado, el Esperar el intérprete se ejecuta de forma interactiva.

establecer CTRLZ \ 032
interactuar {
-reset $ CTRLZ {exec kill -STOP [pid]}
\ 001 {send_user "escribiste un control-A \ n";
enviar "\ 001"
}
$ {send_user "La fecha es [formato de reloj [segundos de reloj]]."}
\ 003 salir
foo {send_user "bar"}
~~
}

En los pares cadena-cuerpo, las cadenas se hacen coincidir en el orden en que se enumeran como argumentos.
Las cadenas que coinciden parcialmente no se envían al proceso actual en previsión de
el resto viene. Si luego se ingresan caracteres de manera que ya no
posiblemente sea una coincidencia, solo la parte de la cadena se enviará al proceso que
No es posible que comience otro partido. Por lo tanto, las cadenas que son subcadenas de parcial
las coincidencias pueden coincidir más tarde, si las cadenas originales que intentaban coincidir
finalmente falla.

De forma predeterminada, la coincidencia de cadenas es exacta sin comodines. (En contraste, el esperar
El comando usa patrones de estilo glob por defecto). -ej la bandera puede usarse para proteger
patrones que de otro modo podrían coincidir interactuar banderas de hacerlo. Cualquier patrón
que comience con un "-" debe protegerse de esta manera. (Todas las cadenas comienzan con "-"
están reservados para opciones futuras).

El -re flag obliga a que la cadena se interprete como un patrón de estilo regexp. En esto
caso, las subcadenas coincidentes se almacenan en la variable interactuar_fuera de manera similar a la
way esperar almacena su salida en la variable esperar_de_fuera. -índices bandera es
compatible de forma similar.

El patrón eof introduce una acción que se ejecuta al final del archivo. Una separacion
eof El patrón también puede seguir el -producción bandera en cuyo caso coincide si un eof
se detecta mientras se escribe la salida. El valor por defecto eof la acción es "volver", de modo que
interactuar simplemente regresa en cualquier EOF.

El patrón tiempo de espera introduce un tiempo de espera (en segundos) y una acción que se ejecuta
después de que no se hayan leído caracteres durante un tiempo determinado. El tiempo de espera el patrón se aplica a
el proceso especificado más recientemente. No hay tiempo de espera predeterminado. El especial
variable "tiempo de espera" (utilizado por el esperar comando) no tiene ningún efecto en este tiempo de espera.

Por ejemplo, la siguiente declaración podría usarse para cerrar automáticamente la sesión de los usuarios que no
escribió cualquier cosa durante una hora pero que todavía recibe mensajes frecuentes del sistema:

interactuar -input $ user_spawn_id timeout 3600 return -output \
$ spawn_id

Si el patrón es la palabra clave nulo, y se permiten nulos (a través del eliminar_nulls
comando), el cuerpo correspondiente se ejecuta si un solo ASCII 0 coincide. Está
no es posible hacer coincidir 0 bytes a través de patrones glob o regexp.

Prefacio de un patrón con la bandera -yo escribo causa la variable interact_out (spawn_id)
para establecerse en spawn_id que coincidió con el patrón (o eof).

Acciones como break y continue causar estructuras de control (es decir, for, Proc) A
comportarse de la manera habitual. Sin embargo volvemos hace que interactuar vuelva a su llamador,
mientras inter_retorno causas interactuar para provocar un retorno en su llamador. Por ejemplo, si
"proc foo" llamado interactuar que luego ejecutó la acción inter_retorno, Proc foo
volvería. (Esto significa que si interactuar llamadas Interprete escribiendo interactivamente
volvemos hará que la interacción continúe, mientras inter_retorno hará que el
interactuar para volver a su interlocutor.)

Durante interactuar, el modo sin procesar se utiliza para que todos los caracteres se puedan pasar al
proceso actual. Si el proceso actual no capta las señales de control del trabajo,
detener si se envía una señal de parada (por defecto ^ Z). Para reiniciarlo, envíe una señal de continuar
(como por "kill -CONT "). Si realmente desea enviar un SIGSTOP a un
proceso (por ^ Z), considere generar csh primero y luego ejecutar su programa. Sobre el
Por otro lado, si desea enviar un SIGSTOP a Esperar sí mismo, intérprete de primera llamada
(quizás usando un carácter de escape) y luego presione ^ Z.

Los pares de cuerda-cuerpo se pueden utilizar como una forma abreviada de evitar tener que ingresar
interpretar y ejecutar comandos de forma interactiva. Se utiliza el modo de terminal anterior
mientras se ejecuta el cuerpo de un par cadena-cuerpo.

Para mayor velocidad, las acciones se ejecutan en modo crudo de forma predeterminada. El -Reiniciar bandera restablece el
terminal al modo que tenía antes interactuar fue ejecutado (invariablemente, modo cocinado).
Tenga en cuenta que los caracteres introducidos cuando se cambia el modo pueden perderse (un
característica desafortunada del controlador de terminal en algunos sistemas). La única razón para usar
-Reiniciar es si su acción depende de la ejecución en modo cocinado.

El -eco bandera envía caracteres que coinciden con el siguiente patrón de vuelta al proceso
que los generó a medida que se lee cada carácter. Esto puede resultar útil cuando el usuario
necesita ver comentarios de patrones parcialmente escritos.

Si se repite un patrón pero finalmente no coincide, los caracteres se envían
al proceso generado. Si el proceso generado se hace eco de ellos, el usuario verá
los personajes dos veces. -eco probablemente solo sea apropiado en situaciones donde el
Es poco probable que el usuario no complete el patrón. Por ejemplo, el siguiente extracto es
desde rftp, el script ftp recursivo, donde se le pide al usuario que ingrese ~ g, ~ p, o
~ l, para obtener, poner o listar el directorio actual de forma recursiva. Estos estan tan lejos
de los comandos ftp normales, que es poco probable que el usuario escriba ~ seguido de
cualquier otra cosa, excepto por error, en cuyo caso, probablemente ignorarán la
resultado de todos modos.

interactuar {
-echo ~ g {getcurdirectory 1}
-echo ~ l {getcurdirectory 0}
-echo ~ p {putcurdirectory}
}

El -sin búfer La bandera envía caracteres que coinciden con el siguiente patrón en el
proceso de salida a medida que se leen los caracteres.

Esto es útil cuando desea que un programa repita el patrón. Por ejemplo,
lo siguiente podría usarse para monitorear dónde está marcando una persona (un estilo Hayes
módem). Cada vez que se ve "atd", el script registra el resto de la línea.

número de registro de proceso {} {
interactuar -nobuffer -re "(. *) \ r" return
pone $ log "[formato de reloj [segundos de reloj]]: marcado $ interact_out (1, string)"
}

interactuar -nobuffer "atd" lognumber

Durante interactuar, uso previo de registro_usuario se ignora. En particular, interactuar will
forzar que se registre su salida (enviada a la salida estándar) ya que se presume que
el usuario no desea interactuar a ciegas.

El -o La bandera hace que los siguientes pares clave-cuerpo se apliquen a la salida del
proceso actual. Esto puede resultar útil, por ejemplo, cuando se trata de hosts que envían
caracteres no deseados durante una sesión de telnet.

De forma predeterminada, interactuar espera que el usuario escriba stdin y lea stdout del
Esperar proceso en sí. El -u bandera (para "usuario") hace interactuar buscar al usuario como
el proceso nombrado por su argumento (que debe ser una identificación generada).

Esto permite que dos procesos no relacionados se unan sin utilizar un explícito
círculo. Para ayudar en la depuración, los diagnósticos esperados siempre van a stderr (o stdout para
cierta información de registro y depuración). Por la misma razón, el Interprete
El comando leerá de forma interactiva desde stdin.

Por ejemplo, el siguiente fragmento crea un proceso de inicio de sesión. Luego marca al usuario
(no se muestra), y finalmente conecta los dos juntos. Por supuesto, cualquier proceso puede ser
sustituido por inicio de sesión. Un shell, por ejemplo, permitiría al usuario trabajar sin
proporcionando una cuenta y contraseña.

inicio de sesión de spawn
establecer inicio de sesión $ spawn_id
módem de punta de generación
# volver a marcar al usuario
# conectar usuario para iniciar sesión
interactuar -u $ iniciar sesión

Para enviar resultados a varios procesos, enumere cada lista de ID de generación precedida por un -producción
bandera. La entrada para un grupo de ID de generación de salida se puede determinar mediante una lista de ID de generación
precedido por un -aporte bandera. (Ambos -aporte y -producción puede tomar listas en la misma forma
como el -i bandera en el esperar comando, excepto que any_spawn_id no es significativo en
interactuar.) Todos los siguientes indicadores y cadenas (o patrones) se aplican a esta entrada hasta
aparece otro indicador de entrada. Si no -aporte aparece, -producción implica "-input
$ user_spawn_id -output ". (De manera similar, con patrones que no tienen -aporte.) Si
one -aporte se especifica, anula $ user_spawn_id. Si un segundo -aporte is
especificado, anula $ spawn_id. Adicional -aporte se pueden especificar banderas.

Los dos procesos de entrada implícitos tienen por defecto sus salidas especificadas como
$ spawn_id y $ user_spawn_id (al revés). Si un -aporte la bandera aparece sin -producción
, los personajes de ese proceso se descartan.

El -i flag introduce un reemplazo para el spawn_id actual cuando ningún otro -aporte
or -producción se utilizan banderas. Una bandera -i implica una bandera -o.

Es posible cambiar los procesos con los que se interactúa utilizando
ID de generación indirectos. (Los identificadores de generación indirecta se describen en la sección sobre
) Los ID de generación indirectos se pueden especificar con -i, -u, -input o -output
banderas.

Interprete [argumentos]
hace que al usuario se le solicite de forma interactiva Esperar y comandos Tcl. El
Se imprime el resultado de cada comando.

Acciones como break y continue causar estructuras de control (es decir, for, Proc) A
comportarse de la manera habitual. Sin embargo volvemos hace que el intérprete regrese a su interlocutor,
mientras inter_retorno causas Interprete para provocar un retorno en su llamador. Por ejemplo,
si se llama "proc foo" Interprete que luego ejecutó la acción inter_retorno, Proc
foo volvería. Cualquier otro comando causa Interprete para continuar pidiendo
nuevos comandos.

De forma predeterminada, el mensaje contiene dos números enteros. El primer número entero describe la profundidad
de la pila de evaluación (es decir, cuántas veces se ha llamado a Tcl_Eval). El segundo
integer es el identificador del historial de Tcl. La solicitud se puede configurar definiendo un
procedimiento llamado "prompt1" cuyo valor de retorno se convierte en el siguiente prompt. Si un
declaración tiene comillas abiertas, paréntesis, llaves o corchetes, una indicación secundaria (por
predeterminado "+>") se emite en la nueva línea. El indicador secundario se puede configurar definiendo
un procedimiento llamado "prompt2".

Durante Interprete, se usa el modo cocido, incluso si la persona que llama estaba usando el modo crudo.

Si stdin está cerrado, Interprete Regresará a menos que el -eof se utiliza la bandera, en la que
caso se invoca el argumento siguiente.

archivo de registro [argumentos] [[-un] expediente]
Si se proporciona un nombre de archivo, archivo de registro registrará una transcripción de la sesión
(comenzando en ese punto) en el archivo. archivo de registro dejará de grabar si no hay argumento
es dado. Se cierra cualquier archivo de registro anterior.

En lugar de un nombre de archivo, se puede proporcionar un identificador de archivo Tcl utilizando el -abierto or
-dejar abierto banderas. Esto es similar al desovar mando. (Ver desovar para más información.)

El -a La bandera obliga a registrar la salida que fue suprimida por el registro_usuario mando.

Por defecto, el archivo de registro comando anexa a archivos antiguos en lugar de truncarlos,
por la conveniencia de poder apagar y encender el inicio de sesión varias veces en una
sesión. Para truncar archivos, use el -noagregar bandera.

El -información flag hace que log_file devuelva una descripción de la no información más reciente
argumentos dados.

registro_usuario -info | 0 | 1
De forma predeterminada, el diálogo de envío / espera se registra en stdout (y un archivo de registro si está abierto).
El inicio de sesión en stdout se deshabilita con el comando "log_user 0" y se vuelve a habilitar mediante
"log_user 1". El registro en el archivo de registro no se modifica.

El -información flag hace que log_user devuelva una descripción de la no información más reciente
argumentos dados.

partido_max [-D] [-I spawn_id] [Tamaño]
define el tamaño del búfer (en bytes) utilizado internamente por esperar. Sin tamaño
argumento, se devuelve el tamaño actual.

Con la -d bandera, se establece el tamaño predeterminado. (El valor predeterminado inicial es 2000).
-i bandera, el tamaño se establece para el ID de generación con nombre, de lo contrario, se establece para el actual
.

superposición [- # spawn_id] [- # spawn_id] [...] programa [argumentos]
ejecuta programa args en lugar de la corriente Esperar programa, que termina. A
El argumento de guión desnudo fuerza un guión delante del nombre del comando como si fuera un
shell de inicio de sesión. Todos los spawn_ids están cerrados excepto aquellos nombrados como argumentos. Estos
se asignan a los identificadores de archivos con nombre.

Spawn_ids se asignan a identificadores de archivo para que el nuevo programa los herede. Para
ejemplo, la siguiente línea ejecuta ajedrez y permite que sea controlado por la corriente
proceso - digamos, un maestro de ajedrez.

overlay -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id ajedrez

Esto es más eficiente que "interactuar -u", sin embargo, sacrifica la capacidad de hacer
interacción programada desde el Esperar el proceso ya no está bajo control.

Tenga en cuenta que no se proporciona ningún terminal de control. Por lo tanto, si desconecta o reasigna
entrada estándar, los programas que controlan el trabajo (shells, inicio de sesión, etc.) no funcionarán
correctamente.

paridad [-D] [-I spawn_id] [valor]
define si la paridad debe retenerse o eliminarse de la salida de generados
Procesos. Si propuesta de es cero, la paridad se elimina; de lo contrario, no se elimina.
Con ningún propuesta de argumento, se devuelve el valor actual.

Con la -d marca, se establece el valor de paridad predeterminado. (El valor predeterminado inicial es 1, es decir,
la paridad no se elimina). -i bandera, el valor de paridad se establece para el nombre
spawn id, de lo contrario, está configurado para el proceso actual.

eliminar_nulls [-D] [-I spawn_id] [valor]
define si los nulos se retienen o eliminan de la salida de los procesos generados
antes de la coincidencia de patrones o el almacenamiento en la variable esperar_de_fuera or interactuar_fuera. Si
propuesta de es 1, se eliminan los nulos. Si propuesta de es 0, los nulos no se eliminan. Sin propuesta de
argumento, se devuelve el valor actual.

Con la -d bandera, se establece el valor predeterminado. (El valor predeterminado inicial es 1, es decir, nulos
se eliminan.) Con el -i bandera, el valor se establece para el ID de generación con nombre, de lo contrario
está configurado para el proceso actual.

Ya sea que se eliminen o no los nulos, Esperar registrará bytes nulos en el registro y
salida estándar.

send [-banderas] cadena
Envíos cadena al proceso actual. Por ejemplo, el comando

enviar "hola mundo \ r"

envía los personajes, hola mundo al proceso actual.
(Tcl incluye un comando similar a printf (llamado formato) que puede construir arbitrariamente
cadenas complejas.)

Los caracteres se envían inmediatamente, aunque los programas con entrada en búfer de línea no
leer los caracteres hasta que se envíe un carácter de retorno. Se denota un carácter de retorno
"\ r".

El -- bandera obliga al siguiente argumento a ser interpretado como una cadena en lugar de una
bandera. Cualquier cadena puede ir precedida de "-", ya sea que parezca una
bandera. Esto proporciona un mecanismo confiable para especificar cadenas de variables sin ser
tropezado por aquellos que accidentalmente parecen banderas. (Todas las cadenas que comienzan con
"-" están reservados para opciones futuras).

El -i flag declara que la cadena se enviará al spawn_id con nombre. Si spawn_id
is usuario_spawn_id, y la terminal está en modo raw, las nuevas líneas en la cadena son
traducido a secuencias de retorno-nueva línea para que parezcan como si el terminal estuviera en
modo cocinado. El -crudo bandera desactiva esta traducción.

El -nulo bandera envía caracteres nulos (0 bytes). De forma predeterminada, se envía un nulo. Un
entero puede seguir al -nulo para indicar cuántos nulos enviar.

El -descanso bandera genera una condición de ruptura. Esto solo tiene sentido si el ID de generación
se refiere a un dispositivo tty abierto a través de "spawn -open". Si ha generado un proceso como
como sugerencia, debe utilizar la convención de la sugerencia para generar una ruptura.

El -s La bandera obliga a que la salida se envíe "lentamente", evitando así la situación común en la que
una computadora sobrepasa un búfer de entrada que fue diseñado para un humano que nunca
supere el mismo búfer. Esta salida está controlada por el valor de la variable
"send_slow" que toma una lista de dos elementos. El primer elemento es un número entero que
describe la cantidad de bytes para enviar atómicamente. El segundo elemento es un real
número que describe el número de segundos por los cuales los envíos atómicos deben ser
apartado. Por ejemplo, "set send_slow {10 .001}" forzaría a "send -s" a enviar
cadenas con 1 milisegundo entre cada 10 caracteres enviados.

El -h flag obliga a que la salida se envíe (algo) como si un humano estuviera escribiendo.
Aparecen retrasos similares a los humanos entre los personajes. (El algoritmo se basa en un
Distribución de Weibull, con modificaciones para adaptarse a esta aplicación en particular).
la salida está controlada por el valor de la variable "send_human" que toma un valor de cinco
lista de elementos. Los dos primeros elementos son el tiempo medio entre llegadas de los personajes en
segundos. El primero se utiliza de forma predeterminada. El segundo se usa al final de las palabras, para
simule las pausas sutiles que ocurren ocasionalmente en tales transiciones. El tercero
El parámetro es una medida de variabilidad donde .1 es bastante variable, 1 es razonablemente
variable, y 10 es bastante invariable. Los extremos van del 0 al infinito. Los últimos dos
Los parámetros son, respectivamente, un tiempo mínimo y máximo entre llegadas. El mínimo
y el máximo se utilizan al final y "recortar" la última vez. El promedio final puede ser
bastante diferente del promedio dado si el clip mínimo y máximo es suficiente
valores.

Como ejemplo, el siguiente comando emula a un mecanógrafo rápido y consistente:

establecer enviar_humano {.1 .3 1 .05 2}
enviar -h "Tengo hambre. Vamos a almorzar".

mientras que lo siguiente podría ser más adecuado después de una resaca:

establecer enviar_humano {.4 .4 .2 .5 100}
enviar -h "¡Buenas noches de fiesta!"

Tenga en cuenta que los errores no se simulan, aunque puede configurar la corrección de errores
situaciones usted mismo incorporando errores y correcciones en un argumento de envío.

Las banderas para enviar caracteres nulos, para enviar saltos, para forzar una salida lenta
y para la salida de estilo humano son mutuamente excluyentes. Solo el último especificado será
ser usado. Además, no cadena El argumento se puede especificar con las banderas para enviar
Caracteres nulos o saltos.

Es una buena idea preceder al primero send a un proceso por un esperar. esperar will
espere a que comience el proceso, mientras send no puede. En particular, si el primer send
se completa antes de que el proceso comience a ejecutarse, corre el riesgo de que sus datos
ignorado. En situaciones en las que los programas interactivos no ofrecen un mensaje inicial, puede
mencionadas send por un retraso como en:

# Para evitar dar pistas a los piratas informáticos sobre cómo ingresar,
# este sistema no solicita una contraseña externa.
# Espere 5 segundos a que se complete el ejecutivo
generar telnet very.secure.gov
sueño 5
enviar contraseña \ r

Exp_enviar es un alias para send. Si está utilizando Expectk o alguna otra variante de
Espere en el entorno Tk, send está definido por Tk para un concepto completamente diferente
propósito. Exp_enviar se proporciona para la compatibilidad entre entornos. Similar
se proporcionan alias para otros comandos de envío de Expect.

enviar error [-banderas] cadena
es como send, excepto que la salida se envía a stderr en lugar de la corriente
.

enviar_registro [-] cadena
es como send, excepto que la cadena solo se envía al archivo de registro (consulte archivo de registro.)
Los argumentos se ignoran si no hay ningún archivo de registro abierto.

enviar_tty [-banderas] cadena
es como send, excepto que la salida se envía a / dev / tty en lugar del actual
.

enviar_usuario [-banderas] cadena
es como send, excepto que la salida se envía a stdout en lugar de a la actual
.

sleep segundos
hace que la secuencia de comandos se duerma durante el número de segundos especificado. Los segundos pueden ser un
número decimal. Las interrupciones (y los eventos Tk si está utilizando Expectk) se procesan
mientras Expect duerme.

desovar [argumentos] programa [argumentos]
crea un nuevo proceso en ejecución programa args. Sus stdin, stdout y stderr son
conectados a Expect, para que puedan ser leídos y escritos por otros Esperar comandos.
La conexión se rompe por Cerrar o si el proceso en sí cierra alguno de los archivos
identificadores.

Cuando un proceso es iniciado por desovar, La variable spawn_id se establece en un descriptor
refiriéndose a ese proceso. El proceso descrito por spawn_id es considerado el
corriente . spawn_id puede leerse o escribirse, proporcionando en efecto control del trabajo.

usuario_spawn_id es una variable global que contiene un descriptor que se refiere al usuario.
Por ejemplo, cuando spawn_id se establece en este valor, esperar se comporta como esperar_usuario.

error_spawn_id es una variable global que contiene un descriptor que se refiere a la
Error estándar. Por ejemplo, cuando spawn_id se establece en este valor, send se comporta como
enviar error.

tty_spawn_id es una variable global que contiene un descriptor que se refiere a / dev / tty.
Si / dev / tty no existe (como en un cron, at o script por lotes), entonces
tty_spawn_id no está definido. Esto se puede probar como:

si {[info vars tty_spawn_id]} {
# / dev / tty existe
} Else {
# / dev / tty no existe
# probablemente en cron, lote o en script
}

desovar devuelve el ID del proceso de UNIX. Si no se genera ningún proceso, se devuelve 0. El
variable spawn_out (esclavo, nombre) se establece en el nombre del dispositivo esclavo pty.

De forma predeterminada, desovar repite el nombre del comando y los argumentos. El -noeco bandera se detiene
desovar de hacer esto.

El consola flag hace que la salida de la consola sea redirigida al proceso generado.
Esto no es compatible con todos los sistemas.

Internamente, desovar usa un pty, inicializado de la misma manera que el tty del usuario. Esto es
más inicializado para que todos los ajustes estén "cuerdos" (de acuerdo con pocilga(1)). Si el
variable stty_init está definido, se interpreta en el estilo de los argumentos stty como
configuración adicional. Por ejemplo, "set stty_init raw" provocará que se generen más
Los terminales de los procesos se inician en modo raw. -nottycopia omite la inicialización
basado en el tty del usuario. -nottyinit omite la inicialización "cuerda".

Normalmente, desovar toma poco tiempo para ejecutarse. Si nota que el spawn toma un
una cantidad significativa de tiempo, es probable que encuentre ptys que estén encajados. A
Se ejecutan varias pruebas en ptys para evitar enredos con procesos errantes.
(Estos tardan 10 segundos por pieza encajada). Ejecutar Expect con el -d la opción mostrará
if Esperar se encuentra con muchos ptys en estados extraños. Si no puede matar los procesos
al que se adjuntan estos ptys, su único recurso puede ser reiniciar.

If programa no se puede generar correctamente porque ejecutivo(2) falla (por ejemplo, cuando programa
no existe), el siguiente mensaje de error interactuar or esperar
comando como si programa se había ejecutado y produjo el mensaje de error como salida. Esta
El comportamiento es una consecuencia natural de la implementación de desovar. Internamente, desovar
bifurcaciones, después de lo cual el proceso generado no tiene forma de comunicarse con el original
Esperar proceso excepto por comunicación a través de spawn_id.

El -abierto flag hace que el siguiente argumento se interprete como un identificador de archivo Tcl
(es decir, devuelto por abierto.) La identificación de generación se puede usar como si fuera una
proceso. (El identificador de archivo ya no debe usarse). Esto le permite tratar
dispositivos, archivos y canalizaciones como procesos generados sin usar un pty. 0 es
devuelto para indicar que no hay ningún proceso asociado. Cuando la conexión al
El proceso generado está cerrado, al igual que el identificador de archivo Tcl. El -dejar abierto bandera es
similar a -abierto excepto eso -dejar abierto hace que el identificador de archivo se deje abierto
incluso después de que se cierre el ID de generación.

El -pty flag hace que se abra un pty pero no se genere ningún proceso. 0 se devuelve a
indican que no hay ningún proceso asociado. Spawn_id se establece como de costumbre.

La variable spawn_out (esclavo, fd) se establece en un identificador de archivo correspondiente a la
pty esclavo. Se puede cerrar usando "close -slave".

El -ignorar bandera nombra una señal que se ignorará en el proceso generado. De lo contrario,
las señales obtienen el comportamiento predeterminado. Las señales se nombran como en el trampa comando, excepto
que cada señal requiere una bandera separada.

rastro nivel
hace que las siguientes sentencias se impriman antes de ejecutarse. (Rastro de Tcl
comando rastrea variables.) nivel indica qué tan abajo se debe rastrear en la pila de llamadas.
Por ejemplo, el siguiente comando se ejecuta Esperar mientras rastrea los primeros 4 niveles de
llamadas, pero ninguna por debajo de eso.

esperar -c "strace 4" script.exp

El -información La bandera hace que Strace devuelva una descripción de la información no informativa más reciente.
argumentos dados.

pocilga args
cambia los modos de terminal de manera similar al comando stty externo.

Por defecto, se accede al terminal de control. Se puede acceder a otras terminales
agregando "</ dev / tty ..." al comando. (Tenga en cuenta que los argumentos no deben ser
agrupados en un solo argumento.)

Las solicitudes de estado lo devuelven como resultado del comando. Si no hay estado
solicitado y se accede al terminal de control, el estado anterior del raw
y los atributos de eco se devuelven en una forma que luego puede ser utilizada por el comando.

Por ejemplo, los argumentos crudo or -cocido poner el terminal en modo raw. El
argumentos -crudo or cerdo Ponga el terminal en modo cocinado. Los argumentos echo y
-eco Ponga el terminal en modo eco y no eco respectivamente.

El siguiente ejemplo ilustra cómo deshabilitar temporalmente el eco. Esto podría ser
utilizado en scripts que de otro modo serían automáticos para evitar incrustar contraseñas en ellos. (Ver más
discusión sobre esto en ESPERA SUGERENCIAS a continuación.)

stty-echo
send_user "Contraseña:"
esperar_usuario -re "(. *) \ n"
establecer contraseña $ espera_salida (1, cadena)
eco stty

te args
da args a sh(1) como entrada, como si se hubiera escrito como un comando de un
terminal. Esperar espera hasta que termine el caparazón. El estado de retorno de sh es
manejado de la misma manera que ejecutivo maneja su estado de devolución.

En contraste con ejecutivo que redirige stdin y stdout al script, te realiza
sin redirección (aparte de la indicada por la propia cadena). Por lo tanto, es
posible utilizar programas que deben comunicarse directamente con / dev / tty. Por la misma razón,
Los resultados de te no se registran en el registro.

fecha y hora [argumentos]
devuelve una marca de tiempo. Sin argumentos, el número de segundos desde la época es
devuelto.

El -formato bandera introduce una cadena que se devuelve pero con sustituciones realizadas
de acuerdo con las reglas POSIX para strftime. Por ejemplo,% a se reemplaza por un
nombre abreviado del día de la semana (es decir, sábado). Otros son:
% un nombre abreviado del día de la semana
% Un nombre completo del día de la semana
% b nombre del mes abreviado
% B nombre del mes completo
% c fecha-hora como en: miércoles 6 de octubre 11:45:56 1993
% d día del mes (01-31)
% H hora (00-23)
% I hora (01-12)
% j día (001-366)
% m mes (01-12)
% M minuto (00-59)
% p am o pm
% S segundo (00-61)
% u día (1-7, el lunes es el primer día de la semana)
% U semana (00-53, el primer domingo es el primer día de la semana uno)
% V semana (01-53, estilo ISO 8601)
% w día (0-6)
% W semana (00-53, el primer lunes es el primer día de la semana uno)
% x fecha-hora como en: miércoles 6 de octubre de 1993
% X tiempo como en: 23:59:59
% y año (00-99)
% Y año como en: 1993
% Z zona horaria (o nada si no se puede determinar)
%% un signo de porcentaje desnudo

Otras especificaciones de% no están definidas. Se pasarán otros personajes
intacto. Solo se admite la configuración regional C.

El -segundos La bandera introduce un número de segundos desde la época que se utilizará como
fuente desde la que formatear. De lo contrario, se utiliza la hora actual.

El -GMT flag obliga a la salida de la marca de tiempo a utilizar la zona horaria GMT. Sin bandera, el
se utiliza la zona horaria local.

trampa [[mando] señales]
causa lo dado comando que se ejecutará al recibir en el futuro cualquiera de los
señales. El comando se ejecuta en el ámbito global. Si comando está ausente, el
se devuelve la acción de la señal. Si comando es la cadena SIG_IGN, las señales son
ignorado. Si comando es la cadena SIG_DFL, las señales son el resultado del sistema
predeterminada. señales es una sola señal o una lista de señales. Las señales pueden ser
especificado numérica o simbólicamente según señal(3). El prefijo "SIG" puede ser
omitido.

Sin argumentos (o el número de argumento), trampa devuelve el número de señal del
comando trap que se está ejecutando actualmente.

El -código flag usa el código de retorno del comando en lugar de cualquier código Tcl
a punto de regresar cuando el comando comenzó a ejecutarse originalmente.

El -interp. La bandera hace que el comando sea evaluado usando el intérprete activo en
el momento en que el comando comenzó a ejecutarse en lugar de cuando se declaró la trampa.

El -nombre bandera causa el trampa comando para devolver el nombre de la señal del comando trap
actualmente en ejecución.

El -máx bandera causa el trampa comando para devolver el número de señal más grande que puede
ser establecido

Por ejemplo, el comando "trap {send_user" ¡Ay! "} SIGINT" imprimirá "¡Ay!" cada
vez que el usuario presiona ^ C.

Por defecto, SIGINT (que generalmente se puede generar presionando ^ C) y SIGTERM causan
Espere salir. Esto se debe a la siguiente trampa, creada por defecto cuando Expect
empieza.

salida de trampa {SIGINT SIGTERM}

Si usa el indicador -D para iniciar el depurador, SIGINT se redefine para iniciar el
depurador interactivo. Esto se debe a la siguiente trampa:

trampa {exp_debug 1} SIGINT

La trampa del depurador se puede cambiar configurando la variable de entorno
EXPECT_DEBUG_INIT a un nuevo comando trap.

Por supuesto, puede anular ambos con solo agregar comandos trap a su
texto. En particular, si tiene su propia "salida de trampa SIGINT", esto anulará
la trampa del depurador. Esto es útil si desea evitar que los usuarios accedan al
depurador en absoluto.

Si desea definir su propia trampa en SIGINT pero aún atrapar al depurador cuando
se está ejecutando, use:

if {! [exp_debug]} {trap mystuff SIGINT}

Alternativamente, puede atrapar al depurador usando alguna otra señal.

trampa no le permitirá anular la acción para SIGALRM ya que se usa internamente para
Esperar. El comando de desconexión establece SIGALRM en SIG_IGN (ignorar). Puedes volver a habilitar
esto siempre que lo desactive durante los siguientes comandos de generación.

See señal(3) para obtener más información.

esperar [argumentos]
se retrasa hasta que termina un proceso generado (o el proceso actual si no se nombra ninguno).

esperar normalmente devuelve una lista de cuatro enteros. El primer entero es el pid del
proceso que se esperaba. El segundo entero es el correspondiente ID de generación.
El tercer número entero es -1 si ocurrió un error del sistema operativo, o 0 en caso contrario. Si
el tercer entero fue 0, el cuarto entero es el estado devuelto por el generado
proceso. Si el tercer entero fue -1, el cuarto entero es el valor de errno set
por el sistema operativo. También se establece la variable global errorCode.

Pueden aparecer elementos adicionales al final del valor de retorno de esperar. Un
El quinto elemento opcional identifica una clase de información. Actualmente, el único
El valor posible para este elemento es CHILDKILLED, en cuyo caso los dos valores siguientes son
el nombre de la señal de estilo C y una breve descripción textual.

El -i flag declara el proceso a esperar correspondiente al spawn_id nombrado (NO
el ID del proceso). Dentro de un controlador SIGCHLD, es posible esperar a que se genere
proceso utilizando el ID de generación -1.

El -no, espera La bandera hace que la espera regrese inmediatamente con la indicación de un
espera exitosa. Cuando el proceso salga (más tarde), desaparecerá automáticamente
sin la necesidad de una espera explícita.

El esperar El comando también se puede usar esperar por un proceso bifurcado usando los argumentos "-i
-1 ". A diferencia de su uso con procesos generados, este comando se puede ejecutar en cualquier
hora. No hay control sobre qué proceso se cosecha. Sin embargo, el valor de retorno
se puede verificar el ID del proceso.

BIBLIOTECAS

Expect conoce automáticamente dos bibliotecas integradas para los scripts de Expect. Estos son
definido por los directorios nombrados en las variables exp_library y exp_exec_library. Ambos
están destinados a contener archivos de utilidad que pueden ser utilizados por otros scripts.

exp_library contiene archivos independientes de la arquitectura. exp_exec_library contiene
archivos dependientes de la arquitectura. Dependiendo de su sistema, ambos directorios pueden estar totalmente
vacío. La existencia del archivo $ exp_exec_library / cat-buffers describe si su
/ papelera / gato búferes de forma predeterminada.

IMPRESIÓN BONITA

Hay una definición de vgrind disponible para impresiones bonitas. Esperar guiones. Asumiendo el vgrind
definición suministrada con el Esperar La distribución está instalada correctamente, puedes usarla.
como:

vgrind -archivo de expectativas

EJEMPLOS

Es posible que no sea evidente cómo unir todo lo que describe la página de manual. I
animarle a leer y probar los ejemplos en el directorio de ejemplo de la Esperar
distribución. Algunos de ellos son programas reales. Otros son simplemente ilustrativos de ciertos
técnicas y, por supuesto, un par de trucos rápidos. El archivo INSTALL tiene una
descripción general de estos programas.

El Esperar Los artículos (ver VEA TAMBIÉN) también son útiles. Mientras que algunos artículos usan sintaxis
correspondiente a versiones anteriores de Expect, los fundamentos que lo acompañan siguen siendo válidos
y entrar en muchos más detalles que esta página de manual.

AVISOS

Las extensiones pueden colisionar con los nombres de los comandos de Expect. Por ejemplo, send está definido por Tk
para un propósito completamente diferente. Por esta razón, la mayoría de Esperar los comandos también son
disponible como "exp_XXXX". Comandos y variables que comienzan con "exp", "inter", "spawn",
y "timeout" no tienen alias. Use los nombres de comando extendidos si lo necesita
compatibilidad entre entornos.

Esperar adopta una visión bastante liberal del alcance. En particular, las variables leídas por comandos
específico para el Esperar El programa se buscará primero en el ámbito local, y si no
encontrado, en el ámbito global. Por ejemplo, esto evita la necesidad de colocar un "tiempo de espera global"
en cada procedimiento que escribe que usa esperar. Por otro lado, las variables escritas son
siempre en el ámbito local (a menos que se haya emitido un comando "global"). Los más comunes
El problema que esto causa es cuando se ejecuta spawn en un procedimiento. Fuera del procedimiento,
spawn_id ya no existe, por lo que el proceso generado ya no es accesible simplemente porque
del alcance. Agregue un "spawn_id global" a dicho procedimiento.

Si no puede habilitar la capacidad de aparición múltiple (es decir, su sistema no admite ninguna
seleccione (BSD *. *), encuesta (SVR> 2), ni algo equivalente), Esperar solo podré
controlar un solo proceso a la vez. En este caso, no intente configurar spawn_id, ni
debe ejecutar procesos a través de exec mientras se está ejecutando un proceso generado. Además,
No estaras disponible para esperar de múltiples procesos (incluido el usuario como uno) en el
al mismo tiempo

Los parámetros de la terminal pueden tener un gran efecto en los scripts. Por ejemplo, si se escribe un guión
para buscar eco, se comportará mal si el eco está desactivado. Por esta razón, espere
fuerza los parámetros sanos del terminal por defecto. Desafortunadamente, esto puede hacer que las cosas
desagradable para otros programas. Como ejemplo, el shell emacs quiere cambiar el "habitual"
asignaciones: las nuevas líneas se asignan a las nuevas líneas en lugar de las nuevas líneas de retorno de carro y el eco
está desactivado. Esto permite usar emacs para editar la línea de entrada. Desafortunadamente, espere
posiblemente no puedo adivinar esto.

Puede solicitar que Expect no anule su configuración predeterminada de parámetros de terminal, pero
por lo tanto, debe tener mucho cuidado al escribir scripts para dichos entornos. En el caso de
emacs, evite depender de cosas como el eco y las asignaciones de final de línea.

Los comandos que aceptaban argumentos reforzados en una sola lista (el esperar variantes y
interactuar) utilizan una heurística para decidir si la lista es en realidad un argumento o varios. El
La heurística solo puede fallar en el caso en que la lista realmente represente una
argumento que tiene múltiples \ n incrustadas con caracteres que no son espacios en blanco entre ellos.
Esto parece suficientemente improbable, sin embargo, el argumento "-nobrace" puede usarse para forzar una
un solo argumento para ser manejado como un solo argumento. Esto podría posiblemente usarse con
código Expect generado por máquina. De manera similar, -brace obliga a que un solo argumento se maneje como
múltiples patrones / acciones.

Utilice esperar en línea utilizando los servicios de onworks.net