expect - מקוון בענן

תָכְנִית:

שֵׁם

expect - דיאלוג מתוכנת עם תוכניות אינטראקטיביות, גרסה 5

תַקצִיר

לצפות [ -dDinN ] [ -c cmds ] [ [ -[f|b]] קובץ cmd ] [ טוען ]

מבוא

לצפות היא תוכנה ש"מדברת" עם תוכנות אינטראקטיביות אחרות לפי תסריט.
בעקבות התסריט, לצפות יודע מה ניתן לצפות מתוכנית ומה
תגובה נכונה צריכה להיות. שפה מתפרשת מספקת מסתעפת וברמה גבוהה
מבני שליטה כדי לכוון את הדיאלוג. בנוסף, המשתמש יכול לקחת שליטה ו
אינטראקציה ישירה כאשר תרצה, לאחר מכן להחזיר את השליטה לתסריט.

מצפה הוא תערובת של לצפות ו Tk. זה מתנהג בדיוק כמו לצפות ו Tk's רצון. לצפות
ניתן להשתמש גם ישירות ב-C או C++ (כלומר, ללא Tcl). לִרְאוֹת libexpect(3).

השם "צפוי" מגיע מהרעיון של לשלוח/לצפות רצפים פופולריים על ידי uucp, kermit
ותוכניות אחרות לבקרת מודם. אולם בניגוד ל-uucp, לצפות מוכלל כך שהוא
ניתן להפעיל כפקודה ברמת המשתמש תוך מחשבה על כל תוכנית ומשימה. לצפות יכול למעשה
לדבר עם כמה תוכניות בו זמנית.

לדוגמה, הנה כמה דברים לצפות יכול לעשות:

· לגרום למחשב שלך לחייג אליך בחזרה, כדי שתוכל להתחבר מבלי לשלם עבורו
השיחה.

· התחל משחק (למשל, נוכל) ואם התצורה האופטימלית לא מופיעה,
הפעל אותו מחדש (שוב ושוב) עד שיעשה זאת, ואז תעביר את השליטה לידיך.

· הפעל את fsck, ובתגובה לשאלותיו, ענה "כן", "לא" או תן שליטה
בחזרה אליך, בהתבסס על קריטריונים שנקבעו מראש.

· התחבר לרשת אחרת או BBS (למשל, MCI Mail, CompuServe) ו
אחזר אוטומטית את הדואר שלך כך שייראה כאילו היה במקור
נשלח למערכת המקומית שלך.

· לשאת משתני סביבה, ספרייה נוכחית או כל סוג של מידע
על פני rlogin, telnet, tip, su, chgrp וכו'.

ישנן מגוון סיבות לכך שהמעטפת אינה יכולה לבצע משימות אלו. (תנסה, אתה תצליח
ראה.) הכל אפשרי עם לצפות.

באופן כללי, לצפות שימושי להפעלת כל תוכנית הדורשת אינטראקציה ביניהן
התוכנית והמשתמש. כל מה שצריך הוא שהאינטראקציה יכולה להיות
מאופיין תוכניתית. לצפות יכול גם להחזיר למשתמש את השליטה (ללא
עצירת התוכנית בשליטה) אם תרצה בכך. באופן דומה, המשתמש יכול להחזיר שליטה
לתסריט בכל עת.

נוהג

לצפות קורא קובץ cmd לרשימת פקודות לביצוע. לצפות ניתן להפעיל גם
באופן מרומז במערכות התומכות ב-#! סימון על ידי סימון קובץ ההפעלה של הסקריפט, ו
ביצוע השורה הראשונה בתסריט שלך:

#!/usr/bin/expect -f

כמובן, הנתיב חייב לתאר במדויק היכן לצפות חיים. / usr / bin הוא רק
דוגמא.

השמיים -c דגל מקדים פקודה שתתבצע לפני כל אחת בסקריפט. הפקודה
יש לצטט כדי למנוע את פירוק הקונכייה. ניתן להשתמש באפשרות זו
מספר פעמים. ניתן לבצע מספר פקודות עם אחד -c על ידי הפרדה ביניהם
עם נקודות פסיק. הפקודות מבוצעות לפי סדר הופעתן. (בעת שימוש ב- Expectk,
אפשרות זו מצוינת כ - פקודה.)

השמיים -d הדגל מאפשר פלט אבחון כלשהו, ​​המדווח בעיקר על פעילות פנימית של
פקודות כגון לצפות ו אינטראקציה. לדגל זה יש את אותו אפקט כמו "exp_internal 1"
בתחילת תסריט Expect, בתוספת הגרסה של לצפות מודפס. (ה שטרס
הפקודה שימושית למעקב אחר הצהרות, וה- להתחקות הפקודה שימושית למעקב
הקצאות משתנים.) (בעת שימוש ב- Expectk, אפשרות זו מצוינת בתור -תמונה.)

השמיים -D דגל מאפשר ניפוי באגים אינטראקטיבי. צריך להופיע ערך של מספר שלם. ה
באגים ישתלט לפני הליך Tcl הבא אם הערך אינו אפס או אם א
לוחצים על ^C (או שנפגעת נקודת עצירה, או מופיעה פקודת ניפוי באגים מתאימה אחרת
התסריט). עיין בקובץ README או ראה גם (להלן) למידע נוסף על
מנפה. (בעת שימוש ב- Expectk, אפשרות זו מצוינת בתור -לנפות.)

השמיים -f דגל מקדים קובץ שממנו ניתן לקרוא פקודות. הדגל עצמו הוא אופציונלי
מכיוון שהוא שימושי רק בעת שימוש ב-#! סימון (ראה לעיל), כדי לטיעונים אחרים עשויים
יסופק בשורת הפקודה. (בעת שימוש ב- Expectk, אפשרות זו מצוינת בתור -file.)

כברירת מחדל, קובץ הפקודה נקרא לזיכרון ומבוצע בשלמותו. זה
מדי פעם רצוי לקרוא קבצים שורה אחת בכל פעם. לדוגמה, סטדין נקרא את זה
דֶרֶך. על מנת לאלץ לטפל בקבצים שרירותיים בדרך זו, השתמש ב- -b דֶגֶל. (מתי
באמצעות Expectk, אפשרות זו מצוינת בתור -בַּלָם.)הערותזֶהסטודיו-
חציצהאוליעודלקחתמקוםאולםזֶה לא אמור לגרום לבעיות בעת קריאה מ-fifo או
סטדין.

אם המחרוזת "-" מסופקת כשם קובץ, קלט סטנדרטי נקרא במקום זאת. (להשתמש "./-"
לקרוא מקובץ ששמו למעשה "-".)

השמיים -i גורם גורם לצפות לבקש באופן אינטראקטיבי פקודות במקום לקרוא אותן
מתוך קובץ. ההנחיה מסתיימת באמצעות יציאה פקודה או על EOF. לִרְאוֹת מְתוּרגְמָן
(למטה) למידע נוסף. -i ההנחה היא אם לא קובץ פקודה ולא -c משמש.
(בעת שימוש ב- Expectk, אפשרות זו מצוינת בתור -אינטראקטיבי.)

-- ניתן להשתמש כדי לתחום את סוף האפשרויות. זה שימושי אם אתה רוצה לעבור א
טיעון דמוי אופציה לתסריט שלך מבלי שהוא יתפרש על ידי לצפות. זה יכול
מועיל להיות ממוקם ב-#! קו כדי למנוע כל פרשנות דמוית דגל על ​​ידי Expect. ל
לדוגמה, הארגומנטים הבאים ישאירו את הארגומנטים המקוריים (כולל שם הסקריפט).
המשתנה argv.

#!/usr/bin/expect --

שימו לב שהרגיל getopt(3) ו בכיר(2) יש להקפיד על מוסכמות בעת הוספה
טיעונים ל-#! קַו.

הקובץ $exp_library/expect.rc מקורו אוטומטית אם קיים, אלא אם כן -N דגל הוא
בשימוש. (בעת שימוש ב- Expectk, אפשרות זו מצוינת בתור -NORC.) מיד לאחר מכן,
הקובץ ~/.expect.rc מקורו אוטומטית, אלא אם כן -n נעשה שימוש בדגל. אם ה
משתנה הסביבה DOTDIR מוגדר, הוא מטופל כספרייה ו-.expect.rc הוא
לקרוא משם. (בעת שימוש ב- Expectk, אפשרות זו מצוינת בתור -נורק.) המקור הזה
מתרחש רק לאחר ביצוע כל -c דגלים.

-v גורם לצפות להדפיס את מספר הגרסה שלו ולצאת. (הדגל המתאים ב
Expectk, המשתמש בשמות דגל ארוכים, הוא -version.)

אופציונלי טוען בנויים לרשימה ומאוחסנים במשתנה בשם argv. טען is
אתחול באורך argv.

argv0 מוגדר להיות שם הסקריפט (או בינארי אם לא נעשה שימוש בסקריפט). ל
לדוגמה, הטקסט הבא מדפיס את שם התסריט ואת שלושת הארגומנטים הראשונים:

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

פקודות

לצפות שימושים Tcl (שפת פיקוד הכלי). Tcl מספק זרימת בקרה (למשל, אם, עבור,
הפסקה), הערכת ביטוי ועוד מספר תכונות כגון רקורסיה, פרוצדורה
הגדרה וכו'. פקודות המשמשות כאן אך אינן מוגדרות (למשל, סט, if, Exec) הם Tcl
פקודות (ראה TCL(3)). לצפות תומך בפקודות נוספות, המתוארות להלן. אֶלָא אִם
שצוין אחרת, הפקודות מחזירות את המחרוזת הריקה.

הפקודות מופיעות בסדר אלפביתי כך שניתן יהיה לאתר אותן במהירות. עם זאת, חדש
למשתמשים אולי יהיה קל יותר להתחיל בקריאת התיאורים של להשריץ, לשלוח, לצפות, ו
אינטראקציה, בסדר הזה.

שימו לב שהמבוא הטוב ביותר לשפה (גם Expect וגם Tcl) מסופק ב-
ספר "Exploring Expect" (ראה גם למטה). דוגמאות כלולות בדף האיש הזה אבל
הם מוגבלים מאוד מכיוון שדף אדם זה נועד בעיקר כחומר עזר.

שים לב שבטקסט של דף אדם זה, "צפוי" עם אותיות גדולות "E" מתייחס ל-
לצפות תוכנית בעוד "צפוי" באותיות קטנות "e" מתייחס ל- לצפות פקודה בפנים
מה היא לצפות תכנית.)

close [-עֶבֶד] [-onexec 0|1] [-אני spawn_id]
סוגר את הקשר לתהליך הנוכחי. רוב התוכניות האינטראקטיביות יזהו
EOF על הסטדין והיציאה שלהם; לכן close בדרך כלל מספיק כדי להרוג את התהליך כמו
נו. ה -i הדגל מכריז על סגירת התהליך בהתאם לשמו
spawn_id.

שניהם לצפות ו אינטראקציה יזהה מתי התהליך הנוכחי יוצא ובמרומז
לעשות א close. אבל אם אתה הורג את התהליך על ידי, נגיד, "Exec kill $pid", תצטרך לעשות זאת
להתקשר במפורש close.

