लिनक्स / यूनिक्स कमांड उम्मीद

उम्मीद एक कार्यक्रम है जो एक स्क्रिप्ट के अनुसार अन्य इंटरैक्टिव कार्यक्रमों से बात करता है। स्क्रिप्ट के बाद, उम्मीद है कि किसी प्रोग्राम से क्या उम्मीद की जा सकती है और सही प्रतिक्रिया क्या होनी चाहिए। एक व्याख्या की गई भाषा संवाद को निर्देशित करने के लिए शाखाकरण और उच्च स्तरीय नियंत्रण संरचना प्रदान करती है। इसके अलावा, उपयोगकर्ता वांछित होने पर सीधे नियंत्रण कर सकते हैं और स्क्रिप्ट पर नियंत्रण लौटने के बाद सीधे बातचीत कर सकते हैं।

एक्सपेक्टक उम्मीद और रुपये का मिश्रण है। यह अपेक्षा और टी की इच्छा की तरह व्यवहार करता है। उम्मीद टीसीएल के बिना सीधे सी या सी ++ में भी इस्तेमाल की जा सकती है।

"उम्मीद" नाम यूकेपी, किर्मिट और अन्य मॉडेम नियंत्रण कार्यक्रमों द्वारा लोकप्रिय / भेजने के अनुक्रमों के विचार से आता है। हालांकि यूकेपी के विपरीत, उम्मीद सामान्यीकृत की जाती है ताकि इसे किसी भी प्रोग्राम और कार्य के साथ उपयोगकर्ता स्तर के कमांड के रूप में चलाया जा सके। उम्मीद एक ही समय में कई कार्यक्रमों से बात कर सकते हैं।

क्या उम्मीद कर सकते हैं

उदाहरण के लिए, यहां कुछ चीजें हैं जो उम्मीद कमांड कर सकती हैं:

• अपने कंप्यूटर को वापस डायल करने के कारण, ताकि आप कॉल के भुगतान के बिना लॉग इन कर सकें।
• एक गेम शुरू करें और यदि इष्टतम कॉन्फ़िगरेशन प्रकट नहीं होता है, तो इसे बार-बार पुनरारंभ करें) जब तक यह नहीं करता है, और फिर आपको नियंत्रण सौंपता है।
• Fsck चलाएं, और इसके सवालों के जवाब में, पूर्व निर्धारित मानदंडों के आधार पर "हां" या "नहीं" का उत्तर दें या आपको वापस नियंत्रण दें।
• किसी अन्य नेटवर्क से कनेक्ट करें और स्वचालित रूप से अपना मेल पुनर्प्राप्त करें ताकि ऐसा प्रतीत होता है कि यह मूल रूप से आपके स्थानीय सिस्टम को भेजा गया था।
• पर्यावरण चर, वर्तमान निर्देशिका, या rlogin, टेलनेट, टिप, सु , या chgrp भर में किसी भी तरह की जानकारी ले लो

शेल इन कार्यों को निष्पादित नहीं कर सकता है इसके कई कारण हैं। उम्मीद के साथ सभी संभव हैं।

आम तौर पर, उम्मीद किसी भी प्रोग्राम को चलाने के लिए उपयोगी होती है जिसके लिए कार्यक्रम और उपयोगकर्ता के बीच बातचीत की आवश्यकता होती है। यह आवश्यक है कि बातचीत को प्रोग्रामेटिक रूप से चिह्नित किया जा सके। उम्मीद है कि प्रोग्राम को नियंत्रित किए बिना प्रोग्राम को वापस नियंत्रण भी दे सकता है। इसी प्रकार, उपयोगकर्ता किसी भी समय स्क्रिप्ट पर नियंत्रण वापस कर सकता है।

प्रयोग

निष्पादित करने के लिए आदेशों की सूची के लिए cmdfile को पढ़ने की अपेक्षा करें। अपेक्षाएं उन प्रणालियों पर पूरी तरह से लागू की जा सकती हैं जो # का समर्थन करती हैं! स्क्रिप्ट को निष्पादन योग्य के रूप में चिह्नित करके और स्क्रिप्ट में पहली पंक्ति बनाने के द्वारा नोटेशन:

#! / usr / स्थानीय / बिन / उम्मीद-एफ

बेशक, पथ को सटीक रूप से वर्णन करना चाहिए कि जीवन की अपेक्षा करें। / usr / स्थानीय / बिन सिर्फ एक उदाहरण है।

-सी ध्वज स्क्रिप्ट में किसी भी से पहले निष्पादित करने के लिए कमांड को प्रीफ़ेस करता है। शेल द्वारा तोड़ने से रोकने के लिए कमांड को उद्धृत किया जाना चाहिए। यह विकल्प कई बार इस्तेमाल किया जा सकता है। एकाधिक आदेशों को अर्धविराम से अलग करके एकल-सी के साथ निष्पादित किया जा सकता है। आदेशों को उनके आदेश में निष्पादित किया जाता है। Expectk का उपयोग करते समय, यह विकल्प -command के रूप में निर्दिष्ट है।

-d ध्वज कुछ नैदानिक ​​आउटपुट को सक्षम बनाता है, जो मुख्य रूप से आदेशों और इंटरैक्ट जैसे कमांड की आंतरिक गतिविधि की रिपोर्ट करता है। एक ध्वज स्क्रिप्ट की शुरुआत में इस ध्वज का "exp_internal 1" जैसा ही प्रभाव होता है, साथ ही उम्मीद का संस्करण मुद्रित होता है।

डीडी ध्वज एक इंटरैक्टिव डीबगर सक्षम बनाता है। एक पूर्णांक मान का पालन करना चाहिए। डीबगर अगली टीसीएल प्रक्रिया से पहले नियंत्रण लेगा यदि मान गैर-शून्य है या यदि कोई ^ सी दबाया जाता है या ब्रेकपॉइंट मारा जाता है, या स्क्रिप्ट में अन्य उपयुक्त डीबगर कमांड दिखाई देता है। Expectk का उपयोग करते समय, यह विकल्प - डीबग के रूप में निर्दिष्ट है।

-एफ ध्वज एक फ़ाइल को प्रीफ़ेस करता है जिससे कमांड को पढ़ना है। झंडा स्वयं वैकल्पिक है क्योंकि # का उपयोग करते समय यह केवल उपयोगी है! नोटेशन, ताकि कमांड लाइन पर अन्य तर्क प्रदान किए जा सकें। Expectk का उपयोग करते समय, यह विकल्प -फाइल के रूप में निर्दिष्ट है।

डिफ़ॉल्ट रूप से, कमांड फ़ाइल को स्मृति में पढ़ा जाता है और पूरी तरह से निष्पादित किया जाता है। कभी-कभी फ़ाइलों को एक पंक्ति में पढ़ने के लिए वांछनीय होता है। मनमाने ढंग से फ़ाइलों को इस तरह से संभालने के लिए मजबूर करने के लिए, -b ध्वज का उपयोग करें। Expectk का उपयोग करते समय, यह विकल्प -बफर के रूप में निर्दिष्ट है।

यदि स्ट्रिंग "-" को फ़ाइल नाम के रूप में आपूर्ति की जाती है, तो इसके बजाय मानक इनपुट पढ़ा जाता है। वास्तव में "-" नाम की फ़ाइल से पढ़ने के लिए "./-" का प्रयोग करें।

-i ध्वज किसी फ़ाइल से पढ़ने के बजाय आदेशों के लिए इंटरैक्टिव रूप से संकेत करने की अपेक्षा करता है। निकास निकास आदेश या ईओएफ पर समाप्त हो जाता है। -i ध्वज माना जाता है कि न तो एक कमांड फ़ाइल nor -c का उपयोग किया जाता है। Expectk का उपयोग करते समय, यह विकल्प -इंटरिएक्टिव के रूप में निर्दिष्ट है।

- विकल्पों के अंत को सीमित करने के लिए इस्तेमाल किया जा सकता है। यह उपयोगी है यदि आप अपनी स्क्रिप्ट के लिए एक विकल्प-जैसे तर्क को बिना किसी अनुमान के व्याख्या करना चाहते हैं। यह उपयोगी रूप से # में रखा जा सकता है! उम्मीद से किसी भी झंडेदार व्याख्या को रोकने के लिए लाइन। उदाहरण के लिए, निम्नलिखित वैरिएबल argv में स्क्रिप्ट नाम सहित मूल तर्क छोड़ देंगे।

#! / usr / स्थानीय / बिन / उम्मीद -

ध्यान दें कि सामान्य getopt (3) और निष्पादित (2) सम्मेलनों को # पर तर्क जोड़ते समय देखा जाना चाहिए! लाइन।

फाइल $ exp_library / expect.rc स्वचालित रूप से मौजूद है, जब तक कि -एन ध्वज का उपयोग नहीं किया जाता है। (Expectk का उपयोग करते समय, यह विकल्प -एनओआरसी के रूप में निर्दिष्ट किया जाता है।) इसके तुरंत बाद, फ़ाइल ~ / .expect.rc स्वचालित रूप से सोर्स की जाती है, जब तक कि ध्वज का उपयोग नहीं किया जाता है। यदि पर्यावरण परिवर्तनीय DOTDIR परिभाषित किया गया है, तो इसे एक निर्देशिका के रूप में माना जाता है और .expect.rc वहां से पढ़ा जाता है। Expectk का उपयोग करते समय, यह विकल्प -norc के रूप में निर्दिष्ट है। यह सोर्सिंग किसी भी -सी झंडे को निष्पादित करने के बाद ही होती है।

-v अपने संस्करण संख्या को मुद्रित करने और बाहर निकलने का अनुमान लगाता है। एक्सपेक्टक में इसी ध्वज, जो लंबे ध्वज नामों का उपयोग करता है, है -वर्जन।

वैकल्पिक तर्क एक सूची में बनाए जाते हैं और argv नामक चर में संग्रहीत होते हैं। argc argv की लंबाई के लिए शुरू किया गया है।

यदि कोई स्क्रिप्ट उपयोग नहीं की जाती है तो Argv0 को स्क्रिप्ट या बाइनरी का नाम माना जाता है। उदाहरण के लिए, निम्नलिखित स्क्रिप्ट के नाम और पहले तीन तर्कों को प्रिंट करता है:

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

आदेश

टूल कमांड भाषा का उपयोग करें। टीसीएल नियंत्रण प्रवाह प्रदान करता है (यदि, ब्रेक), अभिव्यक्ति मूल्यांकन और कई अन्य विशेषताओं जैसे कि रिकर्सन और प्रक्रिया परिभाषा। यहां इस्तेमाल किए गए आदेश लेकिन परिभाषित नहीं किए गए (सेट, अगर, निष्पादन) टीसीएल कमांड हैं। उम्मीद अतिरिक्त आदेशों का समर्थन करता है। अन्यथा निर्दिष्ट किए जाने तक, आदेश खाली स्ट्रिंग को वापस कर देते हैं।

आदेश वर्णानुक्रम में सूचीबद्ध हैं ताकि वे जल्दी से स्थित हो सकें। हालांकि, नए उपयोगकर्ताओं को उस क्रम में स्पॉन, भेज, उम्मीद, और बातचीत के विवरण पढ़ने से शुरू करना आसान हो सकता है।

बंद करें [-स्लेव] [-onexec 0 | 1] [-i spawn_id]

वर्तमान प्रक्रिया से कनेक्शन बंद कर देता है । अधिकांश इंटरैक्टिव प्रोग्राम ईओएफ को अपने स्टडीन और बाहर निकलने पर पहचानेंगे; इस प्रकार आमतौर पर प्रक्रिया को मारने के लिए पर्याप्त रूप से बंद होता है। -i ध्वज नाम spawn_id के अनुरूप बंद करने की प्रक्रिया की घोषणा करता है।

दोनों अपेक्षाओं और बातचीत का पता लगाएगा कि वर्तमान प्रक्रिया कब निकलती है और पूरी तरह से बंद होती है, लेकिन अगर आप प्रक्रिया को मार देते हैं , तो कहें, "$ pid को निष्पादित करें", आपको स्पष्ट रूप से बंद करने की आवश्यकता है ।

Theonex ध्वज यह निर्धारित करता है कि स्पॉन आईडी किसी भी नई उत्पन्न प्रक्रियाओं में बंद है या यदि प्रक्रिया ओवरले हो गई है। एक स्पॉन आईडी खोलने के लिए, मान 0 का उपयोग करें। एक गैर-शून्य पूर्णांक मान किसी भी नई प्रक्रिया में स्पॉन को बंद कर देता है।

स्लेव ध्वज स्पॉन आईडी से जुड़े दास को बंद कर देता है। जब कनेक्शन बंद हो जाता है, तो दास स्वचालित रूप से बंद हो जाता है यदि यह अभी भी खुला है।

इससे कोई फर्क नहीं पड़ता कि कनेक्शन पूरी तरह से या स्पष्ट रूप से बंद है या नहीं, आपको संबंधित कर्नेल प्रक्रिया स्लॉट को साफ़ करने के लिए प्रतीक्षा करना चाहिए। क्लोज कमांड प्रतीक्षा नहीं करता है क्योंकि कोई गारंटी नहीं है कि एक प्रक्रिया कनेक्शन बंद करने से यह निकल जाएगा।

डीबग [[-now] 0 | 1]

एक टीसीएल डीबगर को नियंत्रित करता है जिससे आप कथन के माध्यम से कदम उठा सकते हैं और ब्रेकपॉइंट्स सेट कर सकते हैं।

कोई तर्क नहीं के साथ, अगर डीबगर नहीं चल रहा है तो 1 वापस कर दिया जाता है, अन्यथा 0 वापस लौटाया जाता है।

1 तर्क के साथ, डीबगर शुरू हो गया है। 0 तर्क के साथ, डीबगर बंद कर दिया गया है। यदि कोई तर्क पहले ध्वज से पहले होता है, तो डीबगर तुरंत शुरू होता है। अन्यथा, डीबगर अगले टीसीएल कथन के साथ शुरू किया गया है।

डीबग कमांड किसी भी जाल को नहीं बदलता है। -डी ध्वज के साथ उम्मीद शुरू करने के लिए इसकी तुलना करें।

डिस्कनेक्ट कमांड टर्मिनल से एक फोर्क प्रक्रिया को डिस्कनेक्ट करता है । यह पृष्ठभूमि में चल रहा है। प्रक्रिया को अपना स्वयं का प्रक्रिया समूह दिया जाता है। मानक I / O को / dev / null पर रीडायरेक्ट किया गया है।

निम्न खंड पृष्ठभूमि में स्क्रिप्ट को जारी रखने के लिए डिस्कनेक्ट का उपयोग करता है।

अगर {[कांटा]! = 0} डिस्कनेक्ट से बाहर निकलें। । ।

निम्न स्क्रिप्ट एक पासवर्ड पढ़ती है और फिर हर घंटे एक प्रोग्राम चलाती है जो प्रत्येक बार चलने पर पासवर्ड मांगती है। स्क्रिप्ट पासवर्ड प्रदान करती है ताकि आपको केवल इसे एक बार टाइप करना पड़े।

send_user "पासवर्ड? \" expect_user -re "(। *) \ n" के लिए {} 1 {} {अगर {[कांटा]! = 0} {नींद 3600; जारी रखें} sponn priv_prog डिस्कनेक्ट करें पासवर्ड: "$ hope_out भेजें ( 1, स्ट्रिंग) \ r "। । । बाहर जाएं }

खोल एसिंक्रोनस प्रक्रिया सुविधा (&) पर डिस्कनेक्ट का उपयोग करने का एक लाभ यह है कि डिस्कनेक्शन से पहले टर्मिनल पैरामीटर को सहेज सकते हैं और बाद में उन्हें नए ptys पर लागू कर सकते हैं। के साथ, उम्मीदवार को टर्मिनल के पैरामीटर को पढ़ने का मौका नहीं है क्योंकि टर्मिनल पहले से ही डिस्कनेक्ट हो जाता है, उम्मीद को नियंत्रण प्राप्त होता है।

बाहर निकलें [-opts] [स्थिति]

बाहर निकलने की अपेक्षा करता है या अन्यथा ऐसा करने के लिए तैयार होता है।

