ലിനക്സ് / യൂണിക്സ് കമാൻഡ് പ്രതീക്ഷിക്കുക

ഒരു സ്ക്രിപ്റ്റ് പ്രകാരം മറ്റ് ആശയവിനിമയ പ്രോഗ്രാമുകളോട് സംസാരിക്കുന്ന ഒരു പ്രോഗ്രാം ആണ് പ്രതീക്ഷ. തിരക്കഥയെത്തുടർന്ന്, ഒരു പരിപാടിയിൽ നിന്ന് പ്രതീക്ഷിക്കപ്പെടുന്നത് എന്താണെന്നും, ശരിയായ പ്രതികരണം എന്താണെന്നും പ്രതീക്ഷിക്കുന്നു. ഡയലോഗിലേക്ക് നയിക്കാനായി ഭാഷ വ്യാഖ്യാനിക്കുന്ന ഭാഷയും ബ്രൌസിംഗും ഉയർന്ന തലത്തിലുള്ള നിയന്ത്രണ സംവിധാനങ്ങളും നൽകുന്നു. ഇതിനുപുറമെ, ഉപയോക്താവിന് നിയന്ത്രണം കൈക്കലാക്കുകയും അതുമായി നേരിട്ട് ഇടപെടുകയും ചെയ്യാവുന്നതാണ്, തുടർന്ന് സ്ക്രിപ്റ്റിന് നിയന്ത്രണം തിരികെ നൽകുന്നു.

പ്രതീക്ഷയും പ്രതീക്ഷയുമുള്ള ഒരു മിശ്രിതമാണ് പ്രതീക്ഷ. അതു പ്രതീക്ഷയും ടി.കെ. ആഗ്രഹവും പോലെ പ്രവർത്തിക്കുന്നു. ടിക്സി ഇല്ലാതെയും സി, സി എന്നിവയിലും നേരിട്ട് ഉപയോഗിക്കാം.

Uucp, kermit, മറ്റ് മോഡം കണ്ട്രോൾ പ്രോഗ്രാമുകൾ എന്നിവ വഴി പ്രചാരമുള്ള സീക്വൻസുകൾ അയക്കുവാനുള്ള പ്രതീക്ഷയിൽ നിന്നാണ് "പ്രതീക്ഷ" എന്ന പേര് വരുന്നത്. എന്നിരുന്നാലും, UUCP- ൽ നിന്നും വ്യത്യസ്തമായി, പ്രതീക്ഷിക്കുന്നത് ഒരു ഉപയോക്തൃ-ലെവൽ കമാൻഡായി ഏതെങ്കിലും പ്രോഗ്രാം അല്ലെങ്കിൽ ടാസ്ക് ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കാൻ കഴിയും. പ്രതീക്ഷിക്കുന്നത് ഒരേ സമയം വിവിധ പരിപാടികളോട് സംസാരിക്കാനാവും.

എന്തു പ്രതീക്ഷിക്കാം

ഉദാഹരണത്തിന്, expect കമാൻറ് ചെയ്യാൻ കഴിയുന്ന ചില കാര്യങ്ങൾ ഇതാ:

• നിങ്ങളുടെ കമ്പ്യൂട്ടർ നിങ്ങളെ തിരികെ വിളിക്കാൻ അനുവദിക്കുക, അതിനാൽ കോളിനായി പണം നൽകാതെ ലോഗിൻ ചെയ്യാനാകും.
• ഒരു ഗെയിം ആരംഭിക്കുക, അനുയോജ്യമായ കോൺഫിഗറേഷൻ ദൃശ്യമാകുന്നില്ലെങ്കിൽ, അത് വീണ്ടും വീണ്ടും ആരംഭിക്കുക) അതു ചെയ്യുന്നതുവരെ, തുടർന്ന് നിങ്ങൾക്ക് നിയന്ത്രണം കൈമാറുക.
• Fsck പ്രവർത്തിപ്പിക്കുക , അതിന്റെ ചോദ്യങ്ങൾക്കുള്ള മറുപടിയായി, മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുള്ള മാനദണ്ഡങ്ങളെ അടിസ്ഥാനമാക്കി "അതെ" അല്ലെങ്കിൽ "ഇല്ല" എന്ന് മറുപടി നൽകുക അല്ലെങ്കിൽ നിങ്ങൾക്ക് വീണ്ടും നിയന്ത്രണം നൽകുക.
• മറ്റൊരു നെറ്റ്വർക്കിൽ കണക്റ്റുചെയ്ത് നിങ്ങളുടെ മെയിൽ സ്വപ്രേരിതമായി വീണ്ടെടുക്കുന്നതിലൂടെ നിങ്ങളുടെ പ്രാദേശിക സിസ്റ്റത്തിലേക്ക് യഥാർത്ഥത്തിൽ അയച്ചതാണെന്ന് തോന്നുന്നു.
• പരിസ്ഥിതി വേരിയബിളുകൾ, നിലവിലെ ഡയറക്ടറി, അല്ലെങ്കിൽ rlogin, telnet, tip, su , അല്ലെങ്കിൽ chgrp ആയി ഏതു തരത്തിലുള്ള വിവരവും കൈകാര്യം ചെയ്യുക

ഷെൽ എന്തിനാണ് ഈ ചുമതലകൾ നിർവഹിക്കാൻ കഴിയാത്തത് എന്നതിന് പല കാരണങ്ങളുണ്ട്. എല്ലാ പ്രതീക്ഷയും സാധ്യമാണ്.

പ്രോഗ്രാമും ഉപയോക്താവും തമ്മിലുള്ള ആശയവിനിമയം ആവശ്യമുള്ള ഏതെങ്കിലും പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ സാധാരണയായി പ്രതീക്ഷിക്കുന്നത് പ്രയോജനകരമാണ്. പരസ്പരം ഇടപെടൽ പ്രോഗ്രമാറ്റിക്കായി സ്വഭാവത്തിന് വിധേയമാക്കാവുന്നതാണ്. പ്രോഗ്രാം നിയന്ത്രിക്കപ്പെടാതെ തന്നെ ഉപയോക്താവിന് നിയന്ത്രണം തിരികെ നൽകാം. അതുപോലെ, ഉപയോക്താവിന് എപ്പോൾ വേണമെങ്കിലും സ്ക്രിപ്റ്റിലേക്ക് നിയന്ത്രണം തിരികെ ലഭിക്കും.

ഉപയോഗം

എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള കമാൻഡുകളുടെ ഒരു പട്ടികയ്ക്കായി cmdfile വായിക്കുന്നു. # പിന്തുണയ്ക്കുന്ന സിസ്റ്റങ്ങളിൽ പ്രതീക്ഷിക്കുന്നു എന്ന് പ്രതീക്ഷിക്കുന്നു! സ്ക്രിപ്റ്റിനെ എക്സിക്യൂട്ടബിൾ ആയി അടയാളപ്പെടുത്തുന്നത് വഴി സ്ക്രിപ്റ്റിന്റെ ആദ്യ വരി നിർത്തുന്നു.

#! / usr / local / bin / expect -f

തീർച്ചയായും, ജീവനെവിടെ പ്രതീക്ഷിക്കുന്നു എന്നത് കൃത്യമായി വിവരിക്കേണ്ടതുണ്ട്. / usr / local / bin ഒരു ഉദാഹരണം.

സ്ക്രിപ്റ്റിന് മുമ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള കമാൻഡ് ആണ് -c ഫ്ലാഗ് മുൻഗണന നൽകുന്നത്. ഷെല്ലിനൊപ്പം തകരാറിലാക്കുന്നതിനായി ഈ കമാൻഡ് ഉദ്ധരിക്കപ്പെടണം. ഈ ഐച്ഛികം അനവധി തവണ ഉപയോഗിച്ചു് ഉപയോഗിക്കാം. ഒന്നിലധികം കമാൻഡുകൾ ഒറ്റ-സി ഉപയോഗിച്ച് semicolons ഉപയോഗിച്ച് വേർതിരിക്കാനിടയുണ്ട്. കമാൻഡുകൾ അവ പ്രത്യക്ഷപ്പെടുന്ന ക്രമത്തിലാണ് പ്രവർത്തിപ്പിക്കുന്നത്. Expectk ഉപയോഗിക്കുമ്പോള്, ഈ ഐച്ഛികം -command എന്ന് വ്യക്തമാക്കുന്നു.

-d ഫ്ലാഗ് ചില ഡയഗണോസ്റ്റിക് ഔട്ട്പുട്ടുകളെ സജ്ജമാക്കുന്നു, അവ പ്രതീക്ഷിക്കുകയും സംവേദിക്കുകയും ചെയ്യുക തുടങ്ങിയ കമാൻഡുകളുടെ ആന്തരിക പ്രവർത്തനം പ്രാഥമികമായി റിപ്പോർട്ടു ചെയ്യുന്നു. പ്രതീക്ഷിക്കുന്ന സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിൽ ഈ ഫ്ലാഗ് "exp_internal 1" എന്നതിന്റെ അതേ പ്രതീതി ഉണ്ട്, കൂടാതെ പ്രതീക്ഷയുടെ പതിപ്പ് അച്ചടിക്കും.

-D ഫ്ലാഗ് ഒരു ഇന്ററാക്ടീവ് ഡീബഗ്ഗറിനെ പ്രാപ്തമാക്കുന്നു. ഒരു പൂർണ്ണസംഖ്യയുടെ മൂല്യം പാലിക്കണം. പൂജ്യം പൂജ്യമല്ലെങ്കിലോ ഒരു സി അമർത്തിയോ അല്ലെങ്കിൽ ഒരു ബ്രേക്ക് പോയിന്റുയോ ആണെങ്കിൽ, അല്ലെങ്കിൽ മറ്റ് ഉചിതമായ ഡീബഗ്ഗർ കമാൻഡ് ലിപിയിൽ പ്രത്യക്ഷപ്പെടുന്നെങ്കിൽ, ഡീബഗ്ഗർ അടുത്ത Tcl പ്രക്രിയയ്ക്കായി നിയന്ത്രണം എടുക്കും. Expectk ഉപയോഗിക്കുമ്പോള്, ഈ ഉപാധി ഇതായി പറയുക - ഡീബഗ് ചെയ്യുക.

-f ഫ്ലാഗ് ആജ്ഞകൾ വായിക്കേണ്ടി വരുന്ന ഒരു ഫയലിനെ മുൻഗണിക്കുന്നു. # ഉപയോഗിക്കുമ്പോൾ മാത്രമേ ഇത് ഉപയോഗപ്രദമാകൂ എന്നതിന്റെ കൊടി നോട്ടേഷൻ, അങ്ങനെ മറ്റ് ആർഗ്യുമെന്റുകൾ കമാൻഡ് ലൈനിൽ വിതരണം ചെയ്യും. Expectk ഉപയോഗിക്കുന്പോൾ, ഈ ഉപാധി -ഫയൽ എന്ന് പറഞ്ഞിരിക്കുന്നു.

സ്വതവേ, കമാൻഡ് ഫയൽ മെമ്മറിയിലേക്ക് ലഭ്യമാക്കി , പൂർണ്ണമായി നടപ്പിലാക്കുന്നു. ഒരിക്കൽ ഫയലുകൾ ഒരു വരി വായിക്കാൻ ഇടക്കിടെ അവസരങ്ങളുണ്ട്. അനിയന്ത്രിതമായ ഫയലുകൾ ഈ രീതിയിൽ കൈകാര്യം ചെയ്യാൻ നിർബന്ധിക്കുക, -b ഫ്ലാഗ് ഉപയോഗിക്കുക. Expectk ഉപയോഗിക്കുമ്പോള്, ഈ ഓപ്ഷന് -buffer ആയി വ്യക്തമാക്കിയിട്ടുണ്ടു്.

സ്ട്രിക്റ്റ് "-" ഒരു ഫയൽനാമമായി നൽകിയിട്ടുണ്ടെങ്കിൽ, സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് വായനയാണു്. യഥാർത്ഥത്തിൽ "-" പേരുള്ള ഒരു ഫയലിൽ നിന്നും വായിക്കാൻ "./-" ഉപയോഗിക്കുക.

-i ഫ്ലാഗ് ഒരു ഫയലിൽ നിന്ന് അവ വായിക്കുന്നതിന് പകരം കമാൻഡുകൾക്കായി interactively പ്രോംപ്റ്റ് ചെയ്യുന്നു. എക്സിറ്റ് കമാൻറ് അല്ലെങ്കിൽ EOF വഴി ആവശ്യപ്പെടുന്നത്. കമാൻഡ് ഫയൽ അല്ലെങ്കിൽ -c ഉപയോഗിക്കാറില്ല -i ഫ്ലാഗ് അനുമാനിക്കുന്നു. Expectk ഉപയോഗിക്കുമ്പോള്, ഈ ഐച്ഛികം -ഇന്റക്ടീവ് ആണു്.

- ഓപ്ഷനുകളുടെ അവസാനം ഡിലിമിറ്റ് ചെയ്യാൻ ഉപയോഗിച്ചേക്കാം. നിങ്ങളുടെ സ്ക്രിപ്റ്റിൽ പ്രതീക്ഷിച്ച വ്യാഖ്യാനമില്ലാതെ ഒരു ഓപ്ഷൻ പോലുള്ള ആർഗ്യുമെന്റിൽ നിങ്ങൾക്കാവശ്യമുണ്ടെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്. ഇത് ഉപയോഗയോഗ്യമായ # ആകാം! പ്രതീക്ഷിക്കുന്നതിലൂടെ ഏതെങ്കിലും ഫ്ലാഗുചെയ്ത ഇഷ്ട വ്യാഖ്യാനങ്ങളെ തടയുന്നതിനുള്ള ലൈൻ. ഉദാഹരണത്തിന്, ചുവടെയുള്ള argv ൽ സ്ക്രിപ്റ്റ് നാമം ഉൾപ്പെടെ യഥാർത്ഥ ആർഗ്യുമെന്റുകൾ ഇടുകയും ചെയ്യും .

#! / usr / local / bin / expect -

# ആർഗ്യുമെന്റുകൾ ചേർക്കുമ്പോൾ സാധാരണ getopt (3), execute (2) കൺവെൻഷനുകൾ ശ്രദ്ധിക്കണം! ലൈൻ.

$ Exp_library / expect.rc ഫയൽ -N ഫ്ലാഗ് ഉപയോഗിക്കാത്തിടത്തോളം സ്വയമായി ലഭ്യമാണെങ്കിലും. (Expectk ഉപയോഗിക്കുമ്പോൾ, ഈ ഐച്ഛികം -NORC ആയിരിയ്ക്കും.) ഉടൻ തന്നെ, -n ഫ്ലാഗ് ഉപയോഗിക്കുന്നത് വരെ ഫയൽ ~ / .expect.rc യാന്ത്രികമായി ലഭ്യമാക്കുന്നു. എൻവയോൺമെന്റ് വേരിയബിൾ DOTDIR നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, അത് ഒരു ഡയറക്ടറിയായി കണക്കാക്കുകയും അവിടെ നിന്ന് തന്നെ .expect.rc വായിക്കുകയും ചെയ്യുന്നു. Expectk ഉപയോഗിക്കുമ്പോള്, ഈ ഓപ്ഷന് -norc എന്ന് പറഞ്ഞിരിക്കുന്നു. -c flags നടപ്പിലാക്കിയതിനുശേഷമേ ഈ sourcing സംഭവിക്കുന്നത്.

-v കാരണമാകുന്നത് അതിന്റെ പതിപ്പ് നമ്പറും പുറത്തേയും പ്രിന്റ് ചെയ്യാൻ പ്രതീക്ഷിക്കുന്നു. നീളമുള്ള പതാക നാമങ്ങൾ ഉപയോഗിച്ചിരിക്കുന്ന "എക്സ്പെക്ടർ" ലെ അനുബന്ധ പതാകയാണ് - പതിപ്പ്.

ഓപ്ഷണൽ ആർഗുകൾ ഒരു പട്ടികയായി നിർമ്മിച്ചു്, argv എന്ന് പേരുള്ള വേരിയബിളിൽ സൂക്ഷിക്കുകയും ചെയ്യുന്നു. argc എന്ന നീളം വരെ argc ആരംഭിക്കുന്നു.

സ്ക്രിപ്റ്റ് ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ, സ്ക്രിപ്റ്റുകളുടെയോ ബൈനറിയുടെയോ പേര് Argv0 എന്ന് നിർവചിക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, സ്ക്രിപ്റ്റിന്റെ പേരും ആദ്യത്തെ മൂന്ന് ആർഗുമെന്റുകളും താഴെപ്പറയുന്നവയെ പ്രിന്റ് ചെയ്യുന്നു:

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

കമാൻഡുകൾ

ടൂൾ കമാൻഡ് ഭാഷ പ്രയോജനപ്പെടുത്തുക. Tcl നിയന്ത്രണ നിയന്ത്രണം (റിക്കോർഡ് സ്പ്രെഡ് ഷോർട്ട്, എക്സ്പ്രെഷൻ മൂല്യനിർണ്ണയം, റിക്കർഷ്യൻഡിയൻ പ്രോസസ് നിർവചനം തുടങ്ങിയ നിരവധി സവിശേഷതകൾ നൽകുന്നു). ഇവിടെ ഉപയോഗിച്ചിട്ടുള്ള കമാൻഡുകൾ, പക്ഷെ നിർവചിച്ചിട്ടില്ലാത്ത (set, if, exec) എന്നത് Tcl കമാൻഡുകൾ ആണ്. അധിക കമാൻഡുകൾ പിന്തുണയ്ക്കുന്നുവെന്ന് പ്രതീക്ഷിക്കുക. വ്യക്തമാക്കാത്ത പക്ഷം, കമാൻഡുകൾ ശൂന്യമായ സ്ട്രിംഗ് നൽകുന്നു.

കമാൻഡുകൾ അക്ഷരമാലാ ക്രമത്തിൽ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു, അങ്ങനെ അവ വേഗത്തിൽ കണ്ടെത്താൻ കഴിയും. എന്നിരുന്നാലും പുതിയ ഉപയോക്താക്കൾ ആ ക്രമം വിശദമായി വായിക്കുന്നതും, അയയ്ക്കുന്നതും, പ്രതീക്ഷിക്കുന്നതും, ആശയവിനിമയം ചെയ്യുന്നതുമെല്ലാം, എളുപ്പത്തിൽ കണ്ടെത്തുന്നു.

അടയ്ക്കുക [-സ്ലൈഡ്] [-ഓൺസെക് 0 | 1] [-i spawn_id]

ഇപ്പോഴത്തെ പ്രക്രിയയിലേക്കുള്ള കണക്ഷൻ അടയ്ക്കുന്നു. മിക്ക ഇന്ററാക്റ്റീവ് പ്രോഗ്രാമുകളും അവരുടെ സ്റ്റാൻഡിനേഡിൽ എഫും എക്സിറ്റും കണ്ടെത്തി; ഇത് സാധാരണയായി പ്രക്രിയയെ കൊല്ലുന്നതിനു മതിയാകും. പേരുള്ള spawn_id പേരുമായി ബന്ധിപ്പിക്കുന്ന പ്രക്രിയ , -i ഫ്ലാഗ് പ്രഖ്യാപിക്കുന്നു.

നിലവിലുള്ള പ്രോസസ്സ് അവസാനിക്കുമ്പോഴും, സംവേദനാത്മകമാവുമ്പോഴും ഇരുവരും പ്രതീക്ഷിക്കുന്നതും ആശയക്കുഴപ്പത്തിലാക്കും. പക്ഷേ, നിങ്ങൾ ഈ പ്രക്രിയയെ കൊല്ലുകയാണെങ്കിൽ, "execution kill $ pid" എന്ന് പറയുക, നിങ്ങൾ സ്പഷ്ടമായി അടുത്തടുത്ത് വിളിക്കേണ്ടതുണ്ട് .

സ്പോൺഡ് ഐഡൻ ഏതെങ്കിലും പുതിയ പ്ളാൻഡഡ് പ്രക്രിയകളിൽ അടച്ചിട്ടുണ്ടോ അല്ലെങ്കിൽ പ്രോസസ്സ് പൊതിഞ്ഞോ ആണെങ്കിൽ -onexec ഫ്ലാഗ് നിർണ്ണയിക്കുന്നു. ഒരു സ്പോൺ ഐഡി തുറന്നുകൊടുക്കാൻ, മൂല്യം 0 ഉപയോഗിക്കുക. പുതിയ ഒരു പ്രോസസ്സിൽ സ്പോൺ അടച്ചു പൂജ്യമല്ലാത്ത ഒരു പൂർണ്ണസംഖ്യമൂല്യമാണ്.

സ്പാൺ ഐഡിയുമായി ബന്ധപ്പെട്ട അടിമയെ അടയ്ക്കുന്ന പതനം അടയ്ക്കുന്നു. കണക്ഷൻ അടയ്ക്കുമ്പോൾ, അത് ഇപ്പോഴും തുറന്നിട്ടുണ്ടെങ്കിൽ, അത് സ്വയം അടച്ചിരിക്കും.

കണക്ഷൻ അടച്ചു പൂട്ടുവോ അല്ലെങ്കിൽ സ്പഷ്ടമായി അടച്ചു വന്നതോ എന്തുതന്നെയായാലും, ശരിയായ കെർണൽ പ്രൊസസ്സ് സ്ളോട്ട് ക്ലിയർ ചെയ്യാനായി നിങ്ങൾ വിളിക്കുക. ഒരു പ്രോസ്സസ് കണക്ഷൻ അവസാനിപ്പിക്കുന്നത് അവസാനിപ്പിക്കുമെന്ന് ഉറപ്പുണ്ടാകാത്തതിനാൽ അടുത്ത കമാൻഡ് കാത്തിരിക്കുന്നില്ല.

ഡീബഗ് [[-now] 0 | 1]

പ്രസ്താവനകളിലൂടെ കടന്നുപോകാനും ബ്രേക്ക് പോയിന്റുകൾ സജ്ജമാക്കാനും അനുവദിക്കുന്ന ഒരു Tcl ഡീബഗ്ഗറിനെ നിയന്ത്രിക്കുന്നു.

ഡീബഗ്ഗർ പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ ഒരു വാദം ഉന്നയിക്കുന്നില്ല, അല്ലെങ്കിൽ ഒരു 0 തിരിച്ചുനൽകുന്നു.

1 ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് ഡീബഗ്ഗർ ആരംഭിക്കുന്നു. 0 ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് ഡീബഗ്ഗർ നിർത്തിവച്ചിരിക്കുന്നു. 1 ആർഗ്യുമെന്റിനു മുൻപത്തെ-ഫ്ലാഗ് ഉണ്ടെങ്കിൽ, ഡീബഗ്ഗർ ഉടൻ ആരംഭിക്കും. അല്ലെങ്കിൽ, അടുത്ത ടിക് സ്റ്റേറ്റ് ഉപയോഗിച്ച് ഡീബഗ്ഗർ ആരംഭിക്കുന്നു.

ഡീബഗ് കമാന്ഡ് ഒരു കെണികളെ മാറ്റില്ല. -D ഫ്ലാഗ് ഉപയോഗിച്ച് പ്രതീക്ഷിക്കുന്നത് ആരംഭിക്കുക.

വിച്ഛേദന കമാൻഡ് ടെർമിനലിൽ നിന്നും ഒരു ഫോർക്ക് പ്രക്രിയ വിച്ഛേദിക്കുന്നു. ഇത് പശ്ചാത്തലത്തിൽ തുടരുന്നു. പ്രക്രിയ അതിന്റെ സ്വന്തം പ്രക്രിയഗ്രൂപ്പിന് നൽകിയിരിക്കുന്നു. സ്റ്റാന്ഡേർഡ് ഐ / ഒയെ / dev / null ആയി റീഡയറക്ട് ചെയ്യുന്നു.

പശ്ചാത്തലത്തിൽ സ്ക്രിപ്റ്റ് പ്രവർത്തിക്കുന്നത് തുടരുന്നതിന് ഇനിപ്പറയുന്ന ശകലം വിച്ഛേദിക്കുന്നു.

{{fork] = = 0 വിച്ഛേദിക്കുക. . .

താഴെ പറയുന്ന സ്ക്രിപ്റ്റ് രഹസ്യവാക്ക് വായിക്കുകയും ഓരോ തവണ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്ന ഓരോ മണിക്കൂറിലും ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു. നിങ്ങൾ ഒരു തവണ ടൈപ്പുചെയ്യാൻ മാത്രമേ സ്ക്രിപ്റ്റ് പാസ്വേഡ് നൽകൂ.

send_user "password? \" expect_user -re "(. *) \ n" {{fork] "= {fork] = =" {ഉറവിടം 3600; തുടരുക} സ്പാൺ priv_prog വിച്ഛേദിക്കുന്നു പാസ്വേഡ് പ്രതീക്ഷിക്കുന്നു: $ expect_out (" 1, സ്ട്രിംഗ്) \ r ". . . പുറത്ത് }

ഷെൽ എസിൻക്രണസ് പ്രോസസ് ഫീച്ചർ (&) വഴി വിച്ഛേദിക്കുന്നതിനു് ഒരു മുൻകലം വിച്ഛേദിക്കുന്നതിനു മുൻപ് ടെർമിനൽ പരാമീറ്ററുകൾ സേവ് ചെയ്യാനും പിന്നീട് അവയെ പുതിയ ptys ആയി ഉപയോഗിക്കാനും കഴിയും. കൂടാതെ, ടെർമിനൽ ഇതിനകം വിച്ഛേദിക്കപ്പെട്ടതിനാൽ ടെർമിനലിന്റെ പാരാമീറ്ററുകൾ വായിക്കുന്നതിനുള്ള അവസരം പ്രതീക്ഷിക്കുന്നില്ല.