השמיים -onexec הדגל קובע אם מזהה השרצים ייסגר בכל ספאון חדש
תהליכים או אם התהליך הוא שכבת-על. כדי להשאיר מזהה spawn פתוח, השתמש בערך
0. ערך שלם שאינו אפס יכריח את השרצים לסגור (ברירת המחדל) בכל חדש
תהליכים.

השמיים -עֶבֶד הדגל סוגר את העבד המשויך למזהה השרצים. (ראה "spawn -pty".)
כאשר החיבור נסגר, העבד נסגר אוטומטית גם אם עדיין
פתוח.

לא משנה אם הקשר נסגר באופן מרומז או מפורש, כדאי להתקשר
לחכות כדי לנקות את חריץ תהליך הליבה המתאים. close לא מתקשר לחכות
שכן אין ערובה שסגירת חיבור תהליך תגרום לו לצאת.
לִרְאוֹת לחכות למטה למידע נוסף.

באגים [[-עַכשָׁיו] 0|1]
שולט ב-Tcl באגים המאפשר לך לעבור בין הצהרות, להגדיר נקודות שבירה,
וכו '

ללא ארגומנטים, 1 מוחזר אם מאתר הבאגים אינו פועל, אחרת 0 הוא
חזר.

עם ארגומנט 1, מאתר הבאגים מופעל. עם ארגומנט 0, מאתר הבאגים הוא
עצר. אם לפני ארגומנט 1 ה- -עַכשָׁיו דגל, מאתר הבאגים מופעל
מיד (כלומר, באמצע ה באגים הפקודה עצמה). אחרת ה
מאתר הבאגים מופעל עם הצהרת Tcl הבאה.

השמיים באגים הפקודה לא משנה שום מלכודות. השווה את זה להתחלה של Expect עם
מה היא -D דגל (ראה למעלה).

עיין בקובץ README או ראה גם (להלן) למידע נוסף על מאתר הבאגים.

לנתק
מנתק תהליך מזולג מהמסוף. זה ממשיך לרוץ ב
רקע כללי. התהליך מקבל קבוצת תהליכים משלו (אם אפשר). I/O סטנדרטי
מופנה אל /dev/null.

הפרגמנט הבא משתמש לנתק כדי להמשיך להפעיל את הסקריפט ב-
רקע.

אם {[fork]!=0} יוצא
לנתק
. . .

הסקריפט הבא קורא סיסמה, ולאחר מכן מריץ תוכנית בכל שעה
דורש סיסמה בכל פעם שהוא מופעל. הסקריפט מספק את הסיסמה כך
אתה צריך להקליד רק פעם אחת. (ראה את stty פקודה שמדגימה איך לפנות
כבוי הדהוד סיסמה.)

send_user "סיסמה?\"
expect_user -re "(.*)\n"
בשביל 1 {} {
if {[fork]!=0} {sleep 3600;continue}
לנתק
spawn priv_prog
מצפה סיסמה:
שלח "$expect_out(1,string)\r"
. . .
יציאה
}

יתרון לשימוש לנתק תכונת תהליך אסינכרוני מעל המעטפת (&) היא
זֶה לצפות יכול לשמור את פרמטרי הטרמינל לפני הניתוק ולאחר מכן מאוחר יותר
להחיל אותם על Ptys חדשים. עם &, לצפות אין לו הזדמנות לקרוא את
הפרמטרים של המסוף מכיוון שהטרמינל כבר מנותק בזמן לצפות
מקבל שליטה.

יציאה [-opts] [סטָטוּס]
גורמים לצפות לצאת או להתכונן בדרך אחרת לעשות זאת.

השמיים -יציאה אחת דגל גורם לארגומנט הבא לשמש כמטפל יציאה. בלי א
ארגומנט, מטפל היציאה הנוכחי מוחזר.

השמיים -אין יציאה גורם גורם לצפות להתכונן ליציאה אבל לעצור ממש
החזרת השליטה למערכת ההפעלה. מטפל היציאה המוגדר על ידי המשתמש מופעל בתור
כמו גם המטפלים הפנימיים של Expect עצמו. לא אמורות להיות פקודות Expect נוספות
יצא לפועל. זה שימושי אם אתה מפעיל את Expect עם הרחבות Tcl אחרות. ה
המתורגמן הנוכחי (והחלון הראשי אם בסביבת Tk) נשארים כך שהאחר
הרחבות Tcl יכולות לנקות. אם מצפה יציאה נקרא שוב (עם זאת
להתרחש), המטפלים אינם מופעלים מחדש.

עם היציאה, כל החיבורים לתהליכים שנוצרו נסגרים. סגירה תהיה
זוהה כ-EOF על ידי תהליכים שהורדו. יציאה לא נוקט פעולות אחרות מעבר למה
הנורמלי _יְצִיאָה(2) נוהל עושה. לפיכך, הולידו תהליכים שאינם בודקים
EOF עשוי להמשיך לפעול. (חשוב לקבוע מגוון תנאים, עבור
לדוגמה, אילו אותות יישלחו תהליך שהוליד, אבל אלה הם מערכת-
תלוי, מתועד בדרך כלל תחת יציאה(3).) הולידו תהליכים שממשיכים
run יעבור בירושה על ידי init.

מצב (או 0 אם לא צוין) מוחזר כסטטוס היציאה של לצפות. יציאה is
מבוצע באופן מרומז אם מגיעים לסוף הסקריפט.

exp_continue [-continue_timer]
הפקודה exp_continue מאפשר לצפות עצמו להמשיך בביצוע במקום
חוזר כמו שהוא היה רגיל. כברירת מחדל exp_continue מאפס את טיימר הזמן הקצוב.
השמיים -המשך_טיימר הדגל מונע את הפעלת הטיימר מחדש. (לִרְאוֹת לצפות במשך יותר
מֵידָע.)

exp_internal [-ו קוֹבֶץ] ערך
גורם לפקודות נוספות לשלוח מידע אבחון פנימי לצפות לסטדרר
if ערך אינו אפס. פלט זה מושבת אם ערך הוא 0. האבחון
המידע כולל כל דמות שהתקבלה, וכל ניסיון שנעשה להתאים את
פלט זרם כנגד התבניות.

אם האופציונלי פילה מסופק, כל הפלט הרגיל ואיתור הבאגים נכתב לזה
קובץ (ללא קשר לערך של ערך). כל קובץ פלט אבחון קודם הוא
סגור.

השמיים מידע הדגל גורם ל-exp_internal להחזיר תיאור של הלא-אחרון האחרון
טיעוני מידע שניתנו.

exp_open [טיעונים] [-אני spawn_id]
מחזיר מזהה קובץ Tcl שמתאים למזהה השרצים המקורי. הקובץ
לאחר מכן ניתן להשתמש במזהה כאילו הוא נפתח על ידי Tcl's לפתוח פקודה. (השרץ
אין להשתמש יותר ב-id. א לחכות אסור להוציא להורג.

השמיים -תשאיר פתוח הדגל משאיר את מזהה השרצים פתוח לגישה באמצעות פקודות Expect. א
לחכות חייב להתבצע על מזהה השרצים.

exp_pid [-אני spawn_id]
מחזירה את מזהה התהליך המתאים לתהליך שנוצר כעת. אם ה -i
נעשה שימוש בדגל, ה-pid שהוחזר תואם לזה של מזהה השרצים הנתון.

exp_send
הוא כינוי עבור לשלוח.

exp_send_error
הוא כינוי עבור שלח_שגיאה.

exp_send_log
הוא כינוי עבור שלח_לוג.

exp_send_tty
הוא כינוי עבור send_tty.

exp_send_user
הוא כינוי עבור שלח_משתמש.

exp_version [[-יְצִיאָה] גִרְסָה]
שימושי כדי להבטיח שהסקריפט תואם לגרסה הנוכחית של
לְצַפּוֹת.

ללא טיעונים, הגרסה הנוכחית של לצפות מוחזר. גרסה זו עשויה אז
להיות מקודד בסקריפט שלך. אם אתה באמת יודע שאתה לא משתמש בתכונות של
גרסאות אחרונות, אתה יכול לציין גרסה קודמת.

גרסאות מורכבות משלושה מספרים המופרדים בנקודות. הראשון הוא המספר העיקרי.
סקריפטים שנכתבו עבור גרסאות של לצפות עם מספר עיקרי שונה יהיה כמעט
בטח לא עובד. exp_version מחזיר שגיאה אם ​​המספרים העיקריים אינם תואמים.

השני הוא המספר הקטן. תסריטים שנכתבו לגרסה עם מינור גדול יותר
מספר מהגרסה הנוכחית עשוי להיות תלוי בתכונה חדשה כלשהי וייתכן שלא יפעל.
exp_version מחזירה שגיאה אם ​​המספרים העיקריים תואמים, אבל המספר הקטן של הסקריפט
גדול מזה של הריצה לצפות.

שלישית הוא מספר שלא משחק תפקיד בהשוואת הגרסאות. עם זאת, זה כן
גדל כאשר לצפות הפצת התוכנה משתנה בכל דרך, כגון על ידי
תיעוד נוסף או אופטימיזציה. זה מאופס ל-0 בכל קטין חדש
הגירסה.

עם -יציאה דֶגֶל, לצפות מדפיס שגיאה ויוצא אם הגרסה לא מעודכנת.

לצפות [[-opts] pat1 גוף1] ... [-opts] patn [גוף]
ממתין עד שאחת מהדפוסים תואמת את הפלט של תהליך שהולידה, נתון מוגדר
חלפה פרק הזמן, או שנראה סוף קובץ. אם הגוף הסופי ריק, זה
יכול להיות מושמט.

דפוסים מהאחרון מצפה_לפני נעשה שימוש בפקודה באופן מרומז לפני כל
דפוסים אחרים. דפוסים מהאחרון מצפה_אחרי הפקודה הן באופן מרומז
בשימוש לאחר כל דפוס אחר.

אם הטיעונים לכלל לצפות הצהרה דורשת יותר משורה אחת, כל
ניתן "לאגד" ארגומנטים לאחד כדי למנוע סיום כל שורה עם א
מַהֲלָך סְרָק. במקרה אחד זה, החלפות ה-Tcl הרגילות יתרחשו למרות ה
פלטה.

אם דפוס הוא מילת המפתח eof, הגוף המתאים מבוצע בתום-
קוֹבֶץ. אם דפוס הוא מילת המפתח פסק זמן, הגוף המקביל מוצא להורג
פסק זמן. אם לא נעשה שימוש במילת מפתח פסק זמן, מתבצעת פעולת ריק מרומזת
פסק זמן. פרק הזמן הקצוב המוגדר כברירת מחדל הוא 10 שניות, אך ניתן להגדיר אותו, למשל ל
30, על ידי הפקודה "קבע פסק זמן 30". פסק זמן אינסופי עשוי להיות מוגדר על ידי
ערך -1. אם דפוס הוא מילת המפתח ברירת מחדל, הגוף המתאים מבוצע
עם פסק זמן או בסוף הקובץ.