-ऑनिक्सिट ध्वज अगले तर्क को बाहर निकलने वाले हैंडलर के रूप में उपयोग करने का कारण बनता है। एक तर्क के बिना, मौजूदा निकास हैंडलर वापस कर दिया गया है।

-नोएक्सिट ध्वज बाहर निकलने के लिए तैयार होने की अपेक्षा करता है लेकिन वास्तव में ऑपरेटिंग सिस्टम पर नियंत्रण लौटने से कम रोकता है। उपयोगकर्ता द्वारा परिभाषित निकास हैंडलर के साथ-साथ उम्मीदवार के आंतरिक हैंडलर भी चलते हैं। आगे उम्मीदों को निष्पादित नहीं किया जाना चाहिए। यह उपयोगी है अगर आप अन्य टीसीएल एक्सटेंशन के साथ उम्मीद कर रहे हैं। वर्तमान दुभाषिया (और मुख्य खिड़की अगर पर्यावरण में) रहता है तो अन्य टीसीएल एक्सटेंशन साफ ​​हो सकते हैं। यदि अपेक्षित निकास को फिर से बुलाया जाता है (हालांकि यह हो सकता है), हैंडलर पुन: चालू नहीं होते हैं।

बाहर निकलने पर, प्रसंस्कृत प्रक्रियाओं के सभी कनेक्शन बंद हैं। क्लोज़र को प्रोओड प्रोसेस द्वारा ईओएफ के रूप में पहचाना जाएगा। बाहर निकलें सामान्य _exit (2) प्रक्रिया क्या करता है इससे परे कोई अन्य कार्य नहीं करता है। इस प्रकार, उत्पन्न प्रक्रियाएं जो ईओएफ की जांच नहीं करती हैं, जारी रह सकती हैं। (निर्धारित करने के लिए विभिन्न स्थितियां महत्वपूर्ण हैं, उदाहरण के लिए, एक स्पॉन्डेड प्रक्रिया को कौन सा सिग्नल भेजा जाएगा, लेकिन ये सिस्टम-निर्भर हैं, आमतौर पर बाहर निकलने के तहत प्रलेखित (3)।) चलने वाली प्रयुक्त प्रक्रियाओं को init द्वारा विरासत में प्राप्त किया जाएगा।

स्थिति (या 0 निर्दिष्ट नहीं होने पर) को उम्मीद की निकास स्थिति के रूप में वापस कर दिया जाता है। स्क्रिप्ट का अंत तक पहुंचने पर बाहर निकलने पर पूरी तरह निष्पादित किया जाता है।

exp_continue [-continue_timer]
आदेश exp_continue सामान्य रूप से लौटने की बजाए निष्पादन जारी रखने की अपेक्षा करता है। डिफ़ॉल्ट रूप से exp_continue टाइमआउट टाइमर रीसेट करता है। Thecontinue_timer ध्वज टाइमर को पुनरारंभ होने से रोकता है। (अधिक जानकारी के लिए उम्मीद देखें।)

exp_internal [-f फ़ाइल] मान
मान कम शून्य होने पर stderr की अपेक्षा करने के लिए डायग्नोस्टिक जानकारी आंतरिक भेजने के लिए आगे के आदेशों का कारण बनता है। यह मान अक्षम है यदि मान 0 है। नैदानिक ​​जानकारी में प्राप्त प्रत्येक चरित्र, और पैटर्न के खिलाफ वर्तमान आउटपुट से मेल खाने के लिए किए गए हर प्रयास शामिल हैं।

यदि वैकल्पिक फ़ाइल की आपूर्ति की जाती है, तो सभी सामान्य और डिबगिंग आउटपुट उस फ़ाइल में लिखा जाता है (मान के मूल्य के बावजूद)। किसी भी पिछले नैदानिक ​​आउटपुट फ़ाइल बंद है।

-इन्फो झंडा दिए गए सबसे हालिया गैर-जानकारी तर्कों का वर्णन वापस करने के लिए exp_internal का कारण बनता है।

exp_open [args] [-i spawn_id]
एक टीसीएल फ़ाइल पहचानकर्ता देता है जो मूल स्पॉन आईडी से मेल खाता है। फ़ाइल पहचानकर्ता का उपयोग तब किया जा सकता है जैसे कि इसे टीसीएल के ओपन कमांड द्वारा खोला गया था। (स्पॉन आईडी का अब उपयोग नहीं किया जाना चाहिए। प्रतीक्षा को निष्पादित नहीं किया जाना चाहिए।

-लेवॉपेन ध्वज स्पॉन्नी आईडी को अपेक्षाकृत कमांड के माध्यम से एक्सेस के लिए छोड़ देता है। स्पॉन आईडी पर एक इंतजार निष्पादित किया जाना चाहिए।

exp_pid [-i spawn_id]
वर्तमान में तैयार प्रक्रिया से संबंधित प्रक्रिया आईडी लौटाता है। यदि -आई ध्वज का उपयोग किया जाता है, तो पिड वापस दिए गए स्पॉन आईडी के अनुरूप होता है।

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] संस्करण]
यह सुनिश्चित करने के लिए उपयोगी है कि स्क्रिप्ट अपेक्षा के वर्तमान संस्करण के साथ संगत है।

कोई तर्क नहीं के साथ, उम्मीद का वर्तमान संस्करण वापस कर दिया गया है। इस संस्करण को तब आपकी स्क्रिप्ट में एन्कोड किया जा सकता है। यदि आप वास्तव में जानते हैं कि आप हाल के संस्करणों की सुविधाओं का उपयोग नहीं कर रहे हैं, तो आप पहले के संस्करण को निर्दिष्ट कर सकते हैं।

संस्करणों में बिंदुओं से अलग तीन संख्याएं होती हैं। पहला प्रमुख नंबर है। एक अलग प्रमुख संख्या के साथ उम्मीद के संस्करणों के लिए लिखी लिपियों लगभग निश्चित रूप से काम नहीं करेगा। यदि बड़ी संख्या मेल नहीं खाती है तो exp_version एक त्रुटि देता है।

दूसरा मामूली संख्या है। वर्तमान संस्करण की तुलना में अधिक मामूली संख्या वाले संस्करण के लिए लिखी गई स्क्रिप्ट कुछ नई सुविधा पर निर्भर हो सकती है और शायद नहीं चल सकती है। यदि बड़ी संख्या मेल खाती है तो exp_version एक त्रुटि देता है, लेकिन स्क्रिप्ट मामूली संख्या चलती अपेक्षा से अधिक है।

तीसरा एक ऐसा नंबर है जो संस्करण तुलना में कोई भूमिका नहीं निभाता है। हालांकि, यह बढ़ता जा रहा है जब अपेक्षाकृत सॉफ्टवेयर वितरण किसी भी तरह से बदला जाता है, जैसे अतिरिक्त दस्तावेज या अनुकूलन। यह प्रत्येक नए मामूली संस्करण पर 0 पर रीसेट किया गया है।

-एक्सिट ध्वज के साथ, उम्मीद है कि संस्करण एक त्रुटि प्रिंट करता है और यदि संस्करण पुराना है तो बाहर निकलता है।

उम्मीद [[-opts] pat1 body1] ... [-opts] patn [bodyn]
तब तक इंतजार करता है जब तक पैटर्न में से कोई एक स्पॉन्डेड प्रक्रिया के आउटपुट से मेल नहीं खाता है, एक निश्चित समय अवधि बीत चुकी है, या एक अंत-फ़ाइल देखी जाती है। यदि अंतिम निकाय खाली है, तो इसे छोड़ा जा सकता है।

सबसे हालिया उम्मीदों के पैटर्न से पहले किसी भी अन्य पैटर्न से पहले कमांड का उपयोग किया जाता है। सबसे हालिया उम्मीद_पंथी कमांड के पैटर्न किसी अन्य पैटर्न के बाद पूरी तरह से उपयोग किए जाते हैं।

यदि पूरे उम्मीदवार के लिए तर्कों को एक से अधिक पंक्ति की आवश्यकता होती है, तो सभी तर्कों को एक में "ब्रेसिड" किया जा सकता है ताकि बैकस्लैश के साथ प्रत्येक पंक्ति को समाप्त करने से बचें। इस मामले में, ब्रेसिज़ के बावजूद सामान्य टीसीएल प्रतिस्थापन होंगे।

यदि कोई पैटर्न कीवर्ड eof है , तो इसी निकाय को फ़ाइल के अंत में निष्पादित किया जाता है। यदि कोई पैटर्न कीवर्ड टाइमआउट है , तो इसी निकाय को टाइमआउट पर निष्पादित किया जाता है। यदि कोई टाइमआउट कीवर्ड उपयोग नहीं किया जाता है, तो टाइमआउट पर एक अंतर्निहित शून्य कार्रवाई निष्पादित की जाती है। डिफ़ॉल्ट टाइमआउट अवधि 10 सेकंड है लेकिन सेट किया जा सकता है, उदाहरण के लिए 30, "सेट टाइमआउट 30" कमांड द्वारा। एक अनंत टाइमआउट मूल्य -1 द्वारा निर्दिष्ट किया जा सकता है। यदि कोई पैटर्न कीवर्ड डिफ़ॉल्ट है , तो संबंधित निकाय या तो टाइमआउट या अंत-फ़ाइल पर निष्पादित किया जाता है।

यदि कोई पैटर्न मेल खाता है, तो संबंधित निकाय निष्पादित किया जाता है। उम्मीद है कि शरीर के परिणाम (या खाली स्ट्रिंग अगर कोई पैटर्न मेल नहीं खाता है)। यदि कई पैटर्न मिलते हैं, तो पहले दिखाई देने वाला एक शरीर का चयन करने के लिए उपयोग किया जाता है।

हर बार नया आउटपुट आता है, इसकी तुलना प्रत्येक क्रम में सूचीबद्ध क्रम में की जाती है। इस प्रकार, आप अंतिम पैटर्न को प्रकट होने की गारंटी देने वाले कुछ पैटर्न बनाकर एक मैच की अनुपस्थिति का परीक्षण कर सकते हैं, जैसे कि प्रॉम्प्ट। ऐसी स्थितियों में जहां कोई संकेत नहीं है, आपको टाइमआउट का उपयोग करना होगा (जैसे आप चाहते हैं कि आप मैन्युअल रूप से बातचीत कर रहे हों)।

पैटर्न तीन तरीकों से निर्दिष्ट हैं। डिफ़ॉल्ट रूप से, पैटर्न को Tcl के स्ट्रिंग मिलान कमांड के साथ निर्दिष्ट किया जाता है। (ऐसे पैटर्न सी-शैल नियमित अभिव्यक्तियों के समान होते हैं जिन्हें आमतौर पर "ग्लोब" पैटर्न के रूप में जाना जाता है)। -gl ध्वज का उपयोग उन पैटर्नों की सुरक्षा के लिए किया जा सकता है जो अन्यथा ऐसा करने से झंडे की उम्मीद कर सकते हैं। "-" से शुरू होने वाले किसी भी पैटर्न को इस तरह से संरक्षित किया जाना चाहिए। ("-" के साथ शुरू होने वाले सभी तार भविष्य के विकल्पों के लिए आरक्षित हैं।)

उदाहरण के लिए, निम्न खंड एक सफल लॉगिन की तलाश में है। (ध्यान दें कि abort को स्क्रिप्ट में कहीं और परिभाषित प्रक्रिया माना जाता है।)

उम्मीद करें {व्यस्त {व्यस्त रहता है \ n; exp_continue} निरस्त "अमान्य पासवर्ड" निरस्त करने में विफल रहा टाइमआउट निरस्त}

चौथे पैटर्न पर उद्धरण आवश्यक हैं क्योंकि इसमें एक स्थान है, जो अन्यथा कार्रवाई से पैटर्न को अलग करेगा। एक ही क्रिया के साथ पैटर्न (जैसे कि तीसरे और चौथे) को क्रियाओं को फिर से सूचीबद्ध करने की आवश्यकता होती है। यह regexp-style पैटर्न (नीचे देखें) का उपयोग करके टाला जा सकता है। ग्लोब-स्टाइल पैटर्न बनाने के बारे में अधिक जानकारी टीसीएल मैनुअल में मिल सकती है।

Regexp- शैली पैटर्न Tcl के regexp ("नियमित अभिव्यक्ति" के लिए संक्षिप्त) द्वारा परिभाषित वाक्यविन्यास का पालन करें। regexp पैटर्न ध्वज के साथ पेश किए जाते हैं। पिछले उदाहरण को regexp का उपयोग करके पुनः लिखा जा सकता है:

उम्मीद करें {व्यस्त {व्यस्त रहता है \ n; exp_continue} -re "असफल | अमान्य पासवर्ड" abort timeout abort जुड़े}

दोनों प्रकार के पैटर्न "अनचाहे" हैं। इसका मतलब है कि पैटर्न को पूरी स्ट्रिंग से मेल नहीं करना पड़ेगा, लेकिन स्ट्रिंग में कहीं भी मैच शुरू और समाप्त कर सकता है (जब तक कि बाकी सब कुछ मेल खाता हो)। स्ट्रिंग की शुरुआत से मिलान करने के लिए ^ और अंत से मिलान करने के लिए $ का उपयोग करें। ध्यान दें कि यदि आप स्ट्रिंग के अंत की प्रतीक्षा नहीं करते हैं, तो आपकी प्रतिक्रिया आसानी से स्ट्रिंग के बीच में समाप्त हो सकती है क्योंकि वे स्पॉन्डेड प्रक्रिया से प्रतिबिंबित होते हैं। अभी भी सही परिणाम पैदा करते समय, उत्पादन अप्राकृतिक दिख सकता है। इस प्रकार, यदि आप स्ट्रिंग के अंत में वर्णों का बिल्कुल वर्णन कर सकते हैं तो $ का उपयोग प्रोत्साहित किया जाता है।

ध्यान दें कि कई संपादकों में, ^ और $ क्रमशः लाइनों की शुरुआत और अंत से मेल खाते हैं। हालांकि, क्योंकि उम्मीद रेखा उन्मुख नहीं है, इसलिए ये वर्ण वर्तमान में मिलान बफर की अपेक्षा में डेटा की शुरुआत और अंत (लाइनों के विपरीत) से मेल खाते हैं। (इसके अलावा, "सिस्टम अपचन" पर नीचे दिए गए नोट को देखें।)

-एक्स ध्वज पैटर्न को "सटीक" स्ट्रिंग के रूप में मिलान करने का कारण बनता है। *, ^, आदि की कोई व्याख्या नहीं की गई है (हालांकि सामान्य टीसीएल सम्मेलन अभी भी मनाया जाना चाहिए)। सटीक पैटर्न हमेशा अनचाहे होते हैं।

-नोकेज ध्वज आउटपुट के अपरकेस अक्षरों को तुलना करने के लिए कारण बनाता है जैसे कि वे लोअरकेस वर्ण थे। पैटर्न प्रभावित नहीं है।

आउटपुट पढ़ने के दौरान, 2000 से अधिक बाइट्स पहले बाइट को "भूल गए" के लिए मजबूर कर सकते हैं। यह फ़ंक्शन match_max के साथ बदला जा सकता है। (ध्यान दें कि अत्यधिक बड़े मान पैटर्न मैचर को धीमा कर सकते हैं।) यदि पेटलिस्ट पूर्ण_बफर है , तो संबंधित निकाय निष्पादित किया जाता है यदि match_max बाइट प्राप्त हुए हैं और कोई अन्य पैटर्न मेल नहीं खाता है। पूर्ण_बफर कीवर्ड का उपयोग किया गया है या नहीं, भूल गए वर्ण उम्मीद_आउट (बफर) पर लिखे गए हैं।

यदि पेटलिस्ट कीवर्ड नल है , और नल की अनुमति है ( remove_nulls कमांड के माध्यम से), तो एक ही ASCII 0 मिलान होने पर संबंधित निकाय निष्पादित किया जाता है। ग्लोब या regexp पैटर्न के माध्यम से 0 बाइट्स मिलान करना संभव नहीं है।

