Il s'agit de la commande qui peut être exécutée dans le fournisseur d'hébergement gratuit OnWorks en utilisant l'un de nos multiples postes de travail en ligne gratuits tels que Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS.
PROGRAMME:
Nom
attendre - dialogue programmé avec des programmes interactifs, version 5
SYNOPSIS
attendre [ -dDinN ] [ -c cmd ] [ [ -[f|b] ] fichier cmd ] [ args ]
INTRODUCTION
SAVOIR-FAIRE est un programme qui « parle » avec d'autres programmes interactifs selon un script.
En suivant le scénario, SAVOIR-FAIRE sait ce que l'on peut attendre d'un programme et ce que
la réponse correcte devrait être. Un langage interprété fournit des branchements et des
structures de contrôle pour diriger le dialogue. De plus, l'utilisateur peut prendre le contrôle et
interagissez directement lorsque vous le souhaitez, puis restituez le contrôle au script.
Attendez est un mélange de SAVOIR-FAIRE et Tk. Il se comporte comme SAVOIR-FAIRE et Tk's souhaiter. SAVOIR-FAIRE
peut également être utilisé directement en C ou C++ (c'est-à-dire sans Tcl). Voir libattend (3).
Le nom « Expect » vient de l'idée de envoyer/attendre séquences popularisées par uucp, kermit
et d'autres programmes de contrôle de modem. Cependant, contrairement à uucp, SAVOIR-FAIRE est généralisé de sorte qu'il
peut être exécuté en tant que commande au niveau de l'utilisateur avec n'importe quel programme et tâche à l'esprit. SAVOIR-FAIRE peut en fait
parler à plusieurs programmes en même temps.
Par exemple, voici quelques éléments SAVOIR-FAIRE peut faire:
· Faites en sorte que votre ordinateur vous rappelle, afin que vous puissiez vous connecter sans payer
l'appel.
· Démarrez un jeu (par exemple, rogue) et si la configuration optimale n'apparaît pas,
redémarrez-le (encore et encore) jusqu'à ce que ce soit le cas, puis confiez-vous le contrôle.
· Exécutez fsck, et en réponse à ses questions, répondez "oui", "non" ou donnez le contrôle
retour vers vous, sur la base de critères prédéterminés.
· Connectez-vous à un autre réseau ou BBS (par exemple, MCI Mail, CompuServe) et
récupérer automatiquement votre courrier pour qu'il apparaisse comme s'il était à l'origine
envoyé à votre système local.
· Transportez des variables d'environnement, le répertoire actuel ou tout type d'informations
via rlogin, telnet, tip, su, chgrp, etc.
Il existe diverses raisons pour lesquelles le shell ne peut pas effectuer ces tâches. (Essayez, vous allez
voir.) Tout est possible avec SAVOIR-FAIRE.
En général, SAVOIR-FAIRE est utile pour exécuter tout programme nécessitant une interaction entre
le programme et l'utilisateur. Tout ce qui est nécessaire, c'est que l'interaction puisse être
caractérisé par programmation. SAVOIR-FAIRE peut également redonner le contrôle à l'utilisateur (sans
arrêt du programme en cours de contrôle) si vous le souhaitez. De même, l'utilisateur peut reprendre le contrôle
au script à tout moment.
UTILISATION
SAVOIR-FAIRE lit fichier cmd pour une liste de commandes à exécuter. SAVOIR-FAIRE peut également être invoqué
implicitement sur les systèmes qui prennent en charge le #! notation en marquant le script comme exécutable, et
en créant la première ligne de votre script :
#!/usr/bin/expect -f
Bien entendu, le chemin doit décrire avec précision où SAVOIR-FAIRE vies. / usr / bin est juste un
Exemple.
Le manuel de formation -c flag précède une commande à exécuter avant toute commande dans le script. La commande
doit être cité pour éviter d'être brisé par la coque. Cette option peut être utilisée
plusieurs fois. Plusieurs commandes peuvent être exécutées avec une seule -c en les séparant
avec des points-virgules. Les commandes sont exécutées dans l'ordre dans lequel elles apparaissent. (Lorsque vous utilisez Expectk,
cette option est spécifiée comme -commander.)
Le manuel de formation -d L'indicateur active certaines sorties de diagnostic, qui rapportent principalement l'activité interne de
des commandes telles que attendre et interagir. Cet indicateur a le même effet que "exp_internal 1"
au début d'un script Expect, plus la version de SAVOIR-FAIRE est imprimé. (Le strass
La commande est utile pour tracer les instructions, et la commande tracer la commande est utile pour tracer
affectations de variables.) (Lors de l'utilisation d'Expectk, cette option est spécifiée comme -diag.)
Le manuel de formation -D flag active un débogueur interactif. Une valeur entière devrait suivre. Le
le débogueur prendra le contrôle avant la prochaine procédure Tcl si la valeur est différente de zéro ou si un
^C est enfoncé (ou un point d'arrêt est atteint, ou une autre commande de débogueur appropriée apparaît dans
le script). Consultez le fichier README ou VOIR AUSSI (ci-dessous) pour plus d'informations sur le
débogueur. (Lors de l'utilisation d'Expectk, cette option est spécifiée comme -Déboguer.)
Le manuel de formation -f flag fait précéder un fichier à partir duquel lire les commandes. Le drapeau lui-même est facultatif
car cela n'est utile que lorsque vous utilisez le #! notation (voir ci-dessus), afin que d'autres arguments puissent
être fourni sur la ligne de commande. (Lors de l'utilisation d'Expectk, cette option est spécifiée comme -fichier.)
Par défaut, le fichier de commandes est lu en mémoire et exécuté dans son intégralité. C'est
il est parfois souhaitable de lire les fichiers une ligne à la fois. Par exemple, stdin est lu ceci
chemin. Afin de forcer le traitement des fichiers arbitraires de cette façon, utilisez l'option -b drapeau. (Quand
en utilisant Expectk, cette option est spécifiée comme -amortir.)Notequistdio-
tamponAu cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès.parfois surprenantecommencerendroittoutefoisceci. ne devrait pas poser de problèmes lors de la lecture à partir d'un fifo ou
stdin.
Si la chaîne "-" est fournie comme nom de fichier, l'entrée standard est lue à la place. (Utiliser "./-"
lire à partir d'un fichier réellement nommé "-".)
Le manuel de formation -i drapeau causes SAVOIR-FAIRE pour demander de manière interactive des commandes au lieu de les lire
à partir d'un fichier. L'invite est terminée via le sortie commande ou sur EOF. Voir interprète
(ci-dessous) pour plus d’informations. -i est supposé si ni un fichier de commandes ni -c est utilisé.
(Lors de l'utilisation d'Expectk, cette option est spécifiée comme -interactif.)
-- peut être utilisé pour délimiter la fin des options. Ceci est utile si vous souhaitez passer un
argument de type option à votre script sans qu'il soit interprété par SAVOIR-FAIRE. Cela peut
utilement être placé dans le #! ligne pour empêcher toute interprétation de type drapeau par Expect. Pour
Par exemple, ce qui suit laissera les arguments d'origine (y compris le nom du script) dans
la variable argv.
#!/usr/bin/expect --
Notez que l'habituel obtenirde Géographie (3) et avec la executif(2) les conventions doivent être respectées lors de l’ajout
arguments au #! doubler.
Le fichier $exp_library/expect.rc est automatiquement sourcé s'il est présent, sauf si le -N le drapeau est
utilisé. (Lors de l'utilisation d'Expectk, cette option est spécifiée comme -NORC.) Immédiatement après,
le fichier ~/.expect.rc est obtenu automatiquement, à moins que le -n le drapeau est utilisé. Si la
La variable d'environnement DOTDIR est définie, elle est traitée comme un répertoire et .expect.rc est
lire à partir de là. (Lors de l'utilisation d'Expectk, cette option est spécifiée comme -norque.) Ce sourcing
se produit seulement après l'exécution d'un -c drapeaux.
-v oblige Expect à imprimer son numéro de version et à quitter. (Le drapeau correspondant dans
Expectk, qui utilise des noms d'indicateurs longs, est -version.)
Optionnel args sont construits dans une liste et stockés dans la variable nommée argv. argc is
initialisé à la longueur de argv.
argv0 est défini comme étant le nom du script (ou binaire si aucun script n'est utilisé). Pour
Par exemple, ce qui suit affiche le nom du script et les trois premiers arguments :
send_user "$argv0 [lrange $argv 0 2]\n"
COMMANDES
SAVOIR-FAIRE Usages Tcl (Langage de commande d'outil). Tcl fournit un flux de contrôle (par exemple, si, pour,
break), l'évaluation d'expression et plusieurs autres fonctionnalités telles que la récursivité, la procédure
définition, etc. Commandes utilisées ici mais non définies (par exemple, set, if, exec) sont Tcl
commandes (voir tcl(3)). SAVOIR-FAIRE prend en charge des commandes supplémentaires, décrites ci-dessous. Sauf si
autrement spécifié, les commandes renvoient la chaîne vide.
Les commandes sont classées par ordre alphabétique afin de pouvoir les localiser rapidement. Cependant, nouveau
les utilisateurs trouveront peut-être plus facile de commencer en lisant les descriptions de frayer, envoyer, attendreet
interagir, dans cet ordre.
Notez que la meilleure introduction au langage (Expect et Tcl) est fournie dans le
livre "Exploring Expect" (voir AUSSI ci-dessous). Des exemples sont inclus dans cette page de manuel mais
ils sont très limités puisque cette page de manuel est principalement destinée à servir de matériel de référence.
Notez que dans le texte de cette page de manuel, « Attendre » avec un « E » majuscule fait référence au
SAVOIR-FAIRE programme tandis que "attendre" avec un "e" minuscule fait référence au attendre commande à l'intérieur
le SAVOIR-FAIRE programme.)
close [-esclave] [-onexec 0|1] [-je spawn_id]
ferme la connexion au processus en cours. La plupart des programmes interactifs détecteront
EOF sur leur stdin et leur sortie ; ainsi close suffit généralement à tuer le processus car
bien. le -i flag déclare le processus à fermer correspondant au nom
spawn_id.
Le attendre et interagir détectera quand le processus en cours se termine et implicitement
faire un close. Mais si vous tuez le processus, par exemple, "exec kill $pid", vous devrez
appeler explicitement close.
Le manuel de formation -onexec l'indicateur détermine si l'identifiant d'apparition sera fermé dans tout nouveau généré
processus ou si le processus est superposé. Pour laisser un identifiant d'apparition ouvert, utilisez la valeur
0. Une valeur entière non nulle forcera la fermeture du spawn (valeur par défaut) dans tout nouveau
procédés.
Le manuel de formation -trimer flag ferme l'esclave associé à l'identifiant d'apparition. (Voir "spawn -pty".)
Lorsque la connexion est fermée, l'esclave est également automatiquement fermé s'il est toujours
ouverte.
Peu importe si la connexion est fermée implicitement ou explicitement, vous devez appeler
attendez pour libérer l'emplacement de processus du noyau correspondant. close n'appelle pas attendez
car il n'y a aucune garantie que la fermeture d'une connexion de processus entraînera sa fermeture.
See attendez ci-dessous pour plus d'informations.
déboguer [[-maintenant] 0|1]
contrôle un débogueur Tcl vous permettant de parcourir les instructions, de définir des points d'arrêt,
et ainsi de suite
Sans argument, un 1 est renvoyé si le débogueur n'est pas en cours d'exécution, sinon un 0 est renvoyé.
revenu.
Avec un argument 1, le débogueur est démarré. Avec un argument 0, le débogueur est
arrêté. Si un argument 1 est précédé du -maintenant flag, le débogueur est démarré
immédiatement (c'est-à-dire au milieu du déboguer commande elle-même). Sinon, le
le débogueur est démarré avec la prochaine instruction Tcl.
Le manuel de formation déboguer La commande ne modifie aucun piège. Comparez cela au démarrage d'Expect avec
le -D drapeau (voir ci-dessus).
Voir le fichier README ou VOIR AUSSI (ci-dessous) pour plus d'informations sur le débogueur.
couper
déconnecte un processus forké du terminal. Il continue de fonctionner dans le
arrière-plan. Le processus reçoit son propre groupe de processus (si possible). E/S standards
est redirigé vers /dev/null.
Le fragment suivant utilise couper pour continuer à exécuter le script dans le
fond.
si {[fork]!=0} quittez
couper
. . .
Le script suivant lit un mot de passe, puis exécute un programme toutes les heures qui
demande un mot de passe à chaque exécution. Le script fournit le mot de passe afin que
vous ne devez le saisir qu'une seule fois. (Voir le Sty commande qui montre comment tourner
hors écho du mot de passe.)
send_user "mot de passe ?\ "
expect_user -re "(.*)\n"
pour 1 {} {
if {[fork]!=0} {sleep 3600;continue}
couper
spawn priv_prog
attendez-vous à un mot de passe :
envoyer "$expect_out(1,string)\r"
. . .
sortie
}
Un avantage à utiliser couper sur la fonctionnalité de processus asynchrone du shell (&) est
qui SAVOIR-FAIRE peut enregistrer les paramètres du terminal avant la déconnexion, puis plus tard
appliquez-les aux nouveaux ptys. Avec &, SAVOIR-FAIRE n'a pas l'occasion de lire le
paramètres du terminal puisque le terminal est déjà déconnecté au moment où SAVOIR-FAIRE
reçoit le contrôle.
sortie [-options] [statut]
les causes SAVOIR-FAIRE sortir ou se préparer à le faire.
Le manuel de formation -une sortie flag fait que l'argument suivant est utilisé comme gestionnaire de sortie. Sans un
argument, le gestionnaire de sortie actuel est renvoyé.
Le manuel de formation -Sans issue drapeau causes SAVOIR-FAIRE se préparer à sortir mais s'arrêter avant d'en fait
rendre le contrôle au système d’exploitation. Le gestionnaire de sortie défini par l'utilisateur est exécuté en tant que
ainsi que les propres gestionnaires internes d'Expect. Aucune autre commande Expect ne devrait être
réalisé. Ceci est utile si vous exécutez Expect avec d'autres extensions Tcl. Le
l'interpréteur actuel (et la fenêtre principale si dans l'environnement Tk) restent afin que les autres
Les extensions Tcl peuvent nettoyer. Si je m'attends à sortie est appelé à nouveau (même si cela pourrait
se produisent), les gestionnaires ne sont pas réexécutés.
En quittant, toutes les connexions aux processus générés sont fermées. La fermeture sera
détecté comme EOF par les processus générés. sortie ne prend aucune autre mesure au-delà de ce que
la normale _sortir(2) la procédure le fait. Ainsi, des processus générés qui ne vérifient pas
EOF peut continuer à fonctionner. (Diverses conditions sont importantes pour déterminer, par exemple
Par exemple, quels signaux un processus généré sera envoyé, mais ce sont des signaux système.
dépendant, généralement documenté sous sortie(3).) Processus engendrés qui continuent à
run sera hérité par init.
statuts (ou 0 si non spécifié) est renvoyé comme état de sortie de SAVOIR-FAIRE. sortie is
implicitement exécuté si la fin du script est atteinte.
exp_continue [-continue_timer]
La commande exp_continue permet attendre lui-même pour continuer à s'exécuter plutôt que
revenir comme il le ferait normalement. Par défaut exp_continue réinitialise le délai d'attente.
Le manuel de formation -continue_timer L'indicateur empêche le redémarrage de la minuterie. (Voir attendre pour plus d'
informations.)
exp_internal [-F déposer] Plus-value
amène d'autres commandes à envoyer des informations de diagnostic internes à SAVOIR-FAIRE à stderr
if Plus-value est non nul. Cette sortie est désactivée si Plus-value est 0. Le diagnostic
Les informations incluent chaque caractère reçu et chaque tentative faite pour correspondre au
sortie de courant contre les modèles.
Si l'optionnel filet est fourni, toutes les sorties normales et de débogage y sont écrites
fichier (quelle que soit la valeur de Plus-value). Tout fichier de sortie de diagnostic précédent est
mis la clé sous la porte.
Le manuel de formation -Info L'indicateur amène exp_internal à renvoyer une description du dernier non-
arguments d'information donnés.
exp_open [arguments] [-je spawn_id]
renvoie un identifiant de fichier Tcl qui correspond à l'identifiant d'apparition d'origine. Le fichier
l'identifiant peut alors être utilisé comme s'il était ouvert par Tcl ouvert commande. (Le frai
L'identifiant ne devrait plus être utilisé. UN attendez ne doit pas être exécuté.
Le manuel de formation -laisser ouvert L'indicateur laisse l'identifiant d'apparition ouvert pour l'accès via les commandes Expect. UN
attendez doit être exécuté sur l'identifiant d'apparition.
exp_pid [-je spawn_id]
renvoie l'identifiant du processus correspondant au processus actuellement généré. Si la -i
flag est utilisé, le pid renvoyé correspond à celui de l'identifiant d'apparition donné.
exp_send
est un alias pour envoyer.
exp_send_error
est un alias pour envoyer_erreur.
exp_send_log
est un alias pour envoyer_log.
exp_send_tty
est un alias pour envoyer_tty.
exp_send_user
est un alias pour envoyer_utilisateur.
exp_version [[-sortie] version]
est utile pour garantir que le script est compatible avec la version actuelle de
Attendre.
Sans arguments, la version actuelle de SAVOIR-FAIRE est retourné. Cette version pourra alors
être codé dans votre script. Si vous savez réellement que vous n'utilisez pas les fonctionnalités de
versions récentes, vous pouvez spécifier une version antérieure.
Les versions se composent de trois nombres séparés par des points. Le premier est le nombre majeur.
Scripts écrits pour les versions de SAVOIR-FAIRE avec un nombre majeur différent sera presque
ne fonctionne certainement pas. exp_version renvoie une erreur si les nombres majeurs ne correspondent pas.
Le deuxième est le nombre mineur. Scripts écrits pour une version avec un plus grand mineur
numéro supérieur à la version actuelle peut dépendre d'une nouvelle fonctionnalité et peut ne pas fonctionner.
exp_version renvoie une erreur si les nombres majeurs correspondent, mais le numéro mineur du script
est supérieur à celui de la course SAVOIR-FAIRE.
Troisièmement, un nombre qui ne joue aucun rôle dans la comparaison des versions. Cependant, il est
incrémenté lorsque le SAVOIR-FAIRE la distribution du logiciel est modifiée de quelque manière que ce soit, par exemple par
documentation supplémentaire ou optimisation. Il est remis à 0 à chaque nouveau mineur
version.
Avec la collection -sortir drapeau, SAVOIR-FAIRE imprime une erreur et se ferme si la version est obsolète.
attendre [[-opte] pat1 corps1] ... [-options] modèle [corps]
attend que l'un des modèles corresponde à la sortie d'un processus généré, un
une période de temps est écoulée ou une fin de fichier est constatée. Si le corps final est vide, il
peut être omis.
Modèles des plus récents attendre_avant commande sont implicitement utilisées avant tout
d'autres modèles. Modèles des plus récents attendre_après les commandes sont implicitement
utilisé après tout autre modèle.
Si les arguments de l'ensemble attendre l'instruction nécessite plus d'une ligne, toutes les
les arguments peuvent être "regroupés" en un seul afin d'éviter de terminer chaque ligne par un
barre oblique inverse. Dans ce cas, les substitutions Tcl habituelles se produiront malgré le
croisillons.
Si un modèle est le mot-clé eof, l'organisme correspondant est exécuté à la fin de
déposer. Si un modèle est le mot-clé temps mort, l'organisme correspondant est exécuté le
temps mort. Si aucun mot-clé timeout n'est utilisé, une action nulle implicite est exécutée dès
temps mort. Le délai d'attente par défaut est de 10 secondes mais peut être défini, par exemple pour
30, par la commande "set timeout 30". Un délai d'attente infini peut être désigné par le
valeur -1. Si un modèle est le mot-clé défaut, le corps correspondant est exécuté
soit en cas d'expiration du délai, soit en fin de fichier.
Si un modèle correspond, alors le corps correspondant est exécuté. attendre renvoie le
résultat du corps (ou de la chaîne vide si aucun modèle ne correspond). Dans le cas où
plusieurs motifs correspondent, celui qui apparaît en premier est utilisé pour sélectionner un corps.
Chaque fois qu'une nouvelle sortie arrive, elle est comparée à chaque modèle dans l'ordre où ils sont
répertorié. Ainsi, vous pouvez tester l'absence de correspondance en créant le dernier modèle
quelque chose qui apparaîtra à coup sûr, comme une invite. Dans les situations où il n'y a pas
invite, vous devez utiliser temps mort (comme vous le feriez si vous interagissiez manuellement).
Les modèles sont spécifiés de trois manières. Par défaut, les modèles sont spécifiés comme avec
Tcl un magnifique rencontre commande. (Ces modèles sont également similaires aux modèles réguliers du C-shell
expressions généralement appelées modèles « glob »). Le -gl le drapeau peut être utilisé
pour protéger les modèles qui pourraient autrement correspondre attendre drapeaux de le faire. N'importe lequel
le modèle commençant par un "-" doit être protégé de cette façon. (Toutes les chaînes commençant
avec "-" sont réservés aux options futures.)
Par exemple, le fragment suivant recherche une connexion réussie. (Noter que avortement
est présumé être une procédure définie ailleurs dans le script.)
attendre {
occupé {met occupé\n ; exp_continue}
échec de l'abandon
Abandon "mot de passe invalide"
abandon du délai d'attente
connecté
}
Les guillemets sont nécessaires sur le quatrième motif puisqu'il contient un espace, ce qui
sinon, séparez le modèle de l'action. Les modèles avec la même action (comme
comme les 3ème et 4ème) nécessitent de réénumérer les actions. Cela peut être évité en utilisant
modèles de style regexp (voir ci-dessous). Plus d'informations sur la formation de modèles de style global
peut être trouvé dans le manuel Tcl.
Les modèles de style Regexp suivent la syntaxe définie par Tcl regexp (abréviation de "régulier"
expression"). Les modèles d'expression rationnelle sont introduits avec l'indicateur -réL’
L'exemple précédent peut être réécrit en utilisant une expression rationnelle comme :
attendre {
occupé {met occupé\n ; exp_continue}
-re "échec|mot de passe invalide" abandonner
abandon du délai d'attente
connecté
}
Les deux types de modèles sont « non ancrés ». Cela signifie que les modèles ne doivent pas nécessairement
correspond à la chaîne entière, mais peut commencer et terminer la correspondance n'importe où dans la chaîne (comme
tant que tout le reste correspond). Utilisez ^ pour faire correspondre le début d'une chaîne, et $
pour correspondre à la fin. Notez que si vous n'attendez pas la fin d'une chaîne, votre
les réponses peuvent facilement se retrouver au milieu de la chaîne car elles sont renvoyées par le
processus engendré. Tout en produisant des résultats corrects, le résultat peut paraître
non naturel. Ainsi, l'utilisation de $ est encouragée si vous pouvez décrire exactement les caractères
au bout d'une chaîne.
Notez que dans de nombreux éditeurs, le ^ et le $ correspondent au début et à la fin des lignes.
respectivement. Cependant, comme expect n'est pas orienté ligne, ces caractères correspondent
le début et la fin des données (par opposition aux lignes) actuellement attendues
tampon correspondant. (Voir également la note ci-dessous sur « l'indigestion du système ».)
Le manuel de formation -ex flag fait correspondre le modèle comme une chaîne "exacte". Non
l'interprétation de *, ^, etc. est faite (bien que les conventions Tcl habituelles doivent toujours
être observé). Les modèles exacts ne sont toujours pas ancrés.
Le manuel de formation -aucun cas L'indicateur fait comparer les caractères majuscules de la sortie comme s'ils
étaient des caractères minuscules. Le motif n’est pas affecté.
Lors de la lecture de la sortie, plus de 2000 XNUMX octets peuvent forcer l'affichage des octets précédents.
"oublié". Ceci peut être modifié avec la fonction match_max. (Notez que
des valeurs excessivement élevées peuvent ralentir le modèle de correspondance.) Si liste de pataugeoire is
tampon_complet, le corps correspondant est exécuté si match_max les octets ont été
reçu et aucun autre modèle ne correspond. Que ce soit ou non le tampon_complet mot-clé
est utilisé, les caractères oubliés sont écrits dans expect_out(buffer).
If liste de pataugeoire est le mot-clé nul, et les valeurs nulles sont autorisées (via le supprimer_nulls
commande), le corps correspondant est exécuté si un seul 0 ASCII correspond. C'est
impossible de faire correspondre 0 octet via des modèles glob ou regexp.
Lors de la correspondance avec un modèle (ou eof ou full_buffer), toute correspondance et précédemment
la sortie inégalée est enregistrée dans la variable expect_out (tampon). Jusqu'à 9 expressions rationnelles
les correspondances de sous-chaînes sont enregistrées dans les variables expect_out(1,chaîne) à travers
expect_out(9,chaîne). Si l' -indices Le drapeau est utilisé avant un motif, le début
et les indices de fin (sous une forme adaptée à gamme) des 10 chaînes sont stockées dans
les variables expect_out (X, début) et attendre_out(X,fin) où X est un chiffre,
correspond à la position de la sous-chaîne dans le tampon. 0 fait référence aux chaînes qui
correspond à l'intégralité du modèle et est généré pour les modèles globaux ainsi que pour les expressions rationnelles
motifs. Par exemple, si un processus a produit la sortie "abcdefgh\n", le résultat
de:
attendez "cd"
c'est comme si les instructions suivantes avaient été exécutées :
définir expect_out (0, chaîne) cd
définir expect_out (buffer) abcd
et "efgh\n" est laissé dans le tampon de sortie. Si un processus a produit le résultat
"abbbcabkkkka\n", le résultat de :
attendre -indices -re "b(b*).*(k+)"
c'est comme si les instructions suivantes avaient été exécutées :
définir expect_out(0,start) 1
définir expect_out (0, fin) 10
définir expect_out(0,string) bbbcabkkkk
définir expect_out(1,start) 2
définir expect_out (1, fin) 3
définir expect_out(1,string) bb
définir expect_out(2,start) 10
définir expect_out (2, fin) 10
définir expect_out (2, chaîne) k
définir expect_out (buffer) abbbcabkkkk
et "a\n" est laissé dans le tampon de sortie. Le motif "*" (et -re ".*") sera vidé
le tampon de sortie sans lire plus de sortie du processus.
Normalement, la sortie correspondante est supprimée des tampons internes d'Expect. Ceci peut
être évité en préfixant un motif avec le -pas de transfert drapeau. Ce drapeau est
particulièrement utile pour expérimenter (et peut être abrégé en "-not" pour plus de commodité
en expérimentant).
L'identifiant d'apparition associé à la sortie correspondante (ou eof ou full_buffer) est stocké
in expect_out (spawn_id).
Le manuel de formation -temps libre L'indicateur amène la commande attendue actuelle à utiliser la valeur suivante comme valeur
timeout au lieu d'utiliser la valeur de la variable timeout.
Par défaut, les modèles sont comparés aux résultats du processus en cours.
le -i flag déclare que la sortie de la liste spawn_id nommée doit être comparée à n'importe quel
modèles suivants (jusqu'au prochain -i). La liste spawn_id doit être soit un
liste de spawn_ids séparés par des espaces ou une variable faisant référence à une telle liste de
spawn_ids.
Par exemple, l'exemple suivant attend "connecté" du processus en cours,
ou "occupé", "échec" ou "mot de passe invalide" à partir du spawn_id nommé par $proc2.
attendre {
-i $proc2 occupé {met occupé\n ; exp_continue}
-re "échec|mot de passe invalide" abandonner
abandon du délai d'attente
connecté
}
La valeur de la variable globale any_spawn_id peut être utilisé pour faire correspondre des motifs à n'importe quel
spawn_ids nommés avec tous les autres -i drapeaux dans le courant attendre commander. le
spawn_id d'un -i drapeau sans motif associé (c'est-à-dire suivi immédiatement par
une -i) est mis à la disposition de tous les autres modèles du même attendre commander
associé à any_spawn_id.
Le manuel de formation -i flag peut également nommer une variable globale, auquel cas la variable est lue pour un
liste des identifiants d'apparition. La variable est relue à chaque fois qu'elle change. Cela fournit un moyen
de changer la source d'E/S pendant que la commande est en exécution. Identifiants d'apparition fournis
de cette façon sont appelés identifiants d'apparition "indirects".
Des actions telles que pause et continuer provoquer des structures de contrôle (c.-à-d. pour, proc) À
se comporter de la manière habituelle. La commande exp_continue permet attendre lui-même pour continuer
exécuter plutôt que de revenir comme il le ferait normalement.
Ceci est utile pour éviter les boucles explicites ou les instructions attendues répétées. Le
L'exemple suivant fait partie d'un fragment pour automatiser la connexion. Le exp_continue évite
je dois écrire une seconde attendre instruction (pour rechercher à nouveau l'invite) si le
rlogin demande un mot de passe.
attendre {
Mot de passe: {
stty -écho
send_user "mot de passe (pour $user) sur $host : "
expect_user -re "(.*)\n"
utilisateur_expéditeur "\n"
envoyer "$expect_out(1,string)\r"
écho stty
exp_continue
} Incorrect {
send_user "mot de passe ou compte invalide\n"
sortie
} temps mort {
send_user "la connexion à $host a expiré\n"
sortie
} eof {
envoyer_utilisateur \
"La connexion à l'hôte a échoué : $expect_out(buffer)"
sortie
} -re $invite
}
Par exemple, le fragment suivant peut aider un utilisateur à guider une interaction
déjà totalement automatisé. Dans ce cas, le terminal est mis en mode brut. Si la
l'utilisateur appuie sur "+", une variable est incrémentée. Si "p" est enfoncé, plusieurs retours sont
envoyé au processus, peut-être pour le pousser d'une manière ou d'une autre, et "i" permet à l'utilisateur d'interagir
avec le processus, volant ainsi le contrôle du script. Dans chaque cas,
le exp_continue permet au courant attendre pour continuer la correspondance de motifs après
exécuter l’action en cours.
stty brut-écho
attendre_après {
-i $user_spawn_id
"p" {envoyer "\r\r\r" ; exp_continue}
"+" {augmenter foo; exp_continue}
"je" {interagir; exp_continue}
quitter "quitter"
}
Par défaut, exp_continue réinitialise le délai d'attente. La minuterie ne redémarre pas si
exp_continue est appelé avec le -continue_timer drapeau.
attendre_après [expect_args]
fonctionne de la même manière que le attendre_avant sauf que si les modèles des deux attendre et
attendre_après peut correspondre, le attendre le motif est utilisé. Voir le attendre_avant commander
pour plus d'informations.
attente_fond [expect_args]
prend les mêmes arguments que attendre, mais il revient immédiatement. Les modèles sont
testé chaque fois qu’une nouvelle entrée arrive. Le motif temps mort et défaut n'ont aucun sens
à attente_fond et sont silencieusement rejetés. Sinon, le attente_fond
commande utilise attendre_avant et attendre_après des modèles comme attendre t.
Quand attente_fond les actions sont en cours d'évaluation, le traitement en arrière-plan pour le
le même identifiant d'apparition est bloqué. Le traitement en arrière-plan est débloqué lorsque l'action
complète. Pendant que le traitement en arrière-plan est bloqué, il est possible d'effectuer une
(premier plan) attendre sur le même identifiant d'apparition.
Il n'est pas possible d'exécuter un attendre tandis qu'un attente_fond est débloqué.
attente_fond pour un identifiant d'apparition particulier est supprimé en déclarant un nouveau
expect_background avec le même identifiant d'apparition. Déclarer attente_fond sans
pattern supprime l'identifiant d'apparition donné de la possibilité de faire correspondre les modèles dans le
fond.
attendre_avant [expect_args]
prend les mêmes arguments que attendre, mais il revient immédiatement. Modèle-action
paires des plus récentes attendre_avant avec le même identifiant d'apparition sont implicitement ajoutés
à tout ce qui suit attendre commandes. Si un motif correspond, il est traité comme s'il avait
été précisé dans le attendre commande elle-même, et le corps associé est exécuté dans
le contexte de la attendre commande. Si les modèles des deux attendre_avant et attendre
peut correspondre, le attendre_avant le motif est utilisé.
Si aucun modèle n'est spécifié, l'ID d'apparition n'est vérifié pour aucun modèle.
Sauf dérogation par un -i drapeau, attendre_avant les modèles correspondent à l'identifiant d'apparition
défini au moment où le attendre_avant la commande a été exécutée (pas quand elle
le motif correspond).
L'indicateur -info provoque attendre_avant pour renvoyer les spécifications actuelles de ce
modèles auxquels il correspondra. Par défaut, il rapporte l'identifiant d'apparition actuel. Un
Une spécification facultative de l'identifiant d'apparition peut être donnée pour plus d'informations sur cet identifiant d'apparition. Pour
(ici)
expect_before -info -i $proc
Au plus une spécification d'identifiant d'apparition peut être donnée. Le flag -indirect supprime
des identifiants d'apparition directs qui proviennent uniquement de spécifications indirectes.
Au lieu d'une spécification d'identifiant d'apparition, l'indicateur "-all" fera en sorte que "-info" fasse rapport sur
tous les identifiants d'apparition.
La sortie de l'indicateur -info peut être réutilisée comme argument de expect_before.
attendre_tty [expect_args]
c'est comme attendre mais il lit les caractères de /dev/tty (c'est-à-dire les frappes du clavier
utilisateur). Par défaut, la lecture s'effectue en mode cuit. Ainsi, les lignes doivent se terminer par
un retour pour attendre de les voir. Cela peut être modifié via Sty (voir le
Sty commande ci-dessous).
utilisateur_attendu [expect_args]
c'est comme attendre mais il lit les caractères de stdin (c'est-à-dire les frappes de l'utilisateur).
Par défaut, la lecture s'effectue en mode cuit. Ainsi, les lignes doivent se terminer par un retour
afin de attendre de les voir. Cela peut être modifié via Sty (voir le Sty commander
ci-dessous).
fourche crée un nouveau processus. Le nouveau processus est une copie exacte de l'actuel SAVOIR-FAIRE
processus. Sur le succès, fourche renvoie 0 au nouveau processus (enfant) et renvoie le
ID de processus du processus enfant au processus parent. En cas d'échec (invariablement dû
au manque de ressources, par exemple, espace d'échange, mémoire), fourche renvoie -1 au parent
processus, et aucun processus enfant n’est créé.
Les processus forkés sortent via le sortie commande, tout comme le processus original. À bifurcation
les processus sont autorisés à écrire dans les fichiers journaux. Si vous ne désactivez pas le débogage ou
en vous connectant à la plupart des processus, le résultat peut être déroutant.
Certaines implémentations de pty peuvent être confondues par plusieurs lecteurs et rédacteurs, même
momentanément. Ainsi, il est plus sûr de fourche avant les processus de frai.
interagir [chaîne1 corps1] ... [chaîne [corps]]
donne le contrôle du processus en cours à l'utilisateur, de sorte que les frappes soient envoyées au
processus en cours, et les sorties standard et standard du processus en cours sont renvoyées.
Les paires chaîne-corps peuvent être spécifiées comme arguments, auquel cas le corps est exécuté
lorsque la chaîne correspondante est saisie. (Par défaut, la chaîne n'est pas envoyée à
le processus actuel.) Le interprète la commande est supposée, si le corps final est
manquant.
Si les arguments de l'ensemble interagir l'instruction nécessite plus d'une ligne, toutes
les arguments peuvent être "regroupés" en un seul afin d'éviter de terminer chaque ligne par un
barre oblique inverse. Dans ce cas, les substitutions Tcl habituelles se produiront malgré le
croisillons.
Par exemple, les exécutions de commande suivantes interagissent avec le corps de chaîne suivant
paires définies : lorsque ^Z est enfoncé, SAVOIR-FAIRE est suspendue. (Le -réinitialiser le drapeau restaure
les modes du terminal.) Lorsque ^A est enfoncé, l'utilisateur voit "vous avez tapé un contrôle-A" et
le processus reçoit un ^A. Lorsque $ est enfoncé, l'utilisateur voit la date. Quand ^C est
pressé, SAVOIR-FAIRE sorties. Si "foo" est saisi, l'utilisateur voit "bar". Quand ~~ est
pressé, le SAVOIR-FAIRE l'interprète fonctionne de manière interactive.
définir CTRLZ \032
interagir {
-reset $CTRLZ {exec kill -STOP [pid]}
\001 {send_user "vous avez tapé un contrôle-A\n" ;
envoyer "\001"
}
$ {send_user "La date est [format d'horloge [secondes d'horloge]]."}
\003 sortie
foo {send_user "bar"}
~~
}
Dans les paires chaîne-corps, les chaînes sont mises en correspondance dans l'ordre dans lequel elles sont répertoriées comme arguments.
Les chaînes qui correspondent partiellement ne sont pas envoyées au processus en cours en prévision de
le reste arrive. Si des caractères sont ensuite saisis de telle sorte qu'il ne soit plus possible
peut-être une correspondance, seule la partie de la chaîne sera envoyée au processus qui
ne peut pas commencer un autre match. Ainsi, les chaînes qui sont des sous-chaînes de
les correspondances peuvent correspondre plus tard, si les chaînes d'origine qui tentaient de correspondre
échoue finalement.
Par défaut, la correspondance des chaînes est exacte, sans caractères génériques. (En revanche, le attendre
(la commande utilise des modèles de style glob par défaut.) Le -ex le drapeau peut être utilisé pour protéger
des modèles qui pourraient autrement correspondre interagir drapeaux de le faire. N'importe quel modèle
commençant par un "-" doit être protégé de cette façon. (Toutes les chaînes commençant par "-"
sont réservés pour des options futures.)
Le manuel de formation -ré flag force la chaîne à être interprétée comme un modèle de style expression rationnelle. Dans ce
Dans ce cas, les sous-chaînes correspondantes sont stockées dans la variable interagir_out de la même manière que le
manière attendre stocke sa sortie dans la variable attente_outL’ -indices le drapeau est
de la même manière pris en charge.
Le motif eof introduit une action qui est exécutée à la fin du fichier. Un séparé
eof le modèle peut également suivre le -sortir flag auquel cas il correspond si un eof
est détecté lors de l’écriture de la sortie. Le défaut eof l'action est "retour", de sorte que
interagir revient simplement sur n'importe quel EOF.
Le motif temps mort introduit un délai d'attente (en secondes) et une action exécutée
après qu'aucun caractère n'a été lu pendant un temps donné. Le temps mort le modèle s'applique à
le processus spécifié le plus récemment. Il n'y a pas de délai d'attente par défaut. Le spécial
variable "timeout" (utilisée par le attendre commande) n’a aucun effet sur ce délai d’attente.
Par exemple, l'instruction suivante pourrait être utilisée pour déconnecter automatiquement les utilisateurs qui n'ont pas encore
vous avez tapé n'importe quoi pendant une heure mais vous recevez toujours des messages système fréquents :
interagir -input $user_spawn_id timeout 3600 return -output \
$spawn_id
Si le modèle est le mot-clé nul, et les valeurs nulles sont autorisées (via le supprimer_nulls
commande), le corps correspondant est exécuté si un seul 0 ASCII correspond. C'est
impossible de faire correspondre 0 octet via des modèles glob ou regexp.
Faire précéder un motif du drapeau -j'écris provoque la variable interactive_out (spawn_id)
à définir sur le spawn_id qui correspond au modèle (ou eof).
Des actions telles que pause et continuer provoquer des structures de contrôle (c.-à-d. pour, proc) À
se comporter de la manière habituelle. Cependant retourner provoque le retour d'Interact vers son appelant,
tout en inter_retour les causes interagir pour provoquer un retour chez son appelant. Par exemple, si
"proc foo" appelé interagir qui a ensuite exécuté l'action inter_retour, proc foo
retournerais. (Cela signifie que si interagir en cours interprète saisie interactive
retourner entraînera la poursuite de l'interaction, tandis que inter_retour provoque l'
interagir pour revenir à son appelant.)
Pendant interagir, le mode brut est utilisé pour que tous les caractères puissent être transmis au
processus actuel. Si le processus en cours ne capte pas les signaux de contrôle des tâches, il sera
stop si un signal d'arrêt est envoyé (par défaut ^Z). Pour le redémarrer, envoyez un signal de continuation
(comme par "kill -CONT "). Si vous souhaitez vraiment envoyer un SIGSTOP à un tel
processus (par ^Z), envisagez d'abord de générer csh, puis d'exécuter votre programme. Sur le
Par contre, si vous souhaitez envoyer un SIGSTOP à SAVOIR-FAIRE lui-même, interprète de premier appel
(peut-être en utilisant un caractère d'échappement), puis appuyez sur ^Z.
Les paires chaîne-corps peuvent être utilisées comme raccourci pour éviter d'avoir à saisir le
interpréter et exécuter des commandes de manière interactive. Le mode terminal précédent est utilisé
pendant que le corps d'une paire chaîne-corps est en cours d'exécution.
Pour plus de rapidité, les actions s'exécutent en mode brut par défaut. Le -réinitialiser le drapeau réinitialise le
terminal au mode qu'il avait avant interagir a été exécuté (invariablement, mode cuit).
Notez que les caractères saisis lors du changement de mode peuvent être perdus (un
fonctionnalité malheureuse du pilote de terminal sur certains systèmes). La seule raison d'utiliser
-réinitialiser c'est si votre action dépend de l'exécution en mode cuit.
Le manuel de formation -écho l'indicateur renvoie les caractères qui correspondent au modèle suivant au processus
qui les a générés à mesure que chaque caractère est lu. Cela peut être utile lorsque l'utilisateur
doit voir les commentaires des modèles partiellement tapés.
Si un modèle est repris mais ne parvient finalement pas à correspondre, les caractères sont envoyés
au processus engendré. Si le processus généré leur fait ensuite écho, l'utilisateur verra
les personnages deux fois. -écho n'est probablement approprié que dans les situations où le
Il est peu probable que l'utilisateur ne termine pas le modèle. Par exemple, l'extrait suivant est
à partir de rftp, le script ftp récursif, où l'utilisateur est invité à saisir ~g, ~p ou
~l, pour obtenir, mettre ou lister le répertoire courant de manière récursive. Ce sont si loin
à partir des commandes ftp normales, qu'il est peu probable que l'utilisateur tape ~ suivi de
autre chose, sauf erreur, auquel cas ils ignoreront probablement simplement le
résultat quand même.
interagir {
-echo ~g {getcurdirectory 1}
-echo ~l {getcurdirectory 0}
-echo ~p {putcurdirectory}
}
Le manuel de formation -pas de tampon flag envoie les caractères qui correspondent au modèle suivant au
processus de sortie au fur et à mesure de la lecture des caractères.
Ceci est utile lorsque vous souhaitez laisser un programme renvoyer le motif. Par exemple,
ce qui suit peut être utilisé pour surveiller où une personne compose (un style Hayes
modem). Chaque fois que "atd" est vu, le script enregistre le reste de la ligne.
numéro de journal de procédure {} {
interagir -nobuffer -re "(.*)\r" retour
met $log "[format d'horloge [secondes d'horloge]] : composé $interact_out(1,string)"
}
interagir -nobuffer "atd" numéro de journal
Pendant interagir, utilisation antérieure de utilisateur_log est ignoré. En particulier, interagir vont
forcer sa sortie à être enregistrée (envoyée à la sortie standard) car il est présumé que le
l'utilisateur ne souhaite pas interagir aveuglément.
Le manuel de formation -o L'indicateur entraîne l'application de toutes les paires clé-corps suivantes à la sortie du
processus actuel. Cela peut être utile, par exemple, lorsqu'il s'agit d'hôtes qui envoient
caractères indésirables lors d’une session telnet.
Par défaut, interagir s'attend à ce que l'utilisateur écrive stdin et lise stdout du
SAVOIR-FAIRE processus lui-même. Le -u flag (pour "utilisateur") fait interagir recherchez l'utilisateur comme
le processus nommé par son argument (qui doit être un identifiant généré).
Cela permet de relier deux processus non liés sans utiliser d'attribut explicite.
boucle. Pour faciliter le débogage, les diagnostics Expect vont toujours sur stderr (ou stdout pour
certaines informations de journalisation et de débogage). Pour la même raison, le interprète
la commande lira de manière interactive à partir de stdin.
Par exemple, le fragment suivant crée un processus de connexion. Ensuite, il appelle l'utilisateur
(non représenté), et relie finalement les deux ensemble. Bien entendu, tout processus peut être
remplacé par la connexion. Un shell, par exemple, permettrait à l'utilisateur de travailler sans
fournir un compte et un mot de passe.
connexion à l'apparition
définir la connexion $spawn_id
modem de pointe d'apparition
# rappeler l'utilisateur
# connecter l'utilisateur pour se connecter
interagir -u $connexion
Pour envoyer la sortie à plusieurs processus, répertoriez chaque liste d'identifiants d'apparition précédée d'un -sortir
drapeau. L'entrée pour un groupe d'identifiants d'apparition de sortie peut être déterminée par une liste d'identifiants d'apparition
préfacé par un -saisir drapeau. (Les deux -saisir et -sortir peut prendre des listes sous la même forme
car -i drapeau dans le attendre commande, sauf que any_spawn_id n'a pas de sens dans
interagir.) Tous les indicateurs et chaînes (ou modèles) suivants s'appliquent à cette entrée jusqu'à ce que
un autre indicateur -input apparaît. Sinon -saisir apparaît, -sortir implique "-entrée
$user_spawn_id -output". (De même, avec des modèles qui n'ont pas -saisir.) Si
UN -saisir est spécifié, il remplace $user_spawn_id. Si une seconde -saisir is
spécifié, il remplace $spawn_id. Supplémentaire -saisir des drapeaux peuvent être spécifiés.
Les deux processus d'entrée implicites ont par défaut leurs sorties spécifiées comme
$spawn_id et $user_spawn_id (à l'envers). Si un -saisir le drapeau apparaît sans -sortir
flag, les caractères de ce processus sont supprimés.
Le manuel de formation -i flag introduit un remplacement pour le spawn_id actuel lorsqu'aucun autre -saisir
or -sortir des drapeaux sont utilisés. Un indicateur -i implique un indicateur -o.
Il est possible de modifier les processus avec lesquels vous interagissez en utilisant
identifiants d'apparition indirects. (Les identifiants d'apparition indirects sont décrits dans la section sur les attentes.
commande.) Les identifiants d'apparition indirects peuvent être spécifiés avec -i, -u, -input ou -output
drapeaux.
interprète [arguments]
amène l'utilisateur à être invité de manière interactive à SAVOIR-FAIRE et les commandes Tcl. Le
le résultat de chaque commande est imprimé.
Des actions telles que pause et continuer provoquer des structures de contrôle (c.-à-d. pour, proc) À
se comporter de la manière habituelle. Cependant retourner fait revenir l'interprète vers son appelant,
tout en inter_retour les causes interprète pour provoquer un retour chez son appelant. Par exemple,
si "proc foo" est appelé interprète qui a ensuite exécuté l'action inter_retour, proc
foo retournerais. Toute autre commande provoque interprète pour continuer à demander
nouvelles commandes.
Par défaut, l'invite contient deux entiers. Le premier entier décrit la profondeur
de la pile d'évaluation (c'est-à-dire combien de fois Tcl_Eval a été appelé). La deuxième
entier est l'identifiant de l'historique Tcl. L'invite peut être définie en définissant un
procédure appelée "prompt1" dont la valeur de retour devient l'invite suivante. Si un
l'instruction comporte des guillemets ouverts, des parenthèses, des accolades ou des crochets, une invite secondaire (par
par défaut "+> ") est émis lors d'une nouvelle ligne. L'invite secondaire peut être définie en définissant
une procédure appelée "prompt2".
Pendant interprète, le mode cuit est utilisé, même si son appelant utilisait le mode brut.
Si stdin est fermé, interprète reviendra à moins que le -eof le drapeau est utilisé, dans lequel
Dans ce cas, l'argument suivant est invoqué.
fichier journal [arguments] [[-un] déposer]
Si un nom de fichier est fourni, fichier journal enregistrera une transcription de la session
(à partir de ce point) dans le fichier. fichier journal arrêtera l'enregistrement si aucun argument
est donné. Tout fichier journal précédent est fermé.
Au lieu d'un nom de fichier, un identifiant de fichier Tcl peut être fourni en utilisant le -ouvrir or
-laisser ouvert drapeaux. Ceci est similaire au frayer commande. (Voir frayer pour plus d'informations.)
Le manuel de formation -a L'indicateur force la journalisation de la sortie qui a été supprimée par le utilisateur_log commander.
Par défaut, le fichier journal commander ajoute aux anciens fichiers plutôt que de les tronquer,
pour la commodité de pouvoir désactiver et réactiver la connexion plusieurs fois en une seule fois
session. Pour tronquer des fichiers, utilisez le -noappend drapeau.
Le manuel de formation -Info l'indicateur amène log_file à renvoyer une description de la non-information la plus récente
arguments avancés.
utilisateur_log -info|0|1
Par défaut, le dialogue envoyer/attendre est enregistré sur la sortie standard (et dans un fichier journal s'il est ouvert).
La journalisation sur stdout est désactivée par la commande "log_user 0" et réactivée par
"utilisateur_log 1". La journalisation dans le fichier journal est inchangée.
Le manuel de formation -Info l'indicateur amène log_user à renvoyer une description de la non-information la plus récente
arguments avancés.
match_max [-ré] [-je spawn_id] [Taille]
définit la taille du tampon (en octets) utilisé en interne par attendre. Sans longueur du câble
argument, la taille actuelle est renvoyée.
Avec la collection -d drapeau, la taille par défaut est définie. (La valeur par défaut est 2000.) Avec le
-i flag, la taille est définie pour l'identifiant d'apparition nommé, sinon elle est définie pour l'identifiant d'apparition actuel.
processus.
revêtement [-# spawn_id] [-# spawn_id] [...] Programme [arguments]
exécute Programme args à la place du courant SAVOIR-FAIRE programme, qui se termine. UN
L'argument de trait d'union force un trait d'union devant le nom de la commande comme s'il s'agissait d'un
shell de connexion. Tous les spawn_ids sont fermés à l'exception de ceux nommés comme arguments. Ces
sont mappés sur les identifiants de fichiers nommés.
Les Spawn_ids sont mappés aux identifiants de fichiers dont le nouveau programme doit hériter. Pour
Par exemple, la ligne suivante exécute les échecs et lui permet d'être contrôlé par le courant
processus - disons, un maître d'échecs.
superposition -0 $spawn_id -1 $spawn_id -2 $spawn_id échecs
C'est plus efficace que « interact -u », mais cela sacrifie la capacité de faire
interaction programmée depuis le SAVOIR-FAIRE le processus n’est plus sous contrôle.
Notez qu’aucun terminal de contrôle n’est fourni. Ainsi, si vous déconnectez ou remapper
entrée standard, les programmes qui effectuent le contrôle des tâches (shells, connexion, etc.) ne fonctionneront pas
correctement.
parité [-ré] [-je spawn_id] [valeur]
définit si la parité doit être conservée ou supprimée de la sortie des fichiers générés.
processus. Si Plus-value est nul, la parité est supprimée, sinon elle ne l'est pas.
Sans Plus-value argument, la valeur actuelle est renvoyée.
Avec la collection -d flag, la valeur de parité par défaut est définie. (La valeur par défaut initiale est 1, c'est-à-dire
la parité n'est pas supprimée.) Avec le -i drapeau, la valeur de parité est définie pour le nom
ID d'apparition, sinon il est défini pour le processus en cours.
supprimer_nulls [-ré] [-je spawn_id] [valeur]
définit si les valeurs nulles sont conservées ou supprimées de la sortie des processus générés
avant la correspondance de modèle ou le stockage dans la variable attente_out or interagir_out. Si
Plus-value est 1, les valeurs nulles sont supprimées. Si Plus-value est 0, les valeurs nulles ne sont pas supprimées. Sans Plus-value
argument, la valeur actuelle est renvoyée.
Avec la collection -d flag, la valeur par défaut est définie. (La valeur par défaut initiale est 1, c'est-à-dire des valeurs nulles
sont retirés.) Avec le -i flag, la valeur est définie pour l'identifiant d'apparition nommé, sinon
il est défini pour le processus en cours.
Que les valeurs nulles soient supprimées ou non, SAVOIR-FAIRE enregistrera les octets nuls dans le journal et
sortie standard.
envoyer [-drapeaux] un magnifique
Envoie un magnifique au processus actuel. Par exemple, la commande
envoyer "Bonjour tout le monde\r"
envoie les personnages, bonjour monde au processus actuel.
(Tcl inclut une commande de type printf (appelée le format) qui peut construire arbitrairement
chaînes complexes.)
Les caractères sont envoyés immédiatement, bien que les programmes avec entrée en tampon de ligne ne le fassent pas.
lire les caractères jusqu'à ce qu'un caractère de retour soit envoyé. Un caractère de retour est noté
"\r".
Le manuel de formation -- flag force l'argument suivant à être interprété comme une chaîne plutôt que comme un
drapeau. N'importe quelle chaîne peut être précédée de "--", qu'elle ressemble ou non à un
drapeau. Cela fournit un mécanisme fiable pour spécifier des chaînes de variables sans être
trébuché par ceux qui ressemblent accidentellement à des drapeaux. (Toutes les chaînes commençant par
"-" sont réservés aux options futures.)
Le manuel de formation -i flag déclare que la chaîne sera envoyée au spawn_id nommé. Si le spawn_id
is user_spawn_id, et que le terminal est en mode brut, les nouvelles lignes dans la chaîne sont
traduit en séquences de retour à la ligne afin qu'elles apparaissent comme si le terminal était en
mode cuit. Le -cru flag désactive cette traduction.
Le manuel de formation -nul l'indicateur envoie des caractères nuls (0 octets). Par défaut, un null est envoyé. Un
entier peut suivre le -nul pour indiquer le nombre de valeurs nulles à envoyer.
Le manuel de formation -pause flag génère une condition de rupture. Cela n'a de sens que si l'identifiant du spawn
fait référence à un périphérique tty ouvert via "spawn -open". Si vous avez généré un processus tel
comme astuce, vous devez utiliser la convention de tip pour générer une pause.
Le manuel de formation -s le drapeau force la sortie à être envoyée "lentement", évitant ainsi la situation courante où
un ordinateur surclasse un tampon d'entrée conçu pour un humain qui ne le ferait jamais
surtype le même tampon. Cette sortie est contrôlée par la valeur de la variable
"send_slow" qui prend une liste de deux éléments. Le premier élément est un entier qui
décrit le nombre d'octets à envoyer atomiquement. Le deuxième élément est un réel
nombre qui décrit le nombre de secondes pendant lesquelles les envois atomiques doivent être
séparé. Par exemple, "set send_slow {10 .001}" forcerait "send -s" à envoyer
chaînes avec 1 milliseconde entre chaque 10 caractères envoyés.
Le manuel de formation -h flag force la sortie à être envoyée (un peu) comme un humain en train de taper.
Des retards semblables à ceux des humains apparaissent entre les personnages. (L'algorithme est basé sur un
distribution Weibull, avec des modifications pour s'adapter à cette application particulière.) Cette
la sortie est contrôlée par la valeur de la variable "send_human" qui prend cinq
liste d'éléments. Les deux premiers éléments sont le temps moyen entre les arrivées des caractères dans
secondes. Le premier est utilisé par défaut. Le second est utilisé à la fin des mots, pour
simulez les pauses subtiles qui se produisent occasionnellement lors de telles transitions. Le troisième
Le paramètre est une mesure de variabilité où 1 est assez variable, 1 est raisonnablement
variable, et 10 est tout à fait invariable. Les extrêmes vont de 0 à l’infini. Les deux derniers
les paramètres sont respectivement un temps inter-arrivée minimum et maximum. Le minimum
et maximum sont utilisés en dernier et "clipsent" la dernière fois. La moyenne ultime peut être
assez différent de la moyenne donnée si le clip minimum et maximum est suffisant
valeurs.
À titre d'exemple, la commande suivante émule une saisie rapide et cohérente :
définir send_human {.1 .3 1 .05 2}
send -h "J'ai faim. Allons déjeuner."
tandis que ce qui suit pourrait être plus approprié après une gueule de bois :
définir send_human {.4 .4 .2 .5 100}
send -h "Bonne soirée de cils !"
Notez que les erreurs ne sont pas simulées, bien que vous puissiez configurer la correction d'erreurs
situations vous-même en intégrant des erreurs et des corrections dans un argument d'envoi.
Les drapeaux pour envoyer des caractères nuls, pour envoyer des pauses, pour forcer une sortie lente
et pour une production de style humain s'excluent mutuellement. Seul le dernier spécifié sera
être utilisé. Par ailleurs, non un magnifique l'argument peut être spécifié avec les drapeaux pour l'envoi
caractères nuls ou sauts.
C'est une bonne idée de précéder le premier envoyer à un processus par un attendre. attendre vont
attendez que le processus démarre, pendant que envoyer ne peut pas. En particulier, si le premier envoyer
se termine avant le début du processus, vous courez le risque que vos données
ignoré. Dans les situations où les programmes interactifs n'offrent aucune invite initiale, vous pouvez
précède envoyer par un retard comme dans :
# Pour éviter de donner des indications aux pirates sur la manière de s'introduire par effraction,
# ce système ne demande pas de mot de passe externe.
# Attendez 5 secondes pour que l'exécution soit terminée
générer telnet very.secure.gov
sommeil 5
envoyer le mot de passe\r
exp_send est un alias pour envoyer. Si vous utilisez Expectk ou une autre variante de
Attendez-vous à ce que dans l'environnement Tk, envoyer est défini par Tk pour un tout autre
objectif. exp_send est fourni pour la compatibilité entre les environnements. Similaire
des alias sont fournis pour les autres commandes d'envoi d'Expect.
envoyer_erreur [-drapeaux] un magnifique
c'est comme envoyer, sauf que la sortie est envoyée à stderr plutôt qu'au courant
processus.
envoyer_log [-] un magnifique
c'est comme envoyer, sauf que la chaîne est uniquement envoyée au fichier journal (voir fichier journal.)
Les arguments sont ignorés si aucun fichier journal n'est ouvert.
envoyer_tty [-drapeaux] un magnifique
c'est comme envoyer, sauf que la sortie est envoyée à /dev/tty plutôt qu'au courant
processus.
envoyer_utilisateur [-drapeaux] un magnifique
c'est comme envoyer, sauf que la sortie est envoyée vers la sortie standard plutôt que vers la sortie actuelle
processus.
sleep secondes
provoque la mise en veille du script pendant le nombre de secondes donné. Les secondes peuvent être un
nombre décimal. Les interruptions (et les événements Tk si vous utilisez Expectk) sont traitées
pendant que Expect dort.
frayer [arguments] Programme [arguments]
crée un nouveau processus en cours d'exécution Programme args. Ses stdin, stdout et stderr sont
connectés à Expect, afin qu'ils puissent être lus et écrits par d'autres SAVOIR-FAIRE les commandes.
La connexion est rompue par close ou si le processus lui-même ferme l'un des fichiers
identifiants.
Lorsqu'un processus est lancé par frayer, la variable spawn_id est défini sur un descripteur
faisant référence à ce processus. Le processus décrit par spawn_id est considéré comme le
actuel processus. spawn_id peut être lu ou écrit, offrant ainsi un contrôle du travail.
user_spawn_id est une variable globale contenant un descripteur qui fait référence à l'utilisateur.
Par exemple, quand spawn_id est réglé sur cette valeur, attendre se comporte comme utilisateur_attendu.
error_spawn_id est une variable globale contenant un descripteur qui fait référence au
erreur standard. Par exemple, quand spawn_id est réglé sur cette valeur, envoyer se comporte comme
envoyer_erreur.
tty_spawn_id est une variable globale contenant un descripteur qui fait référence à /dev/tty.
Si /dev/tty n'existe pas (comme dans un script cron, at ou batch), alors
tty_spawn_id n'est pas défini. Cela peut être testé comme :
si {[info vars tty_spawn_id]} {
# /dev/tty existe
} Else {
# /dev/tty n'existe pas
# probablement en cron, batch ou at script
}
frayer renvoie l'identifiant du processus UNIX. Si aucun processus n'est généré, 0 est renvoyé. Le
variable spawn_out (esclave, nom) est défini sur le nom du périphérique pty esclave.
Par défaut, frayer fait écho au nom de la commande et aux arguments. Le -noécho le drapeau s'arrête
frayer de faire ça.
Le manuel de formation console L'indicateur entraîne la redirection de la sortie de la console vers le processus généré.
Ceci n'est pas pris en charge sur tous les systèmes.
Intérieurement, frayer utilise un pty, initialisé de la même manière que le tty de l'utilisateur. C'est
encore initialisé afin que tous les paramètres soient "sains" (selon Sty(1)). Si la
variable stty_init est défini, il est interprété dans le style des arguments stty comme
configuration ultérieure. Par exemple, "set stty_init raw" entraînera d'autres
les terminaux des processus pour démarrer en mode brut. -nottycopie ignore l'initialisation
en fonction du terminal de l'utilisateur. -nottyinit ignore l'initialisation "saine".
Normalement, frayer prend peu de temps à exécuter. Si vous remarquez que le frai prend un
un temps considérable, il rencontre probablement des ptys coincés. UN
Un certain nombre de tests sont exécutés sur ptys pour éviter les enchevêtrements avec des processus errants.
(Cela prend 10 secondes par pty coincé.) Exécuter Expect avec le -d l'option affichera
if SAVOIR-FAIRE rencontre de nombreux ptys dans des états impairs. Si vous ne pouvez pas tuer les processus
auquel ces ptys sont attachés, votre seul recours peut être de redémarrer.
If Programme ne peut pas être généré avec succès car exec(2) échoue (par exemple lorsque Programme
n'existe pas), un message d'erreur sera renvoyé par le prochain interagir or attendre
commande comme si Programme avait été exécuté et avait produit le message d'erreur en sortie. Ce
le comportement est une conséquence naturelle de la mise en œuvre de frayer. En interne, spawn
forks, après quoi le processus généré n'a aucun moyen de communiquer avec l'original
SAVOIR-FAIRE processus sauf par communication via le spawn_id.
Le manuel de formation -ouvrir l'indicateur fait que l'argument suivant est interprété comme un identifiant de fichier Tcl
(c'est-à-dire retourné par ouvert.) L'identifiant de spawn peut ensuite être utilisé comme s'il s'agissait d'un
processus. (L'identifiant du fichier ne doit plus être utilisé.) Cela vous permet de traiter les fichiers bruts.
périphériques, fichiers et pipelines en tant que processus générés sans utiliser de pty. 0 est
renvoyé pour indiquer qu’il n’y a aucun processus associé. Lorsque la connexion au
Le processus généré est fermé, tout comme l'identifiant du fichier Tcl. Le -laisser ouvert le drapeau est
similaire à -ouvrir excepté -laisser ouvert fait que l'identifiant du fichier reste ouvert
même après la fermeture de l'identifiant d'apparition.
Le manuel de formation -pty L'indicateur provoque l'ouverture d'un pty mais aucun processus n'est généré. 0 est renvoyé à
indique qu’il n’y a aucun processus associé. Spawn_id est défini comme d'habitude.
La variable spawn_out (esclave, fd) est défini sur un identifiant de fichier correspondant au
pty esclave. Il peut être fermé en utilisant "close -slave".
Le manuel de formation -ignorer flag nomme un signal à ignorer dans le processus généré. Sinon,
les signaux obtiennent le comportement par défaut. Les signaux sont nommés comme dans le piège commande, sauf
que chaque signal nécessite un drapeau distinct.
strass niveau
provoque l'impression des instructions suivantes avant d'être exécutées. (trace de Tcl
la commande trace les variables.) niveau indique jusqu'où il faut tracer dans la pile d'appels.
Par exemple, la commande suivante s'exécute SAVOIR-FAIRE tout en traçant les 4 premiers niveaux de
appels, mais aucun en dessous.
attendez -c "strace 4" script.exp
Le manuel de formation -Info l'indicateur amène strace à renvoyer une description de la non-information la plus récente
arguments avancés.
Sty args
change les modes du terminal de la même manière que la commande externe stty.
Par défaut, le terminal de contrôle est accessible. D'autres terminaux sont accessibles
en ajoutant "< /dev/tty..." à la commande. (Notez que les arguments ne doivent pas être
regroupés en un seul argument.)
Les demandes de statut le renvoient comme résultat de la commande. Si aucun statut n'est
demandé et le terminal de contrôle est accédé, l'état précédent du brut
et les attributs echo sont renvoyés sous une forme qui peut être utilisée ultérieurement par la commande.
Par exemple, les arguments brut or -cuit mettez le terminal en mode brut. Le
arguments -cru or cuit mettez le terminal en mode cuit. Les arguments echo et
-écho mettez le terminal en mode écho et noécho respectivement.
L'exemple suivant illustre comment désactiver temporairement l'écho. Cela pourrait être
utilisé dans des scripts autrement automatiques pour éviter d’y intégrer des mots de passe. (Voir plus
discussion à ce sujet sous ATTENDEZ-VOUS AUX CONSEILS ci-dessous.)
stty -écho
send_user "Mot de passe : "
expect_user -re "(.*)\n"
définir le mot de passe $expect_out(1,string)
écho stty
Système args
donne args à sh(1) en entrée, comme s'il avait été saisi comme commande à partir d'un
Terminal. SAVOIR-FAIRE attend que le shell se termine. Le statut de retour de sh est
traité de la même manière que exec gère son statut de retour.
Contrairement à exec qui redirige stdin et stdout vers le script, Système effectue
pas de redirection (autre que celle indiquée par la chaîne elle-même). Ainsi, c'est
possible d'utiliser des programmes qui doivent communiquer directement avec /dev/tty. Pour la même raison,
les résultats de Système ne sont pas enregistrés dans le journal.
horodatage [arguments]
renvoie un horodatage. Sans argument, le nombre de secondes écoulées depuis l'époque est
revenu.
Le manuel de formation -format flag introduit une chaîne qui est renvoyée mais avec des substitutions effectuées
selon les règles POSIX pour strftime. Par exemple %a est remplacé par un
nom abrégé du jour de la semaine (c'est-à-dire Sam). D'autres sont:
%a nom abrégé du jour de la semaine
%Un nom complet du jour de la semaine
%b nom abrégé du mois
%B nom du mois complet
%c date-heure comme dans : mercredi 6 octobre 11:45:56 1993
%d jour du mois (01-31)
%H heure (00-23)
%I heure (01-12)
%j jour (001-366)
%m mois (01-12)
%M minutes (00-59)
%p matin ou après-midi
%S seconde (00-61)
%u jour (1-7, lundi est le premier jour de la semaine)
%U semaine (00-53, le premier dimanche est le premier jour de la première semaine)
Semaine %V (01-53, style ISO 8601)
%w jour (0-6)
%W semaine (00-53, le premier lundi est le premier jour de la première semaine)
%x date-heure comme dans : mercredi 6 octobre 1993
%X heure comme dans : 23:59:59
%y année (00-99)
%Y année comme en : 1993
Fuseau horaire %Z (ou rien s'il n'est pas déterminable)
%% un simple signe de pourcentage
Les autres spécifications en % ne sont pas définies. D'autres personnages seront transmis
intact. Seules les paramètres régionaux C sont pris en charge.
Le manuel de formation -secondes flag introduit un nombre de secondes depuis l'époque à utiliser comme
source à partir de laquelle formater. Sinon, l'heure actuelle est utilisée.
Le manuel de formation -GMT L'indicateur force la sortie de l'horodatage à utiliser le fuseau horaire GMT. Sans drapeau, le
le fuseau horaire local est utilisé.
piège [[commande] signaux]
provoque le donné commander à exécuter dès réception future de l'un des
signaux. La commande est exécutée dans la portée globale. Si commander est absent, le
l'action du signal est renvoyée. Si commander est la chaîne SIG_IGN, les signaux sont
ignoré. Si commander est la chaîne SIG_DFL, les signaux sont envoyés au système
défaut. signaux est soit un signal unique, soit une liste de signaux. Les signaux peuvent être
spécifié numériquement ou symboliquement selon signal(3). Le préfixe « SIG » peut être
omis.
Sans argument (ou l'argument -numéro), piège renvoie le numéro de signal du
commande trap en cours d'exécution.
Le manuel de formation -code flag utilise le code de retour de la commande à la place du code que Tcl était
sur le point de revenir lorsque la commande a commencé à s'exécuter.
Le manuel de formation -interp flag provoque l'évaluation de la commande à l'aide de l'interpréteur actif à
l'heure à laquelle la commande a commencé à s'exécuter plutôt que l'heure à laquelle le piège a été déclaré.
Le manuel de formation -patate douce drapeau provoque le piège commande pour renvoyer le nom du signal de la commande trap
actuellement en cours d'exécution.
Le manuel de formation -max drapeau provoque le piège commande pour renvoyer le plus grand numéro de signal pouvant être
être réglé.
Par exemple, la commande "trap {send_user "Aïe!"} SIGINT" affichera "Aïe!" chaque
fois que l'utilisateur appuie sur ^C.
Par défaut, SIGINT (qui peut généralement être généré en appuyant sur ^C) et SIGTERM provoquent
Attendez-vous à sortir. Cela est dû au piège suivant, créé par défaut lorsque Expect
départs.
sortie du piège {SIGINT SIGTERM}
Si vous utilisez l'option -D pour démarrer le débogueur, SIGINT est redéfini pour démarrer le
débogueur interactif. Cela est dû au piège suivant :
piège {exp_debug 1} SIGINT
Le piège du débogueur peut être modifié en définissant la variable d'environnement
EXPECT_DEBUG_INIT vers une nouvelle commande trap.
Vous pouvez, bien sûr, remplacer ces deux éléments simplement en ajoutant des commandes trap à votre
scénario. En particulier, si vous disposez de votre propre "trap exit SIGINT", celui-ci remplacera
le piège du débogueur. Ceci est utile si vous souhaitez empêcher les utilisateurs d'accéder au
débogueur du tout.
Si vous souhaitez définir votre propre trap sur SIGINT mais toujours intercepter le débogueur lorsqu'il
est en cours d'exécution, utilisez :
si {![exp_debug]} {trap mystuff SIGINT}
Alternativement, vous pouvez intercepter le débogueur en utilisant un autre signal.
piège ne vous permettra pas de remplacer l'action de SIGALRM car elle est utilisée en interne pour
SAVOIR-FAIRE. La commande de déconnexion définit SIGALRM sur SIG_IGN (ignorer). Vous pouvez réactiver
ceci tant que vous le désactivez lors des commandes d'apparition suivantes.
See signal(3) pour plus d'informations.
attendez [arguments]
retarde jusqu'à ce qu'un processus généré (ou le processus en cours si aucun n'est nommé) se termine.
attendez renvoie normalement une liste de quatre entiers. Le premier entier est le pid du
processus qui était attendu. Le deuxième entier est l'identifiant d'apparition correspondant.
Le troisième nombre entier est -1 si une erreur du système d'exploitation s'est produite, ou 0 dans le cas contraire. Si
le troisième entier était 0, le quatrième entier est le statut renvoyé par le généré
processus. Si le troisième entier était -1, le quatrième entier est la valeur de l'ensemble errno
par le système d'exploitation. La variable globale errorCode est également définie.
Des éléments supplémentaires peuvent apparaître à la fin de la valeur renvoyée par attendez. Un
Le cinquième élément facultatif identifie une classe d’informations. Actuellement, le seul
la valeur possible pour cet élément est CHILDKILLED, auquel cas les deux valeurs suivantes sont
le nom du signal de style C et une brève description textuelle.
Le manuel de formation -i flag déclare le processus à attendre correspondant au spawn_id nommé (PAS
l'identifiant du processus). Dans un gestionnaire SIGCHLD, il est possible d'attendre tout message généré
processus en utilisant l’ID d’apparition -1.
Le manuel de formation -non attends drapeau provoque le retour immédiat de l'attente avec l'indication d'un
attente réussie. Lorsque le processus se termine (plus tard), il disparaîtra automatiquement
sans qu'il soit nécessaire d'attendre explicitement.
Le manuel de formation attendez La commande peut également être utilisée pour attendre un processus forké en utilisant les arguments "-i
-1". Contrairement à son utilisation avec les processus générés, cette commande peut être exécutée à tout moment.
temps. Il n'y a aucun contrôle sur le processus qui est récolté. Cependant, la valeur de retour
peut être vérifié pour l’identifiant du processus.
BIBLIOTHÈQUES
Expect connaît automatiquement deux bibliothèques intégrées pour les scripts Expect. Ceux-ci sont
défini par les répertoires nommés dans les variables exp_library et exp_exec_library. Les deux
sont censés contenir des fichiers utilitaires pouvant être utilisés par d’autres scripts.
exp_library contient des fichiers indépendants de l'architecture. exp_exec_library contient
fichiers dépendants de l'architecture. Selon votre système, les deux répertoires peuvent être totalement
vide. L'existence du fichier $exp_exec_library/cat-buffers indique si votre
/bin/chat tampons par défaut.
JOLIE-IMPRESSION
Une définition vgrind est disponible pour une jolie impression SAVOIR-FAIRE scripts. En supposant que le vgrind
définition fournie avec le SAVOIR-FAIRE la distribution est correctement installée, vous pouvez l'utiliser
comme:
fichier vgrind-expect
EXEMPLES
Il n'est pas toujours évident de savoir comment assembler tout ce que décrit la page de manuel. je
vous encourageons à lire et à essayer les exemples dans le répertoire d'exemples du SAVOIR-FAIRE
distribution. Certains d’entre eux sont de véritables programmes. D'autres sont simplement illustratifs de certains
techniques, et bien sûr, quelques-unes ne sont que des hacks rapides. Le fichier INSTALL a un accès rapide
aperçu de ces programmes.
Le manuel de formation SAVOIR-FAIRE les articles (voir VOIR AUSSI) sont également utiles. Bien que certains articles utilisent la syntaxe
correspondant aux versions antérieures d'Expect, les justifications qui l'accompagnent sont toujours valables
et entrez beaucoup plus en détail que cette page de manuel.
MISES EN GARDE
Les extensions peuvent entrer en collision avec les noms de commandes d'Expect. Par exemple, envoyer est défini par Tk
dans un tout autre but. Pour cette raison, la plupart des SAVOIR-FAIRE les commandes sont également
disponible sous le nom "exp_XXXX". Commandes et variables commençant par "exp", "inter", "spawn",
et "timeout" n'ont pas d'alias. Utilisez les noms de commandes étendus si vous en avez besoin
compatibilité entre les environnements.
SAVOIR-FAIRE adopte une vision plutôt libérale du cadrage. En particulier, les variables lues par les commandes
spécifique au SAVOIR-FAIRE le programme sera recherché d'abord à partir du périmètre local, et sinon
trouvé, dans le cadre global. Par exemple, cela évite d'avoir à placer un "timeout global"
dans chaque procédure que vous écrivez et qui utilise attendre. En revanche, les variables écrites sont
toujours dans la portée locale (sauf si une commande "globale" a été émise). Le plus courant
le problème que cela provoque est lorsque spawn est exécuté dans une procédure. En dehors de la procédure,
spawn_id n'existe plus, donc le processus généré n'est plus accessible simplement parce que
de cadrage. Ajoutez un "spawn_id global" à une telle procédure.
Si vous ne pouvez pas activer la fonctionnalité multispawn (c'est-à-dire que votre système ne prend en charge ni
select (BSD *.*), sondage (SVR>2), ni quelque chose d'équivalent), SAVOIR-FAIRE ne pourra que
contrôler un seul processus à la fois. Dans ce cas, n'essayez pas de régler spawn_id, ni
devriez-vous exécuter des processus via exec pendant qu'un processus généré est en cours d'exécution. En outre,
tu ne pourras pas attendre à partir de plusieurs processus (y compris l'utilisateur en tant qu'un seul) à la fois
en même temps.
Les paramètres du terminal peuvent avoir un effet important sur les scripts. Par exemple, si un script est écrit
pour rechercher l'écho, il se comportera mal si l'écho est désactivé. Pour cette raison, attendez-vous
force les paramètres de terminal sains par défaut. Malheureusement, cela peut rendre les choses
désagréable pour d'autres programmes. A titre d'exemple, le shell emacs veut changer le "habituel"
mappages : les nouvelles lignes sont mappées sur des nouvelles lignes au lieu de nouvelles lignes avec retour chariot, et en écho
est désactivé. Cela permet d'utiliser Emacs pour modifier la ligne d'entrée. Malheureusement, attendez-vous
je ne peux pas le deviner.
Vous pouvez demander à Expect de ne pas remplacer son réglage par défaut des paramètres du terminal, mais
vous devez alors être très prudent lorsque vous écrivez des scripts pour de tels environnements. Dans le cas d
emacs, évitez de dépendre de choses comme l'écho et les mappages de fin de ligne.
Les commandes qui acceptaient des arguments regroupés en une seule liste (la attendre variantes et
interagir) utilisez une heuristique pour décider si la liste est réellement un argument ou plusieurs. Le
L'heuristique ne peut échouer que dans le cas où la liste représente réellement un seul
argument qui contient plusieurs \n intégrés avec des caractères autres que des espaces entre eux.
Cela semble suffisamment improbable, cependant l'argument "-nobrace" peut être utilisé pour forcer un
argument unique à traiter comme un argument unique. Cela pourrait éventuellement être utilisé avec
Code Expect généré par la machine. De même, -brace force un seul argument à être traité comme
plusieurs modèles/actions.
Utilisez Expect en ligne en utilisant les services onworks.net