אם תבנית תואמת, הגוף המתאים מבוצע. לצפות מחזיר את
תוצאת הגוף (או המחרוזת הריקה אם אין תבנית תואמת). באירוע בו
תבניות מרובות תואמות, זו שמופיעה ראשונה משמשת לבחירת גוף.

בכל פעם שמגיע פלט חדש, הוא מושווה לכל דפוס לפי הסדר שהוא
ברשימה. לפיכך, אתה יכול לבדוק אם אין התאמה על ידי יצירת הדפוס האחרון
משהו מובטח שיופיע, כמו הנחיה. במצבים שבהם אין
הנחיה, עליך להשתמש פסק זמן (בדיוק כמו שהיית עושה אם היית באינטראקציה ידנית).

דפוסים מפורטים בשלוש דרכים. כברירת מחדל, דפוסים מוגדרים כמו עם
של Tcl מחרוזת להתאים פקודה. (דפוסים כאלה דומים גם ל-C-shell רגיל
ביטויים המכונים בדרך כלל תבניות "גלוב"). ה -גל ניתן להשתמש בדגל
כדי להגן על דפוסים שאחרת עשויים להתאים לצפות דגלים מלעשות זאת. כל
דפוס שמתחיל ב-"-" צריך להיות מוגן בדרך זו. (כל המיתרים מתחילים
עם "-" שמורות לאפשרויות עתידיות.)

לדוגמה, הפרגמנט הבא מחפש כניסה מוצלחת. (ציין זאת ביטול
יש להניח שהוא הליך המוגדר במקום אחר בסקריפט.)

מצפה {
עסוק {מציב עסוק\n ; exp_continue}
הפלה נכשלה
"סיסמה לא חוקית" לבטל
פסק זמן קצוב
מחובר
}

יש צורך במרכאות על התבנית הרביעית מכיוון שהיא מכילה רווח, מה שכן
אחרת הפרידו את הדפוס מהפעולה. דפוסים עם אותה פעולה (כגון
כמו ה-3 וה-4) דורשים לרשום שוב את הפעולות. ניתן להימנע מכך על ידי שימוש
דפוסים בסגנון regexp (ראה להלן). מידע נוסף על יצירת דפוסים בסגנון גלוב
ניתן למצוא במדריך Tcl.

תבניות בסגנון Regexp עוקבות אחר התחביר שהוגדר על ידי Tcl's regexp (קיצור של "רגיל
expression") הפקודה. תבניות ביטוי regexp מוצגות עם הדגל -re. ה
ניתן לשכתב את הדוגמה הקודמת באמצעות ביטוי רגולרי כ:

מצפה {
עסוק {מציב עסוק\n ; exp_continue}
-re "failed|סיסמה לא חוקית" לבטל
פסק זמן קצוב
מחובר
}

שני סוגי הדפוסים "בלתי מעוגנים". זה אומר שדפוסים לא חייבים
להתאים את כל המיתר, אבל יכול להתחיל ולסיים את ההתאמה בכל מקום במחרוזת (כמו
כל עוד כל השאר תואם). השתמש ב-^ כדי להתאים את ההתחלה של מחרוזת, וב-$
כדי להתאים את הסוף. שים לב שאם אתה לא מחכה לסוף מחרוזת, שלך
תגובות יכולות להסתיים בקלות באמצע המחרוזת כשהן מוחזרות מה-
תהליך שהוליד. למרות שעדיין מפיקים תוצאות נכונות, הפלט יכול להיראות
לֹא טִבעִי. לכן, השימוש ב-$ מומלץ אם אתה יכול לתאר בדיוק את הדמויות
בסוף מחרוזת.

שימו לב שבעורכים רבים, ה-^ ו-$ תואמים את ההתחלה והסוף של השורות
בהתאמה. עם זאת, מכיוון ש-expected אינו מכוון קו, התווים הללו תואמים
ההתחלה והסוף של הנתונים (בניגוד לשורות) כרגע ב-expected
חיץ תואם. (כמו כן, ראה את ההערה למטה על "הפרעות עיכול במערכת").

השמיים -לְשֶׁעָבַר הדגל גורם לתבנית להיות מותאמת כמחרוזת "מדויקת". לא
נוצר פרשנות של *, ^ וכו' (למרות שהמוסכמות הרגילות של Tcl עדיין חייבות
להתבונן). דפוסים מדויקים תמיד לא מעוגנים.

השמיים -אין תיק הדגל גורם לתווים רישיות של הפלט להשוות כאילו הם
היו תווים קטנים. הדפוס אינו מושפע.

בזמן קריאת פלט, יותר מ-2000 בתים יכולים לאלץ בייטים מוקדמים יותר
"ישכח". זה עשוי להשתנות עם הפונקציה match_max. (ציין זאת
ערכים גדולים מדי יכולים להאט את התאמת הדפוסים.) אם פטליסט is
מלא_מאגר, הגוף המתאים מבוצע אם match_max בתים היו
התקבלו ואין דפוסים אחרים שתואמים. בין אם ה מלא_מאגר מילות מפתח
נעשה שימוש, התווים שנשכחו נכתבים ל- expect_out(buffer).

If פטליסט היא מילת המפתח ריק, ומותר לבטל (באמצעות ה remove_nulls
הפקודה), הגוף המתאים מבוצע אם ASCII 0 בודד מותאם. זה
לא ניתן להתאים ל-0 בתים באמצעות דפוסי גלוב או ביטוי רגולי.

עם התאמת דפוס (או eof או full_buffer), כל התאמה ולפני כן
פלט ללא התאמה נשמר במשתנה expect_out(buffer). עד 9 ביטויים רגולריים
התאמות מחרוזות משנה נשמרות במשתנים expect_out(1,string) דרך
expect_out(9,string). אם -מדדים הדגל משמש לפני דפוס, ההתחלה
ומדדי סיום (בצורה המתאימה ל lrange) מתוך 10 המחרוזות מאוחסנות ב
המשתנים expect_out(X,start) ו expect_out(X,end) כאשר X הוא ספרה,
מתאים למיקום המחרוזת המשנה במאגר. 0 מתייחס למחרוזות אשר
תואם את כל הדפוס והוא נוצר עבור דפוסי גלוב כמו גם ביטוי מחודש
דפוסים. לדוגמה, אם תהליך הפיק פלט של "abcdefgh\n", התוצאה
של:

מצפה ל"תקליטורים"

הוא כאילו בוצעו ההצהרות הבאות:

set expect_out(0,string) cd
set expect_out(buffer) abcd

ו-"efgh\n" נשאר במאגר הפלט. אם תהליך הפיק את הפלט
"abbbcabkkkka\n", התוצאה של:

expect -indexe -re "b(b*).*(k+)"

הוא כאילו בוצעו ההצהרות הבאות:

set expect_out(0,start) 1
set expect_out(0,end) 10
set expect_out(0,string) bbbcabkkkk
set expect_out(1,start) 2
set expect_out(1,end) 3
set expect_out(1,string) bb
set expect_out(2,start) 10
set expect_out(2,end) 10
set expect_out(2,string) k
set expect_out(buffer) abbbcabkkkk

ו-"a\n" נשאר במאגר הפלט. הדפוס "*" (ו-re ".*") יסלק
מאגר הפלט מבלי לקרוא פלט נוסף מהתהליך.

בדרך כלל, הפלט המותאם מושלך מהמאגרים הפנימיים של Expect. זה אולי
למנוע על ידי הקדמת דפוס עם -אין העברה דֶגֶל. הדגל הזה הוא
שימושי במיוחד בניסויים (וניתן לקצרו ל-"-not" מטעמי נוחות
תוך כדי ניסוי).

מזהה השרצים המשויך לפלט התואם (או eof או full_buffer) מאוחסן
in expect_out(spawn_id).

השמיים -פסק זמן flag גורם לפקודה הנוכחית expect להשתמש בערך הבא בתור a
פסק זמן במקום להשתמש בערך של משתנה הזמן הקצוב.

עם זאת, כברירת מחדל, תבניות מותאמות לפלט מהתהליך הנוכחי
מה היא -i flag מכריז שהפלט מרשימת spawn_id עם השם מותאם לכל
הדפוסים הבאים (עד הבא -i). רשימת spawn_id צריכה להיות א
רשימה מופרדת עם רווחים לבנים של spawn_ids או משתנה המתייחס לרשימה כזו של
spawn_ids.

לדוגמה, הדוגמה הבאה ממתינה ל"מחוברים" מהתהליך הנוכחי,
או "busy", "failed" או "סיסמה לא חוקית" מה- spawn_id בשם $proc2.

מצפה {
-i $proc2 busy {מכניס לעסוק\n ; exp_continue}
-re "failed|סיסמה לא חוקית" לבטל
פסק זמן קצוב
מחובר
}

הערך של המשתנה הגלובלי any_spawn_id ניתן להשתמש כדי להתאים דפוסים לכל
spawn_ids שנקראים עם כל השאר -i דגלים בזרם לצפות פקודה. ה
spawn_id מ-a -i דגל ללא דפוס משויך (כלומר, מיד אחריו
אַחֵר -i) זמין לכל דפוסים אחרים באותו לצפות הפקודה
הקשורים any_spawn_id.

השמיים -i flag עשוי גם לתת שם למשתנה גלובלי ובמקרה זה נקרא המשתנה עבור a
רשימה של מזהי שרצים. המשתנה נקרא מחדש בכל פעם שהוא משתנה. זה מספק דרך
של שינוי מקור ה-I/O בזמן שהפקודה מתבצעת. מסופק מזהי שרצים
דרך זו נקראת מזהי שרצים "עקיפים".

פעולות כגון לשבור ו להמשיך לגרום למבני בקרה (כלומר, ל, proc) כדי
להתנהג בדרך הרגילה. הפקודה exp_continue מאפשר לצפות עצמו להמשיך
ביצוע במקום להחזיר כפי שהוא היה רגיל.

זה שימושי כדי למנוע לולאות מפורשות או הצהרות ציפיות חוזרות ונשנות. ה
הדוגמה הבאה היא חלק מפרגמנט לאוטומטי של rlogin. ה exp_continue נמנע
צריך לכתוב שנייה לצפות הצהרה (כדי לחפש שוב את ההנחיה) אם ה
rlogin מבקש סיסמה.

מצפה {
סיסמה: {
stty -הד
send_user "סיסמה (עבור $user) ב-$host: "
expect_user -re "(.*)\n"
send_user "\n"
שלח "$expect_out(1,string)\r"
אקו סטטי
exp_continue
} שגוי {
send_user "סיסמה או חשבון לא חוקי\n"
יציאה
} פסק זמן {
send_user "פג הזמן הקצוב לחיבור ל-$host\n"
יציאה
} eof {
שלח_משתמש \
"החיבור למארח נכשל: $expect_out(buffer)"
יציאה
} -re $prompt
}