एक पैटर्न (या eof या full_buffer) से मेल खाने पर, किसी मिलान और पहले बेजोड़ आउटपुट को variable expect_out (बफर) में सहेजा जाता है। 9 regexp सबस्ट्रिंग मैचों को guarant_out (9, स्ट्रिंग) के माध्यम से variable_out ( 1, स्ट्रिंग) चर में सहेजा जाता है। यदि किसी पैटर्न से पहले -इंडिस ध्वज का उपयोग किया जाता है, तो 10 तारों के प्रारंभिक और समापन सूचकांक ( लेंज के लिए उपयुक्त रूप में) चर के रूप में अपेक्षित होते हैं उम्मीद_आउट (एक्स, प्रारंभ) और उम्मीद_आउट (एक्स, अंत) जहां एक्स एक है अंक, बफर में सबस्ट्रिंग स्थिति से मेल खाता है। 0 स्ट्रिंग्स को संदर्भित करता है जो पूरे पैटर्न से मेल खाते हैं और ग्लोब पैटर्न के साथ-साथ regexp पैटर्न के लिए जेनरेट किए जाते हैं। उदाहरण के लिए, यदि किसी प्रक्रिया ने "abcdefgh \ n" के आउटपुट का उत्पादन किया है, तो इसका परिणाम:

"सीडी" की उम्मीद

ऐसा लगता है कि निम्नलिखित कथन निष्पादित किए गए थे:

expect_out (0, स्ट्रिंग) सेट करें cd set_out (buffer) abcd सेट करें

और आउटपुट बफर में "efgh \ n" छोड़ा गया है। अगर किसी प्रक्रिया ने "abbbcabkkkka \ n" आउटपुट का उत्पादन किया, तो इसका नतीजा:

उम्मीद -indices -re "बी (बी *)। * (के +)"

ऐसा लगता है कि निम्नलिखित कथन निष्पादित किए गए थे:

set_out (0, start) सेट करें 1 set hope_out (0, end) 10 सेट expect_out (0, string) bbbcabkkkk set_out (1, start) सेट करें उम्मीद करें सेट_आउट (1, अंत) 3 सेट expect_out (1, स्ट्रिंग) bb set_out सेट करें (2, शुरू करें) 10 सेट उम्मीद_आउट (2, अंत) 10 सेट उम्मीद_आउट (2, स्ट्रिंग) के सेट expect_out (बफर) abbbcabkkkk

और आउटपुट बफर में "एक \ n" छोड़ा गया है। पैटर्न "*" (और -re "। *") प्रक्रिया से किसी और आउटपुट को पढ़ने के बिना आउटपुट बफर को फ्लश करेगा।

आम तौर पर, मिलान आउटपुट अपेक्षाकृत आंतरिक बफर से त्याग दिया जाता है। यह -notransfer ध्वज के साथ एक पैटर्न prefixing से रोका जा सकता है। यह ध्वज प्रयोग में विशेष रूप से उपयोगी है (और प्रयोग के दौरान सुविधा के लिए "-not" के लिए संक्षिप्त नहीं किया जा सकता है)।

मिलान आउटपुट (या eof या full_buffer) से जुड़े स्पॉन आईडी को उम्मीद_आउट (spawn_id) में संग्रहीत किया जाता है।

टाइमटाइम फ्लैग वर्तमान उम्मीद कमांड को टाइमआउट चर के मान का उपयोग करने के बजाय टाइमआउट के रूप में निम्न मान का उपयोग करने का कारण बनता है।

डिफ़ॉल्ट रूप से, पैटर्न को वर्तमान प्रक्रिया से आउटपुट के विरुद्ध मिलान किया जाता है, हालांकि -i ध्वज नामित spawn_id सूची से आउटपुट को किसी भी निम्नलिखित पैटर्न (अगली -i तक ) के मिलान से घोषित करता है। Spawn_id सूची या तो spawn_ids की एक सफेद जगह अलग सूची होनी चाहिए या spawn_ids की ऐसी सूची का संदर्भ देने वाला एक चर होना चाहिए।

उदाहरण के लिए, निम्न उदाहरण वर्तमान प्रक्रिया से "कनेक्टेड", या "व्यस्त", "विफल" या "अवैध पासवर्ड" के लिए इंतजार कर रहा है spawn_id $ proc2 द्वारा नामित।

उम्मीद करें {-i $ proc2 व्यस्त {व्यस्त रहता है \ n; exp_continue} -re "असफल | अमान्य पासवर्ड" abort timeout abort जुड़े}

ग्लोबल वैरिएबल का मान any_spawn_id का उपयोग किसी भी spawn_ids को पैटर्न से मिलान करने के लिए किया जा सकता है, जो मौजूदा उम्मीद कमांड में अन्य सभी -i झंडे के साथ नामित हैं। किसी भी संबंधित पैटर्न के साथ -i ध्वज से spawn_id (यानी, किसी अन्य द्वारा तुरंत पीछा किया जाता है) किसी भी अन्य पैटर्न के लिए किसी भी अन्य पैटर्न के लिए उपलब्ध कराया जाता है जो किसी भी_spawn_id से जुड़ा होता है।

-i ध्वज वैश्विक वैरिएबल का नाम भी दे सकता है, जिस स्थिति में चर को स्पॉन आईडी की सूची के लिए पढ़ा जाता है। जब भी यह बदलता है वैरिएबल फिर से पढ़ा जाता है। कमांड निष्पादन में होने पर यह I / O स्रोत को बदलने का एक तरीका प्रदान करता है। इस तरह प्रदान किए गए स्पॉन आईडी को "अप्रत्यक्ष" स्पॉन आईडी कहा जाता है।

सामान्य तरीके से व्यवहार करने के लिए ब्रेक और जारी नियंत्रण नियंत्रण संरचनाओं (यानी, proc , proc ) जैसी क्रियाएं। आदेश exp_continue सामान्य रूप से लौटने की बजाए निष्पादन जारी रखने की अपेक्षा करता है।

यह स्पष्ट लूप से बचने या बार-बार अपेक्षित बयानों से बचने के लिए उपयोगी है। निम्नलिखित उदाहरण rlogin स्वचालित करने के लिए एक टुकड़े का हिस्सा है। यदि rlogin पासवर्ड के लिए संकेत देता है तो exp_continue एक दूसरी उम्मीद कथन (फिर से प्रॉम्प्ट की तलाश करने के लिए) लिखने से बचाता है।

$ होस्ट पर {पासवर्ड: {stty -echo send_user "पासवर्ड ($ उपयोगकर्ता के लिए) की अपेक्षा करें:" hope_user -re "(। *) \ n" send_user "\ n" भेजें "$ hope_out (1, स्ट्रिंग) \ r" stty echo exp_continue} ग़लत {send_user "अमान्य पासवर्ड या खाता \ n" निकास} टाइमआउट {send_user "$ होस्ट के लिए कनेक्शन का समय समाप्त हो गया \ n" exit} eof {send_user \ "होस्ट करने के लिए कनेक्शन विफल: $ hope_out (buffer)" exit} - पुनः $ प्रॉम्प्ट}

उदाहरण के लिए, निम्न खंड किसी उपयोगकर्ता को एक ऐसी बातचीत को मार्गदर्शन करने में सहायता कर सकता है जो पहले से ही पूरी तरह से स्वचालित है। इस मामले में, टर्मिनल कच्चे मोड में डाल दिया जाता है। यदि उपयोगकर्ता "+" दबाता है, तो एक चर बढ़ाया जाता है। यदि "पी" दबाया जाता है, तो प्रक्रिया में कई रिटर्न भेजे जाते हैं, शायद इसे किसी भी तरह से दबाएंगे, और "मैं" उपयोगकर्ता को इस प्रक्रिया के साथ बातचीत करने देता है, जो प्रभावी रूप से स्क्रिप्ट से नियंत्रण को दूर कर देता है। प्रत्येक मामले में, exp_continue वर्तमान कार्रवाई को निष्पादित करने के बाद वर्तमान मिलान पैटर्न को जारी रखने की अनुमति देता है।

