מצפה היא תוכנית אשר מדבר על תוכניות אינטראקטיביות אחרות על פי סקריפט. בעקבות התסריט, מצפה לדעת מה ניתן לצפות מתוכנית ומה צריכה להיות התגובה הנכונה. שפה מפורשת מספקת מבני בקרה מסתעפים ורמה גבוהה כדי לכוון את הדו-שיח. בנוסף, המשתמש יכול לקחת שליטה אינטראקציה ישירות בעת הצורך, לאחר מכן להחזיר את השליטה על התסריט.
Expectk הוא תערובת של Expect ו Tk. זה מתנהג בדיוק כמו ציפייה של TCP ו Tk. מצפה גם יכול לשמש ישירות C או C + + ללא Tcl.
השם "מצפה" מגיע מהרעיון לשלוח / לצפות sequences לפופולרי על ידי uucp, קרמיט ותוכנות אחרות מודם שליטה. עם זאת שלא כמו uucp, לצפות הוא הכללה, כך שניתן להפעיל כפקודה ברמת המשתמש עם כל תוכנית ומשימה בחשבון. מצפה יכול לדבר עם כמה תוכניות בו זמנית.
מה מצפה לעשות
לדוגמה, הנה כמה דברים שהפקודה הצפויה יכולה לבצע:
- לגרום למחשב לחייג אותך בחזרה, כך שתוכל להיכנס מבלי לשלם עבור השיחה.
- התחל משחק, ואם התצורה האופטימלית לא מופיעה, הפעל אותו שוב ושוב) עד שהוא עושה זאת ולאחר מכן העבר את השליטה אליך.
- הפעל fsck , ובתשובה לשאלות שלה, ענה "כן" או "לא" או לתת שליטה בחזרה לך, על בסיס קריטריונים שנקבעו מראש.
- התחבר לרשת אחרת ובאופן אוטומטי אחזר את הדואר שלך כך שייראה כאילו נשלח במקור למערכת המקומית שלך.
- השתמש במשתני סביבה, בספרייה הנוכחית או בכל סוג של מידע על פני rlogin, telnet, tip, su או chgrp
ישנן מספר סיבות מדוע פגז לא יכול לבצע את המשימות האלה. כל זה אפשרי עם ציפייה.
באופן כללי, צפוי להשתמש עבור כל תוכנית הדורשת אינטראקציה בין התוכנית לבין המשתמש. כל מה שצריך הוא אינטראקציה יכולה להיות מאופיינת תכנותית. מצפה גם לתת בחזרה את השליטה למשתמש מבלי לעצור את התוכנית להיות נשלט. באופן דומה, המשתמש יכול להחזיר את השליטה לסקריפט בכל עת.
נוֹהָג
מצפה לקרוא cmdfile עבור רשימה של פקודות לבצע. אפשר לצפות שיוצגו במפורש במערכות התומכות ב- #! סימון על ידי סימון הסקריפט כהפעלה וביצוע השורה הראשונה בתסריט:
#! / usr / local / bin / expected -fכמובן, הנתיב חייב לתאר במדויק היכן לצפות חיים. / usr / local / bin הוא רק דוגמה.
הדגל -c ממלא פקודה שתבוצע לפני כל התסריט. הפקודה צריכה להיות מצוטט כדי למנוע להיות שבור על ידי פגז. ניתן להשתמש באפשרות זו מספר פעמים. ניתן לבצע פקודות מרובות באמצעות סיבית אחת על-ידי הפרדתן באמצעות נקודה-פסיק. פקודות מבוצעות לפי סדר הופעתן. בעת שימוש ב- Expectk, אפשרות זו מוגדרת כ- COMMAND.
הדגל -D מאפשר פלט אבחוני כלשהו, שמדווח בעיקר על פעילות פנימית של פקודות כגון ציפייה ואינטראקציה. דגל זה יש את אותו אפקט כמו "exp_internal 1" בתחילת סקריפט מצפה, בתוספת גירסה של מצפה מודפס.
דגל -D מאפשר מאתר באגים אינטראקטיבי. ערך שלם צריך לעקוב אחר. הבאגים ייקח שליטה לפני ההליך הבא Tcl אם הערך הוא לא אפס או אם C C הוא לחוץ או נקודת עצירה הוא פגע, או הפקודה המתאימה הבאגים המתאים מופיע בסקריפט. בעת שימוש Expectk, אפשרות זו מוגדרת - Debug.
הדגל -f מקדים קובץ שממנו ניתן לקרוא פקודות. הדגל עצמו הוא אופציונלי כפי שהוא שימושי רק בעת שימוש #! , כך שניתן יהיה לספק ארגומנטים אחרים בשורת הפקודה. בעת שימוש ב- Expectk, אפשרות זו מוגדרת כ- -file.
כברירת מחדל, קובץ הפקודות נקרא בזיכרון ומבוצע בשלמותו. זה רצוי מדי פעם לקרוא קבצים שורה אחת בכל פעם. כדי להכריח קבצים שרירותיים להיות מטופלים בדרך זו, להשתמש בדגל -B. בעת שימוש ב- Expectk, אפשרות זו מוגדרת כ- -buffer.
אם המחרוזת "-" מסופקת כשם קובץ, ישנה קריאה סטנדרטית במקום זאת. השתמש "./" כדי לקרוא מתוך קובץ בשם "-".
הדגל- I גורם לצפות באופן אינטראקטיבי הפקודה במקום לקרוא אותם מקובץ. הפקודה מסתיימת באמצעות פקודת היציאה או על EOF. הדגל - i מניח אם לא נעשה שימוש בקובץ פקודה ו- c-c. בעת שימוש ב- Expectk, אפשרות זו מוגדרת כ--פעילות.
- עשוי לשמש כדי לתחום את סוף האפשרויות. אפשרות זו שימושית אם אתה רוצה להעביר ארגומנט כמו אופציה לסקריפט שלך מבלי שהוא יפורש על ידי Expect. זה יכול להיות מועיל ב #! כדי למנוע כל פרשנות דגל כמו על ידי מצפה. לדוגמה, הפרטים הבאים יותירו את הארגומנטים המקוריים, כולל שם הסקריפט במשתנה argv .
#! / usr / local / bin / צפוי -שים לב כי הרגיל getopt (3) ו execve (2) מוסכמות יש לשים לב בעת הוספת טיעונים #! קַו.
הקובץ exp_library / expected.rc הוא מקור באופן אוטומטי אם קיים, אלא אם כן נעשה שימוש בדגל -N. (בעת שימוש ב- Expectk, אפשרות זו מוגדרת כ- NORC). מיד לאחר מכן, הקובץ ~ / .expect.rc הוא מקור באופן אוטומטי, אלא אם כן נעשה שימוש בדגל -n. אם משתנה הסביבה DOTDIR מוגדר, הוא מטופל כמו ספרייה ו .expect.rc הוא קרא משם. בעת שימוש ב- Expectk, אפשרות זו מוגדרת כ- norc. מקור זה מתרחש רק לאחר ביצוע כל הדגלים.
סיבות לגרום להדפיס את מספר הגירסה שלה ולצאת. הדגל המתאים ב- Expectk, אשר משתמש בשמות דגלים ארוכים, הוא -הגרסה.
ארגומנטים אופציונליים בנויים לרשימה ומאוחסנים במשתנה בשם argv ו-. argc מאותחל לאורך של argv.
Argv0 מוגדר להיות שם התסריט או בינארי אם לא נעשה שימוש בסקריפט. לדוגמה, הדוגמה הבאה מדפיסה את שם הסקריפט ואת שלושת הארגומנטים הראשונים:
send_user "$ argv0 [lrange $ argv 0 2] \ n"פקודות
מצפה להשתמש בכלי פקודת כלי. Tcl מספק זרימת שליטה (אם, עבור, הפסקה), הערכת הביטוי וכמה תכונות אחרות כגון recursionand הגדרת ההליך. פקודות המשמשות כאן אך לא מוגדרות (set, if, exec) הן פקודות TCL. מצפה לתמיכה בפקודות נוספות. אלא אם צוין אחרת, פקודות מחזירות את המחרוזת הריקה.
פקודות מופיעות בסדר אלפביתי, כך שניתן יהיה לאתר אותן במהירות. עם זאת, משתמשים חדשים עשויים למצוא את זה קל יותר להתחיל לקרוא את התיאורים של שרצים, לשלוח, לצפות, אינטראקציה, בסדר הזה.
סגור [-slave] [-onexec 0 | 1] [-i spawn_id]סוגר את החיבור לתהליך הנוכחי. תוכניות אינטראקטיביות ביותר יאתרו EOF על stdin שלהם ולצאת; ולכן בדרך כלל קרוב מספיק כדי להרוג את התהליך גם כן. הדגל - I מצהיר על תהליך סגירה המתאים ל spawn_id.
שניהם מצפים אינטראקציה יזהה כאשר התהליך הנוכחי יוצא באופן מרומז לעשות קרוב, אבל אם אתה הורג את התהליך על ידי, למשל, "exec להרוג $ pid", אתה צריך להתקשר במפורש קרוב .
דגל אונקסק קובע אם מזהה שרצים סגור בכל התהליכים החדשים שנולדו או אם התהליך הוא overayed. כדי להשאיר את הזיהוי פתוח פתוח, השתמש בערך 0. ערך שלם לא אפס כוחות כוחות להשליך את כל התהליכים החדשים.
הדגל של "סלייב" סוגר את העבד המשויך לזיהוי. כאשר החיבור נסגר, העבד נסגר אוטומטית גם אם הוא עדיין פתוח.
לא משנה אם החיבור נסגר במפורש או במפורש, אתה צריך לקרוא להמתין כדי לנקות את חריץ הליבה המקביל. הפקודה הסופית אינה מתקשרת ממתינה מכיוון שאין ערובה לכך שסגירת חיבור תהליך תגרום ליציאה.
Debug [[-now] 0 | 1]שולט על הבאגים Tcl המאפשר לך לשלב את ההצהרות ולהגדיר breakpoints.
ללא ארגומנטים, 1 מוחזר אם הבאגים אינו פועל, אחרת מוחזר 0.
עם ארגומנט אחד, מאתר הבאגים מופעל. עם ארגומנט 0, מאתר הבאגים מופסק. אם בארגומנט אחד קודמת הדגל -now, מאתר הבאגים מופעל באופן מיידי. אחרת, הבאגים מתחיל עם משפט TCL הבא.
הפקודה Debug אינה משנה מלכודות כלשהן. השווה את זה כדי להתחיל מצפה עם דגל.
פקודת הניתוק מנתקת את התהליך המזלג מהמסוף . הוא ממשיך לרוץ ברקע. התהליך מקבל קבוצת תהליך משלה. סטנדרטי אני / O מנותב אל / dev / null .
החלק הבא משתמש בהתנתקות כדי להמשיך בהפעלת הסקריפט ברקע.
אם [{fork]! = 0} התנתק. . .את התסריט הבא קורא סיסמה ולאחר מכן מפעיל תוכנית בכל שעה הדורש סיסמה בכל פעם שהוא פועל. הסקריפט מספק את הסיסמה כך שתצטרך להקליד אותה פעם אחת בלבד.
סיסמא \ u003d \ u003c / b \ u003e \ u003c / b \ u003e \ u003c / b \ u003e \ u003c / b \ u003e \ u003d \ 1, מחרוזת) ". . . היציאהיתרון לשימוש על מנת לנתק את התכונה אסינכרוני פגז התהליך (&) היא כי Expect יכול לשמור את הפרמטרים הטרמינל לפני ניתוק ולאחר מכן להחיל אותם מאוחר יותר ptys חדש. עם &, לצפות אין סיכוי לקרוא את הפרמטרים של הטרמינל מאז הטרמינל כבר מנותק על ידי זמן לצפות מקבל שליטה.
יציאה [-opts] [סטטוס]גורם לצפות לצאת או להתכונן אחרת לעשות זאת.
דגל ה- oxit גורם לארגומנט הבא לשמש כמטפל יציאה. ללא ויכוח, מטפל היציאה הנוכחי מוחזר.
הדגל- מניע גורם לצפות להתכונן ליציאה, אך לא יפסיק להחזיר את השליטה בפועל למערכת ההפעלה. מטפל היציאה המוגדר על ידי המשתמש מופעל כמו גם המטפלים הפנימיים של Expect. אין לבצע פקודות Expect נוספות. אפשרות זו שימושית אם אתה מפעיל Expect עם הרחבות Tcl אחרות. המתורגמן הנוכחי (והחלון הראשי אם בסביבה Tk) נשאר כך הרחבות Tcl אחרים יכולים לנקות. אם היציאה של Expect נקראת שוב (עם זאת, ייתכן שהדבר יתרחש), המפעילים לא יופעלו מחדש.
עם היציאה, כל הקשרים לתהליכים שנולדו סגורים. הסגירה תהיה מזוהה על ידי EOF על ידי תהליכים הולידו. היציאה אינה נוקטת פעולות אחרות מעבר למה שהפרוצדורה הנורמלית (2) עושה. לפיכך, תהליכים שנולדו שאינם בודקים את EOF יכולים להמשיך לרוץ. (מגוון של תנאים חשובים לקביעת, למשל, מה האותות תהליך spawned יישלח, אבל אלה תלויים במערכת, מתועד בדרך כלל תחת יציאה (3). תהליכים מופצים להמשיך לרוץ יירש על ידי init.
הסטטוס (או 0 אם לא צוין) מוחזר כסטטוס היציאה של Expect . היציאה מבוצעת במרומז אם סוף הסקריפט מגיע.
exp_continue [-continue_timer]
פקודת הפקודה מאפשרת לצפות עצמה להמשיך ולהוציא להורג במקום לחזור כרגיל. כברירת מחדל, exp_continue מאפס את טיימר הזמן הקצוב לתפוגה. הדגל - המשך- timer מונע הפעלה מחדש של קוצב זמן. (ראה מידע נוסף).
ערך exp_internal [-f file]
גורם פקודות נוספות לשלוח מידע אבחון פנימי כדי לצפות stderr אם הערך הוא לא אפס. פלט זה מושבת אם הערך הוא 0. מידע האבחון כולל כל תו שהתקבל, וכל ניסיון שבוצע כדי להתאים את הפלט הנוכחי נגד הדפוסים.
אם הקובץ האופציונלי מסופק, כל הפלט הרגיל וניקוי הבאגים נכתבים לקובץ זה (ללא קשר לערך הערך ). כל קובץ פלט אבחון קודם נסגר.
הדגל -info גורם ל- exp_internal להחזיר תיאור של הטיעונים האחרונים שלא קיבלו מידע.
exp_open [args] [-i spawn_id]
מחזירה מזהה קובץ Tcl המתאים לזיהוי המקור המקורי. ניתן להשתמש במזהה הקובץ כאילו הוא נפתח על ידי הפקודה הפתוחה של Tcl. (לא צריך להשתמש עוד בזיהוי הזיהוי, אין להמתין .
דגל ה - Leaveopen משאיר את הזיהוי פתוח לפתוח גישה דרך פקודות מצפה. ההמתנה צריכה להתבצע על תעודת שרצים.
exp_pid [-i spawn_id]
מחזירה את מזהה התהליך המתאים לתהליך שנוצר כעת. אם הדגל - i משמש, pid חזר מתאים לזה של שרצים נתון מזהה.
exp_send
הוא כינוי לשליחה .
exp_send_error
הוא כינוי עבור send_error .
exp_send_log
הוא כינוי עבור send_log .
exp_send_tty
הוא כינוי עבור send_tty .
exp_send_user
הוא כינוי עבור send_user .
exp_version [[-exit] גרסה]
הוא שימושי כדי להבטיח את התסריט תואם את הגירסה הנוכחית של Expect.
ללא טיעונים, הגרסה הנוכחית של Expect מוחזרת. גרסה זו עשויה להיות מקודדים בתסריט שלך. אם אתה באמת יודע שאתה לא משתמש בתכונות של גירסאות אחרונות, תוכל לציין גרסה מוקדמת יותר.
גרסאות מורכבות משלושה מספרים המופרדים בנקודות. ראשית, המספר העיקרי. סקריפטים שנכתב עבור גירסאות של מצפה עם מספר גדול אחר יהיה כמעט בוודאות לא עובד. exp_version מחזירה שגיאה אם המספרים העיקריים אינם תואמים.
השני הוא מספר קטן. סקריפטים שנכתב עבור גרסה עם מספר קטן יותר מאשר הגרסה הנוכחית עשויים לסמוך על תכונה חדשה, ואולי לא לפעול. exp_version מחזירה שגיאה אם המספרים העיקריים תואמים, אך מספר הסקריפט הזעיר גדול מזה של Expect .
השלישי הוא מספר אשר אינו משחק חלק בגירסה השוואה. עם זאת, הוא מתרחב כאשר הפצת התוכנה Expect משתנה בכל דרך שהיא, על ידי תיעוד או אופטימיזציה נוספים. זה reset ל 0 על כל גרסה חדשה קטנה.
עם הדגל Exit , Expect מדפיס שגיאה ויציאה אם הגרסה אינה מעודכנת.
מצפה [[-opts] pat1 body1] ... [--tsts] patn [bodyn]
מחכה עד שאחת הדפוסים תואמת את התפוקה של תהליך שנוצר, תקופת זמן מסוימת חלפה, או שסוף קובץ נראה. אם הגוף הסופי ריק, ייתכן שהוא מושמט.
דפוסי הפקודה האחרונה שצפויה מראש משמשים במרומז לפני כל דפוס אחר. דפוסים מהפקודה expected_after האחרונה משמשים במרומז לאחר כל דפוס אחר.
אם הטיעונים לכל משפט הצפייה דורשים יותר משורה אחת, כל הארגומנטים עשויים להיות "מסודרים" לתוך אחד, כדי להימנע מסיום כל שורה עם קו נטוי הפוך. במקרה אחד זה, תחליפי TCL הרגילים יתרחשו למרות הפלטה.
אם תבנית היא eof מילת מפתח, הגוף המתאים מבוצע בסוף הקובץ. אם תבנית היא פסק הזמן של מילת המפתח, הגוף המתאים מבוצע עם הזמן הקצוב. אם לא נעשה שימוש במילת מפתח של זמן קצוב לתפוגת זמן, תבוצע פעולה לא מוצהרת עם הזמן הקצוב. פרק הזמן המוגדר כברירת מחדל הוא 10 שניות אך ניתן להגדיר, לדוגמה ל 30, על ידי הפקודה "set timeout 30". זמן קצוב אינסופי עשוי להיות מוגדר על ידי הערך -1. אם תבנית היא ברירת המחדל של מילת המפתח, הגוף המתאים מבוצע עם הזמן הקצוב או בסוף הקובץ.
אם התבנית תואמת, הגוף המתאים מבצע. מצפה מחזירה את התוצאה של הגוף (או את המחרוזת הריקה אם אין דפוס מתאים). אם דפוסי מרובות תואמים, זה שמופיע הראשון משמש לבחירת גוף.
בכל פעם שהפלט החדש מגיע, הוא מושווה לכל דפוס בסדר שבו הם מופיעים. לכן, אתה יכול לבדוק את היעדרות של התאמה על ידי ביצוע דפוס האחרון משהו מובטח להופיע, כגון הנחיה. במצבים שבהם אין הנחיה, עליך להשתמש בפסק זמן (בדיוק כפי שהיית עושה אם היית אינטראקציה ידנית).
הדפוסים מפורטים בשלוש דרכים. כברירת מחדל, דפוסי צוינו כמו עם הפקודה מחרוזת של TCL. (דפוסים כאלה דומים גם ביטויים רגילים C- פגז המכונה בדרך כלל "דפוסי" גלובליים). הדגל -gl עשוי לשמש להגנה על דפוסי שעשויים להתאים לדגלים אחרים. כל תבנית שמתחילה ב- "-" צריכה להיות מוגנת בדרך זו. (כל המחרוזות המתחילות ב- "-" שמורות לאפשרויות עתידיות).
לדוגמה, החלק הבא מחפש כניסה מוצלחת. (שים לב שההפלה נוטה להיות פרוצדורה המוגדרת במקום אחר בתסריט).
מצפה {עסוק {מעביר את השדה \ n; exp_continue} נכשל הפלה "סיסמא לא חוקית" הפסק זמן קצוב abort מחובר}ציטוטים נחוצים על התבנית הרביעית משום שהיא מכילה רווח, אשר היה מפריד בין הדפוס לפעולה. דפוסים עם אותה פעולה (כגון 3 ו -4) דורשים לרשום את הפעולות שוב. ניתן למנוע זאת על ידי שימוש בדפוסי סגנונות רגולריים (ראה להלן). מידע נוסף על יצירת דפוסים בסגנון גלוב ניתן למצוא במדריך Tcl.
תבניות בסגנון Regexp עוקבות אחר התחביר המוגדר על ידי rexxp של Tcl (קצר עבור הביטוי "ביטוי רגיל"). דפוסי regexp מוצגים עם הדגל -re . הדוגמה הקודמת ניתן לשכתב מחדש באמצעות regexp כמו:
מצפה {עסוק {מעביר את השדה \ n; exp_continue} -re "נכשל | סיסמא לא חוקית" ביטול הפסק הזמן בוטל.שני סוגי הדפוסים "מעוגנים". משמעות הדבר היא כי דפוסי לא צריך להתאים את כל המחרוזת, אבל יכול להתחיל ולסיים את המשחק בכל מקום במחרוזת (כל עוד כל דבר אחר תואם). השתמש ב- ^ כדי להתאים להתחלת מחרוזת, ו- $ $ כדי להתאים לסוף. שים לב שאם אתה לא מחכה עד סוף מחרוזת, התגובות שלך יכול בקלות בסופו של דבר באמצע המחרוזת כפי שהם מהדהדים מן התהליך הוליד. בעוד עדיין לייצר תוצאות נכונות, הפלט יכול להיראות לא טבעי. לכן, השימוש $ הוא עודד אם אתה יכול לתאר בדיוק את התווים בסוף מחרוזת.
שים לב שבעורכים רבים, ה- ^ ו- $ תואמים את ההתחלה והסוף של השורות בהתאמה. עם זאת, מכיוון שהציפייה אינה מכוונת קו, תווים אלה תואמים את ההתחלה ואת הסוף של הנתונים (בניגוד לקווים) הנמצאים כעת במאגר ההתאמה הצפויה. (כמו כן, ראה הערה להלן על "קלקול קבה במערכת").
הדגל -ex גורם להתאמה של התבנית כמחרוזת "מדויקת". אין פרשנות של *, ^, וכו 'הוא עשה (אם כי מוסכמות Tcl הרגיל עדיין חייב להיות שנצפה). הדפוסים המדויקים תמיד אינם מעוגנים.
דגל ה- nocase גורם לתווים גדולים של הפלט להשוות כאילו היו אותיות קטנות. הדפוס אינו מושפע.
בעת קריאת הפלט, יותר מ 2000 בתים יכול להכריח בתים מוקדמים להיות "נשכח". זה יכול להיות שונה עם match_max את הפונקציה. (שים לב כי ערכים גדולים מדי יכול להאט את ההתאמה דפוס). אם הפטנט הוא full_buffer , הגוף המתאים מבוצע אם bit_max בייטים התקבלו ולא דפוסי אחרים התאימו. בין אם מילת המפתח full_buffer משמשת ובין אם לא, התווים הנשכחים נכתבים ל- exit_out (מאגר).
אם הפטליסט הוא null של מילות מפתח, ו- nulls מותרים (באמצעות הפקודה remove_nulls ), הגוף המתאים מבוצע אם מתואם ASCII 0 יחיד. לא ניתן להתאים 0 בתים באמצעות תבניות גלובליות או regexp.
עם התאמת דפוס (או eof או full_buffer), כל פלט ופלטה בעבר לא נשמר המשתנה expected_out (חיץ) . עד 9 התאמות מחרוזות רגולפיות נשמרות במשתנים expected_out (1, string) דרך expected_out (9, string) . אם דגל האינדיקסים משמש לפני דפוס, מדדי ההתחלה והסיום (בצורה המתאימה לזרם ) של 10 המחרוזות מאוחסנים במשתנים, מצפה (x, start) ו- expected_out (X, end) כאשר X הוא digit, מתאים למיקום החילופין במאגר. 0 מתייחס מחרוזות אשר תאמו את דפוס כולו נוצר עבור דפוסי גלובליים כמו גם דפוסי regexp. לדוגמה, אם תהליך הפיק פלט של "abcdefgh \ n", התוצאה של:
מצפה "cd"היא כאילו בוצעו ההצהרות הבאות:
להגדיר. (0, מחרוזת) cd setp_out (חיץ) abcdו "efgh \ n" נשאר במאגר הפלט. אם תהליך הפיק את הפלט "abbbcabkkkka \ n", התוצאה של:
ציפויים - "b" (b *). * (k +) "היא כאילו בוצעו ההצהרות הבאות:
(0, start) set set_out (0, end) 10 set expected_out (1, string) bb set expected_out (1, start) (2, התחלה) 10 setexp_out (2, סוף) 10 set expected_out (2, מחרוזת) k setout_out (חיץ) abbbcabkkkkו "\ n" נשאר במאגר הפלט. התבנית "*" (ו- "-re".) תרוקן את מאגר הפלט מבלי לקרוא עוד פלט מהתהליך.
בדרך כלל, הפלט התואם נמחק מהמאגרים הפנימיים של Expect. זה יכול להיות מונע על ידי קידומת דפוס עם דגל - transransfer . דגל זה שימושי במיוחד בניסויים (והוא יכול להיות מקוצר ל - "לא" לנוחות בזמן הניסוי).
מזהה השרצים המשויכים לפלט ההתאמה (או eof או full_buffer) מאוחסן ב- expected_out (spawn_id) .
דגל ה- timeout גורם לפקודת הצפייה הנוכחית להשתמש בערך הבא כזמן קצוב במקום להשתמש בערך המשתנה הקצוב.
כברירת מחדל, הדפוסים מותאמים לפלט מהתהליך הנוכחי, אולם הדגל- i מכריז על הפלט מרשימת spawn_id הנקראת כדי להתאים לכל הדפוסים הבאים (עד הבא - i ). רשימת spawn_id צריכה להיות רשימה מופרדת של רשימה של spawn_ids או משתנה המתייחס רשימה כזו של spawn_ids.
לדוגמה, הדוגמה הבאה מחכה "מחובר" מן התהליך הנוכחי, או "עסוק", "נכשל" או "סיסמה לא חוקית" מ spawn_id בשם $ $ proc2.
מצפה {-i $ proc2 עסוק {מעביר את השדה \ n; exp_continue} -re "נכשל | סיסמא לא חוקית" ביטול הפסק הזמן בוטל.הערך של המשתנה הגלובלי Any_spawn_id עשוי לשמש להתאמה לדפוסים לכל spawn_ids אשר נקראים בשאר הדגלים - בפקודת הצפייה הנוכחית. את spawn_id מתוך דגל אני ללא דפוס הקשורים (כלומר, מיד על ידי אחר - i ) זמין לכל דפוסי אחרים באותה פקודת צירוף המשויך any_spawn_id.
הדגל יכול גם לתת שם למשתנה גלובלי, ובמקרה זה קוראים את המשתנה עבור רשימה של עזרים שרצים. המשתנה חוזר וקורא בכל פעם שהוא משתנה. זה מספק דרך לשנות את מקור קלט / פלט בזמן הפקודה נמצאת בביצוע. ספון איידס בתנאי בדרך זו נקראים "עקיפה" שרצים אידיוטים.
פעולות כגון הפסקה ולהמשיך לגרום מבנים שליטה (כלומר, עבור ) להתנהג בדרך הרגילה. פקודת הפקודה מאפשרת לצפות עצמה להמשיך ולהוציא להורג במקום לחזור כרגיל.
אפשרות זו שימושית למניעת לולאות מפורשות או הצהרות חוזרות על עצמן. הדוגמה הבאה היא חלק מקטע כדי להפוך את rlogin לאוטומטי. ה- exp_continue נמנע מלהצטרך לכתוב הצהרת ציפיות שנייה (כדי לחפש שוב את הנחיה) אם הפקודה rlogin מבקשת סיסמה.
(סיסמא: stty -echo send_user) (עבור $ user) על host host: "expected_user -re" (. *) \ n "send_user" \ n "שלח" $ expected_out (1, string) "stty echo exp_continue} סיסמא לא נכונה \ Send_user "לא חוקית או חשבון \ n" יציאה "timeout {send_user" החיבור ל - $ host hosted out \ n "יציאה" eof {send_user \ "לארח נכשל: $ expected_out (buffer)" exit - מחדש פקודת $}לדוגמה, הקטע הבא עשוי לעזור למשתמש להנחות אינטראקציה שכבר אוטומטית לחלוטין. במקרה זה, המסוף מוכנס למצב גלם. אם המשתמש לוחץ על "+", משתנה הוא מוגדל. אם "p" נלחץ, כמה מחזירה נשלחים לתהליך, אולי כדי לדחוף אותו בדרך כלשהי, ו "אני" מאפשר למשתמש לקיים אינטראקציה עם התהליך, ביעילות לגנוב את השליטה מתוך התסריט. בכל מקרה, exp_continue מאפשר הנוכחית מצפה להמשיך דפוס התאמה לאחר ביצוע הפעולה הנוכחית.
stty raw -echo expected_after {-i $ user_spawn_id "p" {שלח "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {אינטראקציה; exp_continue} "צא"כברירת מחדל, exp_continue מאפס את טיימר הזמן הקצוב לתפוגה. הטיימר אינו מופעל מחדש, אם exp_continue נקרא עם הדגל - המשך .
Quote_after [expected_args]
עובד באופן זהה לזה שלפני כן, אלא אם כן, אם דפוסים של ציפיות ושל ציפיות לאחר מכן יכולים להתאים, דפוס הדפוס משמש. עיין בפקודה expected_fore לקבלת מידע נוסף.
מצפה_קרקע [מצפה_ארץ]
לוקח את אותם טיעונים כמו לצפות , אבל זה חוזר מיד. דפוסי נבדקים בכל פעם קלט חדש מגיע. זמן קצוב התבנית וברירת המחדל הם חסרי משמעות כדי לצפות בכתובת_background והם מושלכים בשקט. אחרת, הפקודה expected_background משתמשת בציפייה מראש ובצפוי - אחרי דפוסים בדיוק כמו שהציפייה עושה.
כאשר פעולות expected_background נבדקות , עיבוד רקע עבור אותו שרצים מזהה חסומה. עיבוד הרקע משוחרר כאשר הפעולה מסתיימת. בעוד עיבוד ברקע חסום, אפשר לעשות (בחזית) לצפות על אותו שרצים מזהה.
לא ניתן לבצע ציפייה בעת ביטול חסימת הצפייה . expected_background עבור מזהה שרצים מסוים נמחק על ידי הכרזה על new_background חדש עם אותו שרצים מזהה. ההכרזה על הצפייה ללא שום תבנית מסירה את המזהה המצוין מן היכולת להתאים את הדפוסים ברקע.
ציפית_לפני [מצפה_ארץ]
לוקח את אותם טיעונים כמו לצפות , אבל זה חוזר מיד. זוגות דפוס פעולה מהצפוי האחרון לפני כן עם זהות שרצים זהה מוסיפים במרומז לכל הפקודות הבאות מצפים . אם התבנית תואמת, היא מטופלת כאילו היא צוינה בפקודת הצפייה עצמה, והגוף המשויך מתבצע בהקשר של פקודת הצפייה . אם דפוסים של ציפיות מראש וגם ציפיות יכולים להתאים, נעשה שימוש בתבנית הצפוי .
אם לא צוין דפוס, מזהה שרצים לא נבדק עבור כל הדפוסים.
אלא אם כן על ידי דגל, דגל, לפני שתתאים לדפוסים המזוהים עם הזיהוי המצוין בזמן שהפקודה הצפויה נעשתה (לא כאשר הדפוס שלה תואם).
הדגל-info גורם לצפות מראש את המפרטים הנוכחיים של הדפוסים שהוא יתאים. כברירת מחדל, הוא מדווח על מזהה הנוכחי שרצים. מפרט אופציונלי שרצים מזהה ניתן לתת מידע על זה שרצים מזהה. לדוגמה
ציפו-לפני-פרולכל היותר אחד להשריץ מפרט מזהה עשוי להינתן. הדגל - הפניה מדכאת את המזהים הישירים המגיעים ישירות ממפרטים עקיפים.
במקום מפרט להשריץ מזהה, את הדגל "כל" יגרום "-info" לדווח על כל שרצים איידס.
הפלט של דגל אינפו ניתן לעשות בו שימוש חוזר כטיעון לצפות מראש.
מצפה_צפוי [expected_args]
הוא כמו לצפות אבל הוא קורא תווים מ / dev / tty (כלומר הקשות מהמשתמש). כברירת מחדל, הקריאה מבוצעת במצב מבושל. לכן, הקווים חייבים להסתיים עם החזרה כדי לצפות לראות אותם. זה יכול להיות שונה דרך stty (ראה את הפקודה stty להלן).
Quote_user [expected_args]
הוא כמו לצפות אבל זה קורא תווים stdin (כלומר הקשות מהמשתמש). כברירת מחדל, הקריאה מבוצעת במצב מבושל. לכן, הקווים חייבים להסתיים עם החזרה כדי לצפות לראות אותם. זה יכול להיות שונה דרך stty (ראה את הפקודה stty להלן).
מזלג
יוצר תהליך חדש. התהליך החדש הוא העתק מדויק של התהליך הנוכחי. על ההצלחה, מזלג מחזירה 0 לתהליך החדש (ילד) ומחזירה את מזהה התהליך של תהליך הילד לתהליך ההורה. על כשל (בשל חוסר משאבים, למשל, שטח החלפה, זיכרון), מזלג מחזיר -1 לתהליך ההורה, ולא נוצר תהליך של ילד.
תהליכים פורקדים יוצאים דרך פקודת היציאה , בדיוק כמו התהליך המקורי. תהליכים מורחבים רשאים לכתוב לקבצי היומן. אם לא תשבית איתור באגים או תיכנס ברוב התהליכים, התוצאה עלולה להיות מבלבלת.
כמה יישומים pty עשוי להיות מבולבל על ידי מספר קוראים וסופרים, אפילו לרגע. לכן, הוא הבטוח ביותר לפני תהליכי ההשרצה.
אינטראקציה [string1 body1] ... [stringn [bodyn]]
נותן שליטה על התהליך הנוכחי למשתמש, כך הקשות נשלחות התהליך הנוכחי, ואת stdout ו stderr של התהליך הנוכחי מוחזרים.
זוגות מחרוזות עשויים להיות מוגדרים כטיעונים, ובמקרה זה הגוף מתבצע כאשר מחרוזת מתאימה מוזנת. (כברירת מחדל, המחרוזת אינה נשלחת לתהליך הנוכחי). הפקודה של המתורגמן מניחה, אם הגוף הסופי חסר.
אם הארגומנטים להצהרת האינטראקציה כולה דורשים יותר משורה אחת, כל הארגומנטים עשויים להיות "מסודרים" לאחד, כדי להימנע מסיום כל שורה עם קו נטוי הפוך. במקרה אחד זה, תחליפי TCL הרגילים יתרחשו למרות הפלטה.
לדוגמה, הפקודה הבאה מפעילה אינטראקציה עם זוגות מחרוזת הגוף הבאים: כאשר תלחץ על Z, תוצג ההשעיה. (דגל ה - reset משחזר את מצבי המסוף.) כאשר לחיצה על A, המשתמש רואה "הקלדת פקד - A" והתהליך נשלח A ^. כאשר $ נלחץ, המשתמש רואה את התאריך. כאשר C ^ נלחץ, צפה Exits. אם "foo" מוזן, המשתמש רואה "סרגל". כאשר ~ ~ נלחץ, המתורגמן Expect פועל באופן אינטראקטיבי.
Set CTRLZ \ 032 אינטראקציה {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user \ "הקלדת A-n \ n"; שלח את "\ 001"} $ {send_user "התאריך הוא [תבנית השעון [שעון השעון]."} \ 003 יציאה foo {send_user "bar"} ~ ~}בזוגות של מחרוזת גוף, מחרוזות מותאמות בסדר שבו הן מופיעות כארגומנטים. מיתרים שמתאימים חלקית אינם נשלחים לתהליך הנוכחי, בציפייה לשאר הדברים. אם התווים מוזנים כך שאין עוד אפשרות להיות התאמה, רק החלק של המחרוזת יישלח לתהליך שאינו יכול להתחיל התאמה נוספת. לכן, מחרוזות שהן מחרוזות של התאמות חלקיות יכולות להתאים מאוחר יותר, אם המחרוזות המקוריות שניסו להתאים בסופו של דבר נכשלו.
כברירת מחדל, התאמת מחרוזת היא מדויקת וללא כרטיסי בר . (לעומת זאת, פקודת הצפייה משתמשת בדפוסים בסגנון גלובלי כברירת מחדל). הדגל -ex עשוי לשמש להגנה על דפוסים שעשויים להתאים לדגלים אינטראקטיביים אחרים . כל תבנית שמתחילה ב- "-" צריכה להיות מוגנת בדרך זו. (כל המחרוזות המתחילות ב- "-" שמורות לאפשרויות עתידיות).
הדגל- רץ מאלץ את המחרוזת להתפרש כתבנית בסגנון regexp. במקרה זה, מחרוזות תואמות מאוחסנות במשתנה interact_out באופן דומה לדרך מצפה חנויות הפלט שלה expected_out המשתנה. כמו כן, הדגל של האינדיקסים נתמך.
דפוס eof מציג פעולה המבוצעת בסוף הקובץ. דפוס eof נפרד עשוי גם לעקוב אחר דגל היציאה , ובמקרה זה הוא מתאים אם eof מזוהה בעת כתיבת פלט. פעולת ברירת המחדל היא "החזרה", כך אינטראקציה פשוט מחזירה על כל EOF.
הזמן הקצוב לתבנית מציג פסק זמן (בשניות) ופעולה המתבצעת לאחר שלא הוקראו תווים עבור זמן נתון. דפוס הזמן הקצוב חל על התהליך שצוין לאחרונה. אין זמן קצוב לתפוגה. המשתנה המיוחד "פסק זמן" (המשמש את הפקודה ' ציפייה' ) אינו משפיע על הזמן הזה.
לדוגמה, ניתן להשתמש בהצהרה הבאה כדי לנטרל משתמשים שלא הקלידו דבר במשך שעה, אך עדיין מקבלים הודעות מערכת תכופות:
לא ניתן להחזיר את החזרה \ $ spawn_idאם התבנית היא null של מילת מפתח, ו- nulls מותרים (באמצעות הפקודה remove_nulls ), הגוף המתאים מבוצע אם מתואמים ASCII 0 יחיד. לא ניתן להתאים 0 בתים באמצעות תבניות גלובליות או regexp.
הכנה מראש של תבנית עם הדגל- רייט גורמת למשתנה interact_out (spawn_id) להיות מוגדר spawn_id אשר מתאימים את דפוס (או eof).
פעולות כגון הפסקה ולהמשיך לגרום מבנים שליטה (כלומר, עבור ) להתנהג בדרך הרגילה. עם זאת לחזור גורם אינטראקציה לחזור המתקשר שלה, בעוד inter_return גורם אינטראקציה לגרום החזרת המתקשר שלה. לדוגמה, אם "proc foo" נקרא אינטראקציה ולאחר מכן ביצע את הפעולה inter_return , proc foo יחזור. (משמעות הדבר היא שאם אינטראקציה שיחות מתורגמן באופן אינטראקטיבי ההקלדה לחזור תגרום אינטראקציה להמשיך, בעוד inter_return יגרום אינטראקציה לחזור למתקשר שלה.)
במהלך אינטראקציה , נעשה שימוש במצב גלם כדי שכל התווים יועברו לתהליך הנוכחי. אם התהליך הנוכחי אינו מקבל אותות בקרת עבודה, הוא יפסיק אם נשלח אות עצור (כברירת מחדל ^ Z). כדי להפעיל מחדש את זה, לשלוח אות המשך (כגון על ידי "להרוג -CONT"). אם אתה באמת רוצה לשלוח SIGSTOP לתהליך כזה (על ידי ^ Z), לשקול spawning csh הראשון ולאחר מכן מפעיל את התוכנית. מצד שני, אם אתה רוצה לשלוח SIGSTOP לצפות עצמו, המתורגמן להתקשר הראשון (אולי באמצעות תו בריחה) ולאחר מכן לחץ על ^ Z.
זוגות מחרוזות-גוף יכולים לשמש כקצרנות כדי להימנע מלהיכנס למתורגמן ולבצע פקודות באופן אינטראקטיבי. מצב הטרמינל הקודם משמש כאשר הגוף של זוג מחרוזת גוף מבוצע.
עבור מהירות, פעולות מבוצעות במצב גלם כברירת מחדל. הדגל-איפוס מאפס את הטרמינל למצב שבו היה לפני שהאינטראקציה בוצעה (תמיד, מצב מבושל). שים לב כי תווים שהוזנו בעת החלפת המצב עלול להיות אבוד (תכונה מצערת של מנהל ההתקן המסוף במערכות מסוימות). הסיבה היחידה לשימוש- reset היא אם הפעולה שלך תלוי פועל במצב מבושל.
הדגל- האקו שולח תווים התואמים את הדפוס הבא בחזרה לתהליך שיצר אותם כפי שקוראים כל תו. הדבר עשוי להיות שימושי כאשר המשתמש צריך לראות משוב מדפוסים שהוקלדו חלקית.
אם דפוס הוא להיות מהדהד אבל בסופו של דבר נכשל להתאים, הדמויות נשלחות לתהליך הוליד. אם תהליך הוליד ואז מהדהד אותם, המשתמש יראה את התווים פעמיים. -Echo הוא כנראה רק מתאים במצבים שבהם המשתמש סביר לא להשלים את הדפוס. לדוגמה, הקטע הבא הוא מתוך rftp, את הסקריפט recurive-ftp, שבו המשתמש מתבקש להזין ~ g, ~ p או ~ l, כדי לקבל, להכניס או לרשום את הספריה הנוכחית באופן רקורסיבי. אלה כל כך רחוק פקודות ftp נורמלי, כי המשתמש לא סביר להקליד ~ ואחריו כל דבר אחר, למעט בטעות, ובמקרה זה, הם כנראה פשוט להתעלם את התוצאה בכל מקרה.
אינטראקציה {-Echo ~ g {getcurdirectory 1} -Echo ~ l {getcurdirectory 0} -Echo ~ p {putcurdirectory}}הדגל - nobuffer שולח תווים התואמים את התבנית הבאה לתהליך הפלט, כאשר התווים נקראים.
זה שימושי כאשר אתה רוצה לתת תוכנית הד בחזרה את הדפוס. לדוגמה, ניתן להשתמש בקטע הבא כדי לעקוב אחר המיקום של אדם (מודם בסגנון Hayes). בכל פעם "atd" הוא ראה את התסריט יומני את שאר הקו.
(#), "(),", "#:" #: "#:" #,במהלך אינטראקציה , נעשה שימוש קודם בשימוש ב- log_user . בפרט, אינטראקציה תאלץ את הפלט שלה להיות מחובר (נשלח פלט סטנדרטי) שכן הוא הניח המשתמש לא רוצה אינטראקציה בעיוורון.
הדגל -o גורם לכל זוגות מפתח הגוף הבאים להיות מוחל על הפלט של התהליך הנוכחי. זה יכול להיות שימושי, למשל, כאשר מתמודדים עם המארחים ששולחים תווים לא רצויים במהלך הפעלה Telnet.
כברירת מחדל, אינטראקציה מצפה המשתמש לכתוב stdin קריאה stdout של תהליך מצפה עצמו. הדגל -u (עבור "משתמש") עושה אינטראקציה לחפש את המשתמש כמו תהליך בשם על ידי הטיעון שלה (אשר חייב להיות id spawned).
זה מאפשר לשני תהליכים לא קשורים להיות מחוברים יחד בלי להשתמש בלולאה מפורשת. כדי לסייע באיתור באגים, לצפות באבחון תמיד ללכת stderr (או stdout עבור רישום מסוים מידע באגים). מאותה סיבה, פקודת המתורגמן תקרא באופן אינטראקטיבי מ stdin.
לדוגמה, החלק הבא יוצר תהליך כניסה. לאחר מכן הוא מחייג את המשתמש (לא מוצג), ולבסוף מחבר את השניים יחד. כמובן, כל תהליך עשוי להיות מוחלף עבור הכניסה. פגז, לדוגמה, יאפשר למשתמש לעבוד מבלי לספק חשבון וסיסמה.
שרצים כניסה כניסה כניסה $ spawn_id להפיץ מודם קצה # לחייג חזרה אל המשתמש # להתחבר למשתמש להיכנס login -u $ loginכדי לשלוח פלט לתהליכים מרובים, רשימת כל רשימת שרצים מזהה מראש על ידי דגל exitput . קלט עבור קבוצה של שרצים פלט פלטפורמה עשוי להיקבע על ידי רשימת שרצים מזהה מראש על ידי דגל-input . (הן קלט והן פלט יכול לקחת רשימות באותה צורה כמו הדגל -i בפקודת הצפייה, אלא ש- any_spawn_id אינו משמעותי באינטראקציה .) כל הדגלים והמיתרים (או הדפוסים) חלים על קלט זה, מופיע דגל קלט. אם לא מופיע קלט , משמעות המילה "--put $ user_spawn_id escapeput". (באופן דומה, עם דפוסי שאין להם קלט .) אם אחד מוגדר, הוא עוקף $ user_spawn_id. אם הפלט השני מוגדר, הוא עוקף $ spawn_id. ניתן לציין דגלים נוספים.
שני משתני קלט קלט ברירת המחדל שלהם יש פלטי שצוין $ spawn_id ו $ user_spawn_id (בהיפוך). אם דגל כניסה מופיע ללא דגל יציאה , תווים מתהליך זה נמחקים.
הדגל - i מציג תחליף ל - spawn_id הנוכחי כאשר לא נעשה שימוש בדגל אחר או בדגמי יציאה . A- דגל מרמז על דגל.
אפשר לשנות את התהליכים כי הם להיות אינטראקציה עם באמצעות עקיפת שרצים איידס. (מזהים שרצים עקיפים מתוארים בסעיף על פקודת הציפייה). ניתן לציין את המזהים העקיפים עם הדגלים -i, -u, -put או ב- outputput.
מתורגמן [ארגומנטים]
גורם למשתמש להתבקש באופן אינטראקטיבי עבור פקודות Expect ו- Tcl. התוצאה של כל פקודה מודפסת.
פעולות כגון הפסקה ולהמשיך לגרום מבנים שליטה (כלומר, עבור ) להתנהג בדרך הרגילה. עם זאת, החזרה גורמת למתורגמן לחזור למתקשר, ואילו inter_return גורם למתורגמן לגרום לחזרה למתקשר שלו. לדוגמה, אם "proc foo" נקרא מתורגמן ולאחר מכן ביצע את הפעולה inter_return , proc foo יחזור. כל פקודה אחרת גורמת למתורגמן להמשיך ולבקש פקודות חדשות.
כברירת מחדל, הפקודה מכילה שני מספרים שלמים. המספר הראשון מתאר את עומק ערימת ההערכה (כלומר, כמה פעמים נקרא Tcl_Eval). המספר השלם השני הוא מזהה ההיסטוריה Tcl. ניתן להגדיר את ההנחיה על ידי הגדרת פרוצדורה שנקראת "הודעה 1" שערך ההחזרה שלה הופך להנחיה הבאה. אם להצהרה יש ציטוטים פתוחים, Parens, פלטה או סוגריים, הנחיה משנית (כברירת מחדל "+>") מונפקת על קו חדש. ההנחיה המשנית עשויה להיות מוגדרת על ידי הגדרת הליך הנקרא "הודעה 2".
במהלך המתורגמן , נעשה שימוש במצב מבושל, גם אם המתקשר שלו משתמש במצב גלם.
אם הסגירה סגורה, המתורגמן יחזור אלא אם כן נעשה שימוש בדגל-הדגל, ובמקרה זה מתבצע הטענה הבאה.
log_file [args] [[-a] file]
אם שם הקובץ מסופק, log_file ירשום תמליל של הפגישה (החל בנקודה זו) בקובץ. log_file יפסיק להקליט אם לא יינתן ארגומנט. כל קובץ יומן הקודם נסגר.
במקום שם קובץ, מזהה קובץ Tcl עשוי להינתן על ידי שימוש בדגלי Openen או leleopen . זה דומה הפקודה להשריץ . (ראה שרצים לקבלת מידע נוסף).
-הדגל מכריח את הפלט להיות מחובר שנדחק על ידי הפקודה log_user .
כברירת מחדל, הפקודה log_file מצרפת קבצים ישנים במקום לקצר אותם, לנוחיותם של היכולת לכבות את הרישום ולבצע מספר פעמים בהפעלה אחת. כדי לקטוע קבצים, השתמש ב'דגל לא נמצא ' .
הדגל -info גורם ל- log_file להחזיר תיאור של הטיעונים העדכניים ביותר שקיבלו.
log_user -info | 0 1
כברירת מחדל, הדיאלוג 'שלח / מצפה' נרשם ל- stdout (וכן logfile אם הוא פתוח). רישום stdout מושבת על ידי הפקודה "log_user 0" מחדש על ידי "log_user 1". ההרשמה ל- logfile אינה משתנה.
הדגל -info גורם ל- log_user להחזיר תיאור של הטיעונים האחרונים שלא קיבלו מידע.
match_max [-d] [-i spawn_id] [size]
מגדיר את גודל המאגר (בבתים) בשימוש פנימי על ידי ציפייה . ללא ארגומנט גודל , הגודל הנוכחי מוחזר.
עם דגל -D , גודל ברירת המחדל מוגדר. (ברירת המחדל הראשונית היא 2000). עם הדגל - i , הגודל מוגדר עבור מזהה להשריץ בשם, אחרת הוא מוגדר לתהליך הנוכחי.
כיסוי [- # spawn_id] [- # spawn_id] [...] תוכנית [ארגס]
מבצע "תוכנית " במקום "במקום תוכנית Expect הנוכחי, אשר מסתיים. ארגז מקף חשוף כופה מקף לפני שם הפקודה כאילו היה פגז כניסה. כל spawn_ids סגורים למעט אלה בשם כמו ארגומנטים. אלה ממופים על מזהי הקובץ בשם.
Spawn_ids ממופים למזהי קבצים עבור התוכנית החדשה לרשת. לדוגמה, השורה הבאה מפעילה שחמט ומאפשרת לו להיות נשלט על ידי התהליך הנוכחי - למשל, הורים שחמט.
שכבת -0 $ spawn_id -1 $ spawn_id -2 $ שחמט spawn_idזה יעיל יותר מאשר "אינטראקציה -u", עם זאת, זה מקריב את היכולת לעשות אינטראקציה מתוכנת מאז התהליך מצפה אינו בשליטה.
שים לב שלא סופק מסוף בקרה. לכן, אם תנתק או תקבע קלט סטנדרטי, תוכניות שעושות בקרת עבודה (פגזים, כניסה וכו ') לא יפעלו כראוי.
זוגיות [-D] [-i spawn_id] [ערך]
מגדיר אם יש לשמור על השוויון או להפשיט אותו מתפוקת התהליכים שנולדו. אם הערך הוא אפס, השוויון הוא חשוף, אחרת זה לא מופשטים. ללא ארגומנט ערך , הערך הנוכחי מוחזר.
עם דגל, ערך ברירת המחדל של זוגיות מוגדר. (ברירת המחדל הראשונית היא 1, כלומר, זוגיות לא מופשטת.) עם הדגל - i , ערך השוויון מוגדר עבור שם השמות המצוין, אחרת הוא מוגדר לתהליך הנוכחי.
remove_nulls [-d] [-i spawn_id] [ערך]
מגדיר אם נשמרים או נשמרים מפלט התהליכים שנולדו לפני התאמת תבניות או אחסון במשתנה expected_out או interact_out . אם הערך הוא 1, nulls יוסרו. אם הערך הוא 0, nulls לא יוסרו. ללא ארגומנט ערך , הערך הנוכחי מוחזר.
עם דגל, ערך ברירת המחדל מוגדר. (ברירת המחדל הראשונית היא 1, כלומר, nulls יוסרו.) עם דגל -, הערך מוגדר עבור מזהה להשריץ בשם, אחרת זה מוגדר לתהליך הנוכחי.
בין אם לא יוסרו null, צפוי להקליט בייטים null את יומן ו stdout.
שלח [מחרוזות]
שולח מחרוזת לתהליך הנוכחי. לדוגמה, הפקודה
שולח את התווים, helloworld לתהליך הנוכחי. (Tcl כולל פקודה דמויית printf (הנקראת פורמט ) שיכולה לבנות מחרוזות מורכבות באופן שרירותי).
התווים נשלחים מיד אם כי תוכניות עם קלט שנאגרו בקו לא יקראו את התווים עד שיוחזר תו חזרה. תו החזרה מסומן "".
הדגל מאלץ את הארגומנט הבא להתפרש כמחרוזת ולא בדגל. כל מחרוזת יכולה להיות מוקדמת על ידי "-" אם זה באמת נראה כמו דגל. זה מספק מנגנון אמין כדי להגדיר מחרוזות משתנות מבלי להיות מעד על ידי אלה בטעות להיראות כמו דגלים. (כל המחרוזות המתחילות ב- "-" שמורות לאפשרויות עתידיות).
הדגל-I מצהיר כי המחרוזת תישלח אל השם spawn_id. אם spawn_id הוא user_spawn_id , והמסוף נמצא במצב גלם, שורות חדשות במחרוזת מתורגמות לרצפים חוזרים-חדשים, כך שייראו כאילו המסוף נמצא במצב מבושל. דגל הסמן משבית את התרגום הזה.
הדגל -Null שולח תווים ריקים (0 בתים). כברירת מחדל, אחד null נשלח. מספר שלם יכול לעקוב אחר - null כדי לציין כמה nulls לשלוח.
דגל השבר יוצר מצב הפסקה. זה רק הגיוני אם לשיר מזהה מתייחס למכשיר tty נפתח דרך "להשריץ-פותח". אם יש לך spawned תהליך כגון עצה, אתה צריך להשתמש האמנה של עצה ליצירת הפסקה.
הדגל- s כוחות פלט להישלח "לאט", ובכך למנוע את המצב הנפוץ שבו המחשב outtypes קלט חיץ שתוכנן עבור אדם אשר לעולם לא outtype אותו חיץ . פלט זה נשלט על ידי הערך של המשתנה "send_slow" אשר לוקח רשימה שני אלמנטים. האלמנט הראשון הוא מספר שלם המתאר את מספר הבתים לשלוח באופן אטומי. האלמנט השני הוא מספר אמיתי המתאר את מספר השניות שבאמצעותן יש לשלוח את האטום. לדוגמה, "set send_slow {10 .001}" יאלץ "לשלוח" לשלוח מחרוזות עם 1 אלפיות השנייה בין כל 10 תווים שנשלחו.
דגל ה - F פלט כוחות להישלח (במידת מה) כמו הקלדת אדם. עיכובים דמויי אדם מופיעים בין הדמויות. (האלגוריתם מבוסס על התפלגות Weibull, עם שינויים המתאימים ליישום מסוים זה.) פלט זה נשלט על ידי הערך של המשתנה "send_human" אשר לוקח רשימה של חמישה אלמנטים. שני היסודות הראשונים הם זמן בינוני בין הדמויות בשניות. הראשונה משמשת כברירת מחדל. השנייה משמשת לסיומות מילים, כדי לדמות את ההפסקות העדינות המתרחשות מדי פעם במעברים כאלה. הפרמטר השלישי הוא מדד של השתנות כאשר 1 הוא משתנה למדי, 1 הוא משתנה באופן סביר, ו 10 הוא די בלתי משתנה. הקצוות הם 0 עד אינסוף. שני הפרמטרים האחרונים הם, בהתאמה, מינימום ומקסימום זמן interarrival. מינימום ומקסימום משמשים האחרון "קליפ" בפעם האחרונה. הממוצע האולטימטיבי יכול להיות שונה לגמרי מהממוצע הנתון אם המינימום ומקסימום קליפ ערכים מספיק.
כדוגמה, הפקודה הבאה מחקה כתבנית מהירה ועקבית:
סט Send_human {1 .3 1 .05 2 שלח -h "אני רעב, בוא נעשה צהריים".בעוד שהפעולות הבאות עשויות להיות מתאימות יותר לאחר הנגאובר:
הגדר Send_human {0.4 .4.2. 100} שלח -h "לילה טוב!שים לב שגיאות אינן מדומות, למרות שניתן להגדיר מצבי תיקון שגיאות בעצמך על ידי הטבעה שגיאות ותיקונים בארגומנט שלח.
הדגלים לשליחת תווים ריקים, לשליחת הפסקות, להשלמת תפוקה איטית ולפלט בסגנון אנושי, הם בלעדיים. רק האחד שצוין לאחרונה ישמש. יתר על כן, לא ניתן להגדיר ארגומנט מחרוזת עם הדגלים לשליחת תווים או מעברי ריק.
זה רעיון טוב להקדים את השליחה הראשונה לתהליך על ידי ציפייה . מצפה לחכות תהליך להתחיל, בעוד לשלוח לא יכול. במיוחד, אם השליחה הראשונה מסתיימת לפני שהתהליך מתחיל לפעול, אתה מסתכן בכך שהנתונים שלך יתעלמו. במצבים שבהם תוכניות אינטראקטיביות אינן מציעות הנחיה ראשונית, ניתן לשלוח מראש עיכוב כמו:
# כדי למנוע מתן האקרים רמזים כיצד לפרוץ, # מערכת זו אינה מבקשת סיסמה חיצונית. # המתן 5 שניות עבור exec כדי להשלים להשריץ Telnet. לישון 5 לישוןexp_send הוא כינוי לשליחה. אם אתה משתמש Expectk או גרסה אחרת של ציפייה בסביבה Tk, לשלוח מוגדר על ידי Tk עבור מטרה אחרת לגמרי. exp_send מסופק עבור תאימות בין סביבות. כינויים דומים מסופקים לפקודות אחרות של Expect לשלוח אחרים.
Send_error [-חלילים] מחרוזת
הוא כמו לשלוח , אלא כי הפלט נשלח stderr ולא את התהליך הנוכחי.
Send_log [-] מחרוזת
הוא כמו שלח , אלא שהמחרוזת נשלחת רק לקובץ היומן (ראה log_file ). הארגומנטים מתעלמים אם אין קובץ יומן פתוח.
Send_tty [-flags] string
הוא כמו לשלוח , אלא כי הפלט נשלח ל / dev / tty ולא את התהליך הנוכחי.
מחרוזת [שלח] מחרוזת
הוא כמו לשלוח , אלא כי הפלט נשלח stdout ולא את התהליך הנוכחי.
שניות שינה
גורם לסקריפט לישון למשך מספר שניות נתון. שניות יכול להיות מספר עשרוני. Interrupts (ואירועים Tk אם אתה משתמש Expectk) מעובדים בזמן מצפה לישון.
תוכנית שרצים [ארגזים] [ארגומנטים]
יוצר תהליך חדש פועל "תוכנית מתווכח". Stdin שלה, stdout ו stderr מחוברים ציפייה, כך שהם עשויים להיות לקרוא ולכתוב על ידי פקודות אחרות לצפות . החיבור נשבר קרוב או אם התהליך עצמו סוגר את כל מזהי הקבצים.
כאשר תהליך מתחיל על ידי שרצים , המשתנה spawn_id מוגדר תיאר המתייחס לתהליך זה. התהליך המתואר על ידי spawn_id נחשב " התהליך הנוכחי ". spawn_id ניתן לקרוא או לכתוב, למעשה מתן עבודה שליטה.
user_spawn_id הוא משתנה גלובלי המכיל מתאר המתייחס למשתמש. לדוגמה, כאשר spawn_id מוגדר ערך זה, מצפה מתנהג כמו expected_user .
.I error_spawn_id הוא משתנה גלובלי המכיל מתאר המתייחס לשגיאה הסטנדרטית. לדוגמה, כאשר spawn_id מוגדר לערך זה, שלח מתנהג כמו send_error .
tty_spawn_id הוא משתנה גלובלי המכיל מתאר המתייחס ל / dev / tty. אם / dev / tty אינו קיים (למשל בתסריט cron, at או אצווה), tty_spawn_id אינו מוגדר. ניתן לבדוק זאת כ:
אם {{info vars tty_spawn_id]} {# / dev / tty קיים} אחר # {/ dev / tty לא קיים # כנראה ב- cron, אצווה או ב- script}להשריץ מחזיר את מזהה תהליך UNIX. אם לא הופעל תהליך , 0 מוחזר. המשתנה spawn_out (עבדים, שם) מוגדר שם של התקן העבדים pty.
כברירת מחדל, להשריץ הדים את שם הפקודה ואת הטיעונים. דגל ניוקו מפסיק שרצים לעשות זאת.
הדגל של מסוף גורם להפניה מחדש של פלט המסוף לתהליך שנוצר. הדבר אינו נתמך בכל המערכות.
פנימי, שרצים משתמש pty, מאותחל באותה צורה כמו של המשתמש tty. זה מאופשר עוד יותר, כך שכל ההגדרות הן "שפוי" (על פי stty (1)). אם המשתנה stty_init מוגדר, הוא מתפרש בסגנון של טיעונים stty כקובץ תצורה נוספת. לדוגמה, "set stty_init raw" יגרום להופעת טרמינלים נוספים של תהליכים להתחיל במצב גלם. -nottycopy מדלג על האתחול בהתבסס על tty של המשתמש. -Nottyitit מדלג על "שפוי" אתחול.
בדרך כלל, להשריץ לוקח קצת זמן לבצע. אם אתה מבחין שרצים לוקח כמות משמעותית של זמן, זה כנראה נתקל ptys כי הם תקועים. מספר בדיקות מופעלות על ptys כדי למנוע הסתבכויות עם תהליכים תועים. (אלה לוקחים 10 שניות לכל pty wedged.) ריצה לצפות עם האפשרות -D יראה אם מצפה הוא נתקל ptys רבים במצבים משונים. אם אתה לא יכול להרוג את התהליכים בהם ptys אלה מחוברים, הפנייה היחידה שלך עשויה להיות אתחול מחדש.
אם התוכנית לא יכול להיות spawned בהצלחה בגלל exec (2) נכשל (למשל, כאשר התוכנית אינה קיימת), הודעת שגיאה יוחזר על ידי הבא אינטראקציה או פקודה ציפייה כאילו התוכנית היתה להפעיל והפיק את הודעת השגיאה כפלט. התנהגות זו היא תוצאה טבעית של ביצוע שרצים . באופן פנימי, להשריץ מזלגות, ולאחר מכן תהליך spawned אין שום דרך לתקשר עם התהליך המקורי לצפות למעט באמצעות תקשורת spawn_id.
הדגל שנפתח גורם לארגומנט הבא להתפרש כמזהה קובץ Tcl (כלומר, מוחזר על ידי פתח .) ניתן להשתמש בזיהוי השורש כאילו היה תהליך שנוצר. (לא ניתן עוד להשתמש במזהה הקובץ). פעולה זו מאפשרת לך לטפל בהתקנים, בקבצים ובצינורות גולמיים כתהליכים מובילים ללא שימוש ב- pty. 0 מוחזר כדי לציין שאין תהליך מקושר. כאשר החיבור לתהליך המופעל סגור, כך גם מזהה הקובץ Tcl. הדגל של הלייפופן דומה לזה שנפתח , מלבד העובדה שה-leaveopen גורמת למזהה הקובץ להיות פתוח גם לאחר שהזהה השחרית סגורה.
הדגל- פתיתי גורם לפתיחתו , אך לא נוצר תהליך . 0 מוחזר כדי לציין שאין תהליך מקושר. Spawn_id מוגדר כרגיל.
המשתנה spawn_out (עבדים, fd) מוגדר למזהה קובץ המתאים לעבד pty. זה יכול להיות סגור באמצעות "קרוב לעבד".
הדגל -גביע מציין אות שיש להתעלם ממנו בתהליך שנוצר. אחרת, האותות מקבלים את התנהגות ברירת המחדל. אותות נקראים בשם הפקודה מלכודת , אלא שכל אות דורש דגל נפרד.
רמת החן
גורם להצהרות הבאות שיודפסו לפני ביצוען. (פקודת מעקב של Tcl עוקבת אחר משתנים). רמת מציין עד כמה רחוק למטה בערימת השיחה כדי לעקוב. לדוגמה, הפקודה הבאה מפעילה Expect בעת מעקב אחר 4 רמות השיחות הראשונות, אך אף אחת מהן אינה נמצאת מתחת.
הדגל -info גורם לסטרייס להחזיר תיאור של הטיעונים האחרונים שלא קיבלו מידע.
סטטי טוען
שינויים מצבי מסנן דומה הפקודה חיצוני stty.
כברירת מחדל, מסוף הבקרה נגיש. מסופים אחרים ניתן לגשת על ידי הוספת "בקשות לסטטוס להחזיר אותו כתוצאה של הפקודה.אם לא נדרש מעמד ואת הטרמינל השליטה, המצב הקודם של תכונות גלם הד חוזרים בטופס אשר יכול להיות מאוחר יותר בשימוש על ידי הפקודה.
לדוגמה, הארגומנטים גולמי או מבושל לשים את המסוף למצב גלם. הוויכוחים - סרוקים או מבושלים מעמידים את המסוף למצב מבושל. הוויכוחים מהדהדים ו- אקו לשים את הטרמינל לתוך הד מצב noecho בהתאמה.
הדוגמה הבאה ממחישה כיצד להשבית באופן זמני הד. זה יכול לשמש סקריפטים אוטומטיים אחרת, כדי למנוע הטבעה סיסמאות בהם. (ראה דיון נוסף בנושא זה תחת ציוני EXPECT להלן).
stty -echo send_user "סיסמא:" expected_user -re "(. *) \ n" set password $ expected_out (1, string) stty echo מערכת המערכת
נותנת את הויכוחים ל"שילוט "(1) כקלט, בדיוק כאילו הודפס כפקודה ממסוף. מצפה לחכות עד שהקונכייה תסתיים. מצב החזרה משמאל מטופל באותו אופן שבו exec מטפל במצב החזרתו.
בניגוד exec אשר מפנה stdin ו stdout לסקריפט, המערכת מבצעת שום ניתוב מחדש (מלבד זה מסומן על ידי מחרוזת עצמו). לכן, ניתן להשתמש בתוכניות אשר חייב לדבר ישירות / dev / tty. מאותה סיבה, תוצאות המערכת אינן נרשמות ביומן.
חותמת [ארגומנטים]
מחזיר חותמת. ללא ויכוחים, מספר השניות מאז התקופה מוחזר.
דגל הפורמט מציג מחרוזת המוחזרת אך עם תחליפים שנעשו על פי כללי POSIX עבור strftime. לדוגמה,% a מוחלף על ידי שם שבוע יומי מקוצר (כלומר, יום שבת). אחרים הם:
% שם שבוע מקוצר% שם מלא של יום בשבוע% b חודש חודש מקוצר% B חודש חודש מלא% c תאריך זמן כמו: יום רביעי 6 אוקטובר 11:45:56 1993% יום של החודש (01-31% H שעה (00-36)% 00 (% 01)% (0-12)% (0-12)% m (0-01)% 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 הדגל כוחות חותמת הזמן פלט להשתמש אזור הזמן GMT . ללא דגל, אזור הזמן המקומי משמש.
מלכודת [[הפקודה] אותות]
גורם פקודה נתון להיות מבוצע עם קבלת בעתיד של כל האותות נתון. הפקודה מבוצעת בהיקף הגלובלי. אם הפקודה נעדרת, פעולת האות מוחזרת. אם הפקודה היא מחרוזת SIG_IGN, האותות מתעלמים. אם הפקודה היא מחרוזת SIG_DFL, האותות הם תוצאה של ברירת המחדל של המערכת. אותות הוא אות יחיד או רשימה של אותות. ניתן לציין אותות מספריים או סמליים לפי אות (3). הקידומת "SIG" עשויה להיות מושמטת.
ללא ויכוחים (או הארגומנט), מלכודת מחזירה את מספר האות של פקודת מלכודת המבוצעת כעת.
הדגל- קוד משתמש בקוד החזרה של הפקודה במקום איזה קוד Tcl עמד לחזור כאשר הפקודה התחילה לפעול במקור.
הדגל- אינטרפ גורם לפקודה להיות מוערכת באמצעות המתורגמן הפעיל בזמן שהפקודה החלה לפעול במקום כאשר הכריזה על המלכודת.
דגל- שם גורם לפקודת מלכודת להחזיר את שם האות של פקודת מלכודת המבוצעת כעת.
הדגל -max גורם לפקודת השמנה להחזיר את מספר האות הגדול ביותר שניתן להגדיר.
לדוגמה, הפקודה "מלכודת {send_user" Ouch! "} SIGINT" תדפיס "Ouch!" בכל פעם שהמשתמש לוחץ על C.
כברירת מחדל, SIGINT (אשר בדרך כלל יכול להיות שנוצר על ידי לחיצה על C) ו - SIGTERM לגרום יציאה. זאת בשל המלכודת הבאה, שנוצרת כברירת מחדל כאשר Expect מתחיל.
יציאה מלכודת {SIGINT SIGTERM}אם אתה משתמש בדגל -D כדי להפעיל את הבאגים, SIGINT מוגדר מחדש כדי להפעיל את הבאגים האינטראקטיבי. זאת בשל המלכודת הבאה:
מלכודת {exp_debug 1} SIGINTמלכודת הבאגים ניתנת לשינוי על ידי הגדרת משתנה הסביבה EXPECT_DEBUG_INIT לפקודת מלכודת חדשה.
אתה יכול, כמובן, לעקוף את שני אלה רק על ידי הוספת פקודות מלכודת על התסריט שלך. בפרט, אם יש לך שלך "מלכודת יציאה SIGINT", זה יהיה לעקוף את מלכודת הבאגים. אפשרות זו שימושית אם ברצונך למנוע ממשתמשים להגיע למאתר הבאגים.
אם אתה רוצה להגדיר את המלכודת שלך על SIGINT אבל עדיין מלכודת על הבאגים כאשר הוא פועל, השתמש:
אם {! [exp_debug]} {trap mystuff SIGINT}לחלופין, אתה יכול מלכודת על הבאגים באמצעות אות אחר.
מלכודת לא תאפשר לך לעקוף את הפעולה עבור SIGALRM כמו זה משמש פנימי כדי לצפות . פקודת ההפרדה קובעת את SIGALRM ל- SIG_IGN (התעלם). אתה יכול reenable זה כל עוד אתה להשבית אותו במהלך פקודות להשריץ הבאים.
ראה אות (3) למידע נוסף.
המתן [ארגומנטים]
עיכובים עד להופעת תהליך (או התהליך הנוכחי אם לא נקרא שם) מסתיימת.
לחכות בדרך כלל מחזירה רשימה של ארבעה מספרים שלמים. המספר השלם הראשון הוא pid של התהליך כי היה חיכו. המספר השלם השני הוא מזהה המתאים להשריץ. המספר השלישי הוא -1 אם אירעה שגיאת מערכת הפעלה, או 0 אחרת. אם המספר השלישי היה 0, המספר השלם הרביעי הוא הסטטוס שהוחזר על ידי התהליך שנוצר. אם המספר השלישי הוא -1, המספר השלם הרביעי הוא הערך של errno שנקבע על ידי מערכת ההפעלה. המשתנה הגלובלי errorCode מוגדר גם.
אלמנטים נוספים עשויים להופיע בסוף ערך ההחזרה מהמתנה . אלמנט חמישי אופציונלי מזהה סוג של מידע. נכון לעכשיו, הערך היחיד האפשרי עבור אלמנט זה הוא CHILDKILLED ובמקרה זה שני הערכים הבאים הם האות C בסגנון שם ותיאור טקסט קצר.
הדגל - I מצהיר על תהליך ההמתנה המתאים ל spawn_id בשם (לא את מזהה התהליך ). בתוך המטפל SIGCHLD, ניתן להמתין לכל תהליך הוליד באמצעות id שרצים -1.
דגל הכניסה גורם להחזרה מיידית עם סימן להמתנה מוצלחת. כאשר התהליך יוצא (מאוחר יותר), הוא ייעלם באופן אוטומטי ללא צורך בהמתנה מפורשת.
פקודת ההמתנה עשויה לשמש גם להמתנה לתהליך המזלג באמצעות הארגומנטים "-1 -1". שלא כמו השימוש שלה עם תהליכים הוליד, פקודה זו יכולה להתבצע בכל עת. אין שליטה על איזה תהליך הוא קוצר. עם זאת, ניתן לבדוק את ערך ההחזרה עבור מזהה התהליך .
ספריות
מצפה אוטומטית יודע על שתי ספריות מובנות עבור סקריפט מצפה. אלה מוגדרים על ידי הספריות בשם המשתנים exp_library ו exp_exec_library. שניהם נועדו להכיל קבצי השירות שניתן להשתמש בהם על ידי סקריפטים אחרים.
exp_library מכיל קבצים עצמאיים לארכיטקטורה. exp_exec_library מכיל קבצים תלויי ארכיטקטורה. בהתאם למערכת שלך, שתי הספריות עשויות להיות ריקות לחלוטין. קיומו של הקובץ $ exp_exec_library / cat-buffers מתאר אם המאגרים / bin / cat שלך כברירת מחדל.
PRETTY-PRINT
הגדרה vgrind זמין עבור הדפסה יפה מצפה סקריפטים. בהנחה שההגדרה vgrind שסופקה עם התפלגות Expect מותקנת כהלכה, ניתן להשתמש בה כ:
קובץ vgrind-flexpectדוגמאות
זה הרבה לא להיות ברור איך לשים את הכל ביחד כי דף האיש מתאר. אני ממליץ לך לקרוא ולנסות את הדוגמאות במדריך לדוגמה של הפצה מצפה . חלקם תוכניות אמיתיות. אחרים הם פשוט ממחישים טכניקות מסוימות, וכמובן, זוג הם פשוט פריצות מהירה. קובץ INSTALL כולל סקירה מהירה של תוכניות אלה.
הניירות של Expect (ראה SEE ALSO) שימושיים גם הם. בעוד כמה ניירות להשתמש בתחביר המתאים גירסאות מוקדמות של ציפייה, הנימוקים הנלווים עדיין תקף להיכנס לפרטים הרבה יותר מאשר דף האיש הזה.
קאוויטים
תוספים עשויים להתנגש עם שמות הפקודה של Expect. לדוגמה, שלח מוגדר על ידי Tk עבור מטרה אחרת לגמרי. מסיבה זו, רוב הפקודות מצפה זמינים גם "exp_XXXX". פקודות ומשתנים המתחילים ב- "exp", "inter", "שרצים" ו- "timeout" אינם כוללים כינויים. השתמש בשמות הפקודה המורחבים אם אתה זקוק לתאימות בין סביבות.
מצפה לוקח השקפה ליברלית למדי של scoping. בפרט, משתנים הנקראים על ידי פקודות ספציפיות לתוכנית Expect יחפשו תחילה מהיקף המקומי, ואם לא יימצאו, בהיקף הגלובלי. לדוגמה, זה מבטל את הצורך להציב "פסק זמן גלובלי" בכל הליך שאתה כותב המשתמש בציפייה . מאידך גיסא, משתנים כתובים הם תמיד בהיקפה המקומי (אלא אם כן הוצא פקודה "גלובלית"). הבעיה הנפוצה ביותר היא גורם כאשר שרצים מבוצע בהליך. מחוץ לפרוצדורה, spawn_id כבר לא קיים, ולכן תהליך spawned כבר לא נגיש רק בגלל scoping. הוסף "spawn_id גלובלי" לנוהל כזה.
אם אתה לא יכול להפעיל את היכולת multisawning (כלומר, המערכת שלך לא תומך (BSD *. *), סקר (SVR> 2), ולא משהו שווה ערך), מצפה רק יוכל לשלוט על תהליך בודד בכל פעם. במקרה זה, אל תנסה להגדיר spawn_id , וגם אתה לא צריך לבצע תהליכים באמצעות exec בעת תהליך spawned פועל. יתר על כן, לא תוכל לצפות מתהליכים מרובים (כולל המשתמש כאחד) באותו זמן.
הפרמטרים מסוף יכול להיות בעל השפעה גדולה על סקריפטים. לדוגמה, אם סקריפט כתוב כדי לחפש מהדהד, זה יהיה misbehave אם מהדהד כבוי. מסיבה זו, לצפות כוחות פרמטרים מסוף שפוי כברירת מחדל. למרבה הצער, זה יכול לעשות דברים לא נעימים עבור תוכניות אחרות. לדוגמה, פגז emacs רוצה לשנות את המיפוי "הרגיל": Newlines לקבל ממופה על שורות חדשות במקום מרכבה- return שורות חדשות, ומהדה הוא מושבת. זה מאפשר אחד להשתמש emacs כדי לערוך את הקלט קלט. למרבה הצער, מצפה לא יכול לנחש את זה.
ניתן לבקש כי לא תעקוף את הגדרת ברירת המחדל של פרמטרים סופניים, אך עליך להיות זהיר מאוד בעת כתיבת סקריפטים עבור סביבות כאלה. במקרה של emacs, הימנע בהתאם לדברים כמו מיצוב מהדהד של סוף הקו.
הפקודות שקיבלו את הטיעונים שהוכנסו לרשימה אחת (גרסאות הצפייה והאינטראקציה ) משתמשות בהיוריסטי כדי להחליט אם הרשימה היא למעשה ארגומנט אחד או רבים. ההיוריסטי יכול להיכשל רק במקרה שבו הרשימה אכן מייצגת ארגומנט אחד שיש לו מספר מוטבע \ n עם תווים שאינם לבנים ביניהם. זה נראה די בלתי סביר, אבל את הטענה "נובראסה" ניתן להשתמש כדי לכפות טיעון אחד להיות מטופל כמו טיעון אחד. זה יכול לעלות על הדעת עם קוד שנוצר על ידי מכונה. באופן דומה, -כוחות מאלצים טיעון אחד להיות לטפל כמו דפוסים מרובים / פעולות.
באגים
זה היה באמת מפתה לקרוא את שם התוכנית "סקס" (עבור "או EXEC" חכם או "שלח ציפייה"), אבל השכל הישר (או אולי רק פוריטניות) ששררה.
על כמה מערכות, כאשר פגז הוא הוליד, הוא מתלונן על לא להיות מסוגל לגשת tty אבל רץ בכל זאת. כלומר, למערכת שלך יש מנגנון להשגת השליטה tty כי מצפה לא יודע על. תברר מה זה, ולשלוח את המידע בחזרה אלי.
Ultrix 4.1 (לפחות את הגרסאות העדכניות ביותר כאן) רואה פסק זמן של מעל 1000000 להיות שווה ל 0.
Digital UNIX 4.0A (וכנראה גרסאות אחרות) מסרב להקצות ptys אם אתה מגדיר מטפל SIGCHLD. לקבלת מידע נוסף, ראה דף מענק.
IRIX 6.0 אינו מטפל בהרשאות Pty כהלכה, כך שאם Expect מנסה להקצות pty ששימש בעבר על ידי מישהו אחר, הוא נכשל. שדרג ל- IRIX 6.1.
Telnet (מאומת רק תחת SunOS 4.1.2) תלוי אם TERM אינו מוגדר. זוהי בעיה תחת cron, ב ו ב cgi scripts, אשר אינם מגדירים TERM. לכן, אתה חייב להגדיר את זה במפורש - איזה סוג הוא בדרך כלל לא רלוונטי. זה פשוט צריך להיות מוגדר למשהו! סביר להניח שהסיבות הבאות הן ברוב המקרים.
(TERM) vt100עצה (מאומתת רק תחת BSDI BSD / OS 3.1 i386) תלויה אם SHELL ו- HOME אינם מוגדרים. זוהי בעיה תחת cron , ב ו cgi scripts, אשר אינם מגדירים משתנים אלה הסביבה. לכן, אתה חייב להגדיר אותם במפורש - איזה סוג הוא בדרך כלל לא רלוונטי. זה פשוט צריך להיות מוגדר למשהו! סביר להניח שהסיבות הבאות הן ברוב המקרים.
set env (SHELL) / bin / sh set env (HOME) / usr / local / binחלק מיישומי ptys מתוכננים כך שהקרנל משליך כל פלט שלא נקרא לאחר 10 עד 15 שניות (המספר בפועל תלוי ביישום) לאחר שהתהליך סגר את מתאר הקובץ. כך לצפות תוכניות כגון
תאריך שרצים לישון 20 לצפותייכשל. כדי למנוע זאת, להפעיל תוכניות לא אינטראקטיביות עם exec ולא שרצים . למרות שמצבים כאלה ניתנים לזיהוי, בפועל מעולם לא נתקלתי במצב שבו התפוקה הסופית של תוכנית אינטראקטיבית באמת תלך לאיבוד בגלל התנהגות זו.
מצד שני, Cray UNICOS ptys לזרוק כל פלט שלא נקרא מיד לאחר התהליך סגר את מתאר הקובץ. דיווחתי על כך לקריי והם עובדים על תיקון.
לפעמים נדרש עיכוב בין הנחיה לתגובה, כגון כאשר ממשק tty משנה הגדרות UART או התאמת שיעורי baud על- ידי חיפוש סיביות התחלה / עצירה. בדרך כלל, כל זה דורש הוא לישון למשך שנייה או שתיים. טכניקה חזקה יותר היא לנסות שוב עד שהחומרה מוכנה לקבל קלט. הדוגמה הבאה משתמשת בשתי אסטרטגיות:
שלח "מהירות 9600 r"; לישון 1 לצפות {timeout {שלח "r"; exp_continue} $ prompt}מלכודת-קוד לא תעבוד עם כל פקודה שיושבת בלולאת האירוע של Tcl, כגון שינה. הבעיה היא כי לולאה האירוע, Tcl משליך את קודי ההחזרה מ מטפלים באירועים async. שיטה לעקיפת הבעיה היא להגדיר דגל בקוד המלכודת. ואז לבדוק את הדגל מיד אחרי הפקודה (כלומר, לישון).
הפקודה expected_background מתעלמת - טיעונים של זמן ואין לה מושג על פסק זמן בכלל.
& # 34; מצפה ציפויים & # 34;
ישנם כמה דברים לגבי זה עשוי להיות לא אינטואיטיבי. סעיף זה מנסה לטפל בכמה מהדברים האלה עם כמה הצעות.
בעיה משותפת לצפות היא איך לזהות את הקליפות. מאז אלה מותאמים באופן שונה על ידי אנשים שונים פגזים שונים, automable rlogin automable יכול להיות קשה בלי לדעת את הפקודה. אמנה סבירה היא שיש למשתמשים לאחסן ביטוי רגיל המתאר את הנחיה (בפרט, את הסוף של זה) של משתנה הסביבה EXPECT_PROMPT. קוד כמו הבאה ניתן להשתמש. אם EXPECT_PROMPT אינו קיים, הקוד עדיין יש סיכוי טוב לתפקד כראוי.
(% | # # \ $ $) $ $; # default הפקודה לתפוס {set prompt $ env (EXPECT_PROMPT)}אני ממליץ לך לכתוב דפוסי הצפייה הכוללים את סוף כל מה שאתה מצפה לראות. זה ימנע את האפשרות לענות על שאלה לפני לראות את כל העניין. בנוסף, ייתכן שתוכל לענות על שאלות לפני שתראה אותן לחלוטין, אם תשאל מוקדם, התשובה שלך עשויה להופיע חזרה באמצע השאלה. במילים אחרות, הדיאלוג המתקבל יהיה נכון אבל נראה מקושקש.
רוב ההנחיות כוללות תו רווח בסוף. לדוגמה, הפקודה מ- ftp היא 'f', 't', 'p', '>' ו-. כדי להתאים להנחיה זו, עליך לטפל בכל אחת מהתווים. זוהי טעות נפוצה לא לכלול את ריק. שים את הריק במפורש.
אם אתה משתמש דפוס של X *, * יתאים את כל הפלט המתקבל מסוף X את הדבר האחרון שהתקבל. זה נשמע אינטואיטיבי אבל יכול להיות קצת מבלבל כי הביטוי "הדבר האחרון שהתקבל" יכול להשתנות בהתאם למהירות המחשב ועיבוד של I / O הן על ידי הקרנל ואת מנהל ההתקן.
בפרט, בני אדם נוטים לראות פלט תוכנית המגיעים נתחים ענקיים (אטומית) כאשר במציאות רוב התוכניות לייצר פלט שורה אחת בכל פעם. בהנחה שזה המקרה, * בדפוס של הפסקה הקודמת יכול רק להתאים את הסוף של הקו הנוכחי למרות שנראה שיש יותר, כי בזמן המשחק זה היה כל התפוקה שהתקבלה.
לצפות אין שום דרך לדעת כי פלט נוסף מגיע אלא אם כן דפוס שלך במיוחד עבור זה.
גם תלוי במאגר קו-אוריינטציה הוא לא חכם. לא רק תוכניות לעתים רחוקות לעשות הבטחות על סוג של חציצה שהם עושים, אבל קלקול קלקול המערכת יכולה לשבור קווי פלט למעלה, כך שורות לשבור במקומות אקראיים לכאורה. לכן, אם אתה יכול להביע את הדמויות האחרונות של הפקודה בעת כתיבת דפוסים, זה נבון לעשות זאת.
אם אתה מחכה דפוס בתפוקה האחרונה של התוכנית ואת התוכנית פולטת משהו אחר במקום, לא תוכל לזהות את זה עם מילת המפתח timeout . הסיבה היא כי לא תצא פסק זמן - במקום זה תקבל אינדיקציה eof . השתמש במקום זאת. אפילו יותר טוב, להשתמש בשני. ככה אם הקו הזה הוא אי פעם זז מסביב, אתה לא צריך לערוך את הקו עצמו.
Newlines הם בדרך כלל להמרה לחזור ההובלה, sequfeed linefeed כאשר הפלט על ידי מנהל המסוף. לכן, אם אתה רוצה תבנית שמתאימה במפורש לשתי השורות, מ, למשל, printf ("foo \ nbar"), עליך להשתמש בתבנית "foo \ r \ nbar".
תרגום דומה מתרחש בעת קריאת המשתמש, דרך expected_user . במקרה זה, כאשר תלחץ על החזרה, היא תתורגם לקו חדש. אם Expect ואז עובר את זה לתוכנית אשר קובע את המסוף למצב גלם (כמו Telnet), תהיה בעיה, כמו התוכנית מצפה לחזור אמיתי. (תוכניות מסוימות הם למעשה סלחני כי הם באופן אוטומטי לתרגם newlines כדי מחזירה, אבל רוב לא.) למרבה הצער, אין שום דרך לגלות כי תוכנית לשים את הטרמינל שלה לתוך מצב גלם.
במקום להחליף ידנית שורות חדשות עם החזרות, הפתרון הוא להשתמש בפקודה "stty raw", דבר שיפסיק את התרגום. עם זאת, שים לב, פירוש הדבר שלא תקבל עוד את תכונות עריכת הקו המבושלות.
אינטראקציה מרומזת מגדיר את המסוף שלך למצב גלם כך בעיה זו לא תתעורר לאחר מכן.
לעתים קרובות זה שימושי כדי לאחסן סיסמאות (או מידע פרטי אחר) סקריפטים צפוי . זה לא מומלץ כי כל דבר המאוחסן במחשב הוא רגיש להיות נגיש על ידי מישהו. לכן, באופן אינטראקטיבי הנחיה סיסמאות מתוך סקריפט הוא רעיון חכם יותר מאשר הטבעה אותם פשוטו כמשמעו. עם זאת, לפעמים הטבעה כזו היא האפשרות היחידה.
למרבה הצער, מערכת הקבצים UNIX אין דרך ישירה ליצירת סקריפטים אשר ניתנים לביצוע אבל לא קריא. מערכות התומכות סקריפטים פגז setgid עשוי בעקיפין לדמות זאת כדלקמן:
צור את התסריט Expect (המכיל את הנתונים הסודיים) כרגיל. הפוך את ההרשאות שלה להיות 750 (-Rwxr-x ---) ו בבעלות קבוצה מהימן, כלומר, קבוצה אשר מותר לקרוא את זה. במקרה הצורך, צור קבוצה חדשה למטרה זו. לאחר מכן, צור סקריפט / bin / sh עם הרשאות 2751 (-rwxr-s - x) בבעלות אותה קבוצה כמו קודם.
התוצאה היא סקריפט אשר ניתן לבצע (ולקרוא) על ידי מישהו. כאשר מופעל, הוא מפעיל את התסריט Expect .
& # 34; ראה גם & # 34;
Tcl (3), libexpect (3)
"Exploring Expect: ערכת כלים המבוססת על TCL עבור אוטומציה של תוכניות אינטראקטיביות" מאת דון ליבס, עמ '602, ISBN 1-56592-090-2, O'Reilly and Associates, 1995.
"ציפיות: ריפוי אלה השתלמויות בלתי נשלטות של אינטראקטיביות" על ידי דון ליבס, ההליכים של קיץ 1990 USENIX כנס, אנהיים, קליפורניה, 11-15 יוני 1990.
.I "באמצעות מצפה אוטומציה של מערכת ניהול המשימות" על ידי דון ליבס, ההליכים של USENIX 1990 גדול התקנת מערכות מינהל כנס, קולורדו ספרינגס, קולורדו, 17-19 אוקטובר 1990.
. "Tcl: שפת פקודה Embeddedable" על ידי ג'ון Ousterhout, ההליכים של חורף 1990 כנס USIX, וושינגטון, 22-26 ינואר, 1990 .. "אני מצפה: סקריפטים לשליטה תוכניות אינטראקטיביות" על ידי דון ליבס, מערכות מחשוב , Vol. 4, מס '2, הוצאת אוניברסיטת קליפורניה, נובמבר 1991 .. "מבחני רגרסיה ותוכניות לבחינות קונפורמיות", מאת דון ליבס, פרוטוקולים של הכנס 1992 USENIX, עמ' 135-144, סן אנטוניו, 12-15 ביוני 1992 .. "קיביץ - חיבור של תוכניות אינטראקטיביות מרובות ביחד", מאת דון ליבס, תוכנה - ניסיון וניסיון, ג'ון ויילי ובניו, מערב סאסקס, אנגליה, כרך ב '.
23, 5 במאי 1993. "אני מאתר הבאגים של Tcl Applications", מאת דון ליבס, פרוטוקולים של סדנת TCL / T 1993, ברקלי, קליפורניה, 10-11 ביוני 1993.
מְחַבֵּר
דון ליבס, המכון הלאומי לתקנים וטכנולוגיה
הצהרות
תודה לג'ון אוסטרהאוט על טקל, וסקוט פיזלי על ההשראה. תודה Rob Roboye עבור קוד תצורה של Expect.
הקובץ HISTORY מתעד הרבה מההתפתחות של הציפייה . זה עושה קריאה מעניינת עשוי לתת לך תובנה נוספת לתוכנה זו. תודה לאנשים שהוזכרו בו ששלחו לי תיקוני באגים ונתנו עזרה נוספת.
תכנון וביצוע של Expect שולם בחלקו על ידי ממשלת ארה"ב ולכן הוא ברשות הציבור. עם זאת המחבר ו NIST רוצה אשראי אם תוכנית זו ותיעוד או חלקים מהם משמשים.