לדוגמה, הפרגמנט הבא עשוי לעזור למשתמש להנחות אינטראקציה כלומר
כבר אוטומטי לחלוטין. במקרה זה, הטרמינל מועבר למצב גולמי. אם ה
המשתמש לוחץ על "+", משתנה מוגדל. אם "p" נלחץ, מספר החזרות הן
נשלח לתהליך, אולי כדי לתקוע אותו בדרך כלשהי, וה-"i" מאפשר למשתמש ליצור אינטראקציה
עם התהליך, למעשה גונבים את השליטה מהתסריט. בכל מקרה,
מה היא exp_continue מאפשר את הזרם לצפות כדי להמשיך בהתאמת דפוסים לאחר מכן
ביצוע הפעולה הנוכחית.

stty raw -echo
מצפה_אחרי {
-i $user_spawn_id
"p" {שלח "\r\r\r"; exp_continue}
"+" {incr foo; exp_continue}
"i" {אינטראקציה; exp_continue}
יציאה "צא".
}

כברירת מחדל, exp_continue מאפס את טיימר הזמן הקצוב. הטיימר אינו מופעל מחדש, אם
exp_continue נקרא עם -המשך_טיימר דגל.

מצפה_אחרי [צפו_טיעונים]
עובד באופן זהה ל- מצפה_לפני אלא שאם דפוסים משניהם לצפות ו
מצפה_אחרי יכול להתאים, את לצפות נעשה שימוש בתבנית. ראה את מצפה_לפני הפקודה
לקבלת מידע נוסף.

מצפה_רקע [צפו_טיעונים]
לוקח את אותם טיעונים כמו לצפות, אולם הוא חוזר מיד. דפוסים הם
נבדק בכל פעם שמגיע קלט חדש. הדפוס פסק זמן ו ברירת מחדל חסרי משמעות
ל מצפה_רקע ומושלכים בשקט. אחרת ה מצפה_רקע
שימוש בפקודה מצפה_לפני ו מצפה_אחרי דפוסים בדיוק כמו לצפות עושה.

מתי מצפה_רקע פעולות נבדקות, עיבוד רקע עבור
אותו מזהה שרצים חסום. החסימה של עיבוד רקע בוטלה כאשר הפעולה
משלים. בזמן שעיבוד הרקע חסום, אפשר לעשות א
(חֲזִית) לצפות על אותו מזהה שרצים.

לא ניתן לבצע לצפות ואילו מצפה_רקע חסימה בוטלה.
מצפה_רקע עבור מזהה שרצים מסוים נמחק על ידי הכרזה על חדש
expect_background עם אותו מזהה spawn. מצהיר מצפה_רקע ללא
דפוס מסיר את מזהה השרצים הנתון מהיכולת להתאים דפוסים ב-
רקע.

מצפה_לפני [צפו_טיעונים]
לוקח את אותם טיעונים כמו לצפות, אולם הוא חוזר מיד. דפוס-פעולה
זוגות מהאחרון מצפה_לפני עם אותו מזהה spawn מתווספים באופן מרומז
לכל הבאים לצפות פקודות. אם תבנית תואמת, מתייחסים אליה כאילו הייתה
צוין ב לצפות הפקודה עצמה, והגוף המשויך מבוצע ב
ההקשר של ה לצפות פקודה. אם תבניות משניהם מצפה_לפני ו לצפות
יכול להתאים, את מצפה_לפני נעשה שימוש בתבנית.

אם לא צוין דפוס, מזהה השרצים לא נבדק עבור שום דפוס.

אלא אם כן עוקף א -i דֶגֶל, מצפה_לפני דפוסים תואמים את מזהה השרצים
הוגדר בזמן שה- מצפה_לפני הפקודה בוצעה (לא כשהיא
הדפוס מותאם).

דגל -אינפורמציה גורם מצפה_לפני כדי להחזיר את המפרט הנוכחי של מה
דפוסים שהוא יתאים. כברירת מחדל, הוא מדווח על מזהה השרצים הנוכחי. א
מפרט זיהוי שרצים אופציונלי עשוי להינתן למידע על מזהה שרצים זה. ל
דוגמה

expect_before -info -i $proc

לכל היותר ניתן לתת מפרט מזהה שרצים אחד. הדגל -עקיף מדכא
מזהי שרצים ישירים שמגיעים רק ממפרט עקיף.

במקום מפרט מזהה spawn, הדגל "-all" יגרום ל-"-info" לדווח עליו
כל מזהי השרצים.

ניתן לעשות שימוש חוזר בפלט של הדגל -info בתור הארגומנט ל- expect_before.

expect_tty [צפו_טיעונים]
הוא כמו לצפות אבל הוא קורא תווים מ-/dev/tty (כלומר הקשות מ-
מִשׁתַמֵשׁ). כברירת מחדל, הקריאה מתבצעת במצב בישול. לפיכך, שורות חייבות להסתיים ב
החזר על מנת לצפות לראות אותם. זה עשוי להשתנות באמצעות stty (ראה
stty הפקודה למטה).

expect_user [צפו_טיעונים]
הוא כמו לצפות אבל זה קורא תווים מ-stdin (כלומר הקשות מהמשתמש).
כברירת מחדל, הקריאה מתבצעת במצב בישול. לפיכך, שורות חייבות להסתיים בהחזרה
על מנת ש לצפות לראות אותם. זה עשוי להשתנות באמצעות stty (ראה stty הפקודה
להלן).

מזלג יוצר תהליך חדש. התהליך החדש הוא העתק מדויק של הנוכחי לצפות
תהליך. על הצלחה, מזלג מחזיר 0 לתהליך החדש (ילד) ומחזיר את
מזהה תהליך של תהליך הצאצא לתהליך האב. על כישלון (תמיד עקב
לחוסר משאבים, למשל, החלפת שטח, זיכרון), מזלג מחזיר -1 להורה
תהליך, ולא נוצר תהליך צאצא.

תהליכים מזולגים יוצאים דרך יציאה פקודה, בדיוק כמו התהליך המקורי. מְפוּצָל
מותר לתהליכים לכתוב לקובצי היומן. אם לא תבטל איתור באגים או
כניסה לרוב התהליכים, התוצאה עלולה להיות מבלבלת.

כמה יישומי Pty עשויים להיות מבולבלים על ידי מספר קוראים וכותבים, אפילו
לְרֶגַע. לפיכך, הכי בטוח מזלג לפני תהליכי ההטלה.

אינטראקציה [מחרוזת1 גוף1] ... [מחרוזת [גוף]]
נותן שליטה על התהליך הנוכחי למשתמש, כך שהקשות נשלחות אל
התהליך הנוכחי, וה-stdout וה-stderr של התהליך הנוכחי מוחזרים.

ניתן לציין זוגות גוף-מחרוזת כארגומנטים, ובמקרה זה הגוף מבוצע
כאשר הזנת המחרוזת המתאימה. (כברירת מחדל, המחרוזת לא נשלחת אל
התהליך הנוכחי.) ה מְתוּרגְמָן הפקודה מונחת, אם הגוף הסופי הוא
חסר.

אם הטיעונים לכלל אינטראקציה ההצהרה דורשת יותר משורה אחת, כולם
ניתן "לאגד" את הטיעונים לאחד כדי למנוע סיום כל שורה ב-a
מַהֲלָך סְרָק. במקרה אחד זה, החלפות ה-Tcl הרגילות יתרחשו למרות ה
פלטה.

לדוגמה, הפקודה הבאה פועלת באינטראקציה עם המחרוזת הבאה
זוגות מוגדרים: כאשר ^Z נלחץ, לצפות מושעה. (ה -אִתחוּל הדגל שוחזר
מצבי המסוף.) כאשר ^A נלחץ, המשתמש רואה "הקלדת פקד-A" ו
התהליך נשלח ^A. כאשר $ נלחץ, המשתמש רואה את התאריך. כאשר ^C הוא
לחוץ, לצפות יוצאים. אם הזנת "foo", המשתמש יראה "סרגל". כאשר ~~ הוא
לחוץ, ה לצפות מתורגמן פועל באופן אינטראקטיבי.

הגדר CTRLZ \032
אינטראקציה {
-איפוס $CTRLZ {exec kill -STOP [pid]}
\001 {send_user "הקלדת פקד-A\n";
שלח "\001"
}
$ {send_user "התאריך הוא [פורמט שעון [שניות שעון]]."}
\003 יציאה
foo {send_user "בר"}
~~
}

בזוגות מחרוזת-גוף, מחרוזות מותאמות בסדר שהן מופיעות כארגומנטים.
מחרוזות שתואמות חלקית אינן נשלחות לתהליך הנוכחי בציפייה
השאר מגיע. אם תווים מוזנים כך שלא ניתן יותר
אולי התאמה, רק החלק של המחרוזת יישלח לתהליך ש
לא יכול להתחיל משחק נוסף. לפיכך, מחרוזות שהן מחרוזות משנה של חלקיות
התאמות יכולות להתאים מאוחר יותר, אם המחרוזות המקוריות שניסו להתאים
בסופו של דבר נכשל.

כברירת מחדל, התאמת מחרוזת היא מדויקת ללא תווים כלליים. (לעומת זאת, ה לצפות
הפקודה משתמשת בדפוסים בסגנון גלוב כברירת מחדל.) ה -לְשֶׁעָבַר ניתן להשתמש בדגל כדי להגן
דפוסים שאחרת עשויים להתאים אינטראקציה דגלים מלעשות זאת. כל תבנית
המתחיל ב-"-" צריך להיות מוגן בצורה זו. (כל המחרוזות שמתחילות ב-"-"
שמורות לאפשרויות עתידיות.)

השמיים -re הדגל מאלץ את המחרוזת להתפרש כדפוס בסגנון ביטוי regexp. בזה
מקרה, מחרוזות משנה תואמות מאוחסנות במשתנה interact_out בדומה ל
דרך לצפות מאחסן את הפלט שלו במשתנה מצפה_לחוץ. ה -מדדים דגל הוא
נתמך באופן דומה.

הדפוס eof מציג פעולה שמתבצעת עם סיום הקובץ. נפרד
eof דפוס עשוי גם לעקוב אחר -תְפוּקָה דגל ובמקרה זה הוא מותאם אם eof
מזוהה בזמן כתיבת פלט. ברירת המחדל eof הפעולה היא "החזרה", כך ש
אינטראקציה פשוט חוזר על כל EOF.

הדפוס פסק זמן מציג פסק זמן (בשניות) ופעולה שמתבצעת
לאחר שאף תווים לא נקראו במשך זמן נתון. ה פסק זמן דפוס חל על
התהליך שצוין לאחרונה. אין פסק זמן ברירת מחדל. המיוחד
המשתנה "פסק זמן" (בשימוש על ידי ה- לצפות הפקודה) אין השפעה על הזמן הקצוב הזה.

לדוגמה, ההצהרה הבאה יכולה לשמש ליציאה אוטומטית של משתמשים שלא עשו זאת
הקלידו משהו במשך שעה אבל עדיין מקבלים הודעות מערכת תכופות:

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

אם התבנית היא מילת המפתח ריק, ומותר לבטל (באמצעות ה remove_nulls
הפקודה), הגוף המתאים מבוצע אם ASCII 0 בודד מותאם. זה
לא ניתן להתאים ל-0 בתים באמצעות דפוסי גלוב או ביטוי רגולי.