stty raw -echo hope_after {-i $ user_spawn_id "p" {भेजें "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {इंटरैक्ट; exp_continue} "बाहर निकलें" बाहर निकलें}

डिफ़ॉल्ट रूप से, exp_continue टाइमआउट टाइमर रीसेट करता है। टाइमर को पुनरारंभ नहीं किया जाता है, अगर exp_continue को -continue_timer ध्वज के साथ बुलाया जाता है।

उम्मीद_after [expect_args]
अपेक्षित रूप से अपेक्षाओं के लिए काम करता है इससे पहले कि अगर दोनों अपेक्षाओं और उम्मीदों के पैटर्न से मेल खा सकते हैं, तो उम्मीद पैटर्न का उपयोग किया जाता है। अधिक जानकारी के लिए उम्मीद_before आदेश देखें।

उम्मीद_बैकग्राउंड [उम्मीद_र्ग]
उम्मीद के अनुसार एक ही तर्क लेता है , हालांकि यह तुरंत लौटता है। नए इनपुट आने पर पैटर्न का परीक्षण किया जाता है। पैटर्न टाइमआउट और डिफ़ॉल्ट अपेक्षित_बैकग्राउंड के लिए अर्थहीन हैं और चुपचाप त्याग दिए जाते हैं। अन्यथा, उम्मीद_बैकग्राउंड कमांड अपेक्षित अपेक्षाओं की अपेक्षा करता है और उम्मीद करता है।

जब अपेक्षित_बैकग्राउंड कार्रवाइयों का मूल्यांकन किया जा रहा है, तो उसी स्पॉन आईडी के लिए पृष्ठभूमि प्रोसेसिंग अवरुद्ध है। कार्रवाई पूर्ण होने पर पृष्ठभूमि प्रसंस्करण को अनब्लॉक किया जाता है। जबकि पृष्ठभूमि प्रसंस्करण अवरुद्ध है, वही स्पॉन आईडी पर एक (अग्रभूमि) अपेक्षा करना संभव है।

अपेक्षित निष्पादित करना संभव नहीं है जबकि अपेक्षित_बैकग्राउंड अनब्लॉक किया गया हो। एक विशेष स्पॉन आईडी के लिए उम्मीद_बैकग्राउंड एक ही स्पॉन आईडी के साथ एक नया उम्मीद_बैकग्राउंड घोषित करके हटा दिया जाता है। किसी भी पैटर्न के साथ expect_background घोषित करने से पृष्ठभूमि में पैटर्न मिलान करने की क्षमता से दिए गए स्पॉन आईडी को हटा दिया जाता है।

उम्मीद करें [पहले_args]
उम्मीद के अनुसार एक ही तर्क लेता है , हालांकि यह तुरंत लौटता है। सबसे हालिया उम्मीद से पैटर्न-एक्शन जोड़े- एक ही स्पॉन आईडी के साथ किसी भी निम्नलिखित उम्मीदों के आदेश में अंतर्निहित रूप से जोड़ा जाता है। यदि कोई पैटर्न मेल खाता है, तो ऐसा माना जाता है कि इसे उम्मीद कमांड में निर्दिष्ट किया गया था, और संबंधित निकाय को उम्मीद कमांड के संदर्भ में निष्पादित किया गया है। यदि दोनों अपेक्षाओं से पैटर्न और अपेक्षा से मिलान कर सकते हैं, तो उम्मीद है कि पैटर्न का उपयोग किया जाता है।

यदि कोई पैटर्न निर्दिष्ट नहीं है, तो स्पॉन आईडी किसी भी पैटर्न के लिए जांच नहीं की जाती है।

जब तक ए - फ्लैग द्वारा ओवरराइड नहीं किया जाता है, तो उम्मीद है कि पैटर्न उस स्पॉन्नी आईडी के खिलाफ मेल खाता है जब उस समय परिभाषित किया गया था जब अपेक्षित कमांड निष्पादित किया गया था (जब उसका पैटर्न मिलान नहीं होता है)।

-इन्फो फ्लैग उम्मीद करता है कि मौजूदा पैटर्न को वापस करने के लिए यह किस पैटर्न से मेल खाएगा। डिफ़ॉल्ट रूप से, यह वर्तमान स्पॉन आईडी पर रिपोर्ट करता है। उस स्पॉन आईडी पर जानकारी के लिए एक वैकल्पिक स्पॉन आईडी विनिर्देश दिया जा सकता है। उदाहरण के लिए

उम्मीद_before -info -i $ proc

सबसे अधिक स्पॉन आईडी विनिर्देश दिया जा सकता है। फ्लैग -इंड्रैक्ट प्रत्यक्ष स्पॉन आईडी को दबाता है जो केवल अप्रत्यक्ष विनिर्देशों से आता है।

स्पॉन आईडी विनिर्देश के बजाए, ध्वज "-all" सभी स्पॉन आईडी पर रिपोर्ट करने के लिए "-इन्फो" का कारण बन जाएगा।

-इन्फो ध्वज के आउटपुट को उम्मीद से पहले तर्क के रूप में पुन: उपयोग किया जा सकता है।

उम्मीद_गी [उम्मीद_र्ग]
उम्मीद की तरह है लेकिन यह / dev / tty (यानी उपयोगकर्ता से कीस्ट्रोक) से वर्ण पढ़ता है। डिफ़ॉल्ट रूप से, पकाया मोड में पढ़ा जाता है। इस प्रकार, उन्हें देखने की उम्मीद के लिए लाइनों को वापसी के साथ समाप्त होना चाहिए। इसे stty के माध्यम से बदला जा सकता है (नीचे stty कमांड देखें)।

उम्मीद_user [expect_args]
उम्मीद की तरह है लेकिन यह stdin (यानी उपयोगकर्ता से कीस्ट्रोक) से अक्षर पढ़ता है। डिफ़ॉल्ट रूप से, पकाया मोड में पढ़ा जाता है। इस प्रकार, उन्हें देखने की उम्मीद के लिए लाइनों को वापसी के साथ समाप्त होना चाहिए। इसे stty के माध्यम से बदला जा सकता है (नीचे stty कमांड देखें)।

कांटा
एक नई प्रक्रिया बनाता है। नई प्रक्रिया वर्तमान अपेक्षा प्रक्रिया की एक सटीक प्रति है । सफलता पर, फोर्क नई (बच्चे) प्रक्रिया में 0 लौटाता है और बच्चे की प्रक्रिया की प्रक्रिया प्रक्रिया को मूल प्रक्रिया में देता है । विफलता पर (अनिवार्य रूप से संसाधनों की कमी के कारण, उदाहरण के लिए, स्वैप स्पेस, मेमोरी), फोर्क रिटर्न -1 मूल प्रक्रिया में , और कोई भी बाल प्रक्रिया नहीं बनाई जाती है।

फोर्क की गई प्रक्रिया मूल प्रक्रिया की तरह बाहर निकलने के आदेश से बाहर निकलें । फोर्क की गई प्रक्रियाओं को लॉग फ़ाइलों को लिखने की अनुमति है। यदि आप अधिकांश प्रक्रियाओं में डिबगिंग या लॉगिंग अक्षम नहीं करते हैं, तो परिणाम भ्रमित हो सकता है।

कुछ पीटीआई कार्यान्वयन कई पाठकों और लेखकों द्वारा भी क्षणिक रूप से भ्रमित हो सकते हैं। इस प्रकार, यह प्रक्रियाओं से पहले फोर्क करने के लिए सबसे सुरक्षित है।

बातचीत [स्ट्रिंग 1 body1] ... [स्ट्रिंग [बॉडीन]]
उपयोगकर्ता को वर्तमान प्रक्रिया का नियंत्रण देता है, ताकि कीस्ट्रोक वर्तमान प्रक्रिया में भेजे जाएंगे, और वर्तमान प्रक्रिया के stdout और stderr वापस कर दिए जाते हैं।

स्ट्रिंग-बॉडी जोड़े को तर्क के रूप में निर्दिष्ट किया जा सकता है, इस स्थिति में जब संबंधित स्ट्रिंग दर्ज की जाती है तो शरीर को निष्पादित किया जाता है। (डिफ़ॉल्ट रूप से, स्ट्रिंग को वर्तमान प्रक्रिया में नहीं भेजा जाता है ।) अंतिम निकाय गायब होने पर दुभाषिया आदेश माना जाता है।

यदि पूरे इंटरैक्ट स्टेटमेंट के तर्कों को एक से अधिक पंक्ति की आवश्यकता होती है, तो सभी तर्कों को एक में "ब्रेसिड" किया जा सकता है ताकि बैकस्लैश के साथ प्रत्येक पंक्ति को समाप्त करने से बचें। इस मामले में, ब्रेसिज़ के बावजूद सामान्य टीसीएल प्रतिस्थापन होंगे।

उदाहरण के लिए, निम्न आदेश निम्न स्ट्रिंग-बॉडी जोड़े के साथ इंटरैक्ट करता है परिभाषित करता है: जब ^ ज़ेड दबाया जाता है, तो अपेक्षा निलंबित कर दी जाती है। ( Thereset ध्वज टर्मिनल मोड को पुनर्स्थापित करता है।) जब ^ ए दबाया जाता है, तो उपयोगकर्ता "आपके द्वारा नियंत्रण-ए टाइप किया गया" देखता है और प्रक्रिया को ^ ए भेजा जाता है। जब $ दबाया जाता है, तो उपयोगकर्ता तारीख को देखता है। जब ^ सी दबाया जाता है, तो बाहर निकलें। यदि "foo" दर्ज किया गया है, तो उपयोगकर्ता "बार" देखता है। जब ~~ दबाया जाता है, तो अपेक्षित दुभाषिया अंतःक्रियात्मक रूप से चलता है।

CTRLZ \ 032 इंटरैक्ट {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "सेट करें जिसे आपने एक नियंत्रण-ए \ n" टाइप किया है; "\ 001"} $ {send_user "भेजें दिनांक [घड़ी प्रारूप [घड़ी सेकंड]] है।"} \ 003 निकास foo {send_user "bar"} ~~}

स्ट्रिंग-बॉडी जोड़े में, तारों को तर्क के रूप में सूचीबद्ध क्रम में मिलान किया जाता है। स्ट्रिंग्स जो आंशिक रूप से मेल खाते हैं, शेष आने की प्रत्याशा में वर्तमान प्रक्रिया में नहीं भेजी जाती हैं। यदि पात्रों को तब दर्ज किया जाता है कि संभवतः कोई मिलान नहीं हो सकता है, तो केवल स्ट्रिंग का हिस्सा उस प्रक्रिया में भेजा जाएगा जो संभवतः एक और मैच शुरू नहीं कर सकता है। इस प्रकार, स्ट्रिंग्स जो आंशिक मैचों की सबस्ट्रिंग्स बाद में मिल सकती हैं, अगर मूल तार जो मैच होने का प्रयास कर रहे थे तो अंततः विफल हो जाते हैं।

डिफ़ॉल्ट रूप से, स्ट्रिंग मिलान कोई जंगली कार्ड के साथ सटीक है। (इसके विपरीत, उम्मीद कमांड डिफ़ॉल्ट रूप से ग्लोब-स्टाइल पैटर्न का उपयोग करता है।) -एक्स ध्वज पैटर्न का संरक्षण करने के लिए उपयोग किया जा सकता है जो अन्यथा ऐसा करने से इंटरैक्ट फ्लैग से मेल खाता है। "-" से शुरू होने वाले किसी भी पैटर्न को इस तरह से संरक्षित किया जाना चाहिए। ("-" के साथ शुरू होने वाले सभी तार भविष्य के विकल्पों के लिए आरक्षित हैं।)

-रे झंडा स्ट्रिंग को रेगेक्सपी-स्टाइल पैटर्न के रूप में व्याख्या करने के लिए मजबूर करता है। इस मामले में, मिलान करने वाले सबस्ट्रिंग्स वैरिएबल इंटरैक्ट_आउट में संग्रहीत होते हैं, वैसे ही वैरिएबल उम्मीद_आउट में इसके आउटपुट को स्टोर करने की अपेक्षा करते हैं । -इंडिस ध्वज समान रूप से समर्थित है।

पैटर्न eof एक क्रिया को प्रस्तुत करता है जिसे फ़ाइल के अंत में निष्पादित किया जाता है। आउटपुट लिखते समय एक ईओएफ पता चला है, तो एक अलग eof पैटर्न भी आउटपुट फ्लैग का पालन कर सकता है। डिफ़ॉल्ट ईओफ़ कार्रवाई "वापसी" है, ताकि बातचीत किसी भी ईओएफ पर आसानी से लौट सके।

पैटर्न टाइमआउट एक टाइमआउट (सेकेंड में) और उस क्रिया को प्रस्तुत करता है जिसे किसी दिए गए समय के लिए कोई वर्ण नहीं पढ़ा जाता है। टाइमआउट पैटर्न सबसे हाल ही में निर्दिष्ट प्रक्रिया पर लागू होता है। कोई डिफ़ॉल्ट टाइमआउट नहीं है। विशेष चर "टाइमआउट" ( उम्मीद कमांड द्वारा उपयोग किया जाता है) इस टाइमआउट पर कोई प्रभाव नहीं पड़ता है।

उदाहरण के लिए, निम्नलिखित कथन का उपयोग उन उपयोगकर्ताओं को ऑटोलॉग करने के लिए किया जा सकता है जिन्होंने एक घंटे के लिए कुछ भी टाइप नहीं किया है, लेकिन जो अभी भी सिस्टम सिस्टम प्राप्त करते हैं:

इंटरैक्ट-इनपुट $ user_spawn_id टाइमआउट 3600 रिटर्न-आउटपुट \ $ spawn_id

यदि पैटर्न कीवर्ड शून्य है , और नल की अनुमति है ( remove_nulls कमांड के माध्यम से), यदि एक ASCII 0 मिलान किया जाता है तो संबंधित निकाय निष्पादित किया जाता है। ग्लोब या regexp पैटर्न के माध्यम से 0 बाइट्स मिलान करना संभव नहीं है।

फ्लैग -इराइट के साथ एक पैटर्न को पूर्ववत करने से वैरिएबल इंटरैक्ट_आउट (spawn_id) को spawn_id पर सेट किया जा सकता है जो पैटर्न (या eof) से मेल खाता है।

सामान्य तरीके से व्यवहार करने के लिए ब्रेक और जारी नियंत्रण नियंत्रण संरचनाओं (यानी, proc , proc ) जैसी क्रियाएं। हालांकि रिटर्न अपने कॉलर पर वापस आने के लिए बातचीत का कारण बनता है, जबकि inter_return अपने कॉलर में वापसी का कारण बनता है। उदाहरण के लिए, यदि "proc foo" इंटरैक्ट कहलाता है जिसे फिर कार्रवाई inter_return निष्पादित किया जाता है , proc foo वापस आ जाएगा। (इसका मतलब यह है कि यदि इंटरैक्ट कॉल दुभाषिया इंटरैक्टिव रूप से रिटर्न टाइपिंग को इंटरैक्ट जारी रखने का कारण बनता है , जबकि inter_return इंटरैक्ट को अपने कॉलर पर वापस आने का कारण बनता है।)

बातचीत के दौरान, कच्चे मोड का उपयोग किया जाता है ताकि सभी पात्रों को वर्तमान प्रक्रिया में पारित किया जा सके । यदि वर्तमान प्रक्रिया में जॉब कंट्रोल सिग्नल नहीं मिलते हैं, तो स्टॉप सिग्नल भेजे जाने पर यह रुक जाएगा (डिफ़ॉल्ट रूप से ^ जेड)। इसे पुनरारंभ करने के लिए, एक जारी सिग्नल भेजें (जैसे कि "kill -CONT")। यदि आप वास्तव में ऐसी प्रक्रिया (^ Z द्वारा) के लिए सिगस्टॉप भेजना चाहते हैं, तो पहले प्रोग्रामिंग सीएस पर विचार करें और फिर अपना प्रोग्राम चलाएं। दूसरी तरफ, यदि आप खुद को उम्मीद करने के लिए एक सिगस्टॉप भेजना चाहते हैं, तो पहले दुभाषिया (शायद एक बचने वाले चरित्र का उपयोग करके) कॉल करें, और फिर ^ Z दबाएं।

स्ट्रिंग-बॉडी जोड़े को दुभाषिया में प्रवेश करने से बचने के लिए एक शॉर्टेंड के रूप में उपयोग किया जा सकता है और आदेशों को अंतःक्रियात्मक रूप से निष्पादित किया जा सकता है। पिछले टर्मिनल मोड का उपयोग किया जाता है जबकि स्ट्रिंग-बॉडी जोड़ी का शरीर निष्पादित किया जा रहा है।

गति के लिए, डिफ़ॉल्ट रूप से कच्चे मोड में क्रियाएं निष्पादित होती हैं। -सेटसेट ध्वज टर्मिनल को उस मोड में रीसेट करता है जो इंटरैक्ट निष्पादित होने से पहले था (हमेशा, पकाया मोड)। ध्यान दें कि जब मोड स्विच किया जा रहा है तो अक्षर खोले जा सकते हैं (कुछ सिस्टम पर टर्मिनल ड्राइवर की दुर्भाग्यपूर्ण सुविधा)। -सेट का उपयोग करने का एकमात्र कारण यह है कि यदि आपकी क्रिया पके हुए मोड में चलने पर निर्भर करती है।

-चो फ्लैग उन वर्णों को भेजता है जो निम्न पैटर्न को उस प्रक्रिया से मेल खाते हैं जो उन्हें उत्पन्न करता है क्योंकि प्रत्येक वर्ण पढ़ा जाता है। यह उपयोगी हो सकता है जब उपयोगकर्ता को आंशिक रूप से टाइप किए गए पैटर्न से प्रतिक्रिया देखने की आवश्यकता होती है।

यदि एक पैटर्न प्रतिबिंबित किया जा रहा है लेकिन अंत में मिलान करने में विफल रहता है, तो पात्रों को तैयार प्रक्रिया में भेजा जाता है । यदि पैदा हुई प्रक्रिया तब उन्हें छीन लेती है, तो उपयोगकर्ता दो बार वर्ण देखेंगे। -एचो शायद उन परिस्थितियों में उपयुक्त है जहां उपयोगकर्ता पैटर्न को पूरा नहीं करने की संभावना नहीं है। उदाहरण के लिए, निम्न अंश आरएफटीपी, रिकर्सिव-एफटीपी स्क्रिप्ट से है, जहां उपयोगकर्ता को ~ g, ~ p, या ~ l दर्ज करने के लिए कहा जाता है, ताकि वर्तमान निर्देशिका को पुनः प्राप्त करने, डालने या सूचीबद्ध करने के लिए कहा जा सके। ये सामान्य ftp कमांड से बहुत दूर हैं, कि उपयोगकर्ता को किसी और चीज के बाद ~ टाइप करने की संभावना नहीं है, गलती से, इस मामले में, वे संभवतः परिणाम को अनदेखा कर देंगे।

बातचीत {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}

-नोबफर फ्लैग उन वर्णों को भेजता है जो आउटपुट प्रक्रिया पर निम्न पैटर्न से मेल खाते हैं क्योंकि वर्ण पढ़े जाते हैं।

यह तब उपयोगी होता है जब आप प्रोग्राम को पैटर्न को दोबारा गूंजने देना चाहते हैं। उदाहरण के लिए, निम्न व्यक्ति का उपयोग यह पता लगाने के लिए किया जा सकता है कि कोई व्यक्ति डायलिंग कर रहा है (हेस-स्टाइल मॉडेम)। प्रत्येक बार "एटीडी" देखा जाता है कि स्क्रिप्ट बाकी रेखा को लॉग करता है।

proc lognumber {} {interact -nobuffer -re "(। *) \ r" वापसी $ लॉग डालती है "[घड़ी प्रारूप [घड़ी सेकंड]]: $ interact_out (1, स्ट्रिंग) डायल किया गया"} इंटरैक्ट-नोबफर "एटीडी" लॉगनंबर

बातचीत के दौरान, log_user के पिछले उपयोग को अनदेखा किया जाता है। विशेष रूप से, इंटरैक्ट अपने आउटपुट को लॉग इन करने के लिए मजबूर करेगा (मानक आउटपुट पर भेजा गया है) क्योंकि यह माना जाता है कि उपयोगकर्ता अंधेरे से बातचीत नहीं करना चाहता है।

-ओ ध्वज किसी भी कुंजी-बॉडी जोड़े को वर्तमान प्रक्रिया के आउटपुट पर लागू करने का कारण बनता है । यह उपयोगी हो सकता है, उदाहरण के लिए, मेजबानों से निपटने के दौरान जो टेलनेट सत्र के दौरान अवांछित वर्ण भेजते हैं।

डिफ़ॉल्ट रूप से, बातचीत से उम्मीद है कि उपयोगकर्ता stdin लिख रहा है और उम्मीद प्रक्रिया के stdout पढ़ रहा है। -उ फ्लैग ("उपयोगकर्ता" के लिए) उपयोगकर्ता को इसके तर्क द्वारा नामित प्रक्रिया के रूप में इंटरैक्ट लुक बनाता है (जो एक स्पॉन्डेड आईडी होना चाहिए)।

यह स्पष्ट लूप का उपयोग किए बिना दो असंबंधित प्रक्रियाओं को एक साथ जुड़ने की अनुमति देता है। डिबगिंग में सहायता के लिए, डायग्नोस्टिक्स की अपेक्षा हमेशा stderr (या कुछ लॉगिंग और डीबगिंग जानकारी के लिए stdout) पर जाएं। इसी कारण से, दुभाषिया आदेश stdin से interactively पढ़ा जाएगा।

उदाहरण के लिए, निम्न खंड एक लॉगिन प्रक्रिया बनाता है। फिर यह उपयोगकर्ता को डायल करता है (दिखाया नहीं गया), और अंत में दोनों को एक साथ जोड़ता है। बेशक, लॉगिन के लिए किसी भी प्रक्रिया को प्रतिस्थापित किया जा सकता है। एक खोल, उदाहरण के लिए, उपयोगकर्ता को खाता और पासवर्ड की आपूर्ति किए बिना काम करने की अनुमति देगा।

spawn लॉगिन सेट लॉगिन $ spawn_id spawn tip modem # उपयोगकर्ता को वापस डायल करें # उपयोगकर्ता को इंटरैक्ट -यू $ लॉगिन लॉगिन करने के लिए कनेक्ट करें

एकाधिक प्रक्रियाओं में आउटपुट भेजने के लिए, प्रत्येक स्पॉन आईडी सूची को एक आउटपुट ध्वज से पहले सूचीबद्ध करें। आउटपुट स्पॉन आईडी के समूह के लिए इनपुट एक स्पिन आईडी सूची द्वारा निर्धारित किया जा सकता है जो एक- इनपुट ध्वज से पहले होता है। (दोनों इनपुट और आउटपुट एक ही रूप में सूचियां ले सकते हैं जैसे -i ध्वज अपेक्षित कमांड में, सिवाय इसके कि किसी भी_स्पॉन्विन_आईडी इंटरैक्ट में सार्थक नहीं है।) निम्नलिखित सभी झंडे और तार (या पैटर्न) इस इनपुट पर किसी अन्य तक लागू होते हैं - इनपुट ध्वज प्रकट होता है। यदि कोई इनपुट दिखाई नहीं देता है, तो आउटपुट का अर्थ है "-इनपुट $ user_spawn_id -output"। (इसी तरह, पैटर्न के साथ जिनके पास इनपुट नहीं है।) यदि एक- इनपुट निर्दिष्ट है, तो यह $ user_spawn_id को ओवरराइड करता है। यदि दूसरा- इनपुट निर्दिष्ट है, तो यह $ spawn_id को ओवरराइड करता है। अतिरिक्त- इनपुट झंडे निर्दिष्ट किए जा सकते हैं।

दो अंतर्निहित इनपुट प्रक्रियाओं को उनके आउटपुट को $ spawn_id और $ user_spawn_id (रिवर्स में) के रूप में निर्दिष्ट करने के लिए डिफ़ॉल्ट होता है। यदि कोई- आउटपुट ध्वज नो- आउटपुट ध्वज के साथ प्रकट होता है, तो उस प्रक्रिया के वर्णों को त्याग दिया जाता है।

-i ध्वज वर्तमान spawn_id के लिए एक प्रतिस्थापन पेश करता है जब कोई अन्य इनपुट या आउटपुट झंडे का उपयोग नहीं किया जाता है। ए -आई झंडा एक ध्वज का तात्पर्य है।

अप्रत्यक्ष स्पॉन आईडी का उपयोग करके उन प्रक्रियाओं को बदलना संभव है जिनके साथ बातचीत की जा रही है। (अप्रत्यक्ष स्पॉन आईडी को उम्मीद कमांड पर सेक्शन में वर्णित किया गया है।) अप्रत्यक्ष स्पॉन आईडी को -i, -u, -input, या -output झंडे के साथ निर्दिष्ट किया जा सकता है।

दुभाषिया [तर्क]
उपयोगकर्ता को अपेक्षित और टीसीएल कमांड के लिए इंटरैक्टिव रूप से संकेत दिया जाता है। प्रत्येक कमांड का परिणाम मुद्रित होता है।

सामान्य तरीके से व्यवहार करने के लिए ब्रेक और जारी नियंत्रण नियंत्रण संरचनाओं (यानी, proc , proc ) जैसी क्रियाएं। हालांकि रिटर्न दुभाषिया को अपने कॉलर पर वापस आने का कारण बनता है, जबकि inter_return दुभाषिया को अपने कॉलर में वापसी का कारण बनता है। उदाहरण के लिए, यदि "proc foo" को दुभाषिया कहा जाता है जिसे फिर कार्रवाई inter_return निष्पादित किया जाता है , proc foo वापस आ जाएगा। कोई अन्य आदेश दुभाषिया को नए आदेशों के लिए संकेत जारी रखने का कारण बनता है।

डिफ़ॉल्ट रूप से, प्रॉम्प्ट में दो पूर्णांक होते हैं। पहला पूर्णांक मूल्यांकन स्टैक की गहराई का वर्णन करता है (यानी, Tcl_Eval को कितनी बार बुलाया गया है)। दूसरा पूर्णांक टीसीएल इतिहास पहचानकर्ता है। प्रॉम्प्ट को "प्रॉम्प्ट 1" नामक प्रक्रिया को परिभाषित करके सेट किया जा सकता है जिसका रिटर्न वैल्यू अगले प्रॉम्प्ट बन जाता है। यदि किसी कथन में खुले उद्धरण, माता-पिता, ब्रेसिज़ या ब्रैकेट होते हैं, तो एक द्वितीयक प्रॉम्प्ट (डिफ़ॉल्ट रूप से "+>") न्यूलाइन पर जारी किया जाता है। द्वितीयक प्रॉम्प्ट "प्रॉम्प्ट 2" नामक प्रक्रिया को परिभाषित करके सेट किया जा सकता है।

दुभाषिया के दौरान, पकाया मोड का उपयोग किया जाता है, भले ही उसका कॉलर कच्चे मोड का उपयोग कर रहा हो।

यदि stdin बंद है, तो दुभाषिया वापस लौटाएगा जब तक कि ध्वज ध्वज का उपयोग नहीं किया जाता है, इस मामले में बाद में तर्क लागू किया जाता है।

log_file [args] [[-a] फ़ाइल]
यदि कोई फ़ाइल नाम प्रदान किया गया है, तो log_file फ़ाइल में सत्र (उस बिंदु से शुरू) की प्रतिलिपि रिकॉर्ड करेगा। अगर कोई तर्क नहीं दिया जाता है तो log_file रिकॉर्डिंग बंद कर देगा। कोई पिछली लॉग फ़ाइल बंद है।

फ़ाइल नाम के बजाय, एक टीसीएल फ़ाइल पहचानकर्ता को -ऑपेन या -लेवोपेन झंडे का उपयोग करके प्रदान किया जा सकता है। यह spawn कमांड के समान है। (अधिक जानकारी के लिए स्पॉन देखें।)

-A ध्वज बल आउटपुट लॉग होने के लिए लॉग_user कमांड द्वारा दबाया गया था।

डिफ़ॉल्ट रूप से, लॉग_फाइल कमांड लॉगिंग को बंद करने और एक सत्र में कई बार चालू करने में सक्षम होने की सुविधा के लिए, उन्हें छेड़छाड़ करने के बजाय पुरानी फ़ाइलों में जोड़ता है। फ़ाइलों को छोटा करने के लिए, -नोएपेंड ध्वज का उपयोग करें।

-इन्फो फ्लैग log_file को दिए गए सबसे हालिया गैर-जानकारी तर्कों का विवरण वापस करने का कारण बनता है।

log_user -info | 0 | 1
डिफ़ॉल्ट रूप से, stdout पर भेजें / अपेक्षित संवाद लॉग होता है (और यदि खुला हो तो लॉगफाइल)। Stdout को लॉगिंग "log_user 0" कमांड द्वारा अक्षम किया गया है और "log_user 1" द्वारा पुनः सक्षम किया गया है। लॉगफाइल पर लॉग इन अपरिवर्तित है।

-इन्फो ध्वज लॉग_यूसर को दिए गए सबसे हालिया गैर-जानकारी तर्कों का विवरण वापस करने का कारण बनता है।

match_max [-d] [-i spawn_id] [आकार]
अपेक्षाकृत आंतरिक रूप से उपयोग किए जाने वाले बफर (बाइट्स में) के आकार को परिभाषित करता है । कोई आकार तर्क के साथ, वर्तमान आकार वापस आ गया है।

-d ध्वज के साथ, डिफ़ॉल्ट आकार सेट है। (प्रारंभिक डिफ़ॉल्ट 2000 है।) -आई ध्वज के साथ, आकार नामित स्पॉन आईडी के लिए सेट किया गया है, अन्यथा यह वर्तमान प्रक्रिया के लिए सेट है ।

ओवरले [- # spawn_id] [- # spawn_id] [...] प्रोग्राम [args]
मौजूदा उम्मीद कार्यक्रम के स्थान पर "कार्यक्रम तर्क" निष्पादित करता है, जो समाप्त होता है। एक नंगे हाइफ़न तर्क कमांड नाम के सामने एक हाइफ़न को मजबूर करता है जैसे कि यह लॉगिन शेल था। तर्क के रूप में नामित सभी को छोड़कर सभी spawn_ids बंद हैं। ये नामित फ़ाइल पहचानकर्ताओं पर मैप किए गए हैं।

नए कार्यक्रम के उत्तराधिकारी के लिए Spawn_ids को फ़ाइल पहचानकर्ताओं के लिए मैप किया गया है। उदाहरण के लिए, निम्न पंक्ति शतरंज चलाती है और इसे वर्तमान प्रक्रिया द्वारा नियंत्रित करने की अनुमति देती है - कहें, एक शतरंज मास्टर।

ओवरले -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id शतरंज

यह "इंटरैक्ट-यू" से अधिक कुशल है, हालांकि, यह प्रोग्राम की बातचीत करने की क्षमता को त्याग देता है क्योंकि उम्मीद प्रक्रिया अब नियंत्रण में नहीं है।

ध्यान दें कि कोई नियंत्रण टर्मिनल प्रदान नहीं किया जाता है। इस प्रकार, यदि आप मानक इनपुट डिस्कनेक्ट या रीमेप करते हैं, तो प्रोग्राम जो जॉब कंट्रोल (शैल, लॉगिन इत्यादि) करते हैं, ठीक से काम नहीं करेंगे।

समानता [-d] [-i spawn_id] [मूल्य]
परिभाषित करता है कि समानता को बनाए रखा जाना चाहिए या स्पॉन्डेड प्रक्रियाओं के उत्पादन से अलग किया जाना चाहिए। यदि मान शून्य है, समानता छीन ली गई है, अन्यथा यह छीन नहीं है। कोई मूल्य तर्क के साथ, वर्तमान मान वापस कर दिया जाता है।

-d ध्वज के साथ, डिफ़ॉल्ट समानता मान सेट है। (प्रारंभिक डिफ़ॉल्ट 1 है, यानी, समानता छीन नहीं है।) -i ध्वज के साथ, समानता मान नामित स्पॉन आईडी के लिए सेट है, अन्यथा यह वर्तमान प्रक्रिया के लिए सेट है ।

remove_nulls [-d] [-i spawn_id] [value]
परिभाषित करता है कि क्या पैटर्न को मिलान करने या परिवर्तनीय expect_out या interact_out में संग्रहीत पैटर्न से पहले स्पॉल्ड प्रक्रियाओं के आउटपुट से नल को बनाए रखा जाता है या हटा दिया जाता है। यदि मान 1 है, तो नल हटा दिए जाते हैं। यदि मान 0 है, तो नल को हटाया नहीं जाता है। कोई मूल्य तर्क के साथ, वर्तमान मान वापस कर दिया जाता है।

-d ध्वज के साथ, डिफ़ॉल्ट मान सेट है। (प्रारंभिक डिफ़ॉल्ट 1 है, यानी, नल हटा दिए जाते हैं।) -i ध्वज के साथ, मान नामित स्पॉन आईडी के लिए सेट किया गया है, अन्यथा यह वर्तमान प्रक्रिया के लिए सेट है ।

नल हटा दिए गए हैं या नहीं, उम्मीद लॉग और stdout के लिए शून्य बाइट रिकॉर्ड करेगा।

[-flags] स्ट्रिंग भेजें
वर्तमान प्रक्रिया में स्ट्रिंग भेजता है । उदाहरण के लिए, आदेश

"हैलो वर्ल्ड \ आर" भेजें

वर्तमान प्रक्रिया के लिए पात्रों, helloworld भेजता है । (टीसीएल में एक printf -like कमांड ( प्रारूप कहा जाता है ) शामिल है जो मनमाने ढंग से जटिल तारों का निर्माण कर सकता है।)

अक्षर तुरंत भेजे जाते हैं हालांकि लाइन-बफर किए गए इनपुट वाले प्रोग्राम तब तक वर्ण नहीं पढ़ेंगे जब तक रिटर्न कैरेक्टर भेजा नहीं जाता है। एक वापसी चरित्र "\ r" दर्शाया गया है।

- ध्वज अगले तर्क को ध्वज के बजाए स्ट्रिंग के रूप में व्याख्या करने के लिए मजबूर करता है। किसी भी स्ट्रिंग से पहले "-" हो सकता है कि यह वास्तव में ध्वज की तरह दिखता है या नहीं। यह वैरिएबल रूप से झंडे की तरह दिखने वाले चरम तारों को निर्दिष्ट करने के लिए एक विश्वसनीय तंत्र प्रदान करता है। ("-" के साथ शुरू होने वाले सभी तार भविष्य के विकल्पों के लिए आरक्षित हैं।)

-i ध्वज घोषित करता है कि स्ट्रिंग नामित spawn_id पर भेजी जाएगी। यदि spawn_id user_spawn_id है, और टर्मिनल कच्चे मोड में है, तो स्ट्रिंग में न्यूलाइन को रिटर्न-न्यूलाइन अनुक्रमों में अनुवादित किया जाता है ताकि वे दिखाई दें जैसे टर्मिनल पकाया गया मोड में था। इस ध्वज को इस अनुवाद को अक्षम करता है।

नल झंडा शून्य वर्ण भेजता है (0 बाइट्स)। डिफ़ॉल्ट रूप से, एक शून्य भेजा जाता है। एक पूर्णांक यह इंगित करने के लिए नल का पालन कर सकता है कि कितने नल भेजना है।

-ब्रेक झंडा एक ब्रेक हालत उत्पन्न करता है। यह केवल तभी समझ में आता है जब स्पॉन आईडी "स्पॉन-ओपन" के माध्यम से खोले गए टीटी डिवाइस को संदर्भित करती है। यदि आपने टिप जैसी प्रक्रिया तैयार की है , तो आपको ब्रेक उत्पन्न करने के लिए टिप के सम्मेलन का उपयोग करना चाहिए।

फ्लैग बलों के उत्पादन को धीरे-धीरे "धीरे-धीरे" भेजा जा सकता है, इस प्रकार सामान्य स्थिति से बचें जहां एक कंप्यूटर एक इनपुट बफर से बाहर निकलता है जिसे मानव के लिए डिज़ाइन किया गया था जो कभी भी उसी बफर को टाइप नहीं करेगा। यह आउटपुट वैरिएबल "send_slow" के मान से नियंत्रित होता है जो दो तत्व सूची लेता है। पहला तत्व एक पूर्णांक है जो परमाणु रूप से भेजने के लिए बाइट्स की संख्या का वर्णन करता है। दूसरा तत्व एक वास्तविक संख्या है जो सेकेंड की संख्या का वर्णन करता है जिसके द्वारा परमाणु भेजना अलग होना चाहिए। उदाहरण के लिए, "send send_slow {10 .001}" भेजे गए प्रत्येक 10 वर्णों के बीच 1 मिलीसेकंड के साथ स्ट्रिंग भेजने के लिए "send -s" को मजबूर करेगा।

-एच फ्लैग बलों का आउटपुट भेजने के लिए (कुछ हद तक) मानव वास्तव में टाइपिंग की तरह। मानव-जैसी देरी पात्रों के बीच दिखाई देती है। (एल्गोरिदम इस विशेष अनुप्रयोग के अनुरूप संशोधनों के साथ एक वेबुल वितरण पर आधारित है।) यह आउटपुट वैरिएबल "send_human" के मान से नियंत्रित होता है जो पांच तत्व सूची लेता है। पहले दो तत्व सेकंड में वर्णों का औसत अंतराल समय होते हैं। पहला डिफ़ॉल्ट रूप से प्रयोग किया जाता है। दूसरा शब्द शब्द समाप्ति पर प्रयोग किया जाता है, सूक्ष्म विरामों को अनुकरण करने के लिए जो कभी-कभी ऐसे संक्रमणों पर होते हैं। तीसरा पैरामीटर भिन्नता का एक उपाय है जहां .1 काफी परिवर्तनीय है, 1 उचित रूप से परिवर्तनीय है, और 10 काफी अचूक है। चरम सीमा अनंत तक 0 हैं। पिछले दो पैरामीटर क्रमशः न्यूनतम और अधिकतम अंतराल के समय हैं। न्यूनतम और अधिकतम अंतिम बार उपयोग किया जाता है और अंतिम बार "क्लिप" होता है। अंतिम औसत न्यूनतम और अधिकतम क्लिप पर्याप्त मानों के आधार पर दिए गए औसत से काफी अलग हो सकता है।

एक उदाहरण के रूप में, निम्न आदेश एक तेज़ और सुसंगत टाइपिस्ट का अनुकरण करता है:

set send_human {.1 .3 1 .05 2} भेजें -h "मुझे भूख लगी है। चलो दोपहर का भोजन करें।"

जबकि हैंगओवर के बाद निम्नलिखित अधिक उपयुक्त हो सकता है:

set send_human {.4 .4 .2 .5 100} भेजें -h "गुड पार्टी लश रात!"

ध्यान दें कि त्रुटियां अनुकरण नहीं की जाती हैं, हालांकि आप एक त्रुटि तर्क में गलतियों और सुधारों को एम्बेड करके त्रुटि सुधार स्थितियों को स्वयं सेट कर सकते हैं।

ब्रेक भेजने के लिए, शून्य अक्षरों को भेजने के लिए झंडे, धीमी आउटपुट को मजबूर करने और मानव शैली के आउटपुट के लिए पारस्परिक रूप से अनन्य हैं। केवल अंतिम निर्दिष्ट एक का उपयोग किया जाएगा। इसके अलावा, शून्य अक्षर या ब्रेक भेजने के लिए झंडे के साथ कोई स्ट्रिंग तर्क निर्दिष्ट नहीं किया जा सकता है।

एक अपेक्षा से पहले प्रक्रिया को भेजने के पहले एक अच्छा विचार है । उम्मीद की प्रक्रिया शुरू होने की प्रतीक्षा होगी, जबकि भेज नहीं सकते हैं। विशेष रूप से, यदि प्रक्रिया शुरू होने से पहले पहला प्रेषण पूरा हो जाता है , तो आप अपना डेटा अनदेखा करने का जोखिम चलाते हैं। ऐसी परिस्थितियों में जहां इंटरैक्टिव प्रोग्राम प्रारंभिक संकेत नहीं देते हैं, आप देरी से पहले भेज सकते हैं:

# हैकर्स को तोड़ने के तरीके पर संकेत देने से बचने के लिए, # यह सिस्टम बाहरी पासवर्ड के लिए संकेत नहीं देता है। # स्पॉन टेलनेट को पूरा करने के लिए निष्पादन के लिए 5 सेकंड तक प्रतीक्षा करें very.secure.gov नींद 5 पासवर्ड भेजें \ r

exp_send भेजने के लिए एक उपनाम है । यदि आप एक्सपेक्टक या टीके पर्यावरण में अपेक्षा के कुछ अन्य प्रकार का उपयोग कर रहे हैं, तो भेजकर टी द्वारा पूरी तरह से अलग उद्देश्य के लिए परिभाषित किया जाता है। exp_send वातावरण के बीच संगतता के लिए प्रदान किया जाता है। अन्य उम्मीदों के अन्य प्रेषण आदेशों के लिए समान उपनाम प्रदान किए जाते हैं।

send_error [-flags] स्ट्रिंग
भेजने की तरह है, सिवाय इसके कि आउटपुट वर्तमान प्रक्रिया की बजाय stderr को भेजा जाता है ।

send_log [-] स्ट्रिंग
भेजने की तरह है, सिवाय इसके कि स्ट्रिंग केवल लॉग फ़ाइल में भेजी जाती है ( log_file देखें।) अगर लॉग फ़ाइल खुलती है तो तर्कों को अनदेखा कर दिया जाता है।

send_tty [-flags] स्ट्रिंग
भेजने की तरह है, सिवाय इसके कि आउटपुट वर्तमान प्रक्रिया की बजाय / dev / tty को भेजा जाता है ।

send_user [-flags] स्ट्रिंग
भेजने की तरह है, सिवाय इसके कि आउटपुट को वर्तमान प्रक्रिया के बजाय stdout पर भेजा जाता है ।

नींद सेकंड
स्क्रिप्ट को दिए गए सेकंड के लिए सोने का कारण बनता है। सेकेंड दशमलव संख्या हो सकता है। इंटरप्ट्स (और यदि आप एक्सपेक्ट का उपयोग कर रहे हैं तो टीईसी कार्यक्रम) सोते समय अपेक्षाकृत संसाधित होते हैं।

स्पॉन [तर्क] कार्यक्रम [तर्क]
"प्रोग्राम तर्क" चलाने वाली एक नई प्रक्रिया बनाता है। इसकी stdin, stdout और stderr अपेक्षा से जुड़े हुए हैं, ताकि उन्हें अन्य उम्मीद आदेशों द्वारा पढ़ और लिखा जा सके। कनेक्शन बंद हो जाता है या अगर प्रक्रिया स्वयं फ़ाइल पहचानकर्ताओं को बंद कर देती है।

जब स्पॉन द्वारा एक प्रक्रिया शुरू की जाती है, तो परिवर्तनीय spawn_id उस प्रक्रिया का जिक्र करने वाले वर्णनकर्ता को सेट किया जाता है। Spawn_id द्वारा वर्णित प्रक्रिया को "वर्तमान प्रक्रिया " माना जाता है। spawn_id को पढ़ा या लिखा जा सकता है, असल में नौकरी नियंत्रण प्रदान करना।

user_spawn_id एक वैश्विक चर है जिसमें एक वर्णक होता है जो उपयोगकर्ता को संदर्भित करता है। उदाहरण के लिए, जब spawn_id इस मान पर सेट होता है, तो उम्मीद है कि उम्मीद_user की तरह व्यवहार करें।

I. error_spawn_id एक वैश्विक चर है जिसमें एक वर्णक होता है जो मानक त्रुटि को संदर्भित करता है। उदाहरण के लिए, जब spawn_id इस मान पर सेट होता है, तो send_error की तरह व्यवहार भेजें ।

tty_spawn_id एक वैश्विक चर है जिसमें एक वर्णक होता है जो / dev / tty को संदर्भित करता है। यदि / dev / tty मौजूद नहीं है (जैसे क्रॉन, एट, या बैच स्क्रिप्ट में), तो tty_spawn_id परिभाषित नहीं किया गया है। इसका परीक्षण इस प्रकार किया जा सकता है:

यदि {[info vars tty_spawn_id]} {# / dev / tty मौजूद है} अन्य {# / dev / tty मौजूद नहीं है # शायद क्रॉन, बैच, या स्क्रिप्ट में}

स्पॉन यूनिक्स प्रक्रिया आईडी देता है। यदि कोई प्रक्रिया उत्पन्न नहीं होती है, तो 0 वापस आ जाता है। परिवर्तनीय spawn_out (गुलाम, नाम) pty दास डिवाइस के नाम पर सेट है।

डिफ़ॉल्ट रूप से, spawn कमांड नाम और तर्क echoes। -नोच झंडा इसे करने से रोकता है।

कंसोल ध्वज कंसोल आउटपुट को स्पॉन्डेड प्रक्रिया में रीडायरेक्ट करने का कारण बनता है । यह सभी प्रणालियों पर समर्थित नहीं है।

आंतरिक रूप से, स्पॉन एक पीटीआई का उपयोग करता है, जिस तरह से उपयोगकर्ता की टीटीआई शुरू होती है। इसे आगे शुरू किया गया है ताकि सभी सेटिंग्स "sane" (stty (1) के अनुसार) हैं। यदि परिवर्तनीय stty_init परिभाषित किया गया है, तो इसे आगे विन्यास के रूप में stty तर्कों की शैली में व्याख्या किया जाता है। उदाहरण के लिए, "stty_init कच्चे सेट करें" कच्चे मोड में शुरू होने वाली प्रक्रियाओं के टर्मिनलों को आगे बढ़ाएगा। -nottycopy उपयोगकर्ता के tty के आधार पर प्रारंभिकता छोड़ देता है। -nottyinit " sane " प्रारंभिक छोड़ देता है।

आम तौर पर, स्पॉन को निष्पादित करने में थोड़ा समय लगता है। यदि आप काफी समय लेते हुए देखते हैं, तो शायद यह ptys का सामना कर रहा है जो wedged हैं। गलती प्रक्रियाओं के साथ उलझन से बचने के लिए ptys पर कई परीक्षण चलाए जाते हैं। (ये 10 सेकंड प्रति wedged pty लेते हैं।) -d विकल्प के साथ चलने की उम्मीद दिखाएगी कि क्या अजीब राज्यों में उम्मीदवार कई ptys का सामना कर रहा है। यदि आप उन प्रक्रियाओं को मार नहीं सकते हैं जिनके लिए ये ptys संलग्न हैं, तो आपका एकमात्र सहारा रीबूट हो सकता है।

यदि प्रोग्राम सफलतापूर्वक उत्पन्न नहीं किया जा सकता है क्योंकि निष्पादन (2) विफल रहता है (उदाहरण के लिए जब प्रोग्राम मौजूद नहीं है), तो एक त्रुटि संदेश अगले इंटरैक्ट द्वारा वापस किया जाएगा या कमांड की अपेक्षा की जाएगी जैसे कि प्रोग्राम चलाया गया था और आउटपुट के रूप में त्रुटि संदेश उत्पन्न किया था। यह व्यवहार स्पॉन के कार्यान्वयन का एक प्राकृतिक परिणाम है। आंतरिक रूप से, स्पॉन फोर्क्स, जिसके बाद स्पॉन्ड प्रक्रिया के पास स्पैनिश_आईडी के माध्यम से संचार को छोड़कर मूल अपेक्षा प्रक्रिया के साथ संवाद करने का कोई तरीका नहीं है।

द ओपेन ध्वज अगले तर्क को टीसीएल फ़ाइल पहचानकर्ता के रूप में व्याख्या करने का कारण बनता है (यानी, खुले द्वारा लौटाया जाता है ।) स्पॉन आईडी का उपयोग तब किया जा सकता है जैसे यह एक स्पॉन्डेड प्रक्रिया थी । (फाइल पहचानकर्ता का अब उपयोग नहीं किया जाना चाहिए।) इससे आपको कच्चे उपकरणों, फ़ाइलों और पाइपलाइनों को पीटीआई के बिना स्पॉन्ड प्रक्रियाओं के रूप में पेश करने की सुविधा मिलती है। यह इंगित करने के लिए 0 वापस लौटाया गया है कि कोई संबंधित प्रक्रिया नहीं है । जब स्पॉन्ड प्रक्रिया से कनेक्शन बंद हो जाता है, तो टीसीएल फ़ाइल पहचानकर्ता भी होता है। -लेवॉपेन ध्वज -ओपेन के समान है, सिवाय इसके कि -वॉवेपेन स्पैन आईडी बंद होने के बाद भी फ़ाइल पहचानकर्ता को खुला छोड़ दिया जाता है।

खाली झंडा एक पीटीआई खोला जाता है लेकिन कोई प्रक्रिया उत्पन्न नहीं होती है । यह इंगित करने के लिए 0 वापस लौटाया गया है कि कोई संबंधित प्रक्रिया नहीं है । Spawn_id सामान्य के रूप में सेट है।

परिवर्तनीय spawn_out (गुलाम, एफडी) पीटीई गुलाम के अनुरूप फ़ाइल पहचानकर्ता पर सेट है। इसे "क्लोज-स्लेव" का उपयोग करके बंद किया जा सकता है।

साइन-इन ध्वज एक संकेत को स्पष्ट प्रक्रिया में अनदेखा किया जाता है । अन्यथा, संकेतों को डिफ़ॉल्ट व्यवहार मिलता है। संकेतों को जाल कमांड के रूप में नामित किया गया है, सिवाय इसके कि प्रत्येक सिग्नल को एक अलग ध्वज की आवश्यकता होती है।

स्ट्रेस स्तर
निष्पादित होने से पहले निम्नलिखित कथन मुद्रित किए जाने का कारण बनता है। (टीसीएल का ट्रेस कमांड वेरिएबल्स का पता लगाता है।) स्तर इंगित करता है कि कॉल स्टैक में कितना दूर पता लगाने के लिए। उदाहरण के लिए, निम्न आदेश कॉल के पहले 4 स्तरों का पता लगाने के दौरान अपेक्षा करता है, लेकिन उसके नीचे कोई भी नहीं।

उम्मीद-सी "strace 4" script.exp

-इन्फो ध्वज दिए गए सबसे हालिया गैर-जानकारी तर्कों का वर्णन वापस करने के लिए स्ट्रेस का कारण बनता है।

stty args
टर्मिनल मोड को बाहरी स्टाटी कमांड के समान बदलता है।

डिफ़ॉल्ट रूप से, नियंत्रण टर्मिनल का उपयोग किया जाता है। अन्य टर्मिनलों को "आदेश के अनुरोधों को कमांड के परिणाम के रूप में वापस करने के लिए अनुरोधों को जोड़कर एक्सेस किया जा सकता है। यदि कोई स्थिति अनुरोध नहीं की जाती है और नियंत्रण टर्मिनल का उपयोग किया जाता है, तो कच्चे और गूंज गुणों की पिछली स्थिति एक रूप में लौटा दी जाती है जो बाद में हो सकती है आदेश द्वारा प्रयोग किया जाता है।

उदाहरण के लिए, कच्चे या- खींचे गए तर्क टर्मिनल को कच्चे मोड में डाल देते हैं। तर्क- खींचा या पकाया टर्मिनल पके हुए मोड में डाल दिया। तर्क echo और -echo टर्मिनल को क्रमशः गूंज और नोचो मोड में डाल देते हैं।

निम्न उदाहरण बताता है कि अस्थायी रूप से इकोइंग अक्षम कैसे करें। इसका उपयोग अन्यथा-स्वचालित स्क्रिप्ट में किया जा सकता है ताकि उनमें पासवर्ड एम्बेड करने से बचें। (नीचे EXPECT HINTS के तहत इस पर और चर्चा देखें।)

stty -echo send_user "पासवर्ड:" expect_user -re "(। *) \ n" पासवर्ड $ hope_out (1, स्ट्रिंग) stty echo सेट करें

सिस्टम तर्क देता है
sh (1) इनपुट के रूप में तर्क देता है, जैसे कि इसे टर्मिनल से कमांड के रूप में टाइप किया गया था। खोल समाप्त होने तक प्रतीक्षा करें । Sh से वापसी की स्थिति को उसी तरह से संभाला जाता है जैसे निष्पादन इसकी वापसी स्थिति को संभालता है।

निष्पादन के विपरीत जो स्क्रिप्ट पर stdin और stdout को पुनर्निर्देशित करता है, सिस्टम कोई पुनर्निर्देशन नहीं करता है (इसके अलावा स्ट्रिंग द्वारा इंगित किए गए)। इस प्रकार, उन कार्यक्रमों का उपयोग करना संभव है जिन्हें सीधे / dev / tty से बात करनी चाहिए। इसी कारण से, सिस्टम के परिणाम लॉग में दर्ज नहीं हैं।

टाइमस्टैम्प [तर्क]
एक टाइमस्टैम्प देता है। कोई तर्क नहीं के साथ, युग वापस आने के बाद सेकंड की संख्या।

-फॉर्मेट ध्वज एक स्ट्रिंग पेश करता है जो लौटाया जाता है लेकिन पॉज़िक्स नियमों के अनुसार किए गए प्रतिस्थापन के साथ। उदाहरण के लिए% a को संक्षिप्त सप्ताह के नाम (यानी, शनि) द्वारा प्रतिस्थापित किया जाता है। अन्य हैं:

% एक संक्षिप्त सप्ताह का नाम% एक पूर्ण सप्ताह का नाम% बी संक्षिप्त नाम का नाम% बी पूर्ण महीना नाम% c दिनांक-समय इस प्रकार है: बुध अक्टूबर 6 11:45:56 1 99 3% महीने का दिन दिन (01-31% एच घंटा (00-23)% I घंटा (01-12)% जे दिन (001-366)% एम महीने (01-12)% एम मिनट (00-59)% पी हूँ या अपराह्न% एस सेकेंड (00-61) % u दिन (1-7, सोमवार सप्ताह का पहला दिन है)% यू सप्ताह (00-53, पहला रविवार सप्ताह का पहला दिन है)% वी सप्ताह (01-53, आईएसओ 8601 शैली)% डब्ल्यू दिन (0- 6)% डब्ल्यू सप्ताह (00-53, पहला सोमवार सप्ताह का पहला दिन है)% x दिनांक-समय इस प्रकार है: बुध 6 अक्टूबर 1 99 3% एक्स समय के रूप में: 23:59:59% y वर्ष (00-99) % वाई वर्ष के रूप में: 1 99 3% जेड टाइमज़ोन (या कुछ भी निर्धारित नहीं है) %% एक नंगे प्रतिशत संकेत

अन्य% विनिर्देश अपरिभाषित हैं। अन्य पात्रों को छूटे बिना पारित किया जाएगा। केवल सी लोकेल समर्थित है।

-सेकंड ध्वज युग के रूप में उपयोग किए जाने वाले स्रोत के रूप में उपयोग किए जाने के बाद से कई सेकंड प्रस्तुत करता है। अन्यथा, वर्तमान समय का उपयोग किया जाता है।

जीएमटी टाइमज़ोन का उपयोग करने के लिए -gmt ध्वज टाइमस्टैम्प आउटपुट को मजबूर करता है। कोई ध्वज नहीं के साथ, स्थानीय टाइमज़ोन का उपयोग किया जाता है।

जाल [[आदेश] संकेत]
दिया गया आदेश किसी दिए गए संकेतों की भविष्य की प्राप्ति पर निष्पादित आदेश को निष्पादित करता है। आदेश वैश्विक दायरे में निष्पादित किया गया है। यदि आदेश अनुपस्थित है, तो सिग्नल एक्शन वापस कर दिया जाता है। यदि आदेश स्ट्रिंग SIG_IGN है, तो संकेतों को अनदेखा कर दिया जाता है। यदि आदेश स्ट्रिंग SIG_DFL है, सिग्नल सिस्टम डिफ़ॉल्ट के परिणामस्वरूप हैं। सिग्नल या तो एक सिग्नल या संकेतों की एक सूची है। संकेतों के अनुसार संकेतों को संख्यात्मक रूप से या प्रतीकात्मक रूप से निर्दिष्ट किया जा सकता है (3)। "एसआईजी" उपसर्ग छोड़ा जा सकता है।

कोई तर्क (या तर्क-संख्या) के साथ, जाल वर्तमान में निष्पादित जा रहे जाल आदेश की सिग्नल संख्या देता है।

ऑब्जेक्ट मूल रूप से चलने पर आदेश देने के लिए टीसीएल वापस आने वाले कोड के स्थान पर -कोड ध्वज कमांड के रिटर्न कोड का उपयोग करता है।

-इंटरप ध्वज कमांड को घोषित करने के बजाए कमांड शुरू करने के समय कमांडर का उपयोग करके कमांड का मूल्यांकन करने का कारण बनता है।

नाम ध्वज जाल कमांड को वर्तमान में निष्पादित जा रहे जाल आदेश के सिग्नल नाम को वापस करने का कारण बनता है।

-मैक्स ध्वज जाल कमांड को सबसे बड़ा सिग्नल नंबर वापस करने का कारण बनता है जिसे सेट किया जा सकता है।

उदाहरण के लिए, "जाल {send_user" Ouch! "} SIGINT" आदेश "प्रिंट करेगा" ओच! " प्रत्येक बार जब उपयोगकर्ता ^ सी दबाता है।

डिफ़ॉल्ट रूप से, SIGINT (जिसे आमतौर पर ^ सी दबाकर उत्पन्न किया जा सकता है) और SIGTERM कारण से बाहर निकलने की अपेक्षा करता है। यह निम्न जाल के कारण होता है, जब अपेक्षा शुरू होती है तो डिफ़ॉल्ट रूप से बनाई जाती है।

जाल निकास {SIGINT SIGTERM}

यदि आप डीबगर शुरू करने के लिए -D ध्वज का उपयोग करते हैं, तो SIGINT को इंटरैक्टिव डीबगर शुरू करने के लिए फिर से परिभाषित किया गया है। यह निम्नलिखित जाल के कारण है:

जाल {exp_debug 1} SIGINT

पर्यावरण परिवर्तक EXPECT_DEBUG_INIT को एक नए जाल कमांड में सेट करके डीबगर जाल बदला जा सकता है।

आप निश्चित रूप से, दोनों को अपनी स्क्रिप्ट में जाल आदेश जोड़कर इन दोनों को ओवरराइड कर सकते हैं। विशेष रूप से, यदि आपके पास अपना "जाल निकास SIGINT" है, तो यह डीबगर जाल को ओवरराइड कर देगा। यह उपयोगी है अगर आप उपयोगकर्ताओं को डीबगर पर जाने से रोकना चाहते हैं।

यदि आप SIGINT पर अपने स्वयं के जाल को परिभाषित करना चाहते हैं, लेकिन जब भी यह चल रहा है, तब भी डीबगर को जाल करें, इसका उपयोग करें:

अगर {! [exp_debug]} {जाल mystuff SIGINT}

वैकल्पिक रूप से, आप किसी अन्य सिग्नल का उपयोग करके डीबगर पर जाल कर सकते हैं।

जाल आपको SIGALRM के लिए कार्रवाई को ओवरराइड करने नहीं देगा क्योंकि इसका उपयोग आंतरिक रूप से करने के लिए किया जाता है। डिस्कनेक्ट कमांड SIGALRM को SIG_IGN (अनदेखा) पर सेट करता है। जब तक आप इसे बाद के स्पॉन कमांड के दौरान अक्षम करते हैं, तब तक आप इसे पुनः सक्षम कर सकते हैं।

अधिक जानकारी के लिए सिग्नल (3) देखें।

प्रतीक्षा करें [तर्क]
एक उत्पन्न प्रक्रिया तक देरी (या वर्तमान प्रक्रिया अगर कोई नाम नहीं है) समाप्त हो जाता है।

प्रतीक्षा करें सामान्य रूप से चार पूर्णांक की एक सूची देता है। पहला पूर्णांक उस प्रक्रिया का ढक्कन है जिस पर इंतजार किया गया था। दूसरा पूर्णांक संबंधित स्पॉन आईडी है। तीसरा पूर्णांक -1 है यदि एक ऑपरेटिंग सिस्टम त्रुटि हुई, या 0 अन्यथा। यदि तीसरा पूर्णांक 0 था, तो चौथा पूर्णांक उत्पन्न प्रक्रिया द्वारा लौटाई गई स्थिति है । यदि तीसरा पूर्णांक -1 था, तो चौथा पूर्णांक ऑपरेटिंग सिस्टम द्वारा निर्धारित इरनो का मान है। वैश्विक परिवर्तनीय त्रुटि कोड भी सेट है।

इंतजार से वापसी मूल्य के अंत में अतिरिक्त तत्व दिखाई दे सकते हैं। एक वैकल्पिक पांचवां तत्व जानकारी की एक वर्ग की पहचान करता है। वर्तमान में, इस तत्व के लिए एकमात्र संभावित मूल्य बच्चा है, जिसके मामले में अगले दो मान सी-शैली सिग्नल नाम और एक संक्षिप्त पाठ विवरण हैं।

-i ध्वज नामित spawn_id ( प्रक्रिया आईडी नहीं) के अनुरूप प्रतीक्षा करने की प्रक्रिया की घोषणा करता है। एक सिग्चाल्ड हैंडलर के अंदर, स्पॉन आईडी -1 का उपयोग कर किसी भी स्पॉन्डेड प्रक्रिया की प्रतीक्षा करना संभव है।

--nowait ध्वज एक सफल प्रतीक्षा के संकेत के साथ तत्काल लौटने का इंतजार कर रहा है। जब प्रक्रिया निकलती है (बाद में), यह स्पष्ट प्रतीक्षा की आवश्यकता के बिना स्वचालित रूप से गायब हो जाएगी।

इंतजार कमांड का उपयोग तर्कों का उपयोग करके एक फोर्क प्रक्रिया के लिए भी किया जा सकता है "-i -1"। स्पॉन्ड प्रक्रियाओं के साथ इसके उपयोग के विपरीत, यह आदेश किसी भी समय निष्पादित किया जा सकता है। इस पर कोई नियंत्रण नहीं है कि किस प्रक्रिया का उपयोग किया जाता है। हालांकि, प्रक्रिया आईडी के लिए वापसी मूल्य की जांच की जा सकती है।

पुस्तकालय

उम्मीद स्क्रिप्ट के लिए स्वचालित रूप से दो अंतर्निहित पुस्तकालयों के बारे में पता है। इन्हें variables exp_library और exp_exec_library में नामित निर्देशिकाओं द्वारा परिभाषित किया गया है। दोनों उपयोगिता फ़ाइलों को शामिल करने के लिए हैं जिनका उपयोग अन्य स्क्रिप्ट द्वारा किया जा सकता है।

exp_library में आर्किटेक्चर-स्वतंत्र फ़ाइलें शामिल हैं। exp_exec_library में आर्किटेक्चर-निर्भर फाइलें हैं। आपके सिस्टम के आधार पर, दोनों निर्देशिका पूरी तरह से खाली हो सकती है। फ़ाइल $ exp_exec_library / cat-buffers का अस्तित्व वर्णन करता है कि डिफ़ॉल्ट रूप से आपका / bin / cat buffers है या नहीं।

सुंदर मुद्रण

सुंदर मुद्रण अपेक्षा स्क्रिप्ट के लिए एक vgrind परिभाषा उपलब्ध है। उम्मीद वितरण के साथ आपूर्ति की गई vgrind परिभाषा को सही ढंग से स्थापित किया गया है, आप इसका उपयोग इस प्रकार कर सकते हैं:

vgrind -lexpect फ़ाइल

उदाहरण

यह बहुत स्पष्ट नहीं है कि मनुष्य पृष्ठ का वर्णन कैसे करता है। मैं आपको उम्मीद वितरण की उदाहरण निर्देशिका में उदाहरण पढ़ने और कोशिश करने के लिए प्रोत्साहित करता हूं। उनमें से कुछ असली कार्यक्रम हैं। अन्य बस कुछ तकनीकों का चित्रण कर रहे हैं, और निश्चित रूप से, एक जोड़े बस त्वरित हैक्स हैं। इंस्टाल फ़ाइल में इन कार्यक्रमों का त्वरित अवलोकन है।

उम्मीद पत्र (यह भी देखें) भी उपयोगी हैं। जबकि कुछ कागजात उम्मीद के पुराने संस्करणों के अनुरूप वाक्यविन्यास का उपयोग करते हैं, साथ ही तर्कसंगत तर्क अभी भी मान्य हैं और इस मैन पेज की तुलना में बहुत अधिक विस्तार में जाते हैं।

चेतावनियां

विस्तार उम्मीदवार के कमांड नामों के साथ टकरा सकता है। उदाहरण के लिए, प्रेषण को पूरी तरह से अलग उद्देश्य के लिए टी द्वारा परिभाषित किया जाता है। इस कारण से, अधिकांश उम्मीद आदेश "exp_XXXX" के रूप में भी उपलब्ध हैं। "एक्सप", "इंटर", "स्पॉन", और "टाइमआउट" से शुरू होने वाले कमांड और वेरिएबल में उपनाम नहीं हैं। यदि आपको वातावरण के बीच इस संगतता की आवश्यकता है तो विस्तारित कमांड नामों का उपयोग करें।

उम्मीद स्कोपिंग के बजाय उदारवादी दृष्टिकोण लेता है। विशेष रूप से, अपेक्षित कार्यक्रम के लिए विशिष्ट आदेशों द्वारा पढ़े गए चर को स्थानीय दायरे से पहले और वैश्विक स्तर पर नहीं मिलेगा। उदाहरण के लिए, यह आपके द्वारा लिखे गए प्रत्येक प्रक्रिया में "वैश्विक टाइमआउट" रखने की आवश्यकता को रोकता है जो अपेक्षा करता है । दूसरी ओर, लिखे गए चर हमेशा स्थानीय दायरे में होते हैं (जब तक कि "वैश्विक" आदेश जारी नहीं किया जाता है)। इस कारण सबसे आम समस्या तब होती है जब एक प्रक्रिया में स्पॉन निष्पादित किया जाता है। प्रक्रिया के बाहर, spawn_id अब मौजूद नहीं है, इसलिए स्कोपिंग की वजह से उत्पन्न प्रक्रिया अब पहुंच योग्य नहीं है। ऐसी प्रक्रिया में "वैश्विक spawn_id" जोड़ें।

यदि आप बहुसंख्यक क्षमता को सक्षम नहीं कर सकते हैं (यानी, आपका सिस्टम न तो चयन (बीएसडी *। *), मतदान (एसवीआर> 2), न ही कुछ समकक्ष का समर्थन करता है), उम्मीद केवल एक ही समय में एक ही प्रक्रिया को नियंत्रित करने में सक्षम होगी। इस मामले में, spawn_id को सेट करने का प्रयास न करें, न ही किसी निष्पादित प्रक्रिया के दौरान आप निष्पादन के माध्यम से प्रक्रियाओं को निष्पादित कर सकते हैं। इसके अलावा, आप एक ही समय में एकाधिक प्रक्रियाओं (उपयोगकर्ता के रूप में एक सहित) से अपेक्षा नहीं कर पाएंगे।

टर्मिनल पैरामीटर स्क्रिप्ट पर एक बड़ा प्रभाव हो सकता है। उदाहरण के लिए, यदि गूंजने के लिए एक स्क्रिप्ट लिखी जाती है, तो गूंज बंद होने पर यह गलत व्यवहार करेगा। इस कारण से, डिफ़ॉल्ट रूप से सेनाओं को टर्मिनल पैरामीटर की अपेक्षा करें। दुर्भाग्यवश, यह चीजों को अन्य कार्यक्रमों के लिए अप्रिय बना सकता है। उदाहरण के तौर पर, Emacs shell "सामान्य" मैपिंग को बदलना चाहता है: कैरिज-रिटर्न न्यूलाइन के बजाय न्यूलाइन को न्यूलाइन में मैप किया जाता है, और इकोइंग अक्षम है। यह इनपुट लाइन को संपादित करने के लिए emacs का उपयोग करने की अनुमति देता है। दुर्भाग्य से, उम्मीद संभवतः यह अनुमान नहीं लगा सकता है।

आप अनुरोध कर सकते हैं कि टर्मिनल पैरामीटर की अपनी डिफ़ॉल्ट सेटिंग ओवरराइड न करें, लेकिन ऐसे वातावरणों के लिए स्क्रिप्ट लिखते समय आपको बहुत सावधान रहना चाहिए। Emacs के मामले में, गूंज और अंत-ऑफ-लाइन मैपिंग जैसी चीजों के आधार पर बचें।

आदेश जो एक सूची में अपेक्षित तर्क स्वीकार करते हैं ( अपेक्षित रूपों और बातचीत ) एक हेरिस्टिक का उपयोग यह तय करने के लिए करते हैं कि सूची वास्तव में एक तर्क है या कई। हेरिस्टिक केवल उस मामले में असफल हो सकता है जब सूची वास्तव में एक तर्क का प्रतिनिधित्व करती है जिसमें एकाधिक एम्बेडेड \ n के बीच गैर-व्हाइटस्पेस वर्ण होते हैं। यह पर्याप्त रूप से असंभव प्रतीत होता है, हालांकि तर्क "-नोब्रेस" का उपयोग एक तर्क के रूप में संभालने के लिए एक तर्क को मजबूर करने के लिए किया जा सकता है। यह मशीन-जेनरेटेड उम्मीद कोड के साथ कल्पनापूर्वक इस्तेमाल किया जा सकता है। इसी तरह, -ब्रेस एक पैटर्न को कई पैटर्न / क्रियाओं के रूप में संभालने के लिए मजबूर करता है।

बग

कार्यक्रम "सेक्स" (या तो "स्मार्ट एक्सेक" या "सेंड-एक्सपेक्ट" के लिए) वास्तव में आकर्षक था, लेकिन अच्छी समझ (या शायद सिर्फ प्यूरिज़्मवाद) प्रबल थी।

कुछ प्रणालियों पर, जब एक खोल पैदा होता है, तो यह शिकायत करता है कि टीटी तक पहुंचने में सक्षम नहीं है लेकिन वैसे भी चलता है। इसका मतलब है कि आपके सिस्टम में नियंत्रण टीटी प्राप्त करने के लिए एक तंत्र है जिसे उम्मीद नहीं है। कृपया यह पता लगाएं कि यह क्या है, और यह जानकारी मुझे वापस भेज दें।

Ultrix 4.1 (यहां तक ​​कि कम से कम नवीनतम संस्करण) 1000000 के टाइमआउट को 0 के बराबर मानते हैं।

डिजिटल यूनिक्स 4.0 ए (और शायद अन्य संस्करण) यदि आप सिग्चल्ड हैंडलर को परिभाषित करते हैं तो ptys आवंटित करने से इनकार करते हैं। अधिक जानकारी के लिए अनुदान पृष्ठ देखें।

आईआरईएक्स 6.0 पीटीआई अनुमतियों को सही तरीके से संभाल नहीं पाता है ताकि अगर किसी अन्य व्यक्ति द्वारा पहले इस्तेमाल की गई पीटीआई आवंटित करने का प्रयास किया जाए, तो यह विफल हो जाता है। IRIX 6.1 में अपग्रेड करें।

टेलनेट (केवल सनोस 4.1.2 के तहत सत्यापित) अगर टीईआरएम सेट नहीं है तो लटकता है। यह क्रॉन के तहत और सीजीआई स्क्रिप्ट में एक समस्या है, जो टीईआरएम को परिभाषित नहीं करती है। इस प्रकार, आपको इसे स्पष्ट रूप से सेट करना होगा - आमतौर पर किस प्रकार का अप्रासंगिक है। यह सिर्फ कुछ करने के लिए सेट किया जाना है! निम्नलिखित मामलों के लिए निम्नलिखित शायद पर्याप्त है।

सेट एनवी (टीईआरएम) vt100

युक्ति (केवल बीएसडीआई बीएसडी / ओएस 3.1 i386 के तहत सत्यापित) शेल और होम सेट नहीं होने पर लटकती है। यह क्रॉन के तहत और सीजीआई स्क्रिप्ट में एक समस्या है, जो इन पर्यावरण चर को परिभाषित नहीं करती है। इस प्रकार, आपको उन्हें स्पष्ट रूप से सेट करना होगा - आमतौर पर किस प्रकार का अप्रासंगिक है। यह सिर्फ कुछ करने के लिए सेट किया जाना है! निम्नलिखित मामलों के लिए निम्नलिखित शायद पर्याप्त है।

सेट env (SHELL) / bin / sh set env (HOME) / usr / local / bin

पीटीआईएस के कुछ कार्यान्वयन डिज़ाइन किए गए हैं ताकि प्रक्रिया को फ़ाइल डिस्क्रिप्टर को बंद करने के बाद कर्नेल 10 से 15 सेकंड (वास्तविक संख्या कार्यान्वयन-निर्भर) के बाद किसी भी अपठित आउटपुट को फेंक दे। इस प्रकार कार्यक्रमों की अपेक्षा करें

स्पॉन तिथि नींद 20 उम्मीद है

असफल हो जायेगी। इससे बचने के लिए, स्पॉन के बजाए निष्पादन के साथ गैर-इंटरैक्टिव प्रोग्राम्स का आह्वान करें। हालांकि ऐसी परिस्थितियां कल्पनाशील हैं, प्रैक्टिस में मैंने कभी ऐसी स्थिति का सामना नहीं किया है जिसमें इस व्यवहार के कारण वास्तव में एक इंटरैक्टिव प्रोग्राम का अंतिम आउटपुट खो जाएगा।

दूसरी तरफ, क्रय यूनिकोस ptys ने फ़ाइल डिस्क्रिप्टर को बंद करने के तुरंत बाद किसी भी अपठित आउटपुट को फेंक दिया। मैंने क्रे को यह बताया है और वे एक फिक्स पर काम कर रहे हैं।

कभी-कभी एक प्रॉम्प्ट और प्रतिक्रिया के बीच देरी की आवश्यकता होती है, जैसे कि जब एक टीटी इंटरफ़ेस प्रारंभ / स्टॉप बिट्स की तलाश करके यूएआरटी सेटिंग्स या मेलिंग बॉड दरों को बदल रहा है। आम तौर पर, यह सब एक या दो के लिए सोना आवश्यक है। इनपुट प्राप्त करने के लिए हार्डवेयर तैयार होने तक एक और मजबूत तकनीक फिर से प्रयास करना है। निम्नलिखित उदाहरण दोनों रणनीतियों का उपयोग करता है:

"गति 9600 \ आर" भेजें; नींद 1 उम्मीद {टाइमआउट {भेजें "\ r"; exp_continue} $ प्रॉम्प्ट}

जाल-ऑब्जेक्ट किसी भी कमांड के साथ काम नहीं करेगा जो टीसीएल के इवेंट लूप, जैसे नींद में बैठता है। समस्या यह है कि घटना लूप में, टीसीएल एसिंक घटना हैंडलर से रिटर्न कोड को छोड़ देता है। जाल कोड में ध्वज सेट करना एक कामकाज है। फिर आदेश के बाद तुरंत ध्वज की जांच करें (यानी, नींद)।

उम्मीद_बैकग्राउंड कमांड समय-समय पर तर्कों को अनदेखा करता है और सामान्य रूप से टाइमआउट की कोई अवधारणा नहीं है।

& # 34; हितों की अपेक्षा करें & # 34;

उम्मीद के बारे में कुछ चीजें हैं जो गैर-अंतर्ज्ञानी हो सकती हैं। यह खंड कुछ सुझावों के साथ इन चीजों में से कुछ को संबोधित करने का प्रयास करता है।

एक आम उम्मीद समस्या है कि खोल संकेतों को कैसे पहचानें। चूंकि इन्हें अलग-अलग लोगों और अलग-अलग गोले द्वारा अलग-अलग अनुकूलित किया जाता है, इसलिए पोर्तुगी से स्वचालित रूप से स्वचालित रूप से स्वचालित रूप से रॉग्लिन स्वचालित रूप से स्वचालित हो सकता है। एक उचित सम्मेलन है कि उपयोगकर्ता पर्यावरण परिवर्तनीय EXPECT_PROMPT में अपने संकेत (विशेष रूप से, इसका अंत) का वर्णन करने वाली एक नियमित अभिव्यक्ति संग्रहीत करते हैं। निम्नलिखित जैसे कोड का उपयोग किया जा सकता है। यदि EXPECT_PROMPT मौजूद नहीं है, तो कोड में अभी भी सही तरीके से कार्य करने का एक अच्छा मौका है।

सेट प्रॉम्प्ट "(% | # | \\ $) $"; # डिफ़ॉल्ट प्रॉम्प्ट कैच {सेट प्रॉम्प्ट $ env (EXPECT_PROMPT)} उम्मीद है-$ प्रॉम्प्ट

मैं आपको उम्मीदों के पैटर्न लिखने के लिए प्रोत्साहित करता हूं जिसमें आप जो कुछ भी देखना चाहते हैं उसका अंत शामिल करते हैं। यह पूरी चीज को देखने से पहले एक प्रश्न का उत्तर देने की संभावना से बचाता है। इसके अतिरिक्त, जब आप उन्हें पूरी तरह से देखने से पहले प्रश्नों का उत्तर देने में सक्षम हो सकते हैं, तो यदि आप जल्दी जवाब देते हैं, तो आपका उत्तर प्रश्न के मध्य में वापस प्रतिबिंबित हो सकता है। दूसरे शब्दों में, परिणामस्वरूप संवाद सही होगा लेकिन scrambled देखो।

अधिकांश संकेतों में अंत में एक अंतरिक्ष चरित्र शामिल होता है। उदाहरण के लिए, ftp से प्रॉम्प्ट 'f', 't', 'p', '>' और है। इस प्रॉम्प्ट से मेल खाने के लिए, आपको इन वर्णों में से प्रत्येक के लिए खाता होना चाहिए। रिक्त स्थान शामिल न करना एक आम गलती है। स्पष्ट रूप से खाली रखें।

यदि आप फॉर्म एक्स * के पैटर्न का उपयोग करते हैं, तो * एक्स के अंत से प्राप्त अंतिम आउटपुट से प्राप्त अंतिम आउटपुट से मेल खाएगा। यह अंतर्ज्ञानी लगता है लेकिन कुछ हद तक भ्रमित हो सकता है क्योंकि "अंतिम चीज़ प्राप्त" वाक्यांश कंप्यूटर की गति और कर्नेल और डिवाइस चालक दोनों के I / O की प्रसंस्करण के आधार पर भिन्न हो सकता है।

विशेष रूप से, मनुष्यों को विशाल भाग (परमाणु रूप से) में आने वाले प्रोग्राम आउटपुट को देखते हैं, जब वास्तव में अधिकांश कार्यक्रम एक समय में आउटपुट एक लाइन का उत्पादन करते हैं। मान लीजिए कि यह मामला है, * पिछले पैराग्राफ के पैटर्न में केवल मौजूदा लाइन के अंत से मेल खा सकता है, भले ही ऐसा लगता है कि मैच के समय, जो सभी आउटपुट प्राप्त हुए थे।

उम्मीद है कि यह जानने का कोई तरीका नहीं है कि आगे का आउटपुट तब तक आ रहा है जब तक कि आपका पैटर्न विशेष रूप से इसके लिए जिम्मेदार न हो।

लाइन उन्मुख बफरिंग के आधार पर भी मूर्खतापूर्ण है। न केवल प्रोग्राम ही वे बफरिंग के प्रकार के बारे में वादे करते हैं, लेकिन सिस्टम अपचन आउटपुट लाइनों को तोड़ सकता है ताकि लाइनें यादृच्छिक स्थानों पर टूट जाए। इस प्रकार, यदि आप पैटर्न लिखते समय प्रॉम्प्ट के अंतिम कुछ अक्षर व्यक्त कर सकते हैं, तो ऐसा करना बुद्धिमानी है।

यदि आप किसी प्रोग्राम के अंतिम आउटपुट में पैटर्न की प्रतीक्षा कर रहे हैं और प्रोग्राम इसके बजाए कुछ और उत्सर्जित करता है, तो आप टाइमआउट कीवर्ड के साथ इसका पता लगाने में सक्षम नहीं होंगे। कारण यह है कि उम्मीद समय सीमा नहीं होगी - इसके बजाय इसे एक ईफ संकेत मिलेगा। इसके बजाय इसका प्रयोग करें। इससे भी बेहतर, दोनों का उपयोग करें। इस तरह यदि वह रेखा कभी भी घूमती है, तो आपको लाइन को स्वयं संपादित नहीं करना पड़ेगा।

टर्मिनल ड्राइवर द्वारा आउटपुट करते समय न्यूलाइन आमतौर पर कैरिज रिटर्न, लाइनफीड अनुक्रमों में परिवर्तित हो जाते हैं। इस प्रकार, यदि आप एक पैटर्न चाहते हैं जो स्पष्ट रूप से दो पंक्तियों से मेल खाता है, कहें, printf ("foo \ nbar"), तो आपको "foo \ r \ nbar" पैटर्न का उपयोग करना चाहिए।

उम्मीदवार के माध्यम से उपयोगकर्ता से पढ़ने पर एक समान अनुवाद होता है। इस मामले में, जब आप वापसी दबाते हैं, तो इसका अनुवाद एक नई लाइन में किया जाएगा। यदि उम्मीद है तो उस प्रोग्राम को पास करता है जो अपने टर्मिनल को कच्चे मोड (टेलनेट की तरह) में सेट करता है, तो एक समस्या होगी, क्योंकि कार्यक्रम को वास्तविक वापसी की उम्मीद है। (कुछ कार्यक्रम वास्तव में क्षमा कर रहे हैं कि वे स्वचालित रूप से रिटर्न में न्यूलाइन का अनुवाद करेंगे, लेकिन अधिकांश नहीं।) दुर्भाग्यवश, यह पता लगाने का कोई तरीका नहीं है कि एक प्रोग्राम अपने टर्मिनल को कच्चे मोड में डाल देता है।

रिटर्न के साथ मैनलाइन को मैन्युअल रूप से बदलने की बजाय, समाधान "stty raw" कमांड का उपयोग करना है, जो अनुवाद को रोक देगा। नोट, हालांकि, इसका मतलब है कि अब आपको पकाया लाइन-संपादन सुविधाएं नहीं मिलेंगी।

बातचीत करें अपने टर्मिनल को कच्चे मोड में सेट करें ताकि यह समस्या तब उत्पन्न न हो।

अपेक्षाकृत स्क्रिप्ट में पासवर्ड (या अन्य निजी जानकारी) स्टोर करना अक्सर उपयोगी होता है। यह अनुशंसित नहीं है क्योंकि किसी कंप्यूटर पर संग्रहीत कुछ भी किसी के द्वारा उपयोग किए जाने के लिए अतिसंवेदनशील है। इस प्रकार, स्क्रिप्ट से पासवर्ड के लिए इंटरैक्टिव रूप से संकेत देना सचमुच उन्हें एम्बेड करने से एक बेहतर विचार है। फिर भी, कभी-कभी ऐसी एम्बेडिंग ही एकमात्र संभावना है।

दुर्भाग्यवश, यूनिक्स फ़ाइल सिस्टम में स्क्रिप्ट बनाने का कोई सीधा तरीका नहीं है जो निष्पादन योग्य लेकिन अपठनीय है। सिस्टम जो सेटगिड शैल स्क्रिप्ट का समर्थन करते हैं, अप्रत्यक्ष रूप से निम्नानुसार अनुकरण कर सकते हैं:

सामान्य रूप से अपेक्षित स्क्रिप्ट (जिसमें गुप्त डेटा शामिल है) बनाएं। इसकी अनुमतियां 750 (-rwxr-x ---) बनाएं और एक विश्वसनीय समूह के स्वामित्व में हों, यानी, एक समूह जिसे इसे पढ़ने की अनुमति है। यदि आवश्यक हो, तो इस उद्देश्य के लिए एक नया समूह बनाएं। इसके बाद, पहले समूह के स्वामित्व वाली अनुमतियों 2751 (-rwxr-s-x) के साथ एक / bin / sh स्क्रिप्ट बनाएं।

नतीजा एक ऐसी स्क्रिप्ट है जिसे किसी के द्वारा निष्पादित (और पढ़ा जा सकता है)। जब बुलाया जाता है, तो यह अपेक्षित स्क्रिप्ट चलाता है।

& # 34; यह भी देखें & # 34;

टीसीएल (3), libexpect (3)
डॉन लिब्स, पीपी 602, आईएसबीएन 1-56592-090-2, ओ'रेली और एसोसिएट्स, 1 99 5 द्वारा "एक्सप्लोरिंग एक्सपेक्ट: ऑटोमेटिंग प्रोग्राम्स के लिए एक टीसीएल-आधारित टूलकिट" ।
"उम्मीद: डॉन लिब्स द्वारा अंतःक्रियाशीलता के उन अनियंत्रित फिटयों को ठीक करना, ग्रीष्मकालीन 1 99 0 यूएसएनईक्स सम्मेलन की कार्यवाही , अनाहिम , कैलिफ़ोर्निया, 11-15 जून, 1 99 0।
मैं डॉन लिब्स द्वारा "सिस्टम प्रशासन कार्य स्वचालित करने की अपेक्षा का उपयोग करके, 1 99 0 के यूएसएनईक्स बड़े स्थापना प्रणाली प्रशासन सम्मेलन, कोलोराडो स्प्रिंग्स, कोलोराडो, अक्टूबर 17-19, 1 99 0 की कार्यवाही।
मैं जॉन ओस्टरहाउट द्वारा "टीसीएल: ए एंबेडेबल कमांड लैंग्वेज", सर्दियों की कार्यवाही 1 99 0 यूएसएनईक्स सम्मेलन, वाशिंगटन, डीसी, 22-26 जनवरी, 1 99 0 जनवरी। मैं "उम्मीद करता हूं: डॉन लिब्स, कंप्यूटिंग सिस्टम द्वारा नियंत्रित इंटरैक्टिव प्रोग्राम के लिए स्क्रिप्ट" , वॉल्यूम 4, संख्या 2, कैलिफोर्निया विश्वविद्यालय प्रेस जर्नल, नवंबर 1 99 1। मैं "रिग्रेशन टेस्टिंग एंड कॉन्फॉर्मेंस टेस्टिंग इंटरेक्टिव प्रोग्राम", डॉन लिब्स द्वारा, ग्रीष्मकालीन 1992 यूएसएनईक्स सम्मेलन की कार्यवाही, पीपी 135-144, सैन एंटोनियो, टेक्सस, जून 12-15, 1 99 2। मैं "किबिट्स - कनेक्टिंग मल्टीपल इंटरेक्टिव प्रोग्राम एक साथ", डॉन लिब्स, सॉफ्टवेयर - प्रैक्टिस एंड एक्सपीरियंस, जॉन विली एंड संस, वेस्ट ससेक्स, इंग्लैंड, वॉल्यूम द्वारा।

23, संख्या 5, मई, 1 99 3। मैं "टीसीएल अनुप्रयोगों के लिए एक डीबगर", डॉन लिब्स द्वारा, 1 99 3 टीसीएल / टीई कार्यशाला, बर्कले, सीए, जून 10-11, 1 99 3 की कार्यवाही।

लेखक

डॉन लिब्स, नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड एंड टेक्नोलॉजी

आभार

टीसीएल के लिए जॉन ओस्टरहाउट और प्रेरणा के लिए स्कॉट पैसले के लिए धन्यवाद। उम्मीद के स्वत: कॉन्फ़िगरेशन कोड के लिए रॉब Savoye के लिए धन्यवाद।

इतिहास फ़ाइल दस्तावेजों की उम्मीद के विकास के अधिकांश दस्तावेज। यह दिलचस्प पढ़ता है और आपको इस सॉफ्टवेयर के बारे में और जानकारी दे सकता है। इसमें उल्लिखित लोगों के लिए धन्यवाद जिन्होंने मुझे बग फिक्स भेजा और अन्य सहायता दी।

उम्मीदवार के डिजाइन और कार्यान्वयन का भुगतान अमेरिकी सरकार द्वारा किया गया था और इसलिए सार्वजनिक डोमेन में है। हालांकि लेखक और एनआईएसटी क्रेडिट पसंद करेंगे यदि इस कार्यक्रम और दस्तावेज या उनमें से भाग का उपयोग किया जाता है।