പുറത്തുകടക്കുക [-ഉപകരണങ്ങൾ] [status]

കാരണങ്ങൾ പുറത്തുകടക്കാൻ പ്രതീക്ഷിക്കുക അല്ലെങ്കിൽ അങ്ങനെ ചെയ്യാൻ തയാറാക്കുക.

എക്സിറ്റ് ഹാൻഡ്ലറായി അടുത്ത ആർഗ്യുമെന്റ് ഉപയോഗിക്കുവാൻ -ഇൻക്സിറ്റ് ഫ്ലാഗ് കാരണമാകുന്നു. ഒരു വാദം കൂടാതെ, നിലവിലുള്ള എക്സിറ്റ് ഹാൻഡ്ലർ തിരികെ നൽകും.

ഓപ്പറേറ്റിങ് സിസ്റ്റത്തിലേക്ക് നിയന്ത്രണം തിരികെ കൊണ്ടുപോകാൻ തയ്യാറാകാൻ തയ്യാറാകാൻ -അക്ലെറ്റ് ഫ്ലാഗുകൾ കാരണമാകുന്നു. ഉപയോക്താവ് നിർവ്വചിച്ച എക്സിറ്റ് ഹാൻഡലറും പ്രവർത്തിക്കുന്നു, ഒപ്പം പ്രതീക്ഷയുടെ സ്വന്തം ആന്തരിക ഹാൻഡ്ലറുകൾ പ്രവർത്തിക്കുന്നു. കൂടുതലൊന്നും പ്രതീക്ഷിക്കുന്നില്ല കമാൻഡ്സ് എക്സിക്യൂട്ട് ചെയ്യണം. നിങ്ങൾ മറ്റ് Tcl വിപുലീകരണങ്ങളുമൊത്ത് പ്രതീക്ഷിക്കുകയാണെങ്കില് ഇത് ഉപയോഗപ്രദമായിരിക്കും. നിലവിലുള്ള ടിപ്ക് എക്സ്റ്റൻഷനുകൾ (ടിക്ക് പരിതസ്ഥിതിയിൽ പ്രധാന ജാലകം ഉണ്ടെങ്കിൽ), മറ്റ് ടിക്ക് എക്സ്റ്റെൻഷനുകൾ വൃത്തിയാക്കാൻ കഴിയും. പ്രതീക്ഷയുടെ എക്സിറ്റ് വീണ്ടും വിളിക്കുകയാണെങ്കിൽ (എന്നിരുന്നാലും ഇത് സംഭവിക്കാം), ഹാൻഡ്ലറുകൾ പുനരാപ്യമാകില്ല.

പുറപ്പെടുന്നതിന് ശേഷം, വികസിപ്പിച്ച പ്രോസസ്സുകളിലേക്കുള്ള എല്ലാ കണക്ഷനുകളും അടഞ്ഞിരിക്കുന്നു. ക്ലോഷർ സ്പഷ്ടം പ്രക്രിയകളിലൂടെ ഒരു EOF ആയി കണ്ടെത്തും. സാധാരണ _exit (2) നടപടിക്രമത്തിനപ്പുറമുള്ള മറ്റ് പ്രവർത്തനങ്ങളല്ല പുറത്തെടുക്കുന്നത്. അതിനാൽ, EOF നായുള്ള പരിശോധനകൾ നടക്കാത്ത തുടർനടപടികളായിരിക്കും. (വ്യത്യസ്തങ്ങളായ നിരവധി സാഹചര്യങ്ങൾ നിർണ്ണയിക്കുന്നതിൽ പ്രധാനമാണ്, ഉദാഹരണമായി, ഒരു പ്ളാൻഡഡ് പ്രോസസ് അയയ്ക്കുന്നതിനുള്ള സൂചനകൾ ആണ്, എന്നാൽ ഇവ സിസ്റ്റം-ആശ്രിതമാണ്, സാധാരണയായി പുറംകണ്ണത്തിൽ (3) കീഴിൽ രേഖപ്പെടുത്തപ്പെടും.) പ്രവർത്തിപ്പിക്കുന്ന തുടർവിടൽ പ്രക്രിയകൾ init വഴി പാരാമീറ്റിക്കും.

സ്റ്റാറ്റസ് (അല്ലെങ്കിൽ 0 വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ) പ്രതീക്ഷിക്കുന്ന എക്സിറ്റ് നിലയായി നൽകപ്പെടും . സ്ക്രിപ്റ്റിന്റെ അവസാനം എത്തിയാൽ എക്സിറ്റ് നിഷ്ക്രിയമായി നടപ്പിലാക്കും.

exp_continue [-continue_timer]
കമാന്ഡ്് exp_continue തന്നാല് സാധാരണയായി തന്നെ മടങ്ങുമ്പോള് തന്നെ തുടര്ന്ന് തന്നെ തുടരുന്നതിന് പ്രതീക്ഷിക്കുന്നു . സ്വതവേയുള്ള exp_continue സമയപരിധി ടൈമർ പുനഃക്രമീകരിയ്ക്കുന്നു . -continue_timer ഫ്ലാഗ് വീണ്ടും ആരംഭിക്കുന്നതിൽ നിന്നും ടൈമർ തടയുന്നു. (കൂടുതൽ വിവരങ്ങൾക്ക് പ്രതീക്ഷിക്കുക .)

exp_internal [-f file] മൂല്യം
പൂജ്യം പൂജ്യമല്ലെങ്കിൽ സ്റ്റാൻഡേർഡിനെ പ്രതീക്ഷിക്കുന്നതിനായി ഡയഗണോസ്റ്റിക് ഇൻഫോർമേഷൻ ആന്തരികമായി അയയ്ക്കുന്നതിനുള്ള കൂടുതൽ കമാന്റുകൾ. മൂല്യം 0 ആണെങ്കിൽ ഈ ഔട്ട്പുട്ട് അപ്രാപ്തമാക്കി. ഡയഗനോസ്റ്റിക് വിവരങ്ങളിൽ നിന്നും ലഭിക്കുന്ന എല്ലാ പ്രതീകങ്ങളും, പാറ്റേണുകൾക്കെതിരായ നിലവിലെ ഔട്ട്പുട്ടുമായി പൊരുത്തപ്പെടുന്ന എല്ലാ ശ്രമങ്ങളും ഉൾപ്പെടുന്നു.

ഓപ്ഷണൽ ഫയൽ വിതരണം ചെയ്തിട്ടുണ്ടെങ്കിൽ, എല്ലാ സാധാരണ, ഡീബഗ്ഗിങ് ഔട്ട്പുട്ടുകളും ആ ഫയലിലേക്ക് എഴുതുന്നു (മൂല്യത്തിന്റെ മൂല്യം കണക്കിലെടുക്കാതെ). മുമ്പുള്ള ഏതെങ്കിലും ഡയഗ്നോസ്റ്റിക് ഔട്ട്പുട്ട് ഫയൽ അടച്ചു.

ഏറ്റവും സമീപകാലത്തെ ആർഗ്യുമെന്റുകളുടെ ആർഗ്യുമെന്റുകളുടെ ഒരു വിവരണം നൽകാൻ -info ഫ്ലാഗ് exp_internal കാരണമാകുന്നു.

exp_open [ആർഗുകൾ] [-i spawn_id]
യഥാർത്ഥ സ്കോൺ ഐഡിക്ക് യോജിക്കുന്ന ഒരു Tcl ഫയൽ ഐഡന്റിഫയർ നൽകുന്നു. അപ്പോൾ ഫയൽ ഐഡന്റിഫയർ ടികെക് ഓപ്പൺ കമാൻഡ് ഉപയോഗിച്ച് തുറക്കാവുന്നതു പോലെ ഉപയോഗിക്കാം. (സ്പാൺ ഐഡി ഇനി ഉപയോഗിക്കരുത്.ഒരു കാത്തിരിപ്പ് നടപ്പാക്കാൻ പാടില്ല.

പ്രതീക്ഷിക്കുന്ന കമാൻഡുകൾ വഴിയുള്ള പ്രവേശനത്തിനായി സ്നോൺ ഐഡി തുറന്നുവച്ച -ലേവിയോപൻ ഫ്ലാഗ് ഉപേക്ഷിക്കുന്നു. ഒരു കാത്തിരിപ്പ് സ്പാൺ ഐഡിയിൽ എക്സിക്യൂട്ട് ചെയ്യണം.

exp_pid [-i spawn_id]
നിലവിൽ സ്പോൺ ചെയ്ത പ്രക്രിയയുമായി ബന്ധപ്പെട്ട പ്രോസസ്സ് ഐഡി നൽകുന്നു. -i ഫ്ലാഗ് ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, നൽകിയിരിക്കുന്ന സ്ലൈഡ് ഐഡിയുടെ പിൻഭാഗത്തേക്ക് പിൻ സമർപ്പിക്കും .

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 ഒരു പിശക് നൽകുന്നു, പക്ഷേ സ്ക്രിപ്റ്റിന്റെ ചെറിയ നമ്പർ പ്രവർത്തിപ്പിക്കുന്ന പ്രതീക്ഷയേക്കാൾ കൂടുതലാണ്.

മൂന്നാമത്തെ പതിപ്പാണ് പതിപ്പ് താരതമ്യത്തിൽ ഒരു പങ്കുമില്ലാത്ത ഒരു സംഖ്യയാണ്. എന്നിരുന്നാലും, പ്രതീക്ഷിക്കുന്ന സോഫ്റ്റ്വെയർ വിതരണത്തെ മാറ്റം വരുത്തുന്നത് വർദ്ധിപ്പിക്കും, ഉദാഹരണത്തിന് അധിക ഡോക്യുമെന്റേഷൻ അല്ലെങ്കിൽ ഒപ്റ്റിമൈസേഷൻ. ഓരോ പുതിയ ലഘു പതിപ്പിനും അത് പുനഃസജ്ജമാക്കിയിരിക്കുന്നു.

-exit ഫ്ലാഗ് ഉപയോഗിക്കുമ്പോൾ, ഒരു പതിപ്പ് പ്രിന്റ് ചെയ്തുകഴിഞ്ഞ് , പതിപ്പ് കാലഹരണപ്പെട്ടാൽ പുറത്തു കടക്കുമെന്ന് പ്രതീക്ഷിക്കുക .

[[ops] pat1 body1] ... [-opts]
പ്ലാൻഡഡ് പ്രക്രിയയുടെ ഔട്ട്പുട്ടിനു യോജിക്കുന്ന രീതികളിലൊന്നില് ഒരു നിശ്ചിത കാലാവധി കടന്നുവരുന്നതുവരെ കാത്തിരിക്കുകയോ അവസാനാവാദമോ കാണും വരെ കാത്തിരിക്കുന്നു. അവസാനത്തെ ഭാഗം ശൂന്യമാണെങ്കിൽ, അത് ഒഴിവാക്കാവുന്നതാണ്.

മറ്റേതൊരു പാറ്റേണുകൾക്കുമുമ്പുള്ള ഏറ്റവും അവസാനത്തെ expect_before കമാൻഡിൽ നിന്നുള്ള പാറ്റേണുകൾ പൂർണ്ണമായും ഉപയോഗിക്കപ്പെടുന്നു. മറ്റേതെങ്കിലും പാറ്റേണുകൾക്ക് ശേഷം ഏറ്റവും അവസാനത്തെ expect_after ആജ്ഞയിൽ നിന്ന് മനസ്സിലാക്കാൻ കഴിയുന്ന രീതികൾ ഉപയോഗിക്കുന്നു.

മുഴുവൻ പ്രതീക്ഷയ്ക്കുമുള്ള പ്രസ്താവനയ്ക്കുള്ള ആർഗ്യുമെന്റുകൾ ഒന്നിൽ കൂടുതൽ വരികൾ ആവശ്യമാണെങ്കിൽ, എല്ലാ വരികളും ഒരു വരിയിലേക്ക് മാറ്റണം, അങ്ങനെ ഓരോ വരിയും ഒരു ബാക്ക്ലാഷ് ഉപയോഗിച്ച് അവസാനിപ്പിക്കുക. ഈ ഒരു സാഹചര്യത്തിൽ, ബ്രേസുകൾക്കിടയിലുള്ള സാധാരണ ടിക് വർക്കറികൾ സംഭവിക്കും.

ഒരു പാറ്റേൺ കീവേഡ് eof ആണെങ്കിൽ , അനുയോജ്യമായ ബോഡി അവസാനിക്കുന്നതായിരിക്കും. ഒരു പാറ്റേൺ കീവേഡ് ടൈംഔട്ട് ആണെങ്കിൽ, അനുബന്ധ ശരീരം കാലഹരണപ്പെടുന്നതിന് അനുസരിച്ച് പ്രവർത്തിക്കുന്നു. ടൈംഔട്ട് കീവേഡ് ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, ഒരു ഇൻപുട്ട് നൾ പ്രവർത്തി സമയം കാലഹരണപ്പെടുന്നതാണ്. സ്വതവേയുള്ള സമയപരിധികളുടെ കാലാവധി 10 സെക്കന്റാണ്, പക്ഷെ 30 സെറ്റിനൊപ്പം സജ്ജമാക്കാം, "set timeout 30" എന്ന കമാണ്ട്. അനന്തമായ ടൈംഔട്ട് മൂല്യ മൂല്യ പ്രകാരം സൂചിപ്പിച്ചിരിക്കാം. ഒരു പാറ്റേൺ സ്ഥിരസ്ഥിതി കീവേഡാണെങ്കിൽ, അനുബന്ധ ഘടകം അല്ലെങ്കിൽ കാലാവധി തീരുന്നതിന് അനുസൃതമായി പ്രവർത്തിക്കുന്നു.

ഒരു പാറ്റേൺ പൊരുത്തപ്പെടുന്നെങ്കിൽ, അനുബന്ധ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു. ബോഡി (അല്ലെങ്കിൽ പാറ്റേൺ പൊരുത്തപ്പെട്ടില്ലെങ്കിൽ ശൂന്യമായ സ്ട്രിംഗ്) ഫലത്തിന്റെ ഫലം നൽകുമെന്ന് പ്രതീക്ഷിക്കുന്നു . ഒന്നിലധികം പാറ്റേണുകൾ പൊരുത്തപ്പെടുന്ന സാഹചര്യത്തിൽ, ആദ്യം പ്രത്യക്ഷപ്പെടുന്നത് ഒരു ബോഡി തിരഞ്ഞെടുക്കുന്നതിന് ഉപയോഗിക്കുന്നു.

പുതിയ ഔട്ട്പുട്ട് ലഭിക്കുമ്പോൾ ഓരോ പാറ്റേണും ഓരോ പട്ടികയിലും താരതമ്യം ചെയ്യപ്പെടും. അതിനാൽ, ഒരു പ്രോംപ്റ്റിനെ പോലെയുള്ള പ്രത്യക്ഷപ്പെടാനിടയുള്ള ഏതെങ്കിലും വ്യക്തിയുണ്ടെങ്കിൽ അവസാനത്തെ പാറ്റേൺ ഉപയോഗിച്ച് ഒരു പൊരുത്തം നഷ്ടപ്പെടാതെ പരീക്ഷിക്കാം. ആവശ്യപ്പെടാത്ത സാഹചര്യങ്ങളിൽ, നിങ്ങൾ ടൈംഔട്ട് ഉപയോഗിക്കണം (നിങ്ങൾ നേരിട്ട് ഇടപഴകുന്നതായി തോന്നുകയാണെങ്കിൽ).

പാറ്റേണുകൾ മൂന്നു തരത്തിൽ വ്യക്തമാക്കിയിരിക്കുന്നു. സ്വതവേ, പാറ്റേണുകൾ ടിക്ക് സ്ട്രിങ് പൊരുത്തം ഉപയോഗിച്ച് നൽകപ്പെടുന്നു . (ഇത്തരം പാറ്റേണുകൾ സാധാരണയായി "ഗ്ലോബ്" പാറ്റേണുകൾ എന്നു വിളിക്കുന്ന C-shell റെഗുലർ എക്സ്പ്രഷനുകളെ സമാനമാണ്. ഫ്ലാഗുകൾ പ്രതീക്ഷിക്കുന്നത് പൊരുത്തപ്പെടുത്തുന്നതിനുള്ള പാറ്റേണുകൾ പരിരക്ഷിക്കാൻ -gl ഫ്ലാഗ് ഉപയോഗിക്കാനിടയുണ്ട്. "-" തുടങ്ങുന്ന ഏതു പാറ്റേണും ഈ രീതിയിൽ സംരക്ഷിക്കണം. ("-" തുടങ്ങുന്ന എല്ലാ സ്ട്രിംഗുകളും ഭാവിയിലുള്ള ഓപ്ഷനുകൾക്കായി കരുതി വച്ചിരിക്കുന്നു.)

ഉദാഹരണത്തിന്, ഒരു വിജയകരമായ പ്രവേശനത്തിനായി താഴെ പറയുന്ന ഭാഗം കാണുന്നു. ( ഉപേക്ഷിക്കുക എന്നത് സ്ക്രിപ്റ്റിൽ മറ്റെവിടെയെങ്കിലും നിർവ്വചിച്ചിരിക്കുന്ന ഒരു പ്രക്രിയ ആണെന്ന് കരുതുന്നു.)

തിരക്കിലാണ് \ തിരക്കിലാണ് \ n പ്രതീക്ഷിക്കുന്നു; exp_continue} പരാജയപ്പെട്ടു "അസാധുവായ രഹസ്യവാക്ക്" അസാധു സമയത്തു് ഉപേക്ഷിച്ചു് ഉപേക്ഷിയ്ക്കുന്നു}

നാലിൽ പാറ്റേൺ ആവശ്യമുള്ള ഉദ്ധരണികൾ ഒരു സ്പെയ്സ് ഉള്ളതിനാൽ, ആ പ്രവൃത്തിയിൽ നിന്ന് പാറ്റേൺ വേർതിരിച്ചെടുക്കാൻ കഴിയും. ഒരേ പ്രവൃത്തിക്കുള്ള പാറ്റേണുകൾ (3-ഉം 4-ഉം പോലുള്ളവ) പ്രവർത്തനങ്ങൾ വീണ്ടും പട്ടികപ്പെടുത്തേണ്ടതുണ്ട്. Regexp-style പാറ്റേണുകൾ ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുക (താഴെ കാണുക). ഗ്ലോബ് ശൈലി പാറ്റേണുകൾ രൂപപ്പെടുത്തുന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ Tcl മാന്വലിൽ കാണാം.

Regexp-style പാറ്റേണുകൾ Tcl ന്റെ regexp ("റെഗുലർ എക്സ്പ്രഷൻ" എന്നതിന്റെ ഹ്രസ്വ) നിർവ്വചിച്ച വാക്യഘടന പിന്തുടരുന്നു. regexp പാറ്റേണുകൾ പതാകയോടൊപ്പമുള്ളതാണ്. ഒരു regexp കമാൻഡ് ഉപയോഗിച്ച് മുൻ ഉദാഹരണം തിരുത്തുവാൻ കഴിയും:

തിരക്കിലാണ് \ തിരക്കിലാണ് \ n പ്രതീക്ഷിക്കുന്നു; exp_continue} -re "പരാജയപ്പെട്ടു | അസാധുവായ രഹസ്യവാക്ക്" കാലാവധി നിർത്തലാക്കി നിർത്തലാക്കിയിട്ടുണ്ടു്}

രണ്ട് തരം പാറ്റേണുകൾ "യൂണിഫോം" ആണ്. ഇതിനർത്ഥം, പാറ്റേണുകൾ മുഴുവൻ സ്ട്രിംഗുമായി പൊരുത്തപ്പെടേണ്ടതില്ല എന്നാണ്, എന്നാൽ സ്ട്രിംഗിൽ എവിടെയൊക്കെ മത്സരം ആരംഭിക്കാനും അവസാനിപ്പിക്കാനും കഴിയും (മറ്റെല്ലാറ്റിനും യോജിക്കുന്നിടത്തോളം). ഒരു സ്ട്രിംഗിന്റെ ആരംഭവുമായി പൊരുത്തപ്പെടുത്താൻ ^ ഉപയോഗിക്കുക, അവസാനിക്കുന്നതിനായി $ ഉപയോഗിക്കുക. ഒരു സ്ട്രിംഗിന്റെ അവസാനം നിങ്ങൾ കാത്തിരിക്കുന്നില്ലെങ്കിൽ, സ്പാഡിന്റെ മധ്യത്തിൽ നിങ്ങളുടെ പ്രതികരണങ്ങൾ എളുപ്പത്തിൽ അവസാനിക്കാനിടയുണ്ട്, കാരണം അവർ സ്പാൺ ചെയ്ത പ്രോസസ്സ് മുതൽ പ്രതികരിക്കുന്നതാണ്. ശരിയായ ഫലങ്ങൾ ഉൽപാദിപ്പിക്കുന്ന സമയത്ത്, ഉൽപാദനത്തിന് അസ്വാഭാവികതയുണ്ട്. ഒരു സ്ട്രിങ്ങിന്റെ അവസാനത്തെ കഥാപാത്രങ്ങളെ കൃത്യമായി വിശദീകരിക്കാൻ കഴിയുമെങ്കിൽ $ $ ഉപയോഗിക്കുന്നത് പ്രോത്സാഹിപ്പിക്കുന്നു.

പല എഡിറ്റർമാരിൽ, യഥാക്രമം ^ ഉം $ ഉം തുടർച്ചയായി രേഖകളുടെ ആരംഭവും അവസാനവുമാണെന്നത് ഓർക്കുക. എന്നിരുന്നാലും, പ്രതീക്ഷിക്കുന്നത് ലൈൻ ഓറിയന്റഡ് അല്ല, ഈ പ്രതീകങ്ങൾ നിലവിൽ പൊരുത്തപ്പെടുന്ന ബഫർ പ്രതീക്ഷിക്കുന്ന ഡാറ്റയുടെ ആരംഭവും അവസാനവും (ലൈനുകൾക്ക് എതിരായി) യോജിക്കുന്നു. (അതോടൊപ്പം, "സിസ്റ്റം അൾജേഷ്യം" എന്നതിലെ കുറിപ്പ് കാണുക.)

പാറ്റേൺ "കൃത്യമായ" സ്ട്രിംഗായി പൊരുത്തപ്പെടുത്തുന്നതിന് -ex ഫ്ലാഗ് കാരണമാകുന്നു. *, ^, തുടങ്ങിയവയുടെ വ്യാഖ്യാനങ്ങളൊന്നും ഉണ്ടാകാറില്ല (സാധാരണ ടിക് കൺവെൻഷനുകൾ തുടർന്നും പാലിക്കപ്പെട്ടിരിക്കണം). കൃത്യമായ പാറ്റേണുകൾ എല്ലായ്പ്പോഴും നിരുത്തരവാദികളാണ്.

-nocase ഫ്ലാഗ് ഔട്ട്പുട്ടിന്റെ വലിയ അക്ഷരങ്ങൾ ചെറിയ അക്ഷരങ്ങളായി കണക്കാക്കുന്നതുപോലെ കാണിക്കുന്നു. പാറ്റേൺ ബാധിക്കപ്പെട്ടില്ല.

2000 ത്തിലധികം ബൈറ്റുകൾക്ക് മുമ്പത്തെ ബൈറ്റുകളെ "മറന്നുപോകാൻ" നിർബന്ധിതമാക്കും. ഇത് ഫംഗ്ഷൻ match_max മായി മാറ്റാവുന്നതാണ് . (അമിതമായി വലിയ മൂല്യങ്ങൾ പാറ്റേൺ മാച്ചർ വേഗത കുറയ്ക്കാൻ സഹായിക്കും.) Patlist full_buffer ആണെങ്കിൽ, match_max ബൈറ്റുകൾ ലഭിച്ചാൽ മറ്റേതെങ്കിലും പാറ്റേണുകൾ പൊരുത്തപ്പെടുന്നുവെങ്കിൽ, ബന്ധപ്പെട്ട ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഫുൾ_ബേഫർ കീവേഡ് ഉപയോഗിച്ചിട്ടുണ്ടോ ഇല്ലയോ, മറന്നുപോയ പ്രതീകങ്ങൾ expect_out (ബഫർ) എഴുതപ്പെടുന്നു.

പേറ്റലിസ്റ്റ് കീവേഡ് പൂജ്യം ആണെങ്കിൽ, nulls അനുവദനീയമാണ് ( remove_nulls കമാൻഡ് വഴി), ഒരൊറ്റ ആസ്കിഐ 0 മായി പൊരുത്തപ്പെട്ടാൽ അനുയോജ്യമായ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഗ്ലോബ് അല്ലെങ്കിൽ regexp പാറ്റേണുകൾ വഴി 0 ബൈറ്റുകൾക്ക് യോജിക്കാൻ കഴിയില്ല.

