מצפה לינוקס / הוראות פיקוד יוניקס ודוגמאות

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

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, אפשרות זו מצוינת -באגים.

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

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

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

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

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

#! / 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 סטטוס

גורם לצפות לצאת או להתכונן אחרת לעשות זאת.

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

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

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

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

exp_continue -continue_timer

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

ערך exp_internal -f file

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

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

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

exp_open args -i spawn_id

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

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

exp_pid -i spawn_id

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

exp_send

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

exp_send_error

הוא כינוי עבור Send_ טרור .

exp_send_log

הוא כינוי עבור Send_log .

exp_send_tty

הוא כינוי עבור Send_tty .

exp_send_user

הוא כינוי עבור Send_user .

exp_version -exit גרסה

הוא שימושי כדי להבטיח את התסריט תואם את הגירסה הנוכחית של Expect.

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

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

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

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

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

מצפה -opts pat1 body1 … --tsts patn bodyn

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

עם התאמת תבנית (או eof או full_buffer), כל פלט תואם בעבר לא נשמר במשתנה Quote_out (חיץ) . עד 9 התאמות מחרוזות רגולריות נשמרות במשתנים expected_out (1, string) דרך Quote_out (9, string) . אם -מדדים הדגל משמש לפני דפוס, מדדי ההתחלה והסיום (בצורה המתאימה מסובך ) של 10 מחרוזות מאוחסנים במשתנים expected_out (X, start) ו expected_out (X, end) כאשר X הוא ספרה, תואם את המיקום מחרוזת במאגר. 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. זה יכול להיות מונע על ידי קידומת דפוס עם - העברה דגל. דגל זה שימושי במיוחד בניסויים (והוא יכול להיות מקוצר ל - "לא" לנוחות בזמן הניסוי).

מזהה שרצים הקשורים פלט תואם (או eof או full_buffer) מאוחסן ב expected_out (spawn_id) .

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

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

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

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

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

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

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

אפשרות זו שימושית למניעת לולאות מפורשות או הצהרות חוזרות על עצמן. הדוגמה הבאה היא חלק מקטע כדי להפוך את 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 "exit> 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

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

מצפה_קרקע מצפה_ארץ

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

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

לא ניתן לבצעמצפה בעודexpect_background ללא חסימה.expect_background עבור מזהה להשריץ מסוים נמחק על ידי הכרזה על new_background חדש עם אותו שרצים מזהה. הכרזהexpect_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,מצפה מושעה. (ה-setet דגל משחזר את מצבי המסוף.) כאשר לחיצה על A, המשתמש רואה "הקלדת פקד - A" והתהליך נשלח. כאשר $ נלחץ, המשתמש רואה את התאריך. כאשר C ^ נלחץ,מצפה אקזיטים. אם "foo" מוזן, המשתמש רואה "סרגל". כאשר ~ ~ נלחץ,מצפה המתורגמן פועל באופן אינטראקטיבי.

Set CTRLZ 032 אינטראקציה {-reset $ CTRLZ {exec kill -STOP pid} 001 {send_user "הקלדת A-n n"; שלח את " 001"} $ {send_user "התאריך הוא תבנית השעון שעון השעון."} 003 יציאה foo {send_user "bar"} ~ ~}

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

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

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

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

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

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

לא ניתן להחזיר את החזרה $ spawn_id

אם התבנית היא מילת המפתחריק , ואת nulls מותר (דרךלהסיר הפקודה), הגוף המתאים מבוצע אם אחד ASCII 0 הוא מותאם. לא ניתן להתאים 0 בתים באמצעות תבניות גלובליות או regexp.

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

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

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

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

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

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

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

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

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

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

(#), "(),", "#:" #: "#:" #,

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

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

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

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

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

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

כדי לשלוח פלט לתהליכים מרובים, רשימת כל רשימת שרצים מזהה מראש על ידיפלט דגל. קלט עבור קבוצה של זרעים פלט פלט עשוי להיקבע על ידי רשימת שרצים מזהה מראש על ידיקלט דגל. (שניהםקלט ופלט יכול לקחת רשימות באותה צורה כמו-אני דגל במצפה , אלא ש any_spawn_id אינו משמעותיאינטראקציה ). כל הדגלים והחוטים (או התבניות) הבאים חלים על קלט זה עד שיופיע דגל אחר. אם לאקלט מופיע,פלט מרמז "- input $ user_spawn_id penetput". (באופן דומה, עם דפוסים שאין להםקלט .) אם אחדקלט מוגדר, הוא עוקף $ user_spawn_id. אם שנייהקלט צוין, הוא עוקף $ spawn_id. נוסףקלט דגלים עשויים להיות מוגדרים.

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

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

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

מתורגמן ארגומנטים

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

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

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

במהלךמתורגם , מצב מבושל משמש, גם אם המתקשר שלו משתמש במצב גלם.

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

log_file args -a file

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

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

ה- א דגל כוחות פלט להיות מחובר כי היה מדוכא על ידיlog_user פקודה.

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

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

log_user -info | 0 1

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

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

match_max -d -i spawn_id size

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

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

כיסוי - # spawn_id - # spawn_id … תוכנית ארגס

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

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

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

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

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

זוגיות -D -i spawn_id ערך

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

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

remove_nulls -d -i spawn_id ערך

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

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

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

שלח מחרוזות

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

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

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

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

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

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

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

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

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

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