הקדמת דפוס עם הדגל -אני כותב גורם למשתנה interact_out(spawn_id)
להיות מוגדר ל- spawn_id שתאם את התבנית (או eof).

פעולות כגון לשבור ו להמשיך לגרום למבני בקרה (כלומר, ל, proc) כדי
להתנהג בדרך הרגילה. למרות זאת לַחֲזוֹר גורם לאינטראקציה לחזור למתקשר שלו,
בזמן inter_return גורמים אינטראקציה לגרום להחזרה אצל המתקשר שלו. לדוגמה, אם
קראו "פרוק פו". אינטראקציה אשר לאחר מכן ביצע את הפעולה inter_return, proc Foo
יחזור. (זה אומר שאם אינטראקציה שיחות מְתוּרגְמָן הקלדה אינטראקטיבית
לַחֲזוֹר יגרום להמשך האינטראקציה, תוך כדי inter_return יגרום
ליצור אינטראקציה כדי לחזור למתקשר שלו.)

במהלך אינטראקציה, נעשה שימוש במצב גולמי כך שניתן להעביר את כל התווים ל-
תהליך נוכחי. אם התהליך הנוכחי לא קולט אותות בקרת עבודה, הוא יצליח
עצור אם נשלח אות עצור (כברירת מחדל ^Z). כדי להפעיל אותו מחדש, שלח אות המשך
(כגון על ידי "kill -CONT "). אם אתה באמת רוצה לשלוח SIGSTOP לכזה
תהליך (על ידי ^Z), שקול קודם להריץ csh ולאחר מכן להפעיל את התוכנית שלך. על
מצד שני, אם אתה רוצה לשלוח SIGSTOP ל לצפות עצמו, מתורגמן שיחות ראשון
(אולי באמצעות תו בריחה), ולאחר מכן הקש ^Z.

זוגות מיתר-גוף יכולים לשמש כקיצור כדי להימנע מהצורך להיכנס ל
מתורגמן ומבצע פקודות באופן אינטראקטיבי. נעשה שימוש במצב המסוף הקודם
בזמן שהגוף של זוג מיתר-גוף מבוצע.

עבור מהירות, פעולות מבוצעות במצב גולמי כברירת מחדל. ה -אִתחוּל הדגל מאפס את
מסוף למצב שהיה לו קודם אינטראקציה הוצא להורג (תמיד, מצב מבושל).
שימו לב שתווים שהוזנו בעת החלפת המצב עלולים ללכת לאיבוד (an
תכונה מצערת של מנהל ההתקן של המסוף במערכות מסוימות). הסיבה היחידה להשתמש
-אִתחוּל הוא אם הפעולה שלך תלויה בהפעלה במצב בישול.

השמיים -הֵד הדגל שולח תווים התואמים את הדפוס הבא בחזרה לתהליך
שיצר אותם כאשר כל דמות נקראת. זה עשוי להיות שימושי כאשר המשתמש
צריך לראות משוב מדפוסים שהוקלדו חלקית.

אם הדפוס מקבל הד אבל בסופו של דבר לא מצליח להתאים, התווים נשלחים
לתהליך שנוצר. אם התהליך שנוצר אז מהדהד אותם, המשתמש יראה
הדמויות פעמיים. -הֵד כנראה מתאים רק במצבים שבהם ה
לא סביר שהמשתמש לא ישלים את הדפוס. לדוגמה, הקטע הבא הוא
מ-rftp, הסקריפט רקורסיבי-ftp, שבו המשתמש מתבקש להזין ~g, ~p, או
~l, כדי לקבל, לשים או לרשום את הספרייה הנוכחית באופן רקורסיבי. אלה כל כך רחוקים
מפקודות ה-ftp הרגילות, שהמשתמש לא סביר שיקליד ~ ואחריו
כל דבר אחר, למעט בטעות, ובמקרה זה, הם כנראה פשוט יתעלמו
תוצאה בכל מקרה.

אינטראקציה {
-echo ~g {getcurdirectory 1}
-echo ~l {getcurdirectory 0}
-echo ~p {putcurdirectory}
}

השמיים -ללא מאגר הדגל שולח תווים התואמים את הדפוס הבא אל
תהליך הפלט בזמן קריאת התווים.

זה שימושי כאשר אתה רוצה לתת לתוכנית להדהד את התבנית. לדוגמה,
ניתן להשתמש ברשימה הבאה כדי לעקוב אחר היכן אדם מחייג (בסגנון הייז
מוֹדֶם). בכל פעם שנראה "atd" הסקריפט רושם את שאר השורה.

Proc lognumber {} {
interact -nobuffer -re "(.*)\r" מחזירה
שם $log "[פורמט שעון [שניות שעון]]: חייג $interact_out(1,string)"
}

interact -nobuffer "atd" lognumber

במהלך אינטראקציה, שימוש קודם ב log_user מתעלמים ממנו. באופן מיוחד, אינטראקציה יצטרך
לאלץ את הפלט שלו להירשם (נשלח לפלט הסטנדרטי) מכיוון שהוא נחשב כ-
המשתמש אינו רוצה ליצור אינטראקציה עיוורת.

השמיים -o הדגל גורם להחלת צמדי המפתח-גוף הבאים על הפלט של
תהליך נוכחי. זה יכול להיות שימושי, למשל, כאשר עוסקים במארחים ששולחים
תווים לא רצויים במהלך הפעלת Telnet.

כברירת מחדל, אינטראקציה מצפה מהמשתמש לכתוב סטדין ולקרוא סטדout של
לצפות התהליך עצמו. ה -u דגל (עבור "משתמש") עושה אינטראקציה חפש את המשתמש בתור
התהליך הנקרא על ידי הארגומנט שלו (שחייב להיות מזהה שהולידה).

זה מאפשר לחבר שני תהליכים שאינם קשורים זה לזה מבלי להשתמש במפורש
לוּלָאָה. כדי לסייע באיתור באגים, צפו לאבחון תמיד עוברים אל stderr (או stdout עבור
מידע מסוים על רישום וניפוי באגים). מאותה סיבה, ה מְתוּרגְמָן
הפקודה תקרא באופן אינטראקטיבי מ-stdin.

לדוגמה, הפרגמנט הבא יוצר תהליך התחברות. ואז זה מחייג למשתמש
(לא מוצג), ולבסוף מחבר את שניהם יחד. כמובן, כל תהליך יכול להיות
החלפת כניסה. מעטפת, למשל, תאפשר למשתמש לעבוד בלעדיו
מתן חשבון וסיסמה.

התחברות שרצים
הגדר כניסה $spawn_id
מודם טיפ השרצים
# חיוג חזרה למשתמש
# חבר את המשתמש לכניסה
interact -u $login

כדי לשלוח פלט לתהליכים מרובים, רשום כל רשימת מזהי שרצים עם א -תְפוּקָה
דֶגֶל. קלט עבור קבוצה של מזהי שרצים פלט עשוי להיקבע על ידי רשימת מזהי שרצים
הקדים א -קֶלֶט דֶגֶל. (שניהם -קֶלֶט ו -תְפוּקָה עשוי לקחת רשימות באותה צורה
כמו -i דגל ב לצפות פקודה, פרט לכך שכל_spawn_id אינו משמעותי ב
אינטראקציה.) כל הדגלים והמחרוזות (או הדפוסים) הבאים חלים על קלט זה עד
מופיע דגל קלט נוסף. אם לא -קֶלֶט מופיע, -תְפוּקָה מרמז על "-input
$user_spawn_id -output". (בדומה, עם דפוסים שאין להם -קֶלֶט.) אם
אחד -קֶלֶט מצוין, הוא עוקף את $user_spawn_id. אם שנייה -קֶלֶט is
שצוין, הוא עוקף את $spawn_id. נוֹסָף -קֶלֶט ניתן לציין דגלים.

שני תהליכי הקלט המרומזים כברירת מחדל להגדרת הפלטים שלהם כ
$spawn_id ו-$user_spawn_id (בהפוך על הפוך). אם -קֶלֶט הדגל מופיע עם מס' -תְפוּקָה
דגל, תווים מאותו תהליך נמחקים.

השמיים -i flag מציג תחליף ל-spawn_id הנוכחי כאשר אין אחר -קֶלֶט
or -תְפוּקָה נעשה שימוש בדגלים. דגל -i מרמז על דגל -o.

ניתן לשנות את התהליכים שיש איתם אינטראקציה על ידי שימוש
מזהי שרצים עקיפים. (מזהי שרצים עקיפים מתוארים בסעיף על הציפיות
פקודה.) מזהי שרצים עקיפים יכולים להיות מוגדרים עם -i, -u, -input או -output
דגלים.

מְתוּרגְמָן [טיעונים]
גורם למשתמש להתבקש באופן אינטראקטיבי לצפות ופקודות Tcl. ה
התוצאה של כל פקודה מודפסת.

פעולות כגון לשבור ו להמשיך לגרום למבני בקרה (כלומר, ל, proc) כדי
להתנהג בדרך הרגילה. למרות זאת לַחֲזוֹר גורם למתורגמן לחזור למתקשר שלו,
בזמן inter_return גורמים מְתוּרגְמָן לגרום להחזרה אצל המתקשר שלו. לדוגמה,
אם קרא "פרוק פו". מְתוּרגְמָן אשר לאחר מכן ביצע את הפעולה inter_return, proc
Foo יחזור. כל פקודה אחרת גורמת מְתוּרגְמָן כדי להמשיך לבקש
פקודות חדשות.

כברירת מחדל, הפקודה מכילה שני מספרים שלמים. המספר השלם הראשון מתאר את העומק
של מחסנית ההערכה (כלומר, כמה פעמים נקרא Tcl_Eval). השני
מספר שלם הוא מזהה ההיסטוריה של Tcl. ניתן להגדיר את ההנחיה על ידי הגדרת א
הליך שנקרא "prompt1" שערך ההחזר שלו הופך להנחיה הבאה. אם
להצהרה יש מרכאות פתוחות, פרנס, סוגריים או סוגריים, הנחיה משנית (על ידי
ברירת המחדל "+> ") מונפקת בשורה חדשה. ניתן להגדיר את ההנחיה המשנית על ידי הגדרה
הליך שנקרא "prompt2".

במהלך מְתוּרגְמָן, נעשה שימוש במצב מבושל, גם אם המתקשר שלו השתמש במצב raw.

אם stdin סגור, מְתוּרגְמָן יחזור אלא אם כן -עוף נעשה שימוש בדגל, שבו
במקרה שהטיעון הבא מופעל.

קובץ לוג [טיעונים] [[-א] קוֹבֶץ]
אם מסופק שם קובץ, קובץ לוג יקליט תמליל של הפגישה
(החל מנקודה זו) בקובץ. קובץ לוג יפסיק להקליט אם אין ויכוח
נתון. כל קובץ יומן קודם נסגר.

במקום שם קובץ, ניתן לספק מזהה קובץ Tcl על ידי שימוש ב- פותח or
-תשאיר פתוח דגלים. זה דומה ל להשריץ פקודה. (לִרְאוֹת להשריץ למידע נוסף.)