ഒരു പാറ്റേൺ (അല്ലെങ്കിൽ eof അല്ലെങ്കിൽ full_buffer) പൊരുത്തപ്പെടുന്നതിന് ശേഷം, പൊരുത്തമില്ലാത്തതും മുമ്പ് പൊരുത്തപ്പെടാത്തതുമായ ഔട്ട്പുട്ട്, വേരിയബിൾ expect_out (ബഫർ) ൽ സംരക്ഷിക്കപ്പെടുന്നു . Expect_out (9, സ്ട്രിംഗ്) വഴി വേരിയബിളുകൾ expect_out (1, string) ൽ 9 regexp സബ്ജക്ടുകൾ പൊരുത്തപ്പെടുന്നു . ഒരു മാതൃകയിൽ- ഇൻഡസ് പതാക ഉപയോഗിക്കപ്പെടുന്നെങ്കിൽ, 10 സ്ട്രിംഗുകളുടെ ആരംഭവും അവസാനിക്കുന്ന ഇൻഡിക്കസും (X, ആരംഭം) , എക്സ് എക്സിടൂൺ (എക്സ്, എൻഡ്) , വേരിയബിൾസ് അക്കം, ബഫറിലെ സബ്സ്റ്റിറ്റിയൂൺ സ്ഥാനം നൽകുന്നു. 0, മുഴുവൻ പാറ്റേണിനേയും പൊരുത്തപ്പെടുത്തുന്ന സ്ട്രിങ്ങുകളെ സൂചിപ്പിക്കുന്നു, ഗ്ലോബ് പാറ്റേണുകൾക്കും regexp പാറ്റേണുകൾക്കും വേണ്ടി നിർമ്മിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു പ്രോസസ് "abcdefgh \ n" എന്നതിന്റെ ഉൽപാദനം ഉൽപാദിപ്പിച്ചുവെങ്കിൽ:

പ്രതീക്ഷിക്കുന്നു "സിഡി"

താഴെ പറയുന്ന പ്രസ്താവനകൾ നടപ്പിലാക്കിയതുപോലെ:

set expect_out (0, സ്ട്രിംഗ്) സിഡി സെറ്റ് expect_out (ബഫർ) abcd

ഔട്ട്പുട്ട് ബഫറിൽ "efgh \ n" അവശേഷിക്കുന്നു. ഒരു പ്രക്രിയ ഔട്ട്പുട്ട് "abbbcabkkkka \ n" ഉണ്ടാക്കിയാൽ, അതിന്റെ ഫലം:

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

താഴെ പറയുന്ന പ്രസ്താവനകൾ നടപ്പിലാക്കിയതുപോലെ:

(1, തുടരണം) 2 സെറ്റ് expect_out (1, അവസാനത്തെ) 3 സെറ്റ് expect_out (1, സ്ട്രിംഗ്) ബി ബി സെറ്റ് expect_out (1, അവസാനം) സെറ്റ് expect_out (0, തുടക്കം) 1 സെറ്റ് expect_out (0, അവസാനം) 10 സെറ്റ് expect_out (0, സ്ട്രിംഗ്) bbbcabkkkk സെറ്റ് expect_out (2, ആരംഭം) 10 സെറ്റ് expect_out (2, അവസാനം) 10 സെറ്റ് expect_out (2, സ്ട്രിംഗ്) k സെറ്റ് expect_out (ബഫർ) abbbcabkkkk

ഔട്ട്പുട്ട് ബഫറിൽ "a \ n" അവശേഷിക്കുന്നു. പ്രക്രിയയിൽ നിന്നും കൂടുതൽ ഔട്ട്പുട്ട് വായിക്കാതെയും ഔട്ട്പുട്ട് ബഫറിന്റെ "*" (-R. * *) പാറ്റേൺ ഫ്ലഷ് ചെയ്യും.

സാധാരണ, അന്തിമ ഇൻപുട്ട് ബഫറുകളിൽ നിന്നും പൊരുത്തപ്പെട്ട ഔട്ട്പുട്ട് നിരസിക്കപ്പെടും. -നധാന്ത പതാകയ്ക്കൊപ്പം ഒരു പാറ്റേൺ പ്രീഫിക്സ് ചെയ്തുകൊണ്ട് ഇത് തടയപ്പെട്ടേക്കാം. പരീക്ഷണങ്ങളിൽ ഈ പതാക വളരെ പ്രയോജനപ്രദമാണ് (പരീക്ഷണസമയത്ത് സൌകര്യത്തിനായി "ചുരുക്കി" എന്ന് ചുരുക്കി പറയാം).

പൊരുത്തപ്പെടുന്ന ഔട്ട്പുട്ടുമായി (അല്ലെങ്കിൽ eof അല്ലെങ്കിൽ full_buffer) ബന്ധപ്പെട്ട സ്പാൻ ഐഡി expected_out -ൽ (spawn_id) സംഭരിച്ചിരിക്കുന്നു.

ടൈം ഔട്ട് വേരിയന്റെ മൂല്യം ഉപയോഗിയ്ക്കുന്നതിനു് പകരം, ഇതു് സമയപരിധി ഉപയോഗിയ്ക്കുവാൻ സമയപരിധി ഉപയോഗിയ്ക്കുന്നു.

സ്വതവേ, പാറ്റേണുകൾ നിലവിലുള്ള പ്രക്രിയയിൽ നിന്നും ഔട്ട്പുട്ടിനു് പൊരുത്തപ്പെടുന്നവയാണെങ്കിലും, -a ഫ്ലാഗ് പറയുന്ന പേരു് അനുസരിച്ചുള്ള spawn_id പട്ടികയിൽ നിന്നും താഴെ പറയുന്ന പാറ്റേണുകളിൽ (അടുത്ത് -i വരെ ) പൊരുത്തപ്പെടുന്നു. Spawn_id പട്ടിക സ്പോൺ_വൈഡുകളുടെ വൈറ്റ്സ്പേസ് വേർതിരിച്ച പട്ടിക ആയിരിക്കണം അല്ലെങ്കിൽ spawn_ids അത്തരം ഒരു ലിസ്റ്റ് സൂചിപ്പിക്കുന്ന ഒരു വേരിയബിൾ ആയിരിക്കണം.

ഉദാഹരണത്തിന്, താഴെ കൊടുത്തിരിക്കുന്ന ഉദാഹരണം നിലവിലുള്ള പ്രോസസിൽ നിന്നും "കണക്ട് ചെയ്തിരിയ്ക്കാം" അല്ലെങ്കിൽ $ proc2 എന്ന പേരുള്ള spawn_id ൽ നിന്നും "തിരക്കുള്ള", "പരാജയപ്പെട്ടു" അല്ലെങ്കിൽ "അസാധുവായ രഹസ്യവാക്ക്" എന്നിവ കാത്തിരിക്കുന്നു.

പ്രതീക്ഷിക്കുന്നത് {-i $ proc2 തിരക്കിലാണ് {busy} n സ്ഥാപിക്കുന്നു n; exp_continue} -re "പരാജയപ്പെട്ടു | അസാധുവായ രഹസ്യവാക്ക്" കാലാവധി നിർത്തലാക്കി നിർത്തലാക്കിയിട്ടുണ്ടു്}

നിലവിലെ പ്രതീക്ഷയുടെ കമാൻഡിൽ മറ്റെല്ലാ-ഫ്ലാഗുകളുമൊത്ത് നൽകിയിരിക്കുന്ന ഏതൊരു spawn_ids- ലും പാറ്റേണുകൾ പൊരുത്തപ്പെടുത്തുന്നതിന് ആഗോള വേരിയബിളിന്റെ any_spawn_id ന്റെ മൂല്യം ഉപയോഗിക്കാം. ഏതെങ്കിലും _spawn_id- മായി ബന്ധപ്പെട്ട നിർദ്ദേശത്തിൽ അതേ പാറ്റേണുകളുമായി ബന്ധപ്പെട്ട പാറ്റേൺ ഇല്ലെങ്കിൽ (അതായത്, - -അതിനാൽ തന്നെ മറ്റൊരു ഉപയോക്താവ് -ഉപയോഗിച്ച്) സ്പാൻ_ഡിഡ് ലഭ്യമാക്കും.

-i ഫ്ലാഗ് ഒരു ആഗോള വേരിയബിളിന്റെ പേരിലായിരിക്കാം, സ്പെയ്ന്റെ ഐഡികളുടെ പട്ടികയിൽ വേരിയബിൾ വായിച്ചാൽ. വേരിയബിൾ അത് മാറുന്ന സമയത്ത് റീഡ് ചെയ്യുന്നു. കമാൻഡ് എക്സിക്യൂഷൻ ചെയ്യുമ്പോൾ I / O സ്രോതസ്സ് മാറ്റുന്നതിനുള്ള ഒരു മാർഗ്ഗം ഇത് നൽകുന്നു. സ്പോൺ ഐഡികൾ ഇതിനെ "പരോക്ഷമായ" സ്പോൺ ഐഡികൾ എന്ന് വിളിക്കുന്നു.

സാധാരണ പോലെ പെരുമാറുന്നതിനായി നിയന്ത്രണം ഉണ്ടാക്കുന്നതിനും (അതായത്, proc , വേണ്ടി ) തുടർന്നും വരുന്ന പ്രവർത്തനങ്ങൾ. കമാന്ഡ്് exp_continue തന്നാല് സാധാരണയായി തന്നെ മടങ്ങുമ്പോള് തന്നെ തുടര്ന്ന് തന്നെ തുടരുന്നതിന് പ്രതീക്ഷിക്കുന്നു .

ഇത് പ്രത്യക്ഷമായ ലൂപ്പുകൾ ഒഴിവാക്കുന്നതോ അല്ലെങ്കിൽ തുടർച്ചയായി പ്രതീക്ഷിക്കുന്ന പ്രസ്താവനകൾക്കോ ​​ഇത് ഉപയോഗപ്രദമാണ്. Rlogin ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനായി ഒരു fragment ന്റെ ഭാഗമാണ് താഴെ കൊടുത്തിരിക്കുന്നത്. Rlogin ഒരു രഹസ്യവാക്ക് ആവശ്യപ്പെടുകയാണെങ്കിൽ, രണ്ടാമത്തെ പ്രതീക്ഷയ്ക്കു് സ്റ്റേറ്റ്മെന്റ് എഴുതുന്നതു് (വീണ്ടും പ്രോംപ്റ്റിനായി തിരയുന്നതിനായി) exp_continue ഒഴിവാക്കുന്നു.

$ host = "send_user" (. *) \ n "send_user" \ n "$ expect_out (1, string) \ r" stty "എന്ന പേരിൽ $ {password} {stty-holdo send_user" password ($ ഉപയോക്താവിനുള്ള) echo exp_continue} തെറ്റായ {send_user "തെറ്റായ രഹസ്യവാക്ക് അല്ലെങ്കിൽ അക്കൌണ്ട് \ n" exit} സമയപരിധി \ "$ send_user \" exit} വീണ്ടും $ പ്രോംപ്റ്റ്

ഉദാഹരണത്തിന്, ഇതിനകം പൂർണ്ണമായും സ്വപ്രേരിതമായിട്ടുള്ള ഒരു ആശയവിനിമയത്തെ ഉപയോക്താവിന് സഹായിക്കാൻ താഴെക്കാണുന്ന ശീർഷകം സഹായിച്ചേക്കാം. ഈ കേസിൽ, ടെർമിനൽ അസംസ്കൃത മോഡിലാണ്. ഉപയോക്താവ് "+" അമർത്തിയാൽ, ഒരു വേരിയബിൾ വർദ്ധിപ്പിക്കും. "പി" അമർത്തിയാൽ, പല വരുമാനങ്ങളും ഈ പ്രക്രിയയിലേക്ക് അയയ്ക്കപ്പെടുന്നു, ഒരുപക്ഷേ അത് ആവർത്തിക്കാനും "ഞാൻ" ഉപയോക്താവിനോട് പ്രക്രിയയുമായി ഇടപഴകാനും, സ്ക്രിപ്റ്റിൽ നിന്ന് നിയന്ത്രണം ഒഴിവാക്കാനും അനുവദിക്കുന്നു. ഓരോ സാഹചര്യത്തിലും, നിലവിലുള്ള പ്രവർത്തനത്തെ നിർവ്വഹിച്ച ശേഷം നിലവിലുള്ള പാറ്റേൺ മാസ്റ്ററിനെ തുടരാൻ പ്രതീക്ഷിക്കുന്നതാണ് Exp_continue .