השמיים -a הדגל מאלץ תיעוד פלט שדוכא על ידי ה- log_user פקודה.

כברירת מחדל, קובץ לוג הפקודה מוסיף לקבצים ישנים במקום לקצץ אותם,
לנוחות היכולת לכבות ולהדליק את ההתחברות מספר פעמים באחת
מוֹשָׁב. כדי לחתוך קבצים, השתמש ב- -לא נפילה דגל.

השמיים מידע flag גורם ל-log_file להחזיר תיאור של הלא-מידע העדכני ביותר
טיעונים שניתנו.

log_user -מידע|0|1
כברירת מחדל, תיבת הדו-שיח שליחה/צפוי מתועדת ל-stdout (וקובץ יומן אם פתוח).
הרישום ל-stdout מושבת על ידי הפקודה "log_user 0" ומופעל מחדש על ידי
"log_user 1". הרישום לקובץ היומן לא השתנה.

השמיים מידע flag גורם ל-log_user להחזיר תיאור של הלא-מידע העדכני ביותר
טיעונים שניתנו.

match_max [-ד] [-אני spawn_id] [גודל]
מגדיר את גודל המאגר (בבתים) בשימוש פנימי על ידי לצפות. ללא גודל
ארגומנט, הגודל הנוכחי מוחזר.

עם -d דגל, גודל ברירת המחדל מוגדר. (ברירת המחדל הראשונית היא 2000.) עם ה-
-i דגל, הגודל מוגדר עבור מזהה השרצים הנקרא, אחרת הוא מוגדר עבור הנוכחי
התהליך.

כיסוי [-# spawn_id] [-# spawn_id] [...] התוכנית [טיעונים]
מבצע התוכנית טוען במקום הזרם לצפות תוכנית, אשר מסתיימת. א
ארגומנט המקף bare מאלץ מקף לפני שם הפקודה כאילו היה a
מעטפת כניסה. כל spawn_ids סגורים למעט אלו שנקראו כארגומנטים. אלה
ממופים על מזהי הקבצים בעלי השם.

Spawn_ids ממופים למזהי קבצים עבור התוכנית החדשה לרשת. ל
לדוגמה, השורה הבאה מפעילה שחמט ומאפשרת לשלוט בו על ידי הזרם
תהליך - נגיד, אמן שחמט.

שכבת על -0 $spawn_id -1 $spawn_id -2 $spawn_id שחמט

זה יותר יעיל מ"אינטראקציה -u", עם זאת, זה מקריב את היכולת לעשות
אינטראקציה מתוכנתת מאז לצפות התהליך כבר לא בשליטה.

שימו לב שלא מסופק מסוף שליטה. לפיכך, אם תתנתק או תמפה מחדש
קלט סטנדרטי, תוכניות שעושות בקרת עבודה (קונכיות, התחברות וכו') לא יפעלו
כראוי.

זוגיות [-ד] [-אני spawn_id] [ערך]
מגדיר האם יש לשמור על שוויון או להסיר מהפלט של ה-Spawned
תהליכים. אם ערך הוא אפס, הזוגיות מופשטת, אחרת היא לא מופשטת.
ללא ערך ארגומנט, הערך הנוכחי מוחזר.

עם -d דגל, ערך הזוגיות המוגדר כברירת מחדל מוגדר. (ברירת המחדל הראשונית היא 1, כלומר,
שוויון אינו מופשט.) עם -i דגל, ערך הזוגיות מוגדר עבור הנקרא
מזהה spawn, אחרת הוא מוגדר לתהליך הנוכחי.

remove_nulls [-ד] [-אני spawn_id] [ערך]
מגדיר אם nulls נשמרים או יוסרו מהפלט של תהליכים שהורדו
לפני התאמת דפוסים או אחסון במשתנה מצפה_לחוץ or interact_out. אם
ערך הוא 1, האפסים מוסרים. אם ערך הוא 0, האפסים אינם מוסרים. ללא ערך
ארגומנט, הערך הנוכחי מוחזר.

עם -d דגל, ערך ברירת המחדל מוגדר. (ברירת המחדל הראשונית היא 1, כלומר, nulls
מוסרים.) עם -i flag, הערך מוגדר עבור מזהה השרצים הנקרא, אחרת
הוא מוגדר לתהליך הנוכחי.

בין אם מסירים אפס או לא, לצפות יקליט בתים null ביומן ו
stdout.

לשלוח [-דגלים] מחרוזת
שולח מחרוזת לתהליך הנוכחי. למשל, הפקודה

שלח "שלום עולם"

שולח את התווים, h e l l o w o r l d לתהליך הנוכחי.
(Tcl כולל פקודה דמוית printf (נקראת פוּרמָט) שיכול לבנות באופן שרירותי
מחרוזות מורכבות.)

תווים נשלחים מיד, אם כי תוכניות עם קלט מאגר קווי לא
קרא את התווים עד שנשלח תו חוזר. תו החזרה מסומן
"\r".

השמיים -- הדגל מאלץ את הארגומנט הבא להתפרש כמחרוזת ולא כ-a
דֶגֶל. ניתן להקדים לכל מחרוזת "--" בין אם היא באמת נראית כמו a
דֶגֶל. זה מספק מנגנון אמין לציון מחרוזות משתנות מבלי להיות
מועד על ידי אלה שנראים בטעות כמו דגלים. (כל המחרוזות שמתחילות ב
"-" שמורות לאפשרויות עתידיות.)

השמיים -i flag מצהיר שהמחרוזת תישלח ל- spawn_id בשם. אם spawn_id
is user_spawn_id, והמסוף נמצא במצב גולמי, שורות חדשות במחרוזת הן
מתורגמים לרצפי חזרה-שורה חדשה כך שהם נראים כאילו הטרמינל נמצא בפנים
מצב מבושל. ה -גלם הדגל משבית את התרגום הזה.

השמיים -ריק הדגל שולח תווי אפס (0 בתים). כברירת מחדל, נשלח ריק אחד. א
מספר שלם עשוי לעקוב אחר ה -ריק כדי לציין כמה nulls לשלוח.

השמיים שבר הדגל יוצר מצב הפסקה. זה הגיוני רק אם מזהה השרצים
מתייחס למכשיר tty שנפתח באמצעות "spawn -open". אם הולידת תהליך כזה
בתור טיפ, עליך להשתמש במוסכמה של טיפ ליצירת הפסקה.

השמיים -s הדגל מאלץ את הפלט להישלח "לאט", ובכך למנוע את המצב הנפוץ שבו
מחשב מוציא מאגר קלט שנועד עבור אדם שלעולם לא יעשה זאת
הקלד את אותו מאגר. פלט זה נשלט על ידי ערך המשתנה
"send_slow" אשר לוקח רשימה של שני אלמנטים. האלמנט הראשון הוא מספר שלם ש
מתאר את מספר הבתים לשליחה אטומית. האלמנט השני הוא אמיתי
מספר המתאר את מספר השניות שבהן השלח האטומי חייב להיות
מופרד. לדוגמה, "set send_slow {10 .001}" יכריח את "send -s" לשלוח
מחרוזות עם 1 אלפית שנייה בין כל 10 תווים שנשלחו.

השמיים -h הדגל מאלץ פלט להישלח (במידת מה) כמו שאדם מקליד בפועל.
בין הדמויות מופיעים עיכובים דמויי אדם. (האלגוריתם מבוסס על א
הפצת Weibull, עם שינויים כדי להתאים ליישום הספציפי הזה.) זה
הפלט נשלט על ידי הערך של המשתנה "send_human" שלוקח חמש
רשימת אלמנטים. שני האלמנטים הראשונים הם זמן הגעה ממוצע של תווים ב
שניות. הראשון משמש כברירת מחדל. השני משמש בסיומת מילים, to
לדמות את ההפסקות העדינות שמתרחשות מדי פעם במעברים כאלה. השלישי
פרמטר הוא מדד לשונות כאשר .1 הוא משתנה למדי, 1 הוא סביר
משתנה, ו-10 הוא די בלתי משתנה. הקצוות הם 0 עד אינסוף. השניים האחרונים
הפרמטרים הם, בהתאמה, זמן הגעה ביניים מינימלי ומקסימלי. המינימום
ומקסימום משמשים אחרון ו"קליפ" בפעם האחרונה. הממוצע האולטימטיבי יכול להיות
שונה למדי מהממוצע הנתון אם הקליפ המינימלי והמקסימלי מספיק
ערכים.

כדוגמה, הפקודה הבאה מחקה קלדנית מהירה ועקבית:

set send_human {.1 .3 1 .05 2}
send -h "אני רעב. בוא נעשה ארוחת צהריים."

בעוד שהדברים הבאים עשויים להתאים יותר לאחר הנגאובר:

set send_human {.4 .4 .2 .5 100}
שלח -h "ליל ריסים מסיבה טובה!"

שימו לב ששגיאות אינן מדומות, אם כי ניתן להגדיר תיקון שגיאות
מצב עצמך על ידי הטמעת טעויות ותיקונים בטיעון שליחה.

הדגלים לשליחת תווי אפס, לשליחת הפסקות, לכפיית פלט איטי
ועבור פלט בסגנון אנושי סותרים זה את זה. רק האחד שצוין האחרון ירצה
לשמש. יתר על כן, לא מחרוזת ניתן לציין ארגומנט עם הדגלים לשליחה
תווי אפס או הפסקות.

כדאי להקדים את הראשון לשלוח לתהליך על ידי א לצפות. לצפות יצטרך
המתן עד שהתהליך יתחיל, תוך כדי לשלוח לא יכול. בפרט, אם הראשון לשלוח
מסתיים לפני שהתהליך מתחיל לרוץ, אתה מסתכן בקבלת הנתונים שלך
התעלמו. במצבים שבהם תוכניות אינטראקטיביות לא מציעות הנחיה ראשונית, אתה יכול
לְהַקְדִים לשלוח באיחור כמו ב:

# כדי להימנע מלתת להאקרים רמזים כיצד לפרוץ,
# מערכת זו אינה מבקשת סיסמה חיצונית.
# המתן 5 שניות עד להשלמת ההפעלה
להשריץ telnet very.secure.gov
לישון 5
שלח סיסמה\r

exp_send הוא כינוי עבור לשלוח. אם אתה משתמש ב- Expectk או בגרסה אחרת של
צפו בסביבת Tk, לשלוח מוגדר על ידי Tk עבור שונה לחלוטין
מַטָרָה. exp_send מסופק עבור תאימות בין סביבות. דוֹמֶה
כינויים מסופקים עבור פקודות השליחה האחרות של Expect.

שלח_שגיאה [-דגלים] מחרוזת
הוא כמו לשלוח, אלא שהפלט נשלח ל-stderr ולא לזרם
התהליך.

שלח_לוג [-] מחרוזת
הוא כמו לשלוח, אלא שהמחרוזת נשלחת רק לקובץ היומן (ראה קובץ לוג.)
מתעלמים מהארגומנטים אם אין קובץ יומן פתוח.

send_tty [-דגלים] מחרוזת
הוא כמו לשלוח, אלא שהפלט נשלח אל /dev/tty במקום הנוכחי
התהליך.

שלח_משתמש [-דגלים] מחרוזת
הוא כמו לשלוח, אלא שהפלט נשלח ל-stdout ולא לזרם
התהליך.

לִישׁוֹן שניות
גורם לסקריפט לישון למשך מספר השניות הנתון. שניות עשויות להיות א
מספר עשרוני. שיבושים (ואירועי Tk אם אתה משתמש ב- Expectk) מעובדים
בעוד מצפה ישן.

להשריץ [טיעונים] התוכנית [טיעונים]
יוצר תהליך חדש הפועל התוכנית טוען. stdin, stdout ו-stderr שלו הם
מחוברים ל- Expect, כדי שיוכלו לקרוא ולכתוב על ידי אחרים לצפות פקודות.
הקשר נשבר על ידי close או אם התהליך עצמו סוגר חלק מהקובץ
מזהים.

כאשר מתחיל תהליך על ידי להשריץ, המשתנה spawn_id מוגדר כמתאר
מתייחס לתהליך הזה. התהליך המתואר על ידי spawn_id נחשב ל
נוֹכְחִי תהליך. spawn_id ניתן לקרוא או לכתוב, ולמעשה מספק שליטה בעבודה.

user_spawn_id הוא משתנה גלובלי המכיל מתאר המתייחס למשתמש.
לדוגמה, מתי spawn_id מוגדר לערך זה, לצפות מתנהג כמו expect_user.

error_spawn_id הוא משתנה גלובלי המכיל מתאר המתייחס ל-
שגיאת תקן. למשל, מתי spawn_id מוגדר לערך זה, לשלוח מתנהג כמו
שלח_שגיאה.

tty_spawn_id הוא משתנה גלובלי המכיל מתאר המתייחס ל-/dev/tty.
אם /dev/tty אינו קיים (כגון בסקריפט cron, at או אצווה), אז
tty_spawn_id אינו מוגדר. זה עשוי להיבדק כ:

if {[info vars tty_spawn_id]} {
# /dev/tty קיים
אחר} {
# /dev/tty לא קיים
# כנראה ב-cron, אצווה או בסקריפט
}

להשריץ מחזירה את מזהה התהליך של UNIX. אם לא נוצר תהליך, 0 מוחזר. ה
משתנה spawn_out(slave,name) מוגדר לשם של התקן Pty ​​slave.

כברירת מחדל, להשריץ מהדהד את שם הפקודה והארגומנטים. ה -נאקו הדגל נעצר
להשריץ מלעשות זאת.

השמיים קונסולה הדגל גורם לניתוב מחדש של פלט הקונסולה לתהליך שנוצר.
זה לא נתמך בכל המערכות.

כְּלַפֵּי פְּנִים, להשריץ משתמש ב-pty, מאותחל באותו אופן כמו tty של המשתמש. זה
אתחול נוסף כך שכל ההגדרות יהיו "שפויות" (לפי stty(1)). אם ה
משתנה stty_init מוגדר, הוא מתפרש בסגנון טיעוני stty as
תצורה נוספת. לדוגמא, "set stty_init raw" יגרום להיווצרות נוספות
המסופים של תהליכים כדי להתחיל במצב גולמי. -לא העתק מדלג על האתחול
מבוסס על tty של המשתמש. -nottyinit מדלג על האתחול ה"שפוי".

בדרך כלל, להשריץ לוקח מעט זמן לביצוע. אם אתה מבחין שספאון לוקח א
כמות משמעותית של זמן, זה כנראה נתקל ב-ptys שהם תקולים. א
מספר בדיקות מופעלות על ptys כדי למנוע הסתבכות עם תהליכים שגויים.
(אלה לוקחים 10 שניות לכל Pty wedged.) פועל צפו עם ה- -d האפשרות תוצג
if לצפות הוא נתקל בהרבה Ptys במצבים מוזרים. אם אתה לא יכול להרוג את התהליכים
שאליו מצורפים ה-ptys האלה, ייתכן שהדרך היחידה שלך היא לאתחל מחדש.

If התוכנית לא ניתן להוליד בהצלחה כי Exec(2) נכשל (למשל מתי התוכנית
לא קיים), הודעת שגיאה תוחזר על ידי הבא אינטראקציה or לצפות
פקודה כאילו התוכנית רצה והפיק את הודעת השגיאה כפלט. זֶה
התנהגות היא תוצאה טבעית של יישום להשריץ. פנימית, השרצים
מזלגות, שלאחריו אין לתהליך שהוולד דרך לתקשר עם המקור
לצפות תהליך פרט לתקשורת באמצעות spawn_id.

השמיים פותח דגל גורם לארגומנט הבא להתפרש כמזהה קובץ Tcl
(כלומר, הוחזר על ידי לפתוח.) לאחר מכן ניתן להשתמש במזהה השרצים כאילו הוא הוצא
תהליך. (אין להשתמש יותר במזהה הקובץ.) זה מאפשר לך לטפל ב-raw
התקנים, קבצים וצינורות כתהליכים שהולידו ללא שימוש ב-pty. 0 הוא
הוחזר כדי לציין שאין תהליך משויך. כאשר החיבור ל-
התהליך שנוצר סגור, וכך גם מזהה הקובץ Tcl. ה -תשאיר פתוח דגל הוא
דומה פותח חוץ מזה ש -תשאיר פתוח גורם למזהה הקובץ להישאר פתוח
גם אחרי שמזהה השרצים נסגר.

השמיים -פי הדגל גורם לפתיחת pty אך לא נוצר תהליך. 0 מוחזר ל
מציין שאין תהליך משויך. Spawn_id מוגדר כרגיל.

המשתנה spawn_out(slave,fd) מוגדר למזהה קובץ המתאים ל-
עבד פטי. ניתן לסגור אותו באמצעות "close -slave".

השמיים -להתעלם הדגל נותן שמות לאות שיש להתעלם ממנו בתהליך היווצרותו. אחרת,
אותות מקבלים את התנהגות ברירת המחדל. האותות נקראים כמו ב- מלכודת פקודה, למעט
שכל אות דורש דגל נפרד.

שטרס רָמָה
גורם להדפסת ההצהרות הבאות לפני ביצוען. (עקבות של Tcl
הפקודה עוקבת אחר משתנים.) רָמָה מציין כמה למטה בערימת השיחות לעקוב.
לדוגמה, הפקודה הבאה פועלת לצפות תוך כדי מעקב אחר 4 הרמות הראשונות של
שיחות, אבל אף אחת מתחת לזה.

expect -c "strace 4" script.exp

השמיים מידע הדגל גורם ל-strace להחזיר תיאור של הלא-מידע העדכני ביותר
טיעונים שניתנו.

stty טוען
משנה מצבי מסוף בדומה לפקודת stty החיצונית.

כברירת מחדל, יש גישה למסוף השולט. ניתן לגשת לטרמינלים אחרים
על ידי הוספת "< /dev/tty..." לפקודה. (שים לב שהטיעונים לא צריכים להיות
מקובצים לטיעון אחד.)

בקשות לסטטוס מחזירות אותו כתוצאה מהפקודה. אם אין סטטוס
מבוקש וניגשים למסוף השולט, המצב הקודם של ה-raw
ותכונות הד מוחזרות בצורה שבה ניתן להשתמש בפקודה מאוחר יותר.

למשל, הטיעונים חי or -מְבוּשָׁל הכנס את המסוף למצב גולמי. ה
טיעונים -גלם or מבושל הכניסו את הטרמינל למצב בישול. הטיעונים הד ו
-הֵד הכניסו את הטרמינל למצב הד ו-noecho בהתאמה.

הדוגמה הבאה ממחישה כיצד להשבית זמנית את ההד. זה יכול להיות
בשימוש בסקריפטים אוטומטיים אחרת כדי להימנע מהטמעת סיסמאות בהם. (ראה עוד
דיון על זה תחת רמזים צפויים למטה.)

stty -הד
send_user "סיסמה: "
expect_user -re "(.*)\n"
הגדר סיסמה $expect_out(1,string)
אקו סטטי

מערכת טוען
נותן טוען ל sh(1) כקלט, ממש כאילו הוא הוקלד כפקודה מ-a
מָסוֹף. לצפות מחכה עד שהקליפה תסתיים. סטטוס ההחזרה מ-sh הוא
טיפלו באותו אופן Exec מטפל במצב ההחזרה שלו.

בניגוד ל Exec שמפנה מחדש את stdin ו-stdout לסקריפט, מערכת מבצע
ללא ניתוב מחדש (מלבד זה שמצוין על ידי המחרוזת עצמה). לפיכך, זהו
אפשר להשתמש בתוכנות שחייבות לדבר ישירות אל /dev/tty. מאותה הסיבה,
התוצאות של מערכת אינם נרשמים ביומן.

חותם [טיעונים]
מחזירה חותמת זמן. ללא טיעונים, מספר השניות מאז התקופה
חזר.

השמיים -פוּרמָט הדגל מציג מחרוזת שמוחזרת אך עם ביצוע החלפות
לפי כללי POSIX עבור strftime. לדוגמה %a מוחלף ב-an
שם מקוצר של יום חול (כלומר, שבת). אחרים הם:
%שם מקוצר של יום חול
%שם מלא של יום חול
%b שם חודש מקוצר
%B שם חודש מלא
%c תאריך-שעה כמו ב: רביעי 6 באוקטובר 11:45:56 1993
%d יום בחודש (01-31)
%H שעה (00-23)
%I שעה (01-12)
%j יום (001-366)
%m חודש (01-12)
%M דקה ​​(00-59)
%p am או pm
%S שניה (00-61)
%u יום (1-7, יום שני הוא היום הראשון בשבוע)
שבוע %U (00-53, יום ראשון הראשון הוא היום הראשון בשבוע הראשון)
%V שבוע (01-53, סגנון ISO 8601)
%w יום (0-6)
%W שבוע (00-53, יום שני הראשון הוא היום הראשון בשבוע הראשון)
%x תאריך-שעה כמו ב: ד' 6 באוקטובר 1993
%X זמן כמו ב: 23:59:59
%y שנה (00-99)
%Y שנה כמו ב: 1993
%Z אזור זמן (או כלום אם לא ניתן לקבוע)
%% סימן אחוז חשוף

מפרטי % אחרים אינם מוגדרים. דמויות אחרות יועברו
ללא נגיעה. רק המקום C נתמך.

השמיים -שניות דגל מציג מספר שניות מאז התקופה לשמש כ
מקור שממנו ניתן לעצב. אחרת, השעה הנוכחית משמשת.

השמיים -שעון גריניץ הדגל מאלץ פלט חותמת זמן להשתמש באזור הזמן של GMT. ללא דגל, ה
נעשה שימוש באזור זמן מקומי.

מלכודת [[פקודה] אותות]
גורם לנתון הפקודה לביצוע עם קבלה עתידית של כל אחד מהנתונים
אותות. הפקודה מבוצעת בהיקף הגלובלי. אם הפקודה נעדר, ה
פעולת האות מוחזרת. אם הפקודה הוא המחרוזת SIG_IGN, האותות הם
התעלמו. אם הפקודה הוא המחרוזת SIG_DFL, האותות הם תוצאה למערכת
ברירת המחדל. אותות הוא אות בודד או רשימה של אותות. אותות עשויים להיות
מצוין באופן מספרי או סמלי לפי אוֹת(3). הקידומת "SIG" עשויה להיות
הושמט.

ללא ארגומנטים (או הארגומנט -מספר), מלכודת מחזירה את מספר האות של
פקודת trap שמתבצעת כעת.

השמיים -קוד flag משתמש בקוד ההחזרה של הפקודה במקום הקוד שהיה Tcl
עומד לחזור כאשר הפקודה התחילה לפעול במקור.

השמיים -אינטרפ flag גורם להערכת הפקודה באמצעות המתורגמן הפעיל ב
הזמן שבו הפקודה התחילה לרוץ ולא כאשר הוכרזה המלכודת.

השמיים - שם הדגל גורם ל מלכודת פקודה להחזרת שם האות של פקודת trap
מבוצע כעת.

השמיים -מקסימום הדגל גורם ל מלכודת פקודה כדי להחזיר את מספר האות הגדול ביותר שיכול
להיות מוגדר.

לדוגמה, הפקודה "ללכוד {send_user "אאוש!"} SIGINT תדפיס את "אאוש!" כל אחד
זמן שהמשתמש לוחץ על ^C.

כברירת מחדל, SIGINT (שניתן ליצור בדרך כלל על ידי לחיצה על ^C) ו-SIGTERM סיבה
צפו לצאת. זה נובע מהמלכודת הבאה, שנוצרה כברירת מחדל כאשר Expect
מתחיל.

יציאה מלכודת {SIGINT SIGTERM}

אם אתה משתמש בדגל -D כדי להפעיל את מאתר הבאגים, SIGINT מוגדר מחדש כדי להפעיל את
מאתר באגים אינטראקטיבי. זה נובע מהמלכודת הבאה:

trap {exp_debug 1} SIGINT

ניתן לשנות את מלכודת באגים על ידי הגדרת משתנה הסביבה
EXPECT_DEBUG_INIT לפקודת trap חדשה.

אתה יכול, כמובן, לעקוף את שני אלה רק על ידי הוספת פקודות מלכודת שלך
תַסרִיט. בפרט, אם יש לך "יציאה מלכודת SIGINT", זה יעקוף
מלכודת ניפוי הבאגים. זה שימושי אם ברצונך למנוע ממשתמשים להגיע אל
באגים בכלל.

אם אתה רוצה להגדיר מלכודת משלך ב-SIGINT אבל עדיין מלכודת למאתר הבאגים כאשר זה
פועל, השתמש ב:

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

לחלופין, אתה יכול ללכוד אל מאתר הבאגים באמצעות אות אחר.

מלכודת לא יאפשר לך לעקוף את הפעולה עבור SIGALRM מכיוון שהיא משמשת באופן פנימי
לצפות. פקודת הניתוק מגדירה את SIGALRM ל-SIG_IGN (התעלם). אתה יכול להפעיל מחדש
זה כל עוד אתה משבית אותו במהלך פקודות השרצים עוקבות.

לִרְאוֹת אוֹת(3) למידע נוסף.

לחכות [טיעונים]
עיכובים עד שתהליך שנוצר (או התהליך הנוכחי אם אין שם) מסתיים.

לחכות בדרך כלל מחזיר רשימה של ארבעה מספרים שלמים. המספר השלם הראשון הוא ה-pid של ה-
תהליך שחיכו לו. המספר השלם השני הוא מזהה השרצים המתאים.
המספר השלם השלישי הוא -1 אם אירעה שגיאה במערכת ההפעלה, או 0 אחרת. אם
המספר השלם השלישי היה 0, המספר השלם הרביעי הוא הסטטוס שהוחזר על ידי ה-Spawned
תהליך. אם המספר השלם השלישי היה -1, המספר השלם הרביעי הוא הערך של errno set
על ידי מערכת ההפעלה. המשתנה הגלובלי errorCode מוגדר גם כן.

אלמנטים נוספים עשויים להופיע בסוף ערך ההחזר מ לחכות.
רכיב חמישי אופציונלי מזהה סוג של מידע. נכון לעכשיו, היחיד
הערך האפשרי לרכיב זה הוא CHILDKILLED ובמקרה זה שני הערכים הבאים
שם האות בסגנון C ותיאור טקסטואלי קצר.

השמיים -i flag מכריז על התהליך לחכות המתאים ל- spawn_id בשם (NOT
מזהה התהליך). בתוך מטפל SIGCHLD, אפשר להמתין לכל מולידה
תהליך על ידי שימוש במזהה spawn -1.

השמיים -לא חכה דגל גורם להמתנה לחזור מיד עם ציון א
המתנה מוצלחת. כשהתהליך יוצא (מאוחר יותר), הוא ייעלם אוטומטית
ללא צורך בהמתנה מפורשת.

השמיים לחכות ניתן להשתמש בפקודה wait לתהליך מזולג באמצעות הארגומנטים "-i
-1". בניגוד לשימוש שלה עם תהליכים שהורדו, פקודה זו יכולה להתבצע בכל מקום
זְמַן. אין שליטה באיזה תהליך נקצר. עם זאת, ערך ההחזר
ניתן לבדוק את מזהה התהליך.

ספריות

Expect יודע אוטומטית על שתי ספריות מובנות עבור סקריפטים של Expect. אלו הם
מוגדר על ידי הספריות הנקראות במשתנים exp_library ו-ex_exec_library. שניהם
נועדו להכיל קבצי עזר שיכולים לשמש סקריפטים אחרים.

exp_library מכיל קבצים בלתי תלויים בארכיטקטורה. exp_exec_library מכיל
קבצים תלויי ארכיטקטורה. בהתאם למערכת שלך, שתי הספריות עשויות להיות לגמרי
ריק. קיומו של הקובץ $exp_exec_library/cat-buffers מתאר האם שלך
/bin/cat מאגרים כברירת מחדל.

הדפסה יפה

הגדרת vgrind זמינה להדפסה יפה לצפות תסריטים. בהנחה שה-vgrind
ההגדרה שסופקה עם לצפות ההפצה מותקנת כהלכה, אתה יכול להשתמש בה
כמו:

קובץ vgrind -lexpect

דוגמאות

הרבה לא ברור איך לחבר את כל מה שמתאר דף הגברים. אני
מעודד אותך לקרוא ולנסות את הדוגמאות בספריית הדוגמאות של לצפות
הפצה. חלקן הן תוכניות אמיתיות. אחרים פשוט ממחישים מסוימים
טכניקות, וכמובן, זוג הם רק פריצות מהירות. לקובץ ה-INSTALL יש מהיר
סקירה כללית של תוכניות אלה.

השמיים לצפות ניירות (ראה גם) שימושיים. בעוד כמה מאמרים משתמשים בתחביר
בהתאם לגרסאות קודמות של Expect, הרציונלים הנלווים עדיין תקפים
וללכת להרבה יותר פרטים מדף האיש הזה.

מערות

הרחבות עלולות להתנגש בשמות הפקודות של Expect. לדוגמה, לשלוח מוגדר על ידי Tk
למטרה אחרת לגמרי. מסיבה זו, רוב ה לצפות גם פקודות
זמין בתור "exp_XXXX". פקודות ומשתנים המתחילים ב-"exp", "inter", "spawn",
ול-"פסק זמן" אין כינויים. השתמש בשמות הפקודות המורחבים אם אתה צריך את זה
תאימות בין סביבות.

לצפות נוקט בהשקפה ליברלית למדי לגבי היקף. בפרט, משתנים הנקראים על ידי פקודות
ספציפי ל לצפות תחילה יחפשו את התוכנית מההיקף המקומי, ואם לא
נמצא, בהיקף הגלובלי. לדוגמה, זה מייתר את הצורך להציב "פסק זמן גלובלי"
בכל הליך שאתה כותב שמשתמש לצפות. מצד שני, משתנים שנכתבו הם
תמיד בהיקף המקומי (אלא אם כן ניתנה פקודה "גלובלית"). הנפוץ ביותר
הבעיה שזה גורם היא כאשר השרצים מבוצעים בהליך. מחוץ להליך,
spawn_id כבר לא קיים, כך שהתהליך שנוצר כבר לא נגיש רק בגלל
של היקף. הוסף "גלובל spawn_id" להליך כזה.

אם אינך יכול להפעיל את יכולת ההפצה המרובה (כלומר, המערכת שלך לא תומכת בשניהם
בחר (BSD *.*), סקר (SVR>2), ולא משהו שווה ערך), לצפות רק יוכל
לשלוט בתהליך בודד בכל פעם. במקרה זה, אל תנסה להגדיר spawn_id, ולא
האם אתה צריך לבצע תהליכים באמצעות exec בזמן שתהליך הוצא פועל. יתר על כן,
אתה לא תוכל לצפות ממספר תהליכים (כולל המשתמש כאחד) ב-
אותו זמן.

לפרמטרים מסוף יכולה להיות השפעה גדולה על סקריפטים. למשל, אם נכתב תסריט
כדי לחפש הד, הוא יתנהג בצורה לא נכונה אם ההד כבוי. מסיבה זו, צפו
מאלץ פרמטרים של מסוף שפויים כברירת מחדל. למרבה הצער, זה יכול לעשות דברים
לא נעים עבור תוכניות אחרות. כדוגמה, מעטפת emacs רוצה לשנות את ה"רגיל"
מיפויים: קווים חדשים ממופים לקווים חדשים במקום קווים חדשים להחזרת עגלה, והדים
מושבת. זה מאפשר להשתמש ב-emacs כדי לערוך את שורת הקלט. למרבה הצער, מצפה
לא יכול לנחש את זה.

אתה יכול לבקש ש- Expect לא יעקוף את הגדרת ברירת המחדל של פרמטרי מסוף, אבל
אז עליך להיות זהיר מאוד בעת כתיבת סקריפטים עבור סביבות כאלה. במקרה של
emacs, הימנע מהתלות בדברים כמו הד ומיפוי סוף-שורה.

הפקודות שקיבלו ארגומנטים התאגדו לרשימה אחת (ה לצפות גרסאות ו
אינטראקציה) השתמש בהיוריסטיקה כדי להחליט אם הרשימה היא למעשה טיעון אחד או רבים. ה
היוריסטיקה יכולה להיכשל רק במקרה שהרשימה אכן מייצגת יחיד
ארגומנט הכולל מספר \n'ים מוטבעים עם תווים שאינם רווחים ביניהם.
זה נראה בלתי סביר מספיק, אולם ניתן להשתמש בטיעון "-nobrace" כדי לכפות על א
טיעון יחיד שיטופל כארגומנט יחיד. זה יכול לשמש עם
קוד Expect שנוצר על ידי מכונה. באופן דומה, סד מאלץ טיעון יחיד לטפל בו
דפוסים/פעולות מרובות.

השתמש לצפות באינטרנט באמצעות שירותי onworks.net