stty raw -echo expect_after {-i $ user_spawn_id "p" {send "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {സംവദിക്കുക; exp_continue} "പുറത്തുകടക്കുക" പുറത്തുകടക്കുക

സ്വതവേ, exp_continue സമയപരിധി ടൈമർ പുനഃക്രമീകരിയ്ക്കുന്നു . Exp_continue -continue_timer ഫ്ലാഗ് ഉപയോഗിച്ചു എങ്കിൽ, ടൈമർ പുനരാരംഭിച്ചിട്ടില്ല.

expect_after [expect_args]
പ്രതീക്ഷിക്കുന്നതിനും പ്രതീക്ഷിക്കുന്നതിനും പ്രതീക്ഷിക്കുന്നതിനും പ്രതീക്ഷിക്കുന്നതിനും കഴിയുമെങ്കിൽ expected_after എന്ന രീതിയിൽ പ്രവർത്തിക്കുന്നു, പ്രതീക്ഷിക്കുന്ന മാതൃക ഉപയോഗിക്കും. കൂടുതൽ വിവരങ്ങൾക്കായി expect_before കമാൻഡ് കാണുക.

expect_background [expect_args]
ഒരേ വാദങ്ങൾ പ്രതീക്ഷിക്കുന്നു , പക്ഷേ അത് ഉടൻ തന്നെ തിരികെ നൽകുന്നു. പുതിയ ഇൻപുട്ട് എത്തുമ്പോഴെല്ലാം പാറ്റേണുകൾ പരീക്ഷിക്കപ്പെടും. പാറ്റേണ് ടൈംഔട്ട് , സ്വതവേയുള്ളവ എന്നിവ expect_background ന് നിശബ്ദമാകുകയും നിശബ്ദമായി നിരാകരിക്കുകയും ചെയ്യുന്നു. അല്ലെങ്കിൽ, expect_background കമാൻഡ് പ്രതീക്ഷിക്കുന്നത് പോലെ expect_before പ്രതീക്ഷിക്കുന്ന expect_after പാറ്റേണുകൾ ഉപയോഗിക്കുന്നു.

Expect_background പ്രവർത്തനങ്ങൾ വിലയിരുത്തുമ്പോൾ, അതേ സ്പോൺ ഐഡിനുള്ള പശ്ചാത്തല പ്രോസസ്സ് തടഞ്ഞു. പ്രവർത്തനം പൂർത്തിയാകുമ്പോൾ പശ്ചാത്തല പ്രോസസ്സിംഗ് തടയൽ മാറ്റുന്നു. പശ്ചാത്തല പ്രോസസ്സ് തടയപ്പെട്ടുകൊണ്ടിരിക്കുമ്പോൾ, ഒരു സ്പോൺ ഐഡിയിൽ പ്രതീക്ഷിക്കാനാകുമോ (ഫോർഗ്രൗണ്ട്) ചെയ്യാൻ സാധിക്കും.

Expect_background അൺബ്ലോക്ക് ചെയ്യുമ്പോൾ ഒരു പ്രതീക്ഷ പ്രവർത്തിപ്പിക്കാൻ സാധ്യമല്ല. ഒരു സ്പാൺ ഐഡിയുമായി ഒരു പുതിയ expect_background പ്രഖ്യാപിച്ചുകൊണ്ട് ഒരു പ്രത്യേക സ്പോൺ ഐഡിക്ക് expected_background ഇല്ലാതാക്കപ്പെടും. പാറ്റേൺ ഇല്ലാതെ expect_background പറിച്ച പശ്ചാത്തലത്തിൽ പാറ്റേണുകൾ പൊരുത്തപ്പെടുത്തുന്നതിനുള്ള ശേഷിയിൽ നിന്നും നൽകിയിരിക്കുന്ന സ്പോൺ ഐഡി നീക്കം ചെയ്യുന്നു.

expect_before expect_args
ഒരേ വാദങ്ങൾ പ്രതീക്ഷിക്കുന്നു , പക്ഷേ അത് ഉടൻ തന്നെ തിരികെ നൽകുന്നു. അതേ സ്പാൺ ഐഡിക്ക് മുൻപുള്ള ഏറ്റവും പുതിയ പ്രതീക്ഷകൾ മുതൽ പാറ്റേൺ ആക്ഷൻ ജോഡുകൾ ഏതെങ്കിലുമൊരു പ്രതീക്ഷയോടൊപ്പം പ്രതീക്ഷിക്കുന്നു . ഒരു പാറ്റേൺ പൊരുത്തപ്പെടുന്നെങ്കിൽ, അത് പ്രതീക്ഷയുടെ കമാൻഡിൽ തന്നെയുള്ളതാണെന്ന് കണക്കാക്കപ്പെടുന്നു, കൂടാതെ അനുബന്ധ നിർദ്ദേശം കൺകണ്ടേഡിൽ കൺഡിഷൻ ചെയ്തിരിക്കും. പ്രതീക്ഷിക്കുന്നതിലും പ്രതീക്ഷിക്കുന്നതിലും നിന്നുമുള്ള പാറ്റേണുകൾ പൊരുത്തപ്പെടുത്താൻ കഴിയുമെങ്കിൽ, expect_before pattern ഉപയോഗിക്കുന്നു.

പാറ്റേൺ നൽകിയിട്ടില്ലെങ്കിൽ, പാറ്റേൺ ഐഡി ഏതെങ്കിലും പാറ്റേണിൽ പരിശോധിച്ചിട്ടില്ല.

Ani ഫ്ലാഗ് ഒപ്റ്റിമഡ് ചെയ്തില്ലെങ്കിൽ , expect_before ആജ്ഞ നടപ്പിലാക്കിയ സമയത്തു് (അതു് പാറ്റേൺ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ) നിർവ്വചിച്ച സ്പോൺ ഐഡിനോടു് പൊരുത്തപ്പെടുന്ന രീതികൾ പ്രതീക്ഷിക്കുന്നു .

ഇൻഫൊ-ഫ്ലാഗുകൾക്ക് അത് എങ്ങനെയുണ്ടെന്ന് വ്യക്തമാക്കും, അത് ഏത് തരം പാറ്റേണുകളാണ് നിലവിലെ സ്പെസിഫിക്കേഷനുകൾ നൽകുമെന്ന് പ്രതീക്ഷിക്കുന്നത്. സ്വതവേ, ഇത് ഇപ്പോൾ സ്പോൺ ഐഡിയിൽ റിപ്പോർട്ട് ചെയ്യുന്നു. ആ സ്പോൺ ഐഡിയിലുള്ള വിവരത്തിനായി ഒരു ഓപ്ഷണൽ സ്പാൺ ഐഡി സ്പെസിഫിക്കേഷൻ നൽകപ്പെട്ടേക്കാം. ഉദാഹരണത്തിന്

expect_before -info -i $ proc

ഒരു സ്പാൺ ഐഡി സ്പെസിഫിക്കേഷൻ നൽകാം. പതാക - പരോക്ഷമായ സ്പെസിഫിക്കേഷനുകളിൽ നിന്നുമാത്രമുള്ള നേരിട്ടുള്ള സ്പോൺ ഐഡുകളെ നേരെ വിപരീതമാക്കുക.

ഒരു സ്പാൺ ഐഡി സ്പെസിഫിക്കേഷനുപകരം, എല്ലാ സ്പാൺ ഐഡുകളിലും റിപ്പോർട്ടുചെയ്യാൻ "-all" പതാക "-ഇൻഫോ" ചെയ്യുകയാണ്.

-info ഫ്ലാഗ് ഔട്ട്പുട്ട് വീണ്ടും പ്രതീക്ഷിക്കുന്നതിനു മുമ്പായി പുനരാരംഭിക്കും.

expect_tty [expect_args]
പ്രതീക്ഷിക്കുന്നത് പോലെയാണ് അത് / dev / tty (അതായത് ഉപയോക്താവിൽ നിന്നുള്ള കീസ്ട്രോക്കുകളിൽ നിന്നുള്ള) പ്രതീകങ്ങൾ വായിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, പാകം ചെയ്ത മോഡിലാണ് വായന ചെയ്യുന്നത്. അതിനാൽ, ലൈനുകൾ അവ പ്രതീക്ഷിച്ച് പ്രതീക്ഷയോടെ കാത്തിരിക്കണം . ഇത് സ്റ്റിക്കി വഴി മാറ്റിയേക്കാം (താഴെയുള്ള സ്റ്റൈറ്റ് കമാൻഡ് കാണുക).

expect_user [expect_args]
പ്രതീക്ഷിക്കുന്നത് പോലെയാണ് അത് സ്റ്റാൻഡിൽ (അതായത് ഉപയോക്താവിൽ നിന്നുള്ള കീസ്ട്രോക്കുകളിൽ നിന്ന്) പ്രതീകങ്ങൾ വായിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, പാകം ചെയ്ത മോഡിലാണ് വായന ചെയ്യുന്നത്. അതിനാൽ, ലൈനുകൾ അവ പ്രതീക്ഷിച്ച് പ്രതീക്ഷയോടെ കാത്തിരിക്കണം . ഇത് സ്റ്റിക്കി വഴി മാറ്റിയേക്കാം (താഴെയുള്ള സ്റ്റൈറ്റ് കമാൻഡ് കാണുക).

ഫോർക്ക്
ഒരു പുതിയ പ്രക്രിയ സൃഷ്ടിക്കുന്നു. പുതിയ പ്രോസസ് നിലവിലെ പ്രതീക്ഷയുടെ ഒരു കൃത്യമായ പകർപ്പാണ്. വിജയത്തിൽ, നാൽമൃഗം പുതിയ (കുട്ടി) പ്രക്രിയയിൽ 0 നൽകുന്നു, കൂടാതെ കുട്ടിയുടെ പ്രവർത്തന പ്രക്രിയയുടെ പ്രോസസ് ഐഡി പാരന്റ് പ്രോസസിലേക്ക് തിരികെ നൽകുന്നു. പരാജയപ്പെട്ടാൽ (വിഭവങ്ങളുടെ അഭാവം മൂലം, ഉദാഹരണം, സ്വാപ്പ് സ്പെയ്സ്, മെമ്മറി) കാരണം, നാൽപ്പത്തിരണ്ടുകൾ -1 പേരന്റ് പ്രോസസ്സിനായി നൽകുന്നു, കുട്ടിക പ്രക്രിയയൊന്നും സൃഷ്ടിക്കുന്നില്ല.

യഥാർത്ഥ പ്രക്രിയ പോലെ തന്നെ, ഫോർട്ടിന്റെ പ്രോസസ്സുകൾ എക്സിറ്റ് കമാൻഡിലൂടെ പുറത്തുകടക്കുന്നു . Forked പ്രക്രിയകൾ ലോഗ് ഫയലുകളിലേക്ക് എഴുതാൻ അനുവദിക്കപ്പെട്ടിട്ടുണ്ട്. നിങ്ങൾ ഡീബഗ്ഗിങ് പ്രവർത്തനരഹിതമല്ലെങ്കിൽ അല്ലെങ്കിൽ മിക്ക പ്രോസസ്സുകളിലും ലോഗ് ചെയ്യുന്നുണ്ടെങ്കിൽ, ഫലം ആശയക്കുഴപ്പത്തിലാക്കും.

ചില നാവിഗേഷനുകൾ ഒന്നിലധികം വായനക്കാരും എഴുത്തുകാരും കൂടി ആശയക്കുഴപ്പത്തിലാക്കും. അതിനാൽ, മുട്ടയിടുന്ന പ്രക്രിയകൾക്കു മുൻപായി അത് സുരക്ഷിതമാണ്.

സംവദിക്കുക [സ്ട്രിംഗ് 1 ബോഡി 1] ... [സ്ട്രിംഗ് [ബോഡി]]
നിലവിലുള്ള പ്രക്രിയയെ ഉപയോക്താവിനു് നിയന്ത്രിയ്ക്കുന്നു, അങ്ങനെ കീസ്ട്രോക്കുകൾ നിലവിലുള്ള പ്രക്രിയയിലേക്കു് അയയ്ക്കുന്നു, നിലവിലുള്ള പ്രക്രിയയുടെ stdout- ഉം സ്റ്റഡറും നൽകപ്പെടുന്നു.

സ്ട്രിംഗ്-ബോഡി ജോഡികൾ ആർഗ്യുമെന്റുകളായി നൽകാം, അങ്ങനെയാണെങ്കിൽ സ്ട്രിങ് എന്റർ ചെയ്യുമ്പോൾ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു. (സ്വതവേ, സ്ട്രിങ് നിലവിലുള്ള പ്രക്രിയയിലേക്ക് അയയ്ക്കുന്നില്ല.) അന്തിമ ഘടന നഷ്ടപ്പെട്ടിട്ടുണ്ടെങ്കിൽ, ഇന്റർപ്രിറ്റർ കമാൻഡ് കണക്കാക്കപ്പെടുന്നു.

ഓരോ ഇന്ററാക്റ്റ്യൂട്ട് പ്രസ്താവനയ്ക്കുമുള്ള ആർഗ്യുമെന്റുകൾ ഒന്നിൽ കൂടുതൽ വരികൾ ആവശ്യമാണെങ്കിൽ, എല്ലാ വരികളും ഒരു ബാഗിൽ തകരാറിലാക്കുന്നതു ഒഴിവാക്കാൻ ഒരു "ബ്രൌസ്" ആകും. ഈ ഒരു സാഹചര്യത്തിൽ, ബ്രേസുകൾക്കിടയിലുള്ള സാധാരണ ടിക് വർക്കറികൾ സംഭവിക്കും.

ഉദാഹരണത്തിനു്, താഴെ പറയുന്ന കമാൻഡ് നിഷ്കർഷിയ്ക്കുന്ന താഴെ പറയുന്ന സ്ട്രിങ്-ബോഡി ജോഡികളുമായി സംവദിയ്ക്കുന്നു: എപ്പോൾ ^ Z അമർത്തിയാൽ, അപ്രതീക്ഷിതമായി സസ്പെൻഡ് ചെയ്യുക. (The -set ഫ്ലാഗ് ടെർമിനൽ മോഡുകൾ പുനഃസ്ഥാപിക്കുന്നു.) ^ എ അമർത്തുമ്പോൾ, ഉപയോക്താവ് "നിങ്ങൾ ഒരു നിയന്ത്രണം- ടൈ ടൈപ്പ് ചെയ്തു", പ്രക്രിയ ഒരു ^ എ അയച്ചു. $ അമർത്തിയിരിക്കുമ്പോൾ, ഉപയോക്താവ് തീയതി കാണുന്നു. ^ സി അമർത്തപ്പെടുമ്പോൾ, exits പ്രതീക്ഷിക്കുക . "Foo" നൽകുകയാണെങ്കിൽ, ഉപയോക്താവ് "bar" കാണുന്നു. ~~ അമർത്തിയാൽ, പ്രതീക്ഷിക്കുന്ന ഇന്റർപ്രെട്ടർ പരസ്പരം പ്രവർത്തിക്കുന്നു.

സെറ്റ് CTRLZ \ 032 ഇടപെടുക {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "നിങ്ങൾ ടൈപ്പ് ചെയ്ത നിയന്ത്രണം- A \ n"; "0000"} $ {send_user "എന്ന ദിവസം അയയ്ക്കുക [ക്ലോക്ക് ഫോർമാറ്റ് [ക്ലോക്ക് സെക്കൻഡ്]]."} \ 003 exit foo {send_user "bar"} ~~}

സ്ട്രിംഗ്-ബോഡി ജോഡികളിൽ, സ്ട്രിംഗുകൾ അവ ആർഗ്യുമെന്റായി പട്ടികപ്പെടുത്തിയിരിക്കുന്ന ക്രമത്തിൽ പൊരുത്തപ്പെടുന്നു. അവശേഷിക്കുന്ന വരവിന്റെ മുൻകരുതലെത്തുന്ന ഭാഗത്ത് ഭാഗികമായി ചേർച്ചയുള്ള സ്ട്രിംഗുകൾ നിലവിലെ പ്രക്രിയയിലേക്ക് അയയ്ക്കുന്നില്ല. പ്രതീകങ്ങൾ അങ്ങനെയാണെങ്കിൽ, ഇനിമേൽ ഒരു പൊരുത്തക്കേട് ഉണ്ടായിരിക്കില്ല, സ്ട്രിംഗിന്റെ ഭാഗം മാത്രമേ മറ്റൊരു മത്സരം ആരംഭിക്കാൻ കഴിയാത്ത പ്രക്രിയക്ക് അയയ്ക്കപ്പെടുകയുള്ളൂ. അതിനാൽ, ഭാഗിക മത്സരങ്ങൾ സബ്സ്ട്രിങ്ങുകൾ ആയ സ്ട്രിങുകൾ പിന്നീട് പൊരുത്തപ്പെടാൻ ഇടയുണ്ട്, ആത്യന്തികമായി മൽസരം തീർത്തും പരാജയപ്പെടുകയാണെങ്കിൽ.

സ്വതവേ, സ്ട്രിംഗ് പൊരുത്തപ്പെടുത്തൽ കൃത്യമല്ലെങ്കിൽ വൈൾഡ് കാർഡുകളില്ല . (നേരെമറിച്ച്, കമാൻഡ് സ്വതവേ ഗ്ലോബ്-രീതിയിലുള്ള പാറ്റേണുകൾ ഉപയോഗിക്കും.) ഫ്ലാഗുകളെ പ്രതിരോധിക്കാൻ പാറ്റേൺ ചെയ്യാവുന്ന ഉപാപചയങ്ങൾ ഉപയോഗിക്കാം. "-" തുടങ്ങുന്ന ഏതു പാറ്റേണും ഈ രീതിയിൽ സംരക്ഷിക്കണം. ("-" തുടങ്ങുന്ന എല്ലാ സ്ട്രിംഗുകളും ഭാവിയിലുള്ള ഓപ്ഷനുകൾക്കായി കരുതി വച്ചിരിക്കുന്നു.)

റൊഗെപ്പ് ശൈലി മാതൃകയായി സ്ട്രിംഗ് വ്യാഖ്യാനിക്കാൻ ഈ-പതാക പ്രദർശിപ്പിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, പൊരുത്തപ്പെടുന്ന സബ്സ്ട്രിംഗുകൾ വേരിയബിൾ ഇൻററാക്റ്റൗട്ടിൽ സൂക്ഷിക്കുന്നു, അതുപോലെ തന്നെ അതിന്റെ ഉത്പന്നം വേരിയബിളിന് പ്രതീക്ഷിക്കുന്നു expect_out . ഇൻഡസ് പതാകയും ഇതേപോലെ പിന്തുണയ്ക്കുന്നു.

ഫയലിന്റെ എക്സ്ട്രാ ഫയലുപയോഗിച്ച് eof ആക്റ്റീവ് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു. ഔട്ട്പുട്ട് എഴുതുന്നതിനിടെ ഒരു eof കണ്ടുപിടിച്ചാൽ ഒരു പ്രത്യേക eof പാറ്റേൺ പൊട്ടിത്തെറിക്കുന്ന -ഔട്ട് ഫ്ലാഗ് പിന്തുടരുകയോ ചെയ്യാം. സ്വതവേയുള്ള എഫൊ പ്രവൃത്തി "റിട്ടേൺ" ആണ്, അതുവഴി ഏതെങ്കിലും EOF- ൽ മാത്രം പ്രതികരിക്കുകയും ചെയ്യുന്നു.

പാറ്റേൺ ടൈംഔട്ട് ഒരു ടൈംഔട്ട് (സെക്കൻഡുകളിൽ) പരിചയപ്പെടുത്തുന്നു, കൂടാതെ ഒരു നിശ്ചിത സമയത്തിനായി പ്രതീകങ്ങൾ ഒന്നും വായിക്കാതെയും പ്രവർത്തിപ്പിക്കുന്നു. അടുത്തിടെ നൽകിയിരിക്കുന്ന പ്രക്രിയയിൽ കാലഹരണപ്പെടൽ പാറ്റേൺ ബാധകമാണ്. സഹജമായ സമയപരിധി ഇല്ല. പ്രത്യേകം വേരിയബിൾ "ടൈംഔട്ട്" ( പ്രതീക്ഷയുടെ കമാൻഡിനു് ഉപയോഗിയ്ക്കുന്നു) ഈ സമയപരിധിയ്ക്കു് ഒരു തരത്തിലും ബാധിയ്ക്കുന്നില്ല.

ഉദാഹരണത്തിന്, ഒരു മണിക്കൂറിന് ടൈപ്പുചെയ്തിട്ടില്ലാത്ത എന്നാൽ സ്വയമേവ സന്ദേശ സന്ദേശങ്ങൾ സ്വീകരിക്കുന്ന ഉപയോക്താക്കളായ autologout ഉപയോക്താക്കൾക്ക് ഇനിപ്പറയുന്ന നിർദ്ദേശം ഉപയോഗിക്കാവുന്നതാണ്:

interact -input $ user_spawn_id സമയപരിധി 3600 തിരികെ-ഔട്ട്പുട്ട് \ $ spawn_id

പാറ്റേൺ കീവേഡ് നൾ ആണെങ്കിൽ, nulls അനുവദനീയമാണ് ( remove_nulls കമാൻഡ് വഴി), ഒരൊറ്റ ASCII 0 പൊരുത്തപ്പെടുന്നുവെങ്കിൽ ബന്ധപ്പെട്ട ബോഡി നടപ്പിലാക്കും. ഗ്ലോബ് അല്ലെങ്കിൽ regexp പാറ്റേണുകൾ വഴി 0 ബൈറ്റുകൾക്ക് യോജിക്കാൻ കഴിയില്ല.

പതാകയ്ക്കൊപ്പം ഒരു പാറ്റേൺ മുൻപ് അലങ്കരിക്കുന്നു, ഇത് പാറ്റേൺ (അല്ലെങ്കിൽ ഇഫെ) പൊരുത്തപ്പെടുന്ന spawn_id ൽ സജ്ജമാക്കാൻ വേരിയബിൾ ഇന്ററാക്റ്റ്_ഔട്ട് ( spawn_id) ഉണ്ടാക്കുന്നു.

സാധാരണ പോലെ പെരുമാറുന്നതിനായി നിയന്ത്രണം ഉണ്ടാക്കുന്നതിനും (അതായത്, proc , വേണ്ടി ) തുടർന്നും വരുന്ന പ്രവർത്തനങ്ങൾ. എന്നിരുന്നാലും, കോണ്ടാക്റ്റിന് അതിന്റെ കോളിനടുത്തേക്ക് തിരികെ ഇടപെടുമ്പോൾ ഇടപെടൽ , ഇന്റർററേറ്റർ അതിന്റെ കോളിനടുത്ത് തിരിച്ചുവരാൻ ഇടയാക്കുന്നു. ഉദാഹരണത്തിനു്, "proc foo" പരസ്പരം വിളിച്ചു് കൊണ്ടിരിയ്ക്കുന്നു, അപ്പോൾ പ്രവർത്തനം inter_return പ്രവർത്തിപ്പിച്ചു്, proc foo തിരികെ പോകുന്നു. (അതായത്, കോൾ ഇൻറർപ്രറ്റർ ഇടപെടൽ ടൈപ്പുചെയ്യൽ സംവേദനാത്മക സംവേദനം ഇടപെടാൻ ഇടയാക്കും, ഇന്റർറോൾട്ടൻ സംവേദനം അതിന്റെ കോളിലേയ്ക്ക് തിരികെ കൊണ്ടുപോകാൻ ഇടയാക്കും എന്നാണ്).

ആശയവിനിമയ സമയത്ത്, അസംസ്കൃത മോഡ് ഉപയോഗിക്കും, അതിനാൽ എല്ലാ ക്യാരക്ടറുകളും നിലവിലുള്ള പ്രോസസ് നൽകാം. നിലവിലുള്ള പ്രോസസ് തൊഴിൽ നിയന്ത്രണ സിഗ്നലുകളെ പിടികുന്നില്ലെങ്കിൽ, ഒരു നിർദ്ദിഷ്ട സിഗ്നൽ (സ്ഥിരസ്ഥിതിയായി Z- ന്) അയച്ചാൽ അത് അവസാനിപ്പിക്കും. ഇത് പുനരാരംഭിക്കുന്നതിന് ഒരു തുടർച്ചയായ സിഗ്നൽ അയയ്ക്കുക ("kill -CONT" പോലുള്ളവ). അത്തരമൊരു പ്രക്രിയയിലേയ്ക്ക് ഒരു സിഗ്സ്റ്റ്ഒപ്പ് അയയ്ക്കണമെങ്കിൽ, ആദ്യം csh സ്നോന്നിംഗ് പരിഗണിക്കുക, തുടർന്ന് നിങ്ങളുടെ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക. മറുവശത്ത്, നിങ്ങൾക്ക് ഒരു SIGSTOP അയയ്ക്കാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ, ആദ്യ കോൾ ഇന്റർപ്രെറ്റർ (ഒരു എസ്കേപ്പ് പ്രതീകം ഉപയോഗിച്ചുകൊണ്ട്), തുടർന്ന് Z ^ അമർത്തുക.

സ്ട്രിങ്-ബോഡി ജോഡികൾ ഇന്ററാപ്റ്റർ നൽകി എക്സിക്യൂട്ട് കമാൻഡുകളെ ഇൻററാക്ടറിലേക്ക് പ്രവേശിക്കാതെ ഒഴിവാക്കാനായി ഒരു ഷോർട്ട് ഹാൻഡ് ആയി ഉപയോഗിക്കാവുന്നതാണ്. ഒരു സ്ട്രിംഗ്-ബോഡി ജോഡി ശരീരം എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ മുൻ ടെർമിനൽ മോഡ് ഉപയോഗിക്കും.

വേഗതയ്ക്കായി, പ്രവർത്തനങ്ങൾ സഹജമായി മോഡിൽ പ്രവർത്തിക്കുന്നു. ഇന്ററാക്ടീവ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനു മുമ്പുള്ള (റീട്രോൾ, പാകം ചെയ്ത മോഡ്) റെൻഡർ ഫ്ലാഗ് ടെർമിനലിനെ പുനഃസജ്ജീകരിക്കുന്നു. മോഡ് സ്വിച്ച് ചെയ്യുമ്പോൾ എന്റർ ചെയ്തതു് അക്ഷരങ്ങൾ നഷ്ടപ്പെട്ടേക്കാം (ചില സിസ്റ്റങ്ങളിൽ ടെർമിനൽ ഡ്രൈവർ ഒരു നിർഭാഗ്യകരമായ സവിശേഷത). നിങ്ങളുടെ പ്രവർത്തനം വേവിച്ച മോഡിൽ പ്രവർത്തിക്കുമ്പോൾ മാത്രമേ ഉപയോഗിക്കുകയുള്ളൂ കാരണം.

ഓരോ അക്ഷരവും വായിക്കുന്നതിനനുസരിച്ച് അവ സൃഷ്ടിക്കുന്ന പ്രക്രിയയിലേക്ക് തിരികെ വരുന്ന പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന പ്രതീകങ്ങൾ -മെക്കോ ഫ്ലാഗ് അയയ്ക്കുന്നു. ഭാഗിക ടൈപ്പ് ചെയ്ത പാറ്റേണിൽ നിന്ന് ഉപയോക്താവിനെ കാണുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകും.

ഒരു പാറ്റേൺ ഉയർത്തപ്പെടുകയും എന്നാൽ ഒടുവിൽ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, പ്രതീകങ്ങൾ സ്പാൻ ചെയ്ത പ്രോസസ്സിന് അയച്ചു കൊടുക്കുകയും ചെയ്യുന്നു. പ്ളാൻഡഡ് പ്രക്രിയ അവ പ്രതിധ്വനിക്കുകയാണെങ്കിൽ, ഉപയോക്താവിന് രണ്ട് പ്രാവശ്യം പ്രതീകങ്ങൾ കാണും. പാറ്റേൺ പൂർത്തിയാക്കാൻ സാധിക്കാത്ത ഉപയോക്തൃ സാഹചര്യങ്ങളിൽ മാത്രമേ സെർച്ചിന് അനുയോജ്യം. ഉദാഹരണത്തിനു്, rtrp, recursive-ftp സ്ക്രിപ്റ്റ് എന്നിവയിൽ നിന്നും, ഇവിടെ, ~ g, ~ p, അല്ലെങ്കിൽ ~ l- ൽ എന്റർ ചെയ്യുവാൻ ആവശ്യപ്പെടുന്നു. ഇത് സാധാരണ FTP കമാൻഡുകളിൽ നിന്നും വളരെ അകലെയാണ്, ഉപയോക്താവ് തെറ്റായി ടൈപ്പുചെയ്യാൻ സാധ്യതയില്ലെന്നത്, തെറ്റായി ഒഴികെയുള്ളവയൊക്കെ, അങ്ങനെയാണെങ്കിൽ, അവർ എങ്ങിനെയെങ്കിലും ഫലത്തെ അവഗണിക്കും.

ഇടപെടൽ {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}

പ്രതീകങ്ങൾ വായിക്കുന്നതുപോലെ ഔട്ട്പുട്ട് പ്രക്രിയയിൽ ഇനിപ്പറയുന്ന പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന പ്രതീകങ്ങൾ -നൊബൊഫർ ഫ്ലാഗ് അയയ്ക്കുന്നു.

പാറ്റേൺ വീണ്ടും ഒരു പ്രോഗ്രാം എക്കോ ചെയ്യുവാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമായിരിക്കും. ഉദാഹരണമായി, ഒരു വ്യക്തിയെ വിളിക്കുന്നിടത്ത് (ഹെയ്സ്-സ്റ്റൈൽ മോഡം) എവിടെയാണ് നിരീക്ഷിക്കാനാകുന്നത് എന്ന് ഉപയോഗിച്ചേക്കാം. ഓരോ തവണയും "atd" കാണും, ബാക്കി സ്ക്രിപ്റ്റ് ബാക്കപ്പ് ലോഡ് ചെയ്യും.

$ 1 interact_out (1, string) "} interact -nobuffer" atd "lognumber

ഇന്ററാക്ടീവ് സമയത്ത്, log_user- ന്റെ മുമ്പത്തെ ഉപയോഗം അവഗണിക്കപ്പെടുന്നു. പ്രത്യേകിച്ചും, ആശയവിനിമയം അതിന്റെ ഔട്ട്പുട്ട് ലോഗ് ചെയ്യുവാൻ നിർബന്ധിതമാക്കും (സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് അയയ്ക്കുക) കാരണം ഉപയോക്താവിനെ അന്ധമായി ഇടപെടാൻ ആഗ്രഹിക്കുന്നില്ല എന്നാണ്.

ഇപ്പോഴത്തെ പ്രക്രിയയുടെ ഔട്ട്പുട്ടിനു് പ്രയോഗിയ്ക്കുന്നതിനു് താഴെ പറയുന്ന കീ-ബോഡി ജോഡികളെ -o ഫ്ലാഗ് കാരണമാകുന്നു. ഒരു ടെൽനെറ്റ് സെഷനിലെ അനാവശ്യ പ്രതീകങ്ങൾ അയയ്ക്കുന്ന ഹോസ്റ്റുകളുമായി ഇടപെടുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകും.

സ്ഥിരമായി, ഇടപെടൽ ഉപയോക്താവ് സ്റ്റാൻഡിംഗ് എഴുതും പ്രതീക്ഷിക്കുന്ന പ്രക്രിയയുടെ സ്റ്റാൻഡേർഡ് വായിക്കുന്നതും ഉപയോക്താവിനെ പ്രതീക്ഷിക്കുന്നു . ഉപയോക്താവിന് അതിന്റെ വാദം (അതായത് ഒരു സ്പൈഡ് ഐഡി ആയിരിക്കണം) പേരുള്ള പ്രക്രിയയായി -u ഫ്ലാഗ് ("യൂസർ" എന്നതിനായുള്ള) പരസ്പരപ്രവർത്തനം നടത്തുന്നു.

ഒരു സ്പഷ്ടമായ ലൂപ്പ് ഉപയോഗിക്കാതെ രണ്ട് പരസ്പര ബന്ധിതമല്ലാത്ത ഒരു കൂട്ടം ചേരാനായി ഇത് അനുവദിക്കുന്നു. ഡീബഗ്ഗിങ്ങിൽ സഹായിയ്ക്കാനായി, ഡയഗ്നോസ്റ്റിക്സ് എല്ലായ്പ്പോഴും stderr- ൽ (അല്ലെങ്കിൽ ചില ലോഗ്ഗിങ്, ഡീബഗ്ഗിംഗ് വിവരങ്ങൾക്കായി stdout) പോകുക. ഇതേ കാരണത്താൽ, ഇന്റർപ്രെട്ടർ കമാൻഡ് stdin- ൽ നിന്നും ഇന്ററാക്ടീവായി വായിക്കും.

ഉദാഹരണത്തിന്, താഴെ പറയുന്ന ശീർഷകം ഒരു ലോഗിൻ പ്രോസസ് ഉണ്ടാക്കുന്നു . അപ്പോൾ അത് ഉപയോക്താവിനെ ഡയൽ ചെയ്യുന്നു (കാണിക്കുന്നില്ല), കൂടാതെ ഒടുവിൽ ഇരുവശത്തെയും ബന്ധിപ്പിക്കുന്നു. തീർച്ചയായും, ഏതെങ്കിലും പ്രക്രിയ ലോഗിൻ ചെയ്യാൻ പകരം വയ്ക്കാം. ഒരു ഷെൽ, ഉദാഹരണം, ഒരു അക്കൌണ്ടും പാസ്വേഡും വിതരണം ചെയ്യാതെ തന്നെ പ്രവർത്തിക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കും.

spawn login set login $ spawn_id spawn tip modem # ഉപയോക്താവിനെ തിരിച്ചയയ്ക്കാൻ ഡയൽ ചെയ്യുക # ഇന്ററാക്റ്റ് -u $ ലോഗിൻ പ്രവേശിക്കാൻ ഉപയോക്താവിനെ ബന്ധിപ്പിക്കുക

ഒന്നിലധികം പ്രോസസ്സുകൾക്കായി ഔട്ട്പുട്ട് അയയ്ക്കുന്നതിന്, ഒരു -ഔട്ട് ഫ്ലാഗ് ഉപയോഗിക്കുമ്പോൾ ഓരോ സ്പോൺ ഐഡി ലിസ്റ്റും ലിസ്റ്റുചെയ്യുക. ഔട്ട്പുട്ട് സ്പാഡ് ഐഡികളുടെ ഒരു ഗ്രൂപ്പിനുള്ള ഇൻപുട്ട് ഒരു-ഇൻപുട്ട് ഫ്ലാഗ് ഉപയോഗിക്കുന്നത് സ്പാൺ ഐഡി ലിസ്റ്റിൽ നിർണ്ണയിച്ചേക്കാം. (രണ്ട്- ഇൻപുട്ടും ഔട്ട്പുട്ടും പ്രതീക്ഷിക്കുന്ന കമാൻഡിൽ -i ഫ്ലാഗ് പോലെ സമാന രൂപങ്ങളിൽ എടുക്കാം, അല്ലാതെ ഏത്_ സ്പോൺ_ഡൈറ്റ് ഇൻട്രാക്റ്റുവിൽ അർത്ഥവത്തായതല്ല.) താഴെയുള്ള എല്ലാ ഫ്ലാഗുകളും സ്ട്രിംഗുകളും (അല്ലെങ്കിൽ പാറ്റേണുകൾ) ഈ ഇൻപുട്ടിലേക്ക് മറ്റൊന്ന് വരെ പ്രയോഗിക്കുന്നു - ഇൻപുട്ട് ഫ്ലാഗ് ദൃശ്യമാകുന്നു. നോൺ- ഇൻപുട്ട് ലഭിക്കുകയാണെങ്കിൽ , ഔട്ട്പുട്ട് സൂചിപ്പിക്കുന്നത് "$ user_spawn_id -output- ഇൻപുട്ട്". (അതുപോലെത്തന്നെ, ഇല്ലാത്ത പാറ്റേണുകൾക്കൊപ്പം). ഒരു ഇൻപുട്ട് വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അത് $ user_spawn_id നെ മറികടക്കുന്നു. ഒരു രണ്ടാമത്തെ ഇൻപുട്ട് വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അത് $ spawn_id അസാധുവാക്കുന്നു. അധിക- ഇൻപുട്ട് ഫ്ലാഗുകൾ വ്യക്തമാക്കിയിരിക്കാം.

അവയുടെ ഇൻപുട്ട് പ്രക്രിയകൾ അവയുടെ ഔട്ട്പുട്ട്സ് $ spawn_id, $ user_spawn_id (റിവേഴ്സ്) എന്നീ നിർദ്ദേശങ്ങളായി നൽകിയിരുന്നു. No-output ഫ്ലാഗ് ഉപയോഗിച്ച് ഒരു- ഇൻപുട്ട് ഫ്ലാഗ് ദൃശ്യമായാൽ, ആ പ്രോസസ്സിലെ പ്രതീകങ്ങൾ നിരസിക്കപ്പെടും.

മറ്റ്- ഇൻപുട്ട് അല്ലെങ്കിൽ ഔട്ട്പുട്ട് ഫ്ലാഗുകൾ ഉപയോഗിക്കുമ്പോൾ നിലവിലെ spawn_id- ന് പകരം -i ഫ്ലാഗ് അവതരിപ്പിക്കുന്നു. A- യുടെ ഫ്ലാഗ് ഒരു -o ഫ്ലാഗ് സൂചിപ്പിക്കുന്നു.

പരോക്ഷമായ സ്പൈൻ ഐഡികൾ ഉപയോഗിച്ച് സംവദിക്കപ്പെടുന്ന പ്രക്രിയകൾ മാറ്റുന്നത് സാധ്യമാണ്. (പരോക്ഷമായ സ്കോട്ട് ഐഡങ്ങൾ പ്രതീക്ഷയുടെ കൽപ്പനയിലെ വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നു.) പരോക്ഷമായ സ്പോൺ ഐഡികൾ -i, -u, -input, അല്ലെങ്കിൽ -output flags ഉപയോഗിച്ച് വ്യക്തമാക്കാം.

വ്യാഖ്യാനകൻ [ആർഗുകൾ]
പ്രതീക്ഷ , Tcl എന്നീ കമാൻഡുകൾക്ക് പരസ്പരം ആശയവിനിമയം നടത്താൻ കാരണമാകുന്നു. ഓരോ ആജ്ഞയുടെയും ഫലം അച്ചടിക്കപ്പെടും.

സാധാരണ പോലെ പെരുമാറുന്നതിനായി നിയന്ത്രണം ഉണ്ടാക്കുന്നതിനും (അതായത്, proc , വേണ്ടി ) തുടർന്നും വരുന്ന പ്രവർത്തനങ്ങൾ. എന്നിരുന്നാലും ഇൻറർപ്രറ്റർ അതിന്റെ കോളിനടുത്തേക്ക് തിരികെ വരുന്നതിന് കാരണമാകുന്നു, ഒപ്പം ഇൻറർ_റേറ്റർ അതിന്റെ ഇൻകോർപ്പറേറ്റർ അതിന്റെ കോളിനടുത്ത് തിരികെ വരാൻ ഇടയാക്കുന്നു. ഉദാഹരണത്തിന്, "proc foo" interpreter എന്ന് വിളിക്കുകയും പ്രവർത്തനം inter_return എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്താൽ , proc foo തിരികെ വരും. മറ്റേതെങ്കിലും കമാൻഡ് പുതിയ കമാൻഡുകൾക്കായി ആവശ്യപ്പെടുന്നതിനായി ഇന്റർപ്രെറ്റർ തുടരുന്നു.

സ്വതവേ, പ്രോംപ്റ്റിൽ രണ്ട് പൂർണ്ണസംഖ്യകൾ അടങ്ങിയിരിക്കുന്നു. ആദ്യസംഖ്യ മൂല്യനിർണ്ണയത്തിന്റെ സ്റ്റാക്ക് (അതായത്, Tcl_Eval എത്ര തവണ എന്ന് വിളിക്കപ്പെട്ടു) ആഴത്തിൽ വിശദീകരിക്കുന്നു. രണ്ടാമത്തെ പൂർണ്ണസംഖ്യയാണ് Tcl ചരിത്ര ഐഡന്റിഫയർ. "Prompt1" എന്ന് വിളിക്കുന്ന ഒരു പ്രക്രിയ നിർവചിച്ചുകൊണ്ടാണ് പ്രോംപ്റ്റ് സജ്ജീകരിയ്ക്കാൻ സാധിക്കുക. ഒരു പ്രസ്താവന തുറന്ന ഉദ്ധരണികൾ ആണെങ്കിൽ, പാരൻസുകൾ, ബ്രേക്കുകൾ അല്ലെങ്കിൽ ബ്രാക്കറ്റുകൾ എന്നിവ പുതിയ വരിയിൽ നൽകുമ്പോൾ സെക്കണ്ടറി പ്രോംപ്റ്റ് (സ്ഥിരസ്ഥിതിയായി "+>") പുറപ്പെടുവിക്കുന്നു. "Prompt2" എന്ന ഒരു പ്രക്രിയ നിർവചിച്ചുകൊണ്ട് സെക്കണ്ടറി പ്രോംപ്റ്റ് സജ്ജീകരിയ്ക്കാം.

ഇൻറർപ്രറ്റർ സമയത്ത്, പാകം ചെയ്ത മോഡ് ഉപയോഗിക്കുന്നു, അതിന്റെ കോൾ അസംസ്കൃത മോഡാണ് ഉപയോഗിക്കുന്നത്.

Stdin അടച്ചു കഴിഞ്ഞാൽ, -eof ഫ്ലാഗ് ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ, വ്യാഖ്യാനകൻ തിരികെ വരും, ആ സന്ദർഭത്തിൽ തുടർന്നുള്ള വാദം നടപ്പിലാക്കിയിരിക്കും.

log_file [ആർഗുകൾ] [[-a] ഫയൽ]
ഒരു ഫയൽനാമം നൽകിയിട്ടുണ്ടെങ്കിൽ, log_file ഫയലിൽ ആ സെഷൻ ട്രാൻസ്ക്രിപ്റ്റ് (ആ ഘട്ടത്തിൽ ആരംഭിക്കുന്ന) റെക്കോഡ് ചെയ്യും. ഒരു വാദം നൽകിയില്ലെങ്കിൽ log_file രേഖപ്പെടുത്തുന്നത് നിർത്തും. ഏതെങ്കിലും മുൻ ലോഗ് ഫയൽ അടച്ചു.

ഒരു ഫയൽനാമത്തിന് പകരം, TL ഫയൽ ഐഡന്റിഫയർ -open അല്ലെങ്കിൽ -leaveopen flags ഉപയോഗിച്ച് നൽകാം . ഇത് spawn ആജ്ഞയ്ക്ക് സമാനമാണ്. (കൂടുതൽ വിവരങ്ങൾക്ക് സ്പോൺ കാണുക.)

Log_user കമാന്ഡിനെ നിരോധിച്ചതിനു് -a പതാക ശക്തി ഉത്പാദനം.

സ്വതവേ, ലോഗ്_ഫയൽ കമാൻഡ് അവയെ പഴയവയല്ല , പകരം അടയ്ക്കുന്നതിനു് പകരം, ഒരു സെഷനിൽ ലോഗ്ചെയ്യുന്നു , ഒന്നിലധികം തവണ സാധ്യമാകുന്നു. ഫയലുകൾ ചുരുക്കുക , -noappend ഫ്ലാഗ് ഉപയോഗിക്കുക.

ഏറ്റവും സമീപകാലത്തെ ആർഗ്യുമെന്റുകളുടെ ആർഗ്യുമെന്റുകളുടെ ഒരു വിവരണം നൽകാൻ ഇൻഫൊ- ഫ്ലാഗ് log_file നൽകുന്നു.

log_user -info | 0 | 1
സ്വതവേ, ഡയലോഗ് stdout- ലേക്കു് (തുറന്നിരുന്ന ഒരു ലോഫ്ഫയൽ) ലോഗ് ചെയ്യുന്പോൾ / പ്രതീക്ഷിക്കുന്നു. "Log_user 0" എന്ന കമാൻഡ് ഉപയോഗിച്ച് stdout- ലേക്കു് പ്രവേശിയ്ക്കുന്നതു് പ്രവർത്തന രഹിതമാക്കി "log_user 1" ഉപയോഗിച്ചു് വീണ്ടും വീണ്ടും പ്രവർത്തന രഹിതമാക്കിയിരിയ്ക്കുന്നു. ലോഗ്ഫയലിനു് പ്രവേശനം മാറ്റമില്ല.

ഏറ്റവും സമീപകാലത്തെ ആർഗ്യുമെന്റുകളുടെ ആർഗ്യുമെന്റുകളുടെ ഒരു വിവരണം നൽകാൻ ഇൻ- ഐഫോൺ ഫ്ലാഗ് log_user കാരണമാകുന്നു.

match_max [-d] [-i spawn_id] [size]
പ്രതീക്ഷിക്കുന്ന പ്രകാരം ആന്തരികമായി ഉപയോഗിക്കുന്ന ബഫറിന്റെ വലിപ്പം (ബൈറ്റ്സിൽ) നിർവചിക്കുന്നു. വലിപ്പത്തിലുള്ള ആർഗ്യുമെന്റ് ഇല്ലാതെ, നിലവിലെ വലുപ്പം ലഭിക്കും.

-d ഫ്ലാഗ് ഉപയോഗിച്ചു്, സ്വതവേയുള്ള വ്യാപ്തി സജ്ജമാക്കിയിരിയ്ക്കുന്നു. (പ്രാരംഭ സ്ഥിരസ്ഥിതി 2000 ആണ്.) -i ഫ്ലാഗ് ഉപയോഗിച്ച്, സ്പാൺ ഐഡി എന്നതിന് വലിപ്പം സജ്ജീകരിച്ചു, അല്ലെങ്കിൽ ഇത് നിലവിലെ പ്രോസസ്സിനായി സജ്ജമാക്കിയിട്ടുണ്ട്.

ഓവർലേ [- # spawn_id] [- # spawn_id] [...] പ്രോഗ്രാം [ആർഗുകൾ]
നിലവിലെ പ്രതീക്ഷയുടെ സ്ഥാനത്തിനു പകരം "പ്രോഗ്രാം പ്രോഗ്രാം വാദിക്കുന്നു", ഇത് അവസാനിപ്പിക്കും. ഒരു ഷെൽ എന്ന രീതിയിൽ ഒരു കമാൻഡ് നാമത്തിനു മുന്നിൽ ഒരു ഹൈഫൻ ആർഗ്യുമെന്റ് ഒരു ഹൈഫൻ പ്രവർത്തിക്കുന്നു. ആർഗ്യുമെന്റുകളെന്ന് പേരുള്ളവർ ഒഴികെ എല്ലാ spawn_ids അടയും. ഇവ പേരുള്ള ഫയൽ ഐഡന്റിഫയറുകളിലേക്ക് മാപ്പുചെയ്യുന്നു.

പുതിയ പ്രോഗ്രാമിന്റെ ഭാഗമായ ഫയൽ ഐഡന്റിഫയറുകളിലേക്ക് Spawn_ids മാപ്പുചെയ്തിരിക്കുന്നു. ഉദാഹരണത്തിന്, താഴെ പറയുന്ന വരി ചെസ്സ് റണ്ണും റൺസിന്റെ പ്രവർത്തനവും നിയന്ത്രിക്കുന്നു - ഒരു ചെസ്സ് മാസ്റ്റർ പറയുക.

ഓവർലേ -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id ചെസ്സ്

"Interact -u" എന്നതിനേക്കാളും കൂടുതൽ കാര്യക്ഷമതയുള്ളതാണ്, എന്നിരുന്നാലും പ്രോഗ്രാം പ്രക്രിയയെ നിയന്ത്രിക്കാനുള്ള കഴിവിനെ അത് ബലിയാക്കുന്നു.

കണ്ട്രോൾ ടെർമിനൽ നൽകിയിട്ടില്ല എന്നത് ശ്രദ്ധിക്കുക. അതിനാൽ, നിങ്ങൾ വിച്ഛേദിക്കുകയോ അല്ലെങ്കിൽ സാധാരണ കൈമാറ്റം ചെയ്യുകയോ ചെയ്യുകയാണെങ്കിൽ, ജോലിയുടെ നിയന്ത്രണം (ഷെല്ലുകൾ, ലോഗിൻ തുടങ്ങിയവ) ശരിയായി പ്രവർത്തിക്കില്ല.

പാരിറ്റി [-d] [-i spawn_id] [മൂല്യം]
പാരിസ്ഥിതിക പ്രക്രിയകളുടെ ഔട്പുരിൽ നിന്ന് പാരിറ്റി നിലനിർത്തേണ്ടതുണ്ടോ എന്ന് വ്യക്തമാക്കുന്നു. മൂല്യം പൂജ്യമാണെങ്കിൽ, പാരിറ്റി അഴിച്ച് കളയുന്നു, അല്ലെങ്കിൽ അത് അഴിച്ചുവെച്ചിട്ടില്ല. മൂല്യമൊന്നു ആർഗ്യുമെന്റോടെല്ലെങ്കിൽ, നിലവിലെ മൂല്യം നൽകപ്പെടും.

-d ഫ്ലാഗ് ഉപയോഗിക്കുമ്പോൾ, സ്വതവേയുള്ള പാരിറ്റി മൂല്ല്യം സജ്ജമാക്കിയിരിയ്ക്കുന്നു. (പ്രാരംഭ സ്ഥിരസ്ഥിതി ഒന്നു്, അതായത്, പാരിറ്റി അഴിമതി ഇല്ല.) -i ഫ്ലാഗ് ഉപയോഗിച്ചു്, പാരിറ്റി ഐഡിനായി പാരിറ്റി മൂല്ല്യം സജ്ജീകരിച്ചിരിയ്ക്കുന്നു, അല്ലെങ്കിൽ അതു് നിലവിലെ പ്രക്രിയയ്ക്കായി സജ്ജമാക്കിയിരിയ്ക്കുന്നു.

remove_nulls [-d] [-i spawn_id] [മൂല്യം]
വേരിയബിളിലെ പൊരുത്തപ്പെടുത്തൽ അല്ലെങ്കിൽ സംഭരിക്കുന്നതിനു മുമ്പായി, കാലഹരണപ്പെട്ട പ്രക്രിയകളുടെ ഔട്ട്പുട്ടിൽ നിന്നും നൾ സൂക്ഷിക്കപ്പെടാം അല്ലെങ്കിൽ നീക്കം ചെയ്യണോ എന്ന് നിർവ്വചിക്കുന്നു expect_out അല്ലെങ്കിൽ interact_out . മൂല്യം 1 ആണെങ്കിൽ, നൾ നീക്കംചെയ്യപ്പെടും. മൂല്യം 0 ആണെങ്കിൽ, നൾ നീക്കം ചെയ്യപ്പെടുന്നില്ല. മൂല്യമൊന്നു ആർഗ്യുമെന്റോടെല്ലെങ്കിൽ, നിലവിലെ മൂല്യം നൽകപ്പെടും.

-d ഫ്ലാഗ് ഉപയോഗിക്കുമ്പോൾ സ്വതവേയുള്ള മൂല്യം സജ്ജീകരിച്ചിരിക്കുന്നു. (പ്രാരംഭ സ്ഥിരസ്ഥിതി 1 ആണ്, അതായത്, നൾ നീക്കംചെയ്യപ്പെടും.) -i ഫ്ലാഗ് ഉപയോഗിച്ച്, സ്കോട്ട് ഐഡിക്ക് മൂല്യം സജ്ജമാക്കിയിട്ടുണ്ടെങ്കിൽ, അല്ലെങ്കിൽ അത് ഇപ്പോഴത്തെ പ്രോസസ്സിനായി സജ്ജമാക്കിയിരിക്കണം.

നൾ നീക്കം ചെയ്താലും ഇല്ലെങ്കിലും, കാത്തിരിപ്പ് രേഖയിൽ null ബൈറ്റുകൾ രേഖപ്പെടുത്തുകയും stdout പ്രതീക്ഷിക്കുകയും ചെയ്യും.

[-flags] സ്ട്രിംഗ് അയയ്ക്കുക
നിലവിലെ പ്രക്രിയയിലേക്ക് സ്ട്രിംഗ് അയയ്ക്കുന്നു. ഉദാഹരണത്തിനു്, കമാൻഡ്

"ഹലോ വേൾ \ r" അയയ്ക്കുക

നിലവിലെ പ്രക്രിയയിലേക്ക് പ്രതീകങ്ങൾ, helloworld അയയ്ക്കുന്നു. (Tcl ഒരു അച്ചടിച്ച രൂപത്തിലുള്ള കമാൻഡ് ( ഫോർമാറ്റ് എന്നുവിളിക്കുന്നു) അനേഷ്ടകമായി സങ്കീർണ്ണമായ സ്ട്രിങ്ങുകൾ നിർമ്മിക്കാൻ കഴിയും.)

ലൈൻ-ബഫേർഡ് ഇൻപുട്ട് ഉള്ള പ്രോഗ്രാമുകൾ മറിച്ച് കഥാപാത്രം അയക്കുന്നതു വരെ പ്രതീകങ്ങൾ ഉടനടി അയയ്ക്കുന്നു. ഒരു റിട്ടേൺ അക്ഷരം "\ r" ആണ്.

പതാകയേക്കാൾ ഒരു സ്ട്രിംഗ് ആയി അടുത്ത വാദം സൂചിപ്പിക്കുന്നതിന് - പതാക പരിവർത്തനം ചെയ്യും. ഏതു സ്ട്രിങ്ങിനും മുൻപേ ഒരു പതാക പോലെയാണോ "-" തുടങ്ങാൻ കഴിയുകയുള്ളൂ. ചക്രവാളങ്ങളെ പോലെ അപ്രതീക്ഷിതമായി ഫ്ലാഗുകൾ നോക്കാതെ ട്രാൻസ്ഫർ ചെയ്യാതെ വേരിയബിൾ സ്ട്രിംഗുകൾ വ്യക്തമാക്കുന്നതിനുള്ള ഒരു വിശ്വസനീയമായ സംവിധാനം ഇത് നൽകുന്നു. ("-" തുടങ്ങുന്ന എല്ലാ സ്ട്രിംഗുകളും ഭാവിയിലുള്ള ഓപ്ഷനുകൾക്കായി കരുതി വച്ചിരിക്കുന്നു.)

പേരുള്ള സ്പോൺ_ഡൈറ്റിന് ഈ സ്ട്രിങ് അയയ്ക്കുമെന്ന് -i ഫ്ലാഗ് പ്രഖ്യാപിക്കുന്നു. Spawn_id user_spawn_id ആണെങ്കിൽ, ടെർമിനൽ അസംസ്കൃത മോഡിലാണെങ്കിൽ സ്ട്രിംഗിലെ പുതിയ വരികൾ റിട്ടേൺ-ന്യൂലൈൻ ശ്രേണികളിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടുന്നു, അതിലൂടെ ടെർമിനൽ പാകം ചെയ്ത രീതിയിലാണ് അവ ദൃശ്യമാകുന്നത്. -raw ഫ്ലാഗ് ഈ വിവർത്തനം അപ്രാപ്തമാക്കുന്നു.

-null ഫ്ലാഗ് അസാധുവായ പ്രതീകങ്ങൾ അയയ്ക്കുന്നു (0 ബൈറ്റുകൾ). സ്വതവേ, ഒരു നൾ അയച്ചിരിക്കുന്നു. അയക്കുന്ന അനേകം പൂഴ്ച്ചകളെ സൂചിപ്പിക്കുന്നതിന് ഒരു പൂർണ്ണസംഖ്യ - null നെ പിന്തുടരുന്നു.

ബ്രേക്ക് ഫ്ലാഗ് ഒരു ബ്രേക്ക് അവസ്ഥ സൃഷ്ടിക്കുന്നു. സ്പാൺ ഐഡി "spawn -open" വഴി തുറന്ന ഒരു tty ഡിവൈസ് സൂചിപ്പിക്കുന്നുവെങ്കിൽ ഇതു് അർത്ഥമാക്കുന്നത്. നിങ്ങൾ നുറുങ്ങ് പോലെ ഒരു പ്രക്രിയ ഉണ്ടാക്കിയെങ്കിൽ, ഒരു ഇടവേള സൃഷ്ടിക്കുന്നതിന് ടിപ്പ് കൺവെൻഷൻ ഉപയോഗിക്കേണ്ടതാണ്.

ഒരു സാർവത്രിക സംവിധാനത്തെ "മെല്ലെമെല്ലെ" അയയ്ക്കാനുള്ള ഒരു സംവിധാനമാണിത്, അതിനാൽ തന്നെ ഒരു കമ്പ്യൂട്ടറിനെ രൂപകൽപ്പന ചെയ്യുന്ന ഇൻപുട്ട് ബഫറിനെ ഒരു കമ്പ്യൂട്ടർ രൂപകൽപ്പന ചെയ്യുന്ന സാധാരണ അവസ്ഥ ഒഴിവാക്കും. ഈ ഔട്ട്പുട്ട് നിയന്ത്രിക്കുന്നത് വേരിയബിളിന്റെ "send_slow" ന്റെ മൂല്യത്തിൽ രണ്ട് എലമെൻറ് ലിസ്റ്റ് ആണ്. ആദ്യഘടകം അണുപരമായി അയയ്ക്കുന്നതിനുള്ള ബൈറ്റുകളുടെ എണ്ണം വിവരിക്കുന്ന ഒരു പൂർണ്ണസംഖ്യയാണ്. രണ്ടാമത്തെ മൂലകം എന്നത് ആറ്റോമിക് അയയ്ക്കേണ്ട സെണ്ടുകളുടെ എണ്ണം വിവരിക്കുന്ന ഒരു യഥാർത്ഥ സംഖ്യയാണ്. ഉദാഹരണത്തിന്, അയച്ച 10 അക്ഷരങ്ങൾക്കിടയിൽ 1 മില്ലിസെക്കന്റിൽ സ്ട്രിങുകൾ അയയ്ക്കുന്നതിന് "send -slow {10 .001}" അയയ്ക്കാൻ "send -slow".

മനുഷ്യന്റെ യഥാർഥത്തിൽ ടൈപ്പ് ചെയ്യുന്നതു പോലെയാണ് -h പതാക ശക്തി ഉത്പാദനം അയയ്ക്കുന്നത്. പ്രതീകങ്ങൾക്കിടയിൽ മാനുഷികനീക്കം കാലതാമസമുണ്ടാകും. (ഈ പ്രത്യേക അപേക്ഷയ്ക്ക് അനുയോജ്യമായ മാറ്റങ്ങൾക്കൊപ്പം വെയ്ബുൾ വിതരണത്തെ ആധാരമാക്കിയുള്ളതാണ് അൽഗോരിതം). ഈ ഔട്ട്പുട്ട് നിയന്ത്രിക്കുന്നത് വേരിയബിളിന്റെ "send_human" എന്ന മൂല്യത്തിന്റെ അഞ്ച് മൂലക ലിസ്റ്റ് എടുക്കും. ആദ്യത്തെ രണ്ടു ഘടകങ്ങൾ സെക്കന്റിൽ അക്ഷരങ്ങളുടെ ശരാശരി ഇടവേള സമയമാണ്. ആദ്യത്തെത് സ്വതവേ ഉപയോഗിയ്ക്കുന്നു. രണ്ടാമത്തെ വാചകം എൻഡിൽ ഉപയോഗിക്കുന്നത്, ഇത്തരം പരിവർത്തനങ്ങളിൽ ഇടയ്ക്കിടെ ഉണ്ടാകുന്ന നിശിതമായ താൽപര്യങ്ങൾ പകർത്താൻ. മൂന്നാമത്തെ പാരാമീറ്റർ എന്നത് വ്യത്യാസത്തിന്റെ അളവുകോലാണ്. ഇവിടെ 1 തികച്ചും വേരിയബിളാണ്, 1 യുക്തിസഹമായി വേരിയബിൾ, 10 വളരെ ആകൃതിയാണ്. അചഞ്ചലഫലങ്ങൾ അപ്രതീക്ഷിതമാണ്. അവസാനത്തെ രണ്ട് ഘടകങ്ങളാണ് യഥാക്രമം ഏറ്റവും കുറഞ്ഞതും പരമാവധി ഇടവേളയുള്ളതുമായ സമയം. ഏറ്റവും കുറഞ്ഞതും പരമാവധി ഉപയോഗിച്ചതുമാണ് അവസാന സമയം, "ക്ലിപ്പ്" അവസാന സമയം. മിനിമം പരമാവധി പരമാവധി ക്ലിപ്പ് മതിയായ മൂല്യങ്ങൾ നൽകുമ്പോൾ ആ ശരാശരി ശരാശരിയിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമായിരിക്കും.

ഉദാഹരണമായി, താഴെ പറയുന്ന കമാൻഡ് ഒരു വേഗതയാർന്നതും സ്ഥിരതയുള്ളതുമായ ഒരു ടൈപ്പ്സ്റ്ററെ അനുകരിക്കുന്നു:

send_human {.1 .3 1 .05 2} send -h "എനിക്ക് വിശക്കുന്നു, ഉച്ചഭക്ഷണം ചെയ്യാം."

താഴെപ്പറയുന്നവ ഹാംഗോവറിന് ശേഷവും അനുയോജ്യമാണ്:

അയയ്ക്കുക അയയ്ക്കൂ! {.4 .4 .2 .5 100} send -h "ഗുഡ്ഡ് പാർട്ടി പാർട്ടി രാത്രി!"

തെറ്റുകൾ തിരുത്തരുത് എന്ന കാര്യം ശ്രദ്ധിക്കുക, എന്നിരുന്നാലും പിശകുകളും തിരുത്തുകളും ഉൾപ്പെടുത്തുന്നത് വഴി നിങ്ങൾക്ക് ഒരു തെറ്റ് തിരുത്തൽ സജ്ജീകരിക്കാം.

പൂജ്യം അയയ്ക്കുന്നതിനായി പൂജ്യം അയയ്ക്കുന്നതിനുള്ള പതാകകൾ, സ്ലോ ഔട്ട്പുട്ട് നിർബന്ധിച്ച്, മനുഷ്യ-സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിനു വേണ്ടി പരസ്പരം സമ്പൂർണമായി. അവസാനം സൂചിപ്പിച്ച ഒന്ന് മാത്രമേ ഉപയോഗിക്കാവൂ. കൂടാതെ, അസാധുവായ ആർഗ്യുമെൻറ് പൂജകളോ അല്ലെങ്കിൽ ബ്രേക്കുകൾ അയച്ചോ ചെയ്യാൻ ഫ്ലാഗുകളോട് നിർദ്ദേശിക്കാനാവില്ല.

ഒരു പ്രതീക്ഷയോടെ ആദ്യ പ്രക്രിയയ്ക്ക് മുൻപുള്ള ഒരു നല്ല ആശയമാണ്. പ്രക്രിയ ആരംഭിക്കാൻ കാത്തിരിക്കുക, അയയ്ക്കുക കഴിയില്ല, പ്രതീക്ഷിക്കുന്നു . പ്രത്യേകിച്ചും, പ്രക്രിയ ആരംഭിക്കുന്നതിനുമുമ്പ് ആദ്യത്തെ സന്ദേശം അയയ്ക്കുകയാണെങ്കിൽ , നിങ്ങളുടെ ഡാറ്റ അവഗണിക്കാനുള്ള സാധ്യതയുണ്ട്. ഇന്ററാക്ടീവ് പ്രോഗ്രാമുകൾ പ്രാരംഭ പ്രോംപ്റ്റിനായി നൽകാത്ത സാഹചര്യങ്ങളിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്നതുപോലുള്ള കാലതാമസം കൊണ്ട് അയയ്ക്കാൻ കഴിയും:

# എങ്ങനെ ഹാക്കർമാർ തകരാറുണ്ടാക്കുമെന്നതിനെ സൂചിപ്പിക്കുന്നില്ല, # ഈ സിസ്റ്റം ഒരു ബാഹ്യ പാസ്സ്വേര്ഡിനായി ആവശ്യപ്പെടുന്നില്ല. # Spon telnet പൂർത്തിയാക്കാൻ വേണ്ടി 5 സെക്കൻഡ് നേരം കാത്തിരിക്കുക very.secure.gov സ്ലീപ് 5 പാസ്വേർഡ് അയയ്ക്കുക \ r

exp_send അയയ്ക്കുന്നതിനുള്ള ഒരു അപരനാമമാണ് . Tk എൻവയൺമെന്റിൽ നിങ്ങൾ പ്രതീക്ഷിക്കുന്ന അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും വേരിയബിളാണ് ഉപയോഗിക്കുന്നത് എങ്കിൽ, Tk പൂർണ്ണമായും വ്യത്യസ്തമായ ഉദ്ദേശ്യത്തിനായി അയയ്ക്കുകയാണ്. environments- നായി compatibility അനുവദിക്കുന്നതിനായി exp_send ലഭ്യമാക്കുന്നു. സമാനമായ മറ്റ് പേരുകൾ മറ്റ് പ്രതീക്ഷകൾക്ക് അയയ്ക്കുന്ന മറ്റ് ആജ്ഞകൾക്ക് നൽകുന്നു.

send_error [-flags] സ്ട്രിംഗ്
ഔട്ട്പുട്ട് നിലവിലുള്ള പ്രോസസ്സിനു പകരം stderr ലേക്ക് അയയ്ക്കുന്നതല്ലാതെ അയയ്ക്കുക പോലെയാണ്.

send_log [-] സ്ട്രിംഗ്
സ്ട്രിങ് ലോഗ് ഫയലിലേക്ക് മാത്രം അയയ്ക്കപ്പെടുന്നു എന്നതൊഴികെ അയയ്ക്കുക പോലെയാണ്. ( log_file കാണുക.) ലോഗ് ഫയൽ തുറന്നിട്ടില്ലെങ്കിൽ ആർഗ്യുമെന്റുകൾ അവഗണിക്കും.

send_tty [-flags] സ്ട്രിംഗ്
ഔട്ട്പുട്ട് നിലവിലുള്ള പ്രോസസ്സിനെ അപേക്ഷിച്ച് / dev / tty- ലേക്ക് അയയ്ക്കുന്നതല്ലാതെ , അയയ്ക്കുക പോലെയാണ്.

send_user [-flags] സ്ട്രിംഗ്
ഔട്ട്പുട്ട് നിലവിലുള്ള പ്രോസസ്സിനു പകരം stdout ലേക്ക് അയയ്ക്കുന്നതല്ലാതെ , അയയ്ക്കുക പോലെയാണ്.

ഉറക്ക നിമിഷം
സ്ക്രിപ്റ്റുകൾക്ക് നൽകിയിട്ടുളള സെക്കന്റുകൾക്കുള്ളിൽ ഉറങ്ങുന്നു . സെക്കന്റുകൾ ഒരു ദശാംശ സംഖ്യയായിരിക്കാം. ഉറക്കങ്ങൾ പ്രതീക്ഷിക്കുന്നതിനിടയിൽ ഇൻററപ്റ്റുകൾ (നിങ്ങൾ Tk ഇവന്റുകൾ Expectk ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ) പ്രോസസ് ചെയ്യപ്പെടും.

സ്പാൺ [ആർഗ്സ്] പ്രോഗ്രാം [ആർഗുകൾ]
"പ്രോഗ്രാം ആർഗുകൾ" പ്രവർത്തിപ്പിക്കുന്ന ഒരു പുതിയ പ്രക്രിയ സൃഷ്ടിക്കുന്നു. അതിന്റെ സ്റ്റെഡിൻ, stdout, stderr എന്നിവ പ്രതീക്ഷിക്കുന്നതിനായി കണക്ട് ചെയ്യുന്നു. കണക്ഷൻ ക്രോഡീകരിച്ചതാകുമ്പോൾ അല്ലെങ്കിൽ പ്രക്രിയ ഏതെങ്കിലും ഫയൽ ഐഡന്റിഫയറുകൾ അടയ്ക്കുകയാണെങ്കിൽ.

ഒരു പ്രോസസ്സ് സ്പാൺ ആരംഭിക്കുമ്പോൾ, ആ പ്രക്രിയയെ സൂചിപ്പിക്കുന്ന ഒരു ഡെസിഗ്രേറ്ററിനായി വേരിയബിൾ spawn_id സജ്ജീകരിച്ചിരിക്കുന്നു. Spawn_id വിശദമാക്കിയ പ്രക്രിയ " നിലവിലുള്ള പ്രക്രിയ " ആയി കണക്കാക്കുന്നു. തൊഴിൽ നിയന്ത്രണം നൽകുന്നതിൽ സ്പോൺ_സിഡ് വായിക്കാനോ എഴുതാനോ വായിക്കാവുന്നതാണ്.

user_spawn_id ഉപയോക്താവിനുള്ള ഒരു ഡിസ്ക്രിപ്റ്റര് അടങ്ങുന്ന ഒരു ആഗോള വേരിയബിള്. ഉദാഹരണത്തിന്, spawn_id ഈ മൂല്യത്തിലേക്ക് സെറ്റ് ചെയ്തപ്പോൾ, expect_user പോലുള്ള നടപടികൾ പ്രതീക്ഷിക്കുന്നു .

എന്റർപ്രൈസ് error_spawn_id ഒരു എന്റർപ്രൈസ് വേരിയബിള്. ഉദാഹരണത്തിന്, spawn_id ഈ മൂല്യത്തിലേക്ക് സെറ്റ് ചെയ്തപ്പോൾ send_error പോലെ പ്രവർത്തിക്കുക.

tty_spawn_id എന്നത് / dev / tty എന്ന് സൂചിപ്പിക്കുന്ന അടയാളവാളി അടങ്ങുന്ന ഒരു ആഗോള വേരിയബിള് ആണ്. / Dev / tty നിലവിലില്ലെങ്കിൽ (ഒരു ക്രോൺ, ഓ, അല്ലെങ്കിൽ ബാച്ച് സ്ക്രിപ്റ്റിലുളളത് പോലെ), പിന്നെ tty_spawn_id നിർവചിക്കപ്പെട്ടിട്ടില്ല. ഇതായി ഇതു പരീക്ഷിക്കാം:

{{വിവരം vars tty_spawn_id]} {# / dev / tty exist}} {# / dev / tty നിലവിലില്ല # cron, batch അല്ലെങ്കിൽ script ൽ ആയിരിക്കാം}

യൂണിക്സ് യുണിക്സ് പ്രോസസ് ഐഡി നൽകുന്നു ഒരു പ്രക്രിയയും സ്പോൺ ചെയ്തില്ലെങ്കിൽ, 0 തിരികെ നൽകും. Pty slave ഡിവൈസിന്റെ പേരിനാകുന്നു വേരിയബിൾ spawn_out (സ്ലേവ്, നാമം) .

സ്വതവേ, spawn കമാൻഡ് നെയിം, ആർഗ്യുമെന്റുകൾ പ്രതിധ്വനിക്കുന്നു. ഇത് ചെയ്യുന്നതിൽ നിന്നും -നോച്ചോ ഫ്ലാഗ് സ്റ്റോൺ നിർത്തുന്നു.

കൺസോൾ ഔട്ട്പുട്ട് പ്ലെയിൻ പ്രോസസിലേക്ക് റീഡയറക്ട് ചെയ്യുന്നതിന് കൺസോൾ ഔട്ട്പുട്ട് കാരണമാകുന്നു. എല്ലാ സിസ്റ്റങ്ങളിലും ഇത് പിന്തുണയ്ക്കുന്നില്ല.

ആന്തരികമായി, സ്പോൺ ഒരു പൈ ഉപയോഗിച്ചു്, ഉപയോക്താവിന്റെ tty പോലെ തന്നെ ആരംഭിച്ചു. ഇത് കൂടുതൽ തുടക്കമിടുന്നത് കൊണ്ട് എല്ലാ ക്രമീകരണങ്ങളും "സന്യാസം" (sttt (1) അനുസരിച്ച്). വേരിയബിൾ stty_init നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, കൂടുതൽ ക്രമീകരണം ആയി സ്റ്റാറ്റി ആർഗ്യുമെന്റുകളുടെ ശൈലിയിൽ ഇത് വ്യാഖ്യാനിക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, "set stty_init raw" കൂടുതൽ വികസിതമായ പ്രക്രിയകളുടെ ടെർമിനലുകൾ അസംസ്കൃത മോഡിൽ ആരംഭിക്കും. ഉപയോക്താവിൻറെ tty അടിസ്ഥാനമാക്കിയുള്ള ഇനീഷ്യലൈസേഷൻ ഒഴിവാക്കുക. "സൺ" തുടക്കത്തിൽ തന്നെ.

സാധാരണയായി, സ്പാൺ എക്സിക്യൂട്ട് ചെയ്യാൻ കുറച്ചു സമയം എടുക്കും. സ്പാൺ നിശ്ചിതമായ സമയമെടുക്കുന്നതായി നിങ്ങൾ ശ്രദ്ധിച്ചാൽ, ഒരുപക്ഷേ, അത് വഷളായ ptys- ൽ കണ്ടുമുട്ടാൻ സാധ്യതയുണ്ട്. ചിട്ടയായ പ്രക്രിയകളുമായി അവഗണിക്കപ്പെടാതിരിക്കുവാൻ നിരവധി പരീക്ഷകൾ ptys- ൽ പ്രവർത്തിക്കുന്നു. (ഇവ എടുക്കുന്ന ഓരോ സെക്കൻഡിലും 10 സെക്കൻഡ് എടുക്കുന്നു.) പ്രതീക്ഷിക്കുന്നത് -d ഓപ്ഷനുമൊത്ത് പ്രതീക്ഷിക്കുന്നു പല സംസ്ഥാനങ്ങളിലും ഒറ്റനോട്ടത്തിൽ അനവധി ptys ഉണ്ടാകുന്നുണ്ടോ എന്ന് കാണിക്കുന്നു. ഈ ptys ഘടിപ്പിച്ചിട്ടുള്ള പ്രക്രിയകളെ നിങ്ങൾ കൊന്നാൽ, നിങ്ങളുടെ മാത്രം പിന്തുണ പുനരാരംഭിക്കുക.

എക്സിക്യുട്ടീസം (2) പരാജയപ്പെട്ടതിനാൽ ( പ്രോഗ്രാം ഇല്ലാതിരിക്കുമ്പോൾ) പരാജയപ്പെട്ടതിനാൽ പ്രോഗ്രാമിൽ വിജയകരമായി വികസിപ്പിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, അടുത്ത ആശയവിനിമയത്തിലൂടെ ഒരു പിശക് സന്ദേശം നൽകപ്പെടും അല്ലെങ്കിൽ പ്രോഗ്രാമിൽ പ്രവർത്തിച്ചതുപോലെ കമാൻഡ് പ്രതീക്ഷിക്കുകയും പിശക് സന്ദേശം ഉത്പാദനം ഉത്പാദിപ്പിക്കുകയും ചെയ്യും. ഈ സ്വഭാവം സ്പോൺ നടപ്പാക്കുന്നതിന്റെ സ്വാഭാവികമായ പരിണതഫലമാണ്. ആന്തരികമായി, സ്പാൺ ഫോർക്കുകൾ, പിന്നീട് സ്പാൺ റെഡ് വഴിയുള്ള ആശയവിനിമയത്തിലൂടെ ഒഴികെ പ്രോസസ് ചെയ്ത പ്രോസസ് ഒറിജിനൽ പ്രതീക്ഷയോടെ ആശയവിനിമയം നടത്താനുള്ള യാതൊരു വഴിയുമില്ല.

അടുത്ത പദം ഒരു Tcl ഫയൽ ഐഡന്റിഫയർ (അതായത് തിരിച്ചെത്താം.) ആയി വ്യാഖ്യാനിക്കപ്പെടാൻ കാരണമാകുന്നു. സ്പാൺ ഐഡി പിന്നീട് ഒരു സ്പോൺഡ് പ്രോസസ് ആയി ഉപയോഗിക്കാം. (ഫയൽ ഐഡന്റിഫയർ ഇനി മുതൽ ഉപയോഗിക്കരുത്.) ഇത് പമ്പ് ഉപയോഗിക്കാതെ തന്നെ റോ ഡിവൈസുകളും ഫയലുകളും പൈപ്പ്ലൈനുകളും വികസിപ്പിച്ചെടുക്കുന്ന പ്രക്രിയകളാക്കി മാറ്റാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ബന്ധപ്പെട്ട പ്രോസസ് ഇല്ല എന്ന് സൂചിപ്പിക്കുന്നതിന് 0 മടക്കി നൽകും. സ്പാൺഡ് പ്രോസസ്സിനുളള കണക്ഷൻ അടയ്ക്കുമ്പോൾ, അതുപോലെ Tcl ഫയൽ ഐഡന്റിഫയർ ആണ്. സ്ലൈഡ് ഐഡി അടച്ചതിനു ശേഷവും ഫയൽ ഐഡന്റിഫയർ തുറന്നുകൊടുക്കാൻ ലിവൈപ്പൺ കാരണമാകുന്നു -ലോവപ്പോൺ ഫ്ലാഗ് സമാനമാണ്.

തുമ്പിയ പതാക തുറന്നുവിടാൻ ഒരു പൈപ്പിന് കാരണമാകുന്നു, എന്നാൽ പ്രക്രിയകൾ ഒന്നും തന്നെ നടന്നിട്ടില്ല. ബന്ധപ്പെട്ട പ്രോസസ് ഇല്ല എന്ന് സൂചിപ്പിക്കുന്നതിന് 0 മടക്കി നൽകും. Spawn_id സാധാരണപോലെ സജ്ജീകരിച്ചിരിക്കുന്നു.

Pty slave- ലേക്ക് വരുന്ന ഒരു ഫയൽ ഐഡന്റിഫയറിലേക്ക് സ്പെയ്ൻ_ഔട്ട് (slave, fd) വേരിയബിൾ സജ്ജമാക്കിയിരിയ്ക്കുന്നു. ഇത് "close-slave" ഉപയോഗിച്ച് അടയ്ക്കാം.

അണ്ടർഗ്രൗണ്ട് ഫ്ലാഗ് വികസിപ്പിച്ച പ്രക്രിയയിൽ അവഗണിക്കപ്പെടേണ്ട ഒരു സിഗ്നൽ പേരാണ്. അല്ലെങ്കിൽ, സിഗ്നലുകൾക്ക് സ്വതവേയുള്ള സ്വഭാവം ലഭിക്കുന്നു. ഓരോ സിഗ്നലിനും ഒരു പ്രത്യേക പതാക ആവശ്യമെങ്കിൽ , ട്രാപ്പ് കമാൻഡിൽ സിഗ്നലുകൾ പേര് നൽകിയിരിക്കുന്നു.

സ്റ്റാസ് ലെവൽ
നടപ്പിലാക്കുന്നതിനു മുൻപ് താഴെ പറയുന്ന പ്രസ്താവനകൾ അച്ചടിക്കപ്പെടും. (ടിക്ക് ട്രെയ്സ് കമാൻഡ്, വേരിയബിളുകൾ ട്രേസായി മാറുന്നു.) കോൾ സ്റ്റാക്കിൽ എത്ര ദൂരം പോകും എന്ന് സൂചിപ്പിക്കുന്നു. ഉദാഹരണത്തിനു്, ആദ്യ 4 ലെവലുകൾ കണ്ടുപിടിക്കുന്നതിനു് താഴെ കാണിയ്ക്കുന്ന കമാൻഡ് പ്രതീക്ഷിയ്ക്കുന്നുണ്ടു് , പക്ഷേ താഴെ ഒന്നുമില്ല.

expected -c "strace 4" script.exp പ്രതീക്ഷിക്കുന്നു

ഏറ്റവും പുതിയ അജ്ഞാതമായ ആർഗ്യുമെന്റുകളുടെ ഒരു വിവരണം മടക്കി ഇൻ- ഇൻഫോ പതാകയാണ് സ്ടേറ്റ് .

സ്റ്റ്ടി ആർഗുകൾ
ബാഹ്യ സ്റ്റാറ്റി കമാൻഡുമായി ബന്ധപ്പെട്ട ടെർമിനൽ മോഡുകൾ മാറ്റുന്നു.

സ്വതവേ, കണ്ട്രോൾ ടെർമിനൽ ലഭ്യമാണു്. മറ്റ് ടെർമിനലുകൾ "ആജ്ഞയുടെ ഫലമായി" കമാൻഡ് ഫലമായി നൽകാം, കൂടാതെ സ്റ്റാറ്റസ് ആവശ്യപ്പെടുന്നില്ലെങ്കിൽ കൺട്രോൾ ടെർമിനൽ ലഭ്യമാണെങ്കിൽ, റോയും എക്കോ ആട്രിബ്യൂട്ടുകളുടെയും മുമ്പത്തെ സ്റ്റാറ്റസ് ഒരു ഫോമിൽ തിരികെ വരും, കമാൻഡ് ഉപയോഗിയ്ക്കുന്നു.

ഉദാഹരണത്തിന്, അസംസ്കൃത അല്ലെങ്കിൽ -കൂട്ടിയുള്ള ആർഗ്യുമെന്റ് ടെർമിനൽ അസംസ്കൃത മോഡായി നൽകുക. ആർഗ്യുമെന്റുകൾ -റോ അല്ലെങ്കിൽ പാകം ചെയ്ത ടെർമിനൽ പാകം ചെയ്ത മോഡിലേക്ക് ഇടുക. ആര്ഗ്യുമെന്റുകള് എക്കോയും -കോയും യഥാക്രമം ടെര്ക്കോണുകളെ എക്കോ, നോച്ചോ മോഡ് ആക്കി.

Echoing എങ്ങനെ താത്കാലികമായി പ്രവർത്തനരഹിതമാക്കാമെന്ന് താഴെക്കാണുന്ന ഉദാഹരണം വിവരിക്കുന്നു. പാസ്വേഡുകൾ എംബഡ് ചെയ്യുന്നതിൽ നിന്ന് ഒഴിവാക്കാൻ ഇത് യാന്ത്രിക സ്ക്രിപ്റ്റുകളിലും ഉപയോഗിക്കാം. (താഴെക്കാണിക്കുന്ന EXPECT സൂചനകൾക്ക് താഴെയുള്ള കൂടുതൽ ചർച്ച കാണുക.)

stty -echo send_user "രഹസ്യവാക്ക്:" expect_user -re "(. *) \ n" രഹസ്യവാക്ക് $ expected_out (1, string) stty echo സജ്ജമാക്കുക

സിസ്റ്റം ആർഗ്സ്
ഒരു ടെർമിനലിൽ നിന്ന് കമാന്ഡ് ആയി ടൈപ്പ് ചെയ്ത പോലെ, ഇൻപുട്ടിനായി ഷ (1) ന് args നൽകുന്നു. ഷെൽ അവസാനിപ്പിക്കുന്നതുവരെ കാത്തിരിക്കാൻ പ്രതീക്ഷിക്കുക . ഷിൽ നിന്നും തിരികെ വരുന്ന സ്റ്റാറ്റസ് എക്സിക്യൂട്ട് സ്റ്റൈൽ റിട്ടേൺ സ്റ്റാറ്റസ് കൈകാര്യം ചെയ്യുന്ന അതേ രീതിയിൽ കൈകാര്യം ചെയ്യപ്പെടും.

സ്ക്രിപ്റ്റിന് സ്റ്റാൻഡിനും സ്റ്റാൻഡേറ്റും റീഡയറക്ട് ചെയ്ത എക്സിക്യുട്ടീവിനു പകരം, സിസ്റ്റം റീഡയറക്ഷൻ നടപ്പിലാക്കില്ല (സ്ട്രിംഗ് സൂചിപ്പിച്ചിട്ടുള്ളത് ഒഴികെ). അങ്ങനെ, പ്രോഗ്രാമുകൾ നേരിട്ട് / dev / tty ലേക്ക് സംസാരിക്കേണ്ടതാണ്. അതേ കാരണത്താല്, സിസ്റ്റത്തിന്റെ ഫലങ്ങള് രേഖയില് രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല.

ടൈംസ്റ്റാമ്പ് [തർക്കങ്ങൾ]
ഒരു ടൈംസ്റ്റാമ്പ് തിരികെ നൽകുന്നു. വാദങ്ങൾ ഇല്ലാതെ, യുഗത്തിനു ശേഷമുള്ള സെക്കന്റുകൾ.

സ്ട്രെങ്മെന്റിനുള്ള POSIX നിയമത്തിന് അനുസൃതമായി പകരം വയ്ക്കുന്ന ഒരു സ്ട്രിങ് -ഫോർമാറ്റ് ഫ്ലാഗ് അവതരിപ്പിക്കുന്നു. ഉദാഹരണത്തിന്% a എന്നത് ചുരുക്കിയ ആഴ്ചപ്പതിപ്പ് (അതായത്, സാറ്റ്) ആണ്. മറ്റുള്ളവ:

% ചുരുക്കമില്ലാത്ത ഒരു ദിവസത്തിന്റെ പേര്% A പൂർണ്ണ ആഴ്ചദിനത്തിന്റെ പേര്% b ചുരുക്കിയ മാസത്തിന്റെ പേര്% B പൂർണ്ണമായ മാസം പേര്% c തീയതി ടൈം ഇൻ ടൈപ്പ്: Oct 6 11:45:56 1993% ഡി ദിവസം (01-31% H മണിക്കൂറിൽ (00-23)% ഞാൻ മണിക്കൂർ (01-12)% j ദിവസം (001-366)% m മാസം (01-12)% M മിനിറ്റ് (00-59)% പി അല്ലെങ്കിൽ ഞാൻ S സെക്കൻഡ് (00-61) % u ദിവസം (1-7, തിങ്കൾ ആദ്യ ആഴ്ച ദിവസം)% U ആഴ്ച (00-53, ആദ്യ ഞായർ ആഴ്ചയിലെ ആദ്യ ദിവസം)% V ആഴ്ച (01-53, ISO 8601 രീതി)% w ദിവസം (0- 6)% W ആഴ്ച (00-53, ആദ്യത്തെ തിങ്കളാഴ്ച ആഴ്ചയിൽ ഒരു ദിവസം)% x തീയതി-സമയം അകത്ത്: ഒക്ടോബർ 6, 1993% എക്സ് സമയം: 23:59:59% y വർഷം (00-99) % Y വർഷം: 1993% Z സമയമേഖല (അല്ലെങ്കിൽ ഒന്നും നിർണ്ണയിക്കാൻ ഇല്ലെങ്കിൽ) %% ഒരു ചെറിയ ശതമാനം അടയാളം

മറ്റ്% സ്പെസിഫിക്കേഷനുകൾ വ്യക്തമല്ല. മറ്റ് ക്യാരക്ടുകൾ സ്പർശിക്കില്ല. സി ലോക്കേൽ മാത്രം പിന്തുണയ്ക്കുന്നു.

ഫോർമാറ്റ് ചെയ്യേണ്ട ഒരു സ്രോതസ്സായി യുഗത്തെ ഉപയോഗിച്ചുള്ള സെക്കൻറുകൾക്ക് ശേഷമുള്ള സെക്കൻറുകൾ സെക്കന്റ് സെക്കൻറുകൾ പരിചയപ്പെടുത്തുന്നു. അല്ലെങ്കിൽ, നിലവിലെ സമയം ഉപയോഗിക്കും.

GMT ടൈം സോണിനെ ഉപയോഗപ്പെടുത്തുന്നതിന് GMAT പതാക ടൈംസ്റ്റാമ്പ് ഔട്ട്പുട്ട്. യാതൊരു പതാകയുമില്ലാതെ പ്രാദേശിക സമയമേഖല ഉപയോഗിക്കും.

ട്രാപ് [[കമാൻഡ്] സിഗ്നലുകൾ]
ഏതെങ്കിലും തന്നിരിക്കുന്ന സിഗ്നലുകളുടെ ഭാവിയിൽ ലഭിച്ച നിർദേശം നടപ്പിലാക്കുന്നതിന് കാരണമാകുന്നു. ആഗോള തലത്തിൽ കമാൻഡ് നടപ്പിലാക്കുന്നു. കമാൻഡ് ഇല്ലെങ്കിൽ, സിഗ്നൽ പ്രവർത്തനം നൽകിയിരിക്കുന്നു. കമാൻഡ് സ്ട്രിംഗ് SIG_IGN ആണെങ്കിൽ, സിഗ്നലുകൾ അവഗണിക്കപ്പെടും. കമാൻഡ് സ്ട്രിംഗ് SIG_DFL ആണെങ്കിൽ, സിഗ്നലുകൾ സിസ്റ്റം സ്വതവേയുള്ളതായിരിക്കുന്നു. സിഗ്നലുകൾ ഒരൊറ്റ സിഗ്നലോ അല്ലെങ്കിൽ സിഗ്നലുകളുടെ ലിസ്റ്റോ ആണ്. സിഗ്നൽ പ്രകാരം (3) സിഗ്നലുകൾ എണ്ണം അല്ലെങ്കിൽ പ്രതീകാത്മകമായി സൂചിപ്പിക്കാം. "SIG" പൂർവ്വപ്രത്യയം ഒഴിവാക്കാം.

ആർഗ്യുമെന്റുകളോ (ആർഗുമെൻറ് നമ്പറുകളോ) ട്രാപ്പ് നിലവിൽ നടപ്പിലാക്കുന്ന ട്രാപ്പ് കമാൻഡിന്റെ സിഗ്നൽ നമ്പർ നൽകുന്നു.

Tcl നിലവിൽ തുടങ്ങുന്ന കമാൻഡ് എപ്പോൾ വേണമെങ്കിലും Tcl മടങ്ങിപ്പോകാൻ പോകുകയാണെന്നതിന് പകരം -code ഫ്ലാഗ് ആ കമാൻഡ് നൽകാനുള്ള കോഡ് ഉപയോഗിക്കുന്നു.

ട്രാന്പ്റ്റ് പ്രഖ്യാപിച്ചതിനു മുമ്പല്ല , കമാൻഡ് പ്രവർത്തിച്ചുകൊണ്ടിരുന്ന സമയത്തു്, ഇന്ററാപ്റ്റർ ഉപയോഗിച്ച് ആജ്ഞാപിക ക്രമീകരിക്കപ്പെടുന്നു.

നിലവിൽ നടപ്പിലാക്കുന്ന ട്രപ് ആജ്ഞയുടെ സിഗ്നൽ നാമം നൽകാനുള്ള ട്രാപ് കമാൻഡ് ഇ -നാമ ഫ്ലാഗ് കാരണമാകുന്നു.

ട്രാൻസ്പ് കമാൻഡ് ക്രമീകരിച്ചിട്ടുള്ള ഏറ്റവും വലിയ സിഗ്നൽ നമ്പർ നൽകാനുള്ളതാണ് മമസ് ഫ്ലാഗ്.

ഉദാഹരണത്തിന്, "trap {send_user" Ouch! "} എന്ന ആജ്ഞ," SIGINT "അച്ചടിക്കും" ഓ! " ഓരോ തവണ ഉപയോക്താവും അമർത്തുന്നു ^ സി.

സ്വതവേ, SIGINT (ഇത് C ^ അമർത്തുന്നത് സാധാരണയായി ഉണ്ടാക്കുന്നതാണ്), SIGTERM കാരണം പുറത്തുകടക്കാൻ പ്രതീക്ഷിക്കുന്നു. പ്രതീക്ഷിക്കുന്നത് ആരംഭിക്കുമ്പോൾ ഡിഫാൾട്ട് ആയിട്ടുള്ള, ഇനിപ്പറയുന്ന ട്രാപ്പ് ആണ് ഇത്.

എക്സിറ്റ് എക്സിറ്റ് {SIGINT SIGTERM}

ഡീബഗ്ഗർ ആരംഭിക്കുന്നതിന് നിങ്ങൾ -D ഫ്ലാഗ് ഉപയോഗിച്ചാൽ, ഇന്ററാക്ടീവ് ഡീബഗ്ഗർ ആരംഭിക്കാൻ SIGINT പുനർനിർവചിക്കപ്പെടുന്നു. ഇത് താഴെപ്പറയുന്ന കെണിയിൽ ആണ്:

trap {exp_debug 1} SIGINT

പരിസ്ഥിതി വേരിയബിൾ EXPECT_DEBUG_INIT പുതിയ ട്രാപ്പ് കമാൻഡിലേക്ക് സജ്ജമാക്കി കൊണ്ട് ഡീബഗ്ഗർ ട്രാപ്പ് മാറ്റാനാകും.

നിങ്ങളുടെ സ്ക്രിപ്റ്റിലേക്ക് ട്രാപ്പ് കമാൻഡുകൾ ചേർത്ത് നിങ്ങൾക്ക് ഇവ രണ്ടും അസാധുവാക്കാൻ കഴിയും. പ്രത്യേകിച്ച്, നിങ്ങളുടെ സ്വന്തമായ "trap exit SIGINT" ഉണ്ടെങ്കിൽ, ഇത് ഡീബഗ്ഗർ ട്രാപ്പ് അസാധുവാക്കും. ഉപയോക്താക്കളെ ഡീബഗ്ഗറിലേക്ക് ലഭിക്കുന്നത് തടയാൻ ഇത് ഉപകാരപ്പെടുന്നതാണ്.

നിങ്ങൾ SIGINT- ൽ നിങ്ങളുടെ സ്വന്തം കെണിയിൽ നിർവചിക്കണമെങ്കിൽ, അത് പ്രവർത്തിക്കുമ്പോൾ ഡീബഗ്ഗറിലേക്ക് ഇപ്പോഴും ട്രാക്ക് ചെയ്യണം, ഇത് ഉപയോഗിക്കുക:

{! [exp_debug]} {trap mystuff SIGINT}

മറ്റൊരു സിഗ്നൽ ഉപയോഗിച്ചു് നിങ്ങൾക്ക് ഡീബഗ്ഗറിലേക്കു് ട്രാക്ക് ചെയ്യുവാൻ സാധിക്കുന്നു.

SIGALRM- യ്ക്കായുള്ള പ്രവർത്തനത്തെ അസാധുവാക്കാൻ നിങ്ങളെ അനുവദിക്കില്ല, കാരണം ഇത് പ്രതീക്ഷിക്കാനായി ആന്തരികമായി ഉപയോഗിക്കുന്നു. വിച്ഛേദിക്കുന്ന കമാൻഡ് SIG_IGN (അവഗണിക്കുക) ലേക്ക് SIGALRM സജ്ജമാക്കുന്നു. തുടർന്നുള്ള സ്പോൺ കമാൻഡുകളിൽ നിങ്ങൾക്ക് ഇത് പ്രവർത്തന രഹിതമാകുമ്പോൾ ഇതു് നിങ്ങൾക്കു് വീണ്ടും ലഭ്യമാക്കാം.

കൂടുതൽ വിവരങ്ങൾക്കായി സിഗ്നൽ (3) കാണുക.

കാത്തിരിക്കുക
ഒരു പ്ളാൻഡഡ് പ്രോസസ് (അല്ലെങ്കിൽ ഒരു പേരൊന്നും നൽകിയിട്ടില്ലെങ്കിൽ നിലവിലുള്ള പ്രക്രിയ ) അവസാനിക്കുന്നു വരെ കാലതാമസം വരുത്തുന്നു.

കാത്തിരിക്കുക സാധാരണയായി നാലു പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു. ആദ്യത്തെ പൂർണ്ണസംഘം കാത്തിരിക്കുന്ന പ്രക്രിയയുടെ പിഡ് ആണ്. രണ്ടാമത്തെ പൂർണ്ണസംഖ്യയാണ് സ്പാൺ ഐഡി. ഒരു ഓപ്പറേറ്റിങ് സിസ്റ്റം പിശക് സംഭവിച്ചാൽ, മൂന്നാമത്തെ പൂർണ്ണസംഖ്യ -1 അല്ലെങ്കിൽ 0 അല്ലെങ്കിൽ. മൂന്നാമത്തെ പൂർണ്ണസംഖ്യ 0 ആണെങ്കിൽ, നാലാമത്തെ പൂർണ്ണസംഖ്യയാണ് സ്പാൺ ചെയ്ത പ്രോസസ്സ് നൽകിയ സ്റ്റാറ്റസ്. മൂന്നാമത്തെ പൂർണ്ണസംഖ്യ -1 ആണെങ്കിൽ, നാലാമത്തെ പൂർണ്ണസംഖ്യ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ പിഴവ് വരുത്തുന്ന മൂല്യമാണ്. ഗ്ലോബൽ വേരിയബിൾ എറർ കോഡും സജ്ജമാക്കിയിട്ടുണ്ട്.

റിട്ടേൺ മൂല്യത്തിന്റെ അവസാനം കാത്തിരിക്കുന്നതിൽ നിന്ന് അധിക ഘടകങ്ങൾ ദൃശ്യമാകാം. അഞ്ചാമത്തെ ഘടകം ഓപ്ഷനുകൾ ഒരു ക്ലാസ് തിരിച്ചറിയുന്നു. നിലവിൽ, ഈ മൂലകത്തിന് സാധ്യമായ ഒരേയൊരു മൂല്യം CHILDKILLED ആണ്, അടുത്ത രണ്ടു മൂല്യങ്ങൾ സി-സ്റ്റൈൽ സിഗ്നൽ പേരും ചെറിയ ഹ്രസ്വവിവരണവുമാണ്.

പേരുള്ള spawn_id ( പ്രോസസ് ഐഡി അല്ല) എന്നതിനു യോജിക്കുന്ന പ്രക്രിയ , -i ഫ്ലാഗ് പ്രഖ്യാപിക്കുന്നു. ഒരു SIGCHLD ഹാൻഡലറിനുള്ളിൽ, സ്പാൺ ഐഡി -1 ഉപയോഗിച്ചുകൊണ്ടുള്ള ഏതെങ്കിലും പ്ലെയിൻ പ്രക്രിയയ്ക്കായി കാത്തിരിക്കുക സാധ്യമാണ്.

വിജയത്തിനായി കാത്തിരിക്കുന്നതിന്റെ സൂചനയോടെ ഉടനടി മടങ്ങിയെത്തുന്നതിന് കാത്തിരിക്കൽ -അയ്യിറ്റ് ഫ്ലാഗ് കാരണമാകുന്നു. പ്രക്രിയ (പിന്നീടു്) പുറത്തു് വരുമ്പോൾ, അതു് സ്പഷ്ടമായ കാത്തിരിപ്പ് ആവശ്യമില്ലാതെ സ്വയമായി അപ്രത്യക്ഷമാകും.

"-i -1" ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് ഫോർക്ക്ഡ് പ്രോസസ്സിനായി കാത്തിരിക്കുക കമാൻഡ് ഉപയോഗിക്കാം. പ്ലെയിൻ പ്രോസസ്സിനുള്ള ഉപയോഗത്തിൽ നിന്നും വ്യത്യസ്തമായി, ഈ കമാൻഡ് എപ്പോൾ വേണമെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യാം. ഏത് പ്രക്രിയയാണ് കൊയ്യുന്നത് എന്നതിന്മേൽ നിയന്ത്രണം ഇല്ല. എന്നിരുന്നാലും, പ്രോസസ് ഐഡിക്ക് റിട്ടേൺ മൂല്യം പരിശോധിക്കാനാകും.

ലൈബ്രറികൾ

സ്ക്രിപ്റ്റുകൾ പ്രതീക്ഷിക്കുന്നതിനായി രണ്ട് അന്തർനിർമ്മിത ലൈബ്രറികളെക്കുറിച്ച് അറിയാമായിരിക്കും. ഇവയെ variables exp_library, exp_exec_library എന്നീ പേരുകളിൽ നൽകിയിരിക്കുന്ന ഡയറക്ടറികളാൽ നിർവചിച്ചിരിക്കുന്നു. ഇവ രണ്ടും മറ്റ് സ്ക്രിപ്റ്റുകൾ ഉപയോഗിയ്ക്കുവാനുപയോഗിക്കുന്ന യൂട്ടിലിറ്റി ഫയലുകൾ സൂക്ഷിയ്ക്കുകയാണ്.

exp_library ആർക്കിടക്ചർ-സ്വതന്ത്ര ഫയലുകൾ അടങ്ങുന്നു. exp_exec_library ആർക്കിടെക്ചർ ആശ്രിതത്വ ഫയലുകൾ അടങ്ങുന്നു. നിങ്ങളുടെ സിസ്റ്റം അനുസരിച്ചു്, രണ്ടു് ഡയറക്ടറികളും പൂർണ്ണമായും ഒഴിഞ്ഞേക്കാം. $ Exp_exec_library / cat-buffers എന്ന ഫയൽ നിലവിലുണ്ടെങ്കിൽ നിങ്ങളുടെ / bin / cat buffers ഡിഫോൾട്ട് ആയിരുന്നോ എന്ന് വിവരിക്കുന്നു.

പ്രെറ്റി പ്രിൻറ് ചെയ്യുന്നു

ഒരു VGRrind ഡെഫനിഷൻ പ്രെറ്റി പ്രിന്റിനായി ലഭ്യമാണ് സ്ക്രിപ്റ്റുകൾ പ്രതീക്ഷിക്കുക . പ്രതീക്ഷിക്കുന്ന വിതരണത്തിൽ വിതരണം ചെയ്ത vgrind നിർവചനം ശരിയായി ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്കിത് ഉപയോഗിക്കാവുന്നതാണ്:

vgrind-lexpect ഫയൽ

EXAMPLES

മാൻ പേജ് വിശദീകരിയ്ക്കുന്ന എല്ലാ കാര്യങ്ങളും എങ്ങനെ ഒതുക്കിയിരിക്കണം എന്നു വ്യക്തമല്ല. വിതരണ പ്രതീക്ഷയുടെ ഉദാഹരണ ഡയറക്ടറിയിലെ ഉദാഹരണങ്ങൾ വായിക്കാനും പരീക്ഷിച്ചുനോക്കാനും ഞാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു. അവയിൽ ചിലത് യഥാർത്ഥ പ്രോഗ്രാമുകളാണ്. മറ്റുള്ളവർ ചില സാങ്കേതികവിദ്യകളിൽ ലളിതമായി വിവരിക്കാറുണ്ട്, തീർച്ചയായും, ദമ്പതികൾ പെട്ടെന്നുള്ള ഹാക്കുകളാണ്. INSTALL ഫയലിന് ഈ പ്രോഗ്രാമുകളുടെ ഒരു ദ്രുത അവലോകനം ഉണ്ട്.

പ്രതീക്ഷിക്കുന്ന പേപ്പറുകൾ (കാണുക). ചില പേപ്പറുകൾ മുൻകൂർ പ്രതീക്ഷകൾക്കു മുൻപുള്ള സിന്റാക്സ് ഉപയോഗിക്കുമ്പോൾ, അത്തരം യുക്തിസഹമായ മൂല്യങ്ങൾ ഇന്നും സാധുവാണ്.

CAVEATS

Expect ന്റെ കമാൻഡ് നാമങ്ങളുമായി എക്സ്റ്റെൻഷനുകളുമായി കൂട്ടിയിരിക്കാം. ഉദാഹരണത്തിന്, പൂർണ്ണമായും വ്യത്യസ്തമായ ആവശ്യത്തിനായി ടിക്ക് നിർവ്വചിച്ചിരിക്കുന്നു. ഇക്കാരണത്താൽ തന്നെ, "Ex_XXXX" എന്നതും പ്രതീക്ഷിക്കപ്പെടുന്ന മിക്ക കമാൻഡുകളും ലഭ്യമാണ്. "Exp", "inter", "spawn", "timeout" എന്നിവയിൽ തുടങ്ങുന്ന കമാൻഡുകളും വേരിയബിളുകളും പരസ്പരം ഇല്ല. പരിസ്ഥിതികൾ തമ്മിലുള്ള ഈ പൊരുത്തമുണ്ടാകണമെങ്കിൽ വിപുലീകരിച്ച കമാൻഡ് പേരുകൾ ഉപയോഗിക്കുക.

പ്രതീക്ഷിക്കുന്നത് സ്കോപ്പിംഗിന്റെ കൂടുതൽ ഉദാരവൽക്കരണ കാഴ്ചപ്പാടാണ്. പ്രത്യേകമായി, പ്രതീക്ഷിക്കുന്ന പരിപാടിക്ക് വേണ്ടി നിർദ്ദേശങ്ങൾ അനുസരിച്ച് വേരിയബിളുകൾ പ്രാദേശിക സാമഗ്രിയിൽ നിന്ന് ആദ്യം അന്വേഷിക്കും, കൂടാതെ ആഗോള സാദ്ധ്യതയിൽ കണ്ടില്ലെങ്കിൽ. ഉദാഹരണമായി, നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് ഉപയോഗിക്കുന്ന എല്ലാ നടപടിക്രമങ്ങളിലും "ആഗോള സമയപരിധി" വയ്ക്കേണ്ടതിന്റെ ആവശ്യകതയെ ഇത് ഒഴിവാക്കുന്നു. മറുവശത്ത്, എഴുതപ്പെട്ട ചരങ്ങൾ എല്ലായ്പ്പോഴും പ്രാദേശിക സാമഗ്രികളിൽ ഉണ്ട് (ഒരു "ആഗോള" ആജ്ഞ നൽകിയിട്ടില്ലെങ്കിൽ). ഒരു നടപടിക്രമത്തിൽ സ്പോൺ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ഈ കാരണങ്ങൾ സാധാരണമാണ്. നടപടിക്രമങ്ങൾക്കപ്പുറം, spawn_id തുടർന്നങ്ങോട്ട് നിലവിലില്ല, അതിനാൽ സ്കോപ്പിംഗ് കാരണം പ്ളാൻഡഡ് പ്രോസസ്സ് ഇനി ലഭ്യമല്ല. ഇത്തരത്തിലുള്ള ഒരു "ഗ്ലോബൽ സ്പോൺ_ഐഡി" ചേർക്കുക.

നിങ്ങൾക്ക് മൾട്ടിപിങ്ങ് ശേഷി സാധ്യമല്ലെങ്കിൽ (അതായത്, നിങ്ങളുടെ സിസ്റ്റം പിന്തുണ (BSD *. *), വോട്ടെടുപ്പ് (SVR> 2), അല്ലെങ്കിൽ ഒന്നും തന്നെ) പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ, ഒരു സമയം ഒരു പ്രോസസിനെ നിയന്ത്രിക്കാൻ മാത്രമേ പ്രതീക്ഷിക്കുകയുള്ളൂ . ഈ സാഹചര്യത്തിൽ, spawn_id ക്രമീകരിക്കാൻ ശ്രമിക്കരുത് , അല്ലെങ്കിൽ ഒരു പ്രവർത്തനസജ്ജമായ പ്രക്രിയ പ്രവർത്തിക്കുന്ന സമയത്ത് നിങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ പ്രക്രിയകൾ നടപ്പിലാക്കണം. കൂടാതെ, ഒന്നിലധികം പ്രോസസ്സുകളിൽ നിന്ന് (ഒരേസമയം ഒരു ഉപയോക്താവ് ഉൾപ്പെടെ) നിങ്ങൾക്ക് പ്രതീക്ഷിക്കാനാകില്ല .

ടെർമിനൽ പരാമീറ്ററുകൾ സ്ക്രിപ്റ്റുകളിൽ വലിയ സ്വാധീനം ഉണ്ടാക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു സ്ക്രിപ്റ്റ് echoing നോക്കാൻ എഴുതിയതാണെങ്കിൽ, echoing ഓഫാക്കിയിട്ടുണ്ടെങ്കിൽ അത് ശരിയായി പ്രവർത്തിക്കും. ഇക്കാരണത്താൽ, ഡീഫോൾട്ടായി ശക്തികളെ ടെർമിനൽ പരാമീറ്ററുകൾ പ്രതീക്ഷിക്കുക. നിർഭാഗ്യവശാൽ, ഇത് മറ്റ് പ്രോഗ്രാമുകൾക്ക് അനായാസമായ കാര്യങ്ങൾ ഉണ്ടാക്കാൻ കഴിയും. ഉദാഹരണമായി, emacs ഷെൽ "സാധാരണ" മാപ്പിംഗുകൾ മാറ്റാൻ ആഗ്രഹിക്കുന്നു: പുതിയ വരികൾക്കു പകരം പുതിയ വരികളിലേക്ക് പുതിയ വരികളിലേക്ക് മാപ്പ് ചെയ്തു, കൂടാതെ ആവോത്സവം അപ്രാപ്തമാക്കി. ഇൻപുട്ട് ലൈനിൽ മാറ്റം വരുത്തുന്നതിന് emacs ഉപയോഗിക്കുന്നതിന് ഇത് ഒരാളെ അനുവദിക്കുന്നു. നിർഭാഗ്യവശാൽ, പ്രതീക്ഷിച്ചേക്കാവുന്നത് ഇത് ഊഹിച്ചുകൂടാ.

ടെർമിനൽ പാരാമീറ്ററുകളുടെ ഡീഫോൾട്ട് സെറ്റിംഗിനെ അസാധുവാക്കാതിരിക്കാൻ നിങ്ങൾക്ക് അഭ്യർത്ഥിക്കാം, പക്ഷേ അത്തരം സാഹചര്യങ്ങളിൽ സ്ക്രിപ്റ്റുകൾ എഴുതുമ്പോൾ നിങ്ങൾ വളരെ ശ്രദ്ധിക്കേണ്ടതാണ്. Emacs- ൽ, echoing- ഉം അവസാന-ലൈൻ മാപ്പിംഗുകൾ പോലെയുള്ള കാര്യങ്ങളിൽ നിന്നും ഒഴിവാക്കുക.

ഒരു ലിസ്റ്റ് എന്ന വാദം സ്വീകരിച്ച ആജ്ഞകൾ (ഒരു വേരിയൻറുകളും സംവേദനവും പ്രതീക്ഷിക്കുന്നു ) ലിസ്റ്റ് ഒരു വാദം അല്ലെങ്കിൽ അനേകം ആളാണോ എന്ന് തീരുമാനിക്കാൻ ഒരു ഹ്യൂറിസ്റ്റിക് ഉപയോഗിക്കുക. ഒന്നിൽ കൂടുതൽ ഉൾച്ചേർത്ത \ n ന്റെ വൈസ്പെയ്സ് പ്രതീകങ്ങളുള്ള ഒരു ആർഗ്യുമെയെയാണീ പട്ടികയെ പ്രതിനിധാനം ചെയ്യുന്നത് എന്ന സാഹചര്യത്തിൽ മാത്രമേ ഹ്യൂറിസ്റ്റുകൾക്ക് പരാജയം സംഭവിക്കാൻ കഴിയൂ. ഇത് മതിയായിരിക്കുമെന്നു തോന്നുന്നു, ഒരു വാദഗതിയെ കൈകാര്യം ചെയ്യുവാൻ ഒരൊറ്റ വാദം നിർബന്ധിക്കുവാൻ വാദിക്കുന്നത് "നൊബ്രസ്" എന്ന വാദം ഉപയോഗിക്കാം. മെഷീൻ ജനറേറ്റു ചെയ്ത പ്രതീക്ഷയോടെയുള്ള കോഡ് ഉപയോഗിച്ച് ഇത് മനഃപൂർവ്വം ഉപയോഗിക്കാം. അതുപോലെ, ഒന്നിൽ കൂടുതൽ പാറ്റേണുകൾ / പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യാൻ ഒരൊറ്റ ആർഗ്യുമെന്റ് വെക്കുന്നു.

ബഗ്ഗുകൾ

പ്രോഗ്രാമിൽ "ലൈംഗിക" ("സ്മാർട്ട് എക്ഇക്" അല്ലെങ്കിൽ "സെന്റ്-ഇൻപെക്ട്") എന്ന പേരിൽ പ്രോഗ്രാമുകൾക്ക് ശരിക്കും പ്രലോഭനമുണ്ടായിരുന്നു, പക്ഷേ നല്ല ആശയങ്ങൾ (അല്ലെങ്കിൽ ഒരുപക്ഷേ പ്യൂറിട്ടൻസിസം) വിജയിച്ചു.

ചില സിസ്റ്റങ്ങളിൽ, ഒരു ഷെൽ എപ്പോഴാണ് വികസിപ്പിച്ചെടുത്തത് എന്നതിനെ പറ്റി, അത് tty- ൽ പ്രവേശിക്കാൻ കഴിയാതെ, ഏതുവിധേനയും പ്രവർത്തിക്കുന്നു എന്ന് പരാതിപ്പെടുന്നു. ഇത് നിങ്ങളുടെ സിസ്റ്റം അർത്ഥമാക്കുന്നത് അറിയാത്ത നിയന്ത്രിക്കുന്ന tty നേടുന്നതിന് ഒരു സംവിധാനം ഉണ്ട് എന്നാണ്. അത് എന്താണെന്ന് കണ്ടെത്തുക, ഈ വിവരം എന്നെ തിരികെ അയയ്ക്കുക.

അൾട്രിക്സ് 4.1 (ഇവിടെയെങ്കിലുമുള്ള ഏറ്റവും പുതിയ പതിപ്പുകൾ എങ്കിലും) 1000000 ന് മുകളിലായുള്ള സമയപരിധി 0, 0 ന് തുല്യമായി കണക്കാക്കപ്പെടുന്നു.

നിങ്ങൾ ഒരു SIGCHLD ഹാൻഡ്ലർ നിർവ്വചിക്കുകയാണെങ്കിൽ ptys അനുവദിക്കുവാൻ ഡിജിറ്റൽ യുണിക്സ് 4.0A (മറ്റ് ഒരുപക്ഷേ മറ്റ് പതിപ്പുകളും) നിരാകരിക്കുന്നു. കൂടുതൽ വിവരങ്ങൾക്കായി grantpt പേജ് കാണുക.

ഐആർഐഎക്സ് 6.0 മറ്റൊരാൾ ഉപയോഗിച്ചിരുന്ന മുൻകൂട്ടി നിശ്ചയിക്കാനുള്ള ശ്രമങ്ങൾ പ്രതീക്ഷിക്കുന്നെങ്കിൽ, ഇത് പരാജയപ്പെടാൻ പമ്പായി അനുമതി നൽകില്ല. IRIX 6.1-ലേക്ക് അപ്ഗ്രേഡ് ചെയ്യൂ.

TERM സജ്ജമാക്കിയിട്ടില്ലെങ്കിൽ ടെൽനെറ്റ് (SunOS 4.1.2-ൽ മാത്രം പരിശോധിച്ചു) തടഞ്ഞു. ക്രോൺ, ടി.ജി. നിർവചിക്കാത്ത cgi സ്ക്രിപ്റ്റുകൾ എന്നിവയിൽ ഒരു പ്രശ്നമാണ് ഇത്. അതിനാൽ, നിങ്ങൾ ഇത് വ്യക്തമായി സജ്ജമാക്കണം - ഏതു തരം സാധാരണയായി അപ്രസക്തമാണ്. അത് എന്തെങ്കിലും സജ്ജമാക്കണം! മിക്കപ്പോഴും മിക്ക കേസുകളിലും മതിയാകുന്നു.

env (TERM) vt100 സെറ്റ് ചെയ്യുക

ഷെൽ, ഹോം എന്നിവ സജ്ജമാക്കിയില്ലെങ്കിൽ ടിപ്പ് (BSDI BSD / OS 3.1 i386 പ്രകാരം പരിശോധിച്ചുറപ്പിക്കൽ) തകരാറിലാകുന്നു. Cgi സ്ക്രിപ്റ്റിലുളള cron സ്ക്രിപ്റ്റിലുളള ഒരു പ്രശ്നം ആണ് ഇത്. ഈ എന്വയോണ്മെന്റ് വേരിയബിള്സ് നിര്വചിക്കുന്നില്ല. അതിനാൽ, നിങ്ങൾ അവ വ്യക്തമാക്കണം - ഏതു തരം സാധാരണയായി അപ്രസക്തമാണ്. അത് എന്തെങ്കിലും സജ്ജമാക്കണം! മിക്കപ്പോഴും മിക്ക കേസുകളിലും മതിയാകുന്നു.

env (shell) / bin / sh set env (ഹോം) / usr / local / bin സജ്ജമാക്കുക

Ptys- ന്റെ ചില നടപ്പിലാക്കലുകൾ രൂപകൽപ്പന ചെയ്തിരിയ്ക്കുന്നു. അതിനാൽ, ഫയൽ ഡിസ്ക്രിപ്റ്റർ അടച്ച ശേഷം 10 മുതൽ 15 സെക്കൻഡുകൾക്ക് ശേഷം (യഥാർത്ഥ നമ്പർ നടപ്പിലാക്കുന്നത് അനുസരിച്ച്) കേർണൽ വായിക്കാത്ത ഏതെങ്കിലും ഔട്ട്പുട്ട് അഴിച്ചുമാറ്റുന്നു. അങ്ങനെ അത്തരം പോലുള്ള പ്രോഗ്രാമുകൾ പ്രതീക്ഷിക്കുക

സ്റ്റെയിൻ തീയതി 20 പ്രതീക്ഷിക്കുന്നു

പരാജയപ്പെടും. ഇത് ഒഴിവാക്കുന്നതിന്, നോൺ-ഇൻട്രാക്റ്റീവ് പ്രോഗ്രാമുകൾ സ്പോൺ ചെയ്യുന്നതിനേക്കാൾ നിർവ്വഹിക്കരുത് . അത്തരം സാഹചര്യങ്ങൾ പരിഗണിക്കപ്പെടുമ്പോൾ, പ്രായോഗികമായി ഒരു പ്രശ്നത്തെ നേരിടാതെ, ഒരു യഥാർത്ഥ സംവേദനാത്മക പരിപാടിയുടെ അന്തിമഫലം ഈ സ്വഭാവം മൂലം നഷ്ടപ്പെടും.

പ്രോസസ് ഫയൽ ഡിസ്ക്രിപ്റ്റർ അടച്ചു കഴിഞ്ഞാൽ, ക്രെ UNICOS ptys ഏതെങ്കിലും വായിക്കാത്ത ഔട്ട്പുട്ട് എടുത്തു കളയുന്നു. ഞാൻ ഇത് ക്രെയിമിലേക്ക് റിപ്പോർട്ടുചെയ്തു, അവ പരിഹരിക്കുന്നതിലാണ് പ്രവർത്തിക്കുന്നത്.

ചില സമയങ്ങളിൽ ഒരു നിർദേശവും പ്രതികരണവും തമ്മിൽ ഒരു ആവശ്യം ഉണ്ടാകണം. ഉദാഹരണത്തിന്, ഒരു tty ഇൻഫർമേഷൻ UART ക്രമീകരണങ്ങൾ അല്ലെങ്കിൽ തുടക്കത്തിൽ / നിർത്തിവയ്ക്കുന്നതിന് വേണ്ടി തിരയുന്നതിലൂടെ ബാഡ് റേറ്റ് മാറ്റുന്നു. സാധാരണയായി, ഈ ഒന്നോ രണ്ടോ രണ്ടോ ഉറക്കം വേണം. ഇൻപുട്ട് സ്വീകരിക്കാൻ ഹാർഡ്വെയർ തയാറാകുന്നതുവരെ കൂടുതൽ ശക്തമായ സാങ്കേതികവിദ്യ വീണ്ടും ശ്രമിക്കേണ്ടതാണ്. താഴെക്കാണുന്ന ഉദാഹരണം രണ്ട് തന്ത്രങ്ങളും ഉപയോഗിക്കുന്നു:

"വേഗത 9600 \ r" അയയ്ക്കുക; ഉറക്കം 1 {സമയപരിധി {അയയ്ക്കുക "\ r"; exp_continue} $ prompt}

Tcl ന്റെ ഇവന്റ് ലൂപ്പിയിൽ കിടക്കുന്ന ഏത് ആജ്ഞയുപയോഗിച്ചും ട്രാപ്പ്-കോഡ് പ്രവർത്തിക്കില്ല, ഉദാഹരണത്തിന്, ഉറക്കം. പ്രശ്നം ലൂപ്പ് ചെയ്യുമ്പോൾ, Tcl async ഇവന്റ് ഹാൻഡ്ലറുകളിൽ നിന്നുള്ള റിട്ടേൺ കോഡ് ഉപേക്ഷിക്കുന്നു. ട്രാപ് കോഡിൽ ഒരു പതാകയുണ്ടാക്കാം. ആജ്ഞയ്ക്ക് ശേഷം ഉടൻ പതാക പരിശോധിക്കുക (അതായത്, ഉറക്കം).

Expect_background കമാൻഡ് ignores -timeout ആർഗ്യുമെൻറുകൾക്കും സാധാരണയായി ടൈംഔട്ടുകളുടെ ആശയം ഇല്ല.

& # 34; EXPECT സൂചനകൾ & # 34;

അത് അവഗണിക്കാനാവാത്തതായിരിക്കാം എന്ന് പ്രതീക്ഷിക്കുന്ന ചില കാര്യങ്ങൾ ഉണ്ട്. ഈ രണ്ട് കാര്യങ്ങളുമായി ഈ വിഷയങ്ങൾ ചർച്ചചെയ്യാൻ ഈ വിഭാഗം ശ്രമിക്കുന്നു.

ഒരു സാധാരണ പ്രതീക്ഷിക്കുന്നത് ഷെൽ പ്രോംപ്റ്റ് എങ്ങിനെ തിരിച്ചറിയാം എന്നതാണ്. ഇവ വ്യത്യസ്തമായി വ്യത്യസ്തവും ആളുകളും വ്യത്യസ്ത ഷെല്ലുകളാൽ വ്യത്യസ്തമാംവിധം കസ്റ്റമൈസ് ചെയ്തിരിക്കുന്നതിനാൽ, പ്രോംപ്റ്റിനെ അറിയാതെ തന്നെ സാധാരണഗതിയിൽ ഓട്ടോമാറ്റിക്കായി റോഗോഗിനു കഴിയും. പരിസ്ഥിതി വേരിയബിളിൽ EXPECT_PROMPT ൽ അവരുടെ പ്രോംപ്റ്റ് (പ്രത്യേകിച്ച്, അതിന്റെ അവസാനം) വിവരിക്കുന്ന ഒരു സാധാരണ എക്സ്പ്രഷൻ ഉപയോക്താക്കളെ സംഭരിക്കുക എന്നതാണ് ന്യായമായ ഒരു കൺവെൻഷൻ. താഴെ പറയുന്നതുപോലെ കോഡ് ഉപയോഗിക്കാം. EXPECT_PROMPT നിലവിലില്ലെങ്കിൽ, കോഡ് ഇപ്പോഴും ശരിയായി പ്രവർത്തിക്കുന്നതിന് നല്ല അവസരമുണ്ട്.

set prompt "(% | # | \\ $ $) $"; # default prompt catch {set prompt $ env (EXPECT_PROMPT)} -re $ prompt പ്രതീക്ഷിക്കുന്നു

നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതെന്തും അവസാനിക്കുമെന്ന പ്രതീക്ഷയിൽ പാറ്റേൺ പ്രതീക്ഷിക്കാൻ ഞാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു. ഇത് മുഴുവൻ കാര്യങ്ങളും കാണുന്നതിനുമുമ്പ് ഒരു ചോദ്യത്തിന് ഉത്തരം നൽകാനുള്ള സാധ്യത ഒഴിവാക്കുന്നു. കൂടാതെ, പൂർണ്ണമായി കാണുന്നതിനുമുമ്പ് നിങ്ങൾക്ക് ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകാനാകുമ്പോഴും നിങ്ങൾ നേരത്തേ മറുപടി നൽകുകയാണെങ്കിൽ ചോദ്യത്തിന്റെ മധ്യത്തിൽ നിങ്ങളുടെ ഉത്തരം വീണ്ടും പ്രതികരിച്ചേക്കാം. മറ്റൊരു തരത്തിൽ പറഞ്ഞാൽ ലഭിക്കുന്ന സംഭാഷണം ശരിയാകും.

മിക്ക നിർദ്ദേശങ്ങളും അവസാനം ഒരു സ്പെയ്സ് പ്രതീകം ഉൾക്കൊള്ളുന്നു. ഉദാഹരണത്തിന്, FTP ൽ നിന്നുള്ള പ്രോംപ്റ്റ് 'f', 't', 'p', '>' എന്നിവയാണ്. ഈ പ്രോംപ്റ്റിനായി പൊരുത്തപ്പെടുത്തുന്നതിന്, ഈ ഓരോ ക്യാരക്ടറിലും നിങ്ങൾ അക്കൌണ്ട് നൽകണം. ശൂന്യമായി ഉൾപ്പെടുത്തരുതെന്ന് സാധാരണ തെറ്റാണ്. വ്യക്തമായി സ്പഷ്ടമാക്കി വയ്ക്കുക.

ഫോം X * ന്റെ ഒരു പാറ്റേൺ ഉപയോഗിച്ചാൽ, അവസാനം X- ൽ നിന്നും ലഭിച്ച എല്ലാ ഉൽപാദനവും അവസാനമായി ലഭിക്കും. ഇതു് തികച്ചും ആശയക്കുഴപ്പമുണ്ടാക്കുന്നു. കാരണം, കമ്പ്യൂട്ടറിന്റെ വേഗതയും കെർണലും ഡിവൈസ് ഡ്രൈവർ ഉപയോഗിച്ചു് ഐ / ഒ പ്രക്രിയയും അനുസരിച്ച് "അവസാനത്തെ വസ്തുത" എന്നതിനുള്ള വ്യത്യാസം വ്യത്യാസപ്പെട്ടിരിക്കുന്നു.

പ്രത്യേകിച്ചും, മിക്ക പ്രോഗ്രാമുകളും ഒരു സമയത്ത് ഉൽപാദനം ഒരു വരി ഉൽപ്പാദിപ്പിക്കുമ്പോൾ, മനുഷ്യർ വലിയ കഷണങ്ങളിലേയ്ക്ക് (atomically) എത്തിക്കുന്ന പ്രോഗ്രാം ഔട്ട്പുട്ട് കാണും. ഇതിനെ കണക്കിലെടുക്കുമ്പോൾ, മുൻ ഖണ്ഡികയുടെ മാതൃകയിൽ * നിലവിലെ വരിയുടെ അവസാനം മാത്രമേ അത് ദൃശ്യമാകുകയുള്ളൂവെന്ന തോന്നലുണ്ടായിട്ടും, കൂടുതൽ സമയം തോന്നും, കാരണം മാച്ച് സമയത്ത് അത് നേടിയ എല്ലാ ഔട്ട്പുട്ടുകളും ആയിരുന്നു.

നിങ്ങളുടെ പാറ്റേണിനു പ്രത്യേകം അക്കൌണ്ടുകൾ ഇല്ലെങ്കിൽ കൂടുതൽ ഉൽപാദനക്ഷമത വരുന്നതായി അറിയില്ല.

ലൈൻ ഓറിയെന്റഡ് ബഫറിംഗ് അനുസരിച്ച് പോലും അത് ശരിയല്ല. പ്രോഗ്രാമുകൾ അപൂർവ്വമായി അവർ ചെയ്യുന്ന ബഫറിംഗിനെപ്പറ്റിയുള്ള വാഗ്ദാനങ്ങൾ മാത്രമല്ല, സിസ്റ്റം അൾജറുൽ ഔട്ട്പുട്ട് ലൈനുകൾ തകർക്കാൻ കഴിയും. അതിനാൽ, പാറ്റേണുകൾ എഴുതുമ്പോൾ ഒരു പ്രോംപ്റ്റിന്റെ അവസാനത്തെ ഏതാനും പ്രതീകങ്ങൾ നിങ്ങൾക്ക് പ്രകടിപ്പിക്കാൻ കഴിയുമെന്നത് ജ്ഞാനപൂർവമാണ്.

ഒരു പ്രോഗ്രാമിന്റെ അവസാനത്തെ ഉൽപാദനത്തിൽ നിങ്ങൾ ഒരു പാറ്റേൺ കാത്തിരിക്കുന്നുണ്ടെങ്കിൽ പ്രോഗ്രാം മറ്റെന്തെങ്കിലും പ്രസരിപ്പിക്കും, നിങ്ങൾക്ക് കാലഹരണപ്പെടുന്ന കീവേഡ് ഉപയോഗിച്ച് അത് കണ്ടുപിടിക്കാൻ കഴിയില്ല. കാരണം പ്രതീക്ഷിക്കുന്നത് കാലഹരണപ്പെടാൻ കഴിയില്ല - പകരം അത് ഒരു സൂചന നൽകും. പകരം അത് ഉപയോഗിക്കുക. ഇതിലും മികച്ചത്, രണ്ടും ഉപയോഗിക്കുക. ആ ലൈൻ എപ്പോഴും ചുറ്റും നീങ്ങിയിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ലൈൻ തന്നെ എഡിറ്റുചെയ്യേണ്ടതില്ല.

ടെർമിനൽ ഡ്രൈവറിലൂടെ ഔട്ട്പുട്ട് ചെയ്യുമ്പോൾ പുതിയ വരികൾ സാധാരണയായി കറേജ് റിട്ടേണുകളിലേക്ക് പരിവർത്തനം ചെയ്യും. അതിനാല്, printf ("foo \ nbar") എന്നു പറഞ്ഞാല്, "foo \ r \ nbar" എന്ന പാറ്റേണ് ഉപയോഗിക്കാം.

Expect_user വഴി ഉപയോക്താവിൽ നിന്നു വായിക്കുമ്പോൾ സമാനമായ ഒരു പരിഭാഷ നടക്കുന്നു. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ മടങ്ങിപ്പോകുമ്പോൾ, അത് ഒരു പുതിയ ലൈനിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടും. പ്രതീക്ഷിച്ചതാണെങ്കിൽ , ടെർമിനൽ അസംസ്കൃത മോഡിലേക്ക് (ടെൽനെറ്റ് പോലുള്ളവ) സജ്ജമാക്കുന്ന ഒരു പ്രോഗ്രാമിലേക്ക് അത് കടന്നുപോയാൽ പ്രോഗ്രാം യഥാർഥ വരുമാനം പ്രതീക്ഷിക്കുന്നതുപോലെ ഒരു പ്രശ്നമുണ്ടാകും. (ചില പ്രോഗ്രാമുകൾ യഥാർഥത്തിൽ ക്ഷമാപണം ചെയ്യുന്നു, അവർ സ്വപ്രേരിതമായി പുതിയ ലൈനുകൾക്ക് തർജ്ജമ ചെയ്യും, പക്ഷെ ഭൂരിഭാഗവും ചെയ്യാറില്ല.) നിർഭാഗ്യവശാൽ, ഒരു പ്രോഗ്രാം അതിന്റെ ടെർമിനൽ അസംസ്കൃത മോഡിലേക്ക് കടത്തിവെട്ടുന്നതെങ്ങനെ?

സ്വന്തമായി പുതിയ വരികൾ റിട്ടേണുകൾ പകരം വയ്ക്കുന്നതിനു പകരം, "സ്റ്റിക്കി റോ" എന്ന ആജ്ഞ ഉപയോഗിക്കുന്നത് പരിഹാരമാണ്. എന്നിരുന്നാലും, നിങ്ങൾക്ക് ഇനി പാകം ചെയ്ത ലൈൻ എഡിറ്റിങ് സവിശേഷതകൾ ലഭിക്കില്ല എന്നാണ് ഇതിനർത്ഥം.

സംവേദനം നിങ്ങളുടെ ടെർമിനലിനെ അസംസ്കൃത മോഡിലേക്ക് സജ്ജമാക്കുന്നു, അതിനാൽ ഈ പ്രശ്നം ഉണ്ടാകില്ല.

സ്ക്രിപ്റ്റുകൾ പ്രതീക്ഷിക്കുന്നതിൽ പാസ്വേഡുകൾ (അല്ലെങ്കിൽ മറ്റ് സ്വകാര്യ വിവരങ്ങൾ) സംഭരിക്കുന്നതിന് ഉപകരിക്കും. ഒരു കമ്പ്യൂട്ടറിൽ സംഭരിച്ചിരിക്കുന്നതെന്തും ആരെയും ആക്സസ് ചെയ്യാൻ കഴിയുന്നതായിരിക്കും കാരണം ഇത് ശുപാർശ ചെയ്യപ്പെടുന്നില്ല. അതുകൊണ്ടുതന്നെ, ഒരു സ്ക്രിപ്റ്റിന്റെ രഹസ്യവാക്കുകളുടെ സംവേദനാത്മകമായ ആവേശമാണ് അവരെ അക്ഷരാർത്ഥത്തിൽ ഉൾക്കൊള്ളുന്നതിനേക്കാൾ നല്ല ഒരു ആശയമാണ്. എന്നിരുന്നാലും, ചിലപ്പോൾ അത്തരം എംബെഡിംഗ് മാത്രമാണ് സാധ്യത.

നിർഭാഗ്യവശാൽ, യുണിക്സ് ഫയൽസിസ്റ്റം എക്സിക്യൂട്ടബിൾ എന്നാൽ റീഡ് ചെയ്യാവുന്ന സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള നേരിട്ടുള്ള മാർഗമില്ല. Setgid ഷെൽ സ്ക്രിപ്റ്റുകൾ പിന്തുണയ്ക്കുന്ന സംവിധാനങ്ങൾ ഇത് പരോക്ഷമായി ഇപ്രകാരമായിരുന്നു:

പതിവുപോലെ പ്രതീക്ഷിച്ച സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുക (രഹസ്യ ഡാറ്റ അടങ്ങിയിരിക്കുന്നു). അതിന്റെ അനുവാദം 750 ആയിരിക്കണം (-rwxr-x ---) ഒരു വിശ്വസ്ത ഗ്രൂപ്പിന്റെ ഉടമസ്ഥതയിലുള്ള, അതായത്, വായിക്കാൻ അനുവദിച്ചിരിക്കുന്ന ഒരു ഗ്രൂപ്പ്. ആവശ്യമെങ്കിൽ ഈ ആവശ്യത്തിനായി ഒരു പുതിയ ഗ്രൂപ്പ് സൃഷ്ടിക്കുക. അടുത്തതായി, മുമ്പത്തെ അതേ ഗ്രൂപ്പിന്റെ ഉടമസ്ഥതയിലുള്ള 2751 (-rwxr-s - x) അനുമതികളിൽ ഒരു / ബിൻ / ഷി സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുക.

ഫലം ഒരു സ്ക്രിപ്റ്റ് ആണ്, അത് ആർക്കും നടപ്പിലാക്കാം (വായിക്കുക) ചെയ്യാം. ഇത് നടപ്പിലാക്കിയപ്പോൾ, പ്രതീക്ഷിക്കുന്ന സ്ക്രിപ്റ്റ് പ്രവർത്തിക്കുന്നു.

& # 34; ഇതും കാണുക & # 34;

Tcl (3), ലീലക്സക്സ് (3)
"എക്സ്പ്ലോററിംഗ് എക്സ്പെക്ട്: എ ടി ടി പി-ബേസ്ഡ് ടൂൾകിറ്റ് ഫോർ ഓട്ടോമേറ്റിംഗ് ഇൻട്രാക്റ്റീവ് പ്രോഗ്രാംസ്", by Don Libes, pp. 602, ISBN 1-56592-090-2, ഓ'റീലി ആൻഡ് അസോസിയേറ്റ്സ്, 1995.
"പ്രതീക്ഷിക്കുക: ഡോൺ ലിബീസ്, പ്രോസീഡിങ്ങ്സ് ഓഫ് ദി വേനന്റ് 1990 യുഎസ്ഇനിക്സ് കോൺഫറൻസ്, ആനാഹൈം, കാലിഫോർണിയ, ജൂൺ 11-15, 1990.
ഡോൺ ലിബസ്, 1990 ലെ യുഎസ്ഇനിക്സ് ലാർജ് ഇൻസ്റ്റിറ്റ്യൂട്ട് സിസ്റ്റംസ് അഡ്മിനിസ്ട്രേഷൻ കോൺഫറൻസ് പ്രൊസീഡിംഗ്സ്, കൊളറാഡോ സ്പ്രിങ്ങ്സ്, കൊളറാഡോ, ഒക്ടോബർ 17-19, 1990, എഴുതിയ "ഓട്ടോമേറ്റ് സിസ്റ്റം അഡ്മിനിസ്ട്രേഷൻ ടാസ്ക്കുകളിൽ പ്രതീക്ഷിക്കുന്നു ".
ജോൺ ഓസ്റ്റർഹൗട്ടിന്റെ പ്രൊസീഡിങ്ങ്സ് ഓഫ് ദി വിന്റർ 1990 യുഎസ്എക്സ്ക്സ് കോൺഫറൻസ്, വാഷിംഗ്ടൺ ഡി.സി., ജനുവരി 22-26, 1990. ഞാൻ "പ്രതീക്ഷിക്കുന്ന: സ്ക്രിപ്റ്റുകൾ ഫോർ കൺട്രോൾംഗ് ഇൻററാക്റ്റീവ് പ്രോഗ്രാംസ്" ഡോൺ ലിബസ്, കമ്പ്യൂട്ടിംഗ് സിസ്റ്റങ്ങൾ , വോളിയം. 4, നമ്പർ 2, യൂണിവേഴ്സിറ്റി ഓഫ് കാലിഫോർണിയ പ്രസ് ജേർണലുകൾ, നവംബർ 1991. ഡോൺ ലിബീസ്, "റെസ്ട്രിഷൻ ടെസ്റ്റിംഗ് ആന്റ് കൺഫോർമൻസ് ടെസ്റ്റിംഗ് ഇൻററാക്റ്റീവ് പ്രോഗ്രാമുകൾ", പ്രൊസീഡിങ്ങ്സ് ഓഫ് ദ വേനൽ 1992 USENIX കോൺഫറൻസ്, pp. 135-144, സാൻ അന്റോണിയോ, TX, ഡോൺ ലിബസ്, സോഫ്റ്റ്വെയർ - പ്രാക്റ്റീസ് ആൻഡ് എക്സ്പീരിയൻസ്, ജോൺ വൈലി & സൺസ്, വെസ്റ്റ് സസെക്സ്, ഇംഗ്ലണ്ട്, വോള്യം, 1992 ജൂൺ 12 - 1992, "കിബിറ്റ്സ് - മൾട്ടിപ്പിൾ ഇൻററാക്റ്റീവ് പ്രോഗ്രാമുകൾ ടുഗെദർ".

23, നമ്പർ 5, മേയ്, 1993. ഡോൺ ലിബസ്, 1993 ടി ക്ലബ്ബ് / ടി.കെ. വർക്ക്ഷോപ്പ്, ബെർക്ക്ലി, സി.ഇ., ജൂൺ 10-11, 1993 ന്റെ പ്രൊഡ്യൂസിങ്സ് എഴുതിയ "ഒരു ഡീബഗ്ഗർ ഫോർ ടൺ ആപ്ലിക്കേഷൻസ്".

AUTHOR

ഡോൺ ലിബസ്, നാഷണൽ ഇൻസ്റ്റിറ്റ്യൂട്ട് ഓഫ് സ്റ്റാന്ഡേഡ്സ് ആൻഡ് ടെക്നോളജി

എക്സലൻസ്

ടിക്ക്ക് വേണ്ടി ജോൺ ഓസ്റ്റർഹൗട്ടിനും സ്കോട്ട് പൈസ്ലിയും പ്രചോദനത്തിനായി നന്ദി. പ്രതീക്ഷയുടെ ഓട്ടോകോൺഫിഗറേഷൻ കോഡിനായി റോബ് സവോയിക്ക് നന്ദി.

പ്രതീക്ഷയുടെ പരിണാമം ചരിത്രത്തിൽ രേഖപ്പെടുത്തുന്നു. ഇത് രസകരമായ വായനയും ഈ സോഫ്ട് വെയർ കൂടുതൽ ഉൾക്കാഴ്ച നൽകും. അതിൽ പരാമർശിച്ച ആളുകൾക്ക് നന്ദി ബഗ് ഫിക്സുകൾ അയച്ചുതന്നു, മറ്റ് സഹായം നൽകി.

അമേരിക്കൻ ഗവൺമെൻറിൻറെ ഭാഗത്ത് നിന്നും പ്രതീക്ഷിക്കുന്ന രൂപരേഖ തയ്യാറാക്കുകയും അതു നടപ്പാക്കുകയും ചെയ്യുന്നത് പൊതുജനങ്ങൾക്കുള്ളതാണ്. എന്നിരുന്നാലും, ഈ പ്രോഗ്രാമും ഡോക്യുമെന്റുകളും അല്ലെങ്കിൽ അവയുടെ ഭാഗങ്ങളും ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ രചയിതാവും എൻഐസിസ്റ്റും ക്രെഡിറ്റ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നു.