અપેક્ષા એ એક પ્રોગ્રામ છે જે સ્ક્રીપ્ટના આધારે અન્ય ઇન્ટરેક્ટિવ કાર્યક્રમો સાથે વાત કરે છે. સ્ક્રીપ્ટને અનુસરીને, અપેક્ષિત છે કે કોઈ પ્રોગ્રામથી શું અપેક્ષા કરી શકાય છે અને યોગ્ય પ્રતિક્રિયા શું હોવી જોઇએ. એક અર્થઘટન ભાષા સંવાદ દિશામાન કરવા માટે શાખા અને હાઇ-લેવલ કંટ્રોલ માળખા પ્રદાન કરે છે. વધુમાં, વપરાશકર્તા જ્યારે ઇચ્છિત હોય ત્યારે નિયંત્રણ અને ક્રિયાપ્રતિક્રિયા કરી શકે છે, પછીથી સ્ક્રિપ્ટ પર નિયંત્રણ પાછું મેળવી શકે છે.
Expectk અપેક્ષા અને ટીકાનો મિશ્રણ છે તે અપેક્ષા અને ટીકાની ઇચ્છાની જેમ વર્તે છે. અપેક્ષા સીધી Tcl વગર C અથવા C ++ માં પણ વાપરી શકાય છે.
યુકેપી, કર્મિટ અને અન્ય મોડેમ નિયંત્રણ કાર્યક્રમો દ્વારા લોકપ્રિય સિક્વન્સ મોકલવા / અપેક્ષા રાખીને "અપેક્ષા" નામનું નામ આવે છે. જો કે યુસ્કપની જેમ, અપેક્ષા રાખવામાં આવે છે જેથી તેને કોઈ પણ પ્રોગ્રામ અને કાર્યને ધ્યાનમાં રાખીને યુઝર લેવલ કમાન્ડ તરીકે ચલાવી શકાય. અપેક્ષા એક જ સમયે અનેક કાર્યક્રમો સાથે વાત કરી શકો છો.
શું અપેક્ષા કરી શકો છો
ઉદાહરણ તરીકે, અહીં કેટલીક એવી અપેક્ષાઓ છે જે અપેક્ષિત આદેશ કરી શકે છે:
- તમને પાછા ડાયલાવવા માટે તમારા કમ્પ્યુટરને કારણ આપો, જેથી તમે કૉલ માટે ચૂકવણી કર્યા વગર લૉગ ઇન કરી શકો.
- એક રમત શરૂ કરો અને જો શ્રેષ્ઠ રૂપરેખાંકન દેખાતું નથી, તે ફરીથી અને ફરીથી શરૂ કરો) જ્યાં સુધી તે ન કરે, અને પછી તમારા પર નિયંત્રણ હાથમાં.
- એફએસએચ ચલાવો, અને તેના પ્રશ્નોના જવાબમાં, પૂર્વનિર્ધારિત માપદંડ પર આધારિત "હા" અથવા "ના" જવાબ આપો અથવા તમને પાછા નિયંત્રણ આપો.
- અન્ય નેટવર્કથી કનેક્ટ કરો અને આપમેળે તમારા મેઇલ પુનઃપ્રાપ્ત કરો જેથી તે એવું દેખાય છે કે તે મૂળરૂપે તમારા સ્થાનિક સિસ્ટમમાં મોકલવામાં આવ્યું હતું.
- પર્યાવરણ ચલો, વર્તમાન ડિરેક્ટરી અથવા રૉગિન, ટેલેનેટ, ટિપ, સુ , અથવા સીએનજીઆર
વિવિધ કારણો શા માટે શેલ આ કાર્યો કરી શકતા નથી. અપેક્ષા સાથે તમામ શક્ય છે
સામાન્ય રીતે, કોઈ પણ પ્રોગ્રામ ચલાવવા માટે અપેક્ષિત છે જે પ્રોગ્રામ અને યુઝર વચ્ચેની ક્રિયાપ્રતિક્રિયા જરૂરી છે. આવશ્યક તે છે કે ક્રિયાપ્રતિક્રિયાને પ્રોગ્રામેટિકલી તરીકે વર્ગીકૃત કરી શકાય છે. અપેક્ષિત કાર્યક્રમ નિયંત્રિત કરવામાં આવી અટકાવ્યા વિના પણ વપરાશકર્તાને ફરીથી નિયંત્રણ આપી શકે છે. તેવી જ રીતે, વપરાશકર્તા કોઈપણ સમયે સ્ક્રિપ્ટ પર નિયંત્રણ પાછો મેળવી શકે છે.
વપરાશ
અપેક્ષિત કમાન્ડ્સની સૂચિ માટે cmdfile વાંચે છે. અપેક્ષિત સિસ્ટમો કે જે # ને આધાર આપે છે તેના પર સર્વસામાન્ય રીતે ઉપયોગ કરી શકાય છે! સ્ક્રિપ્ટને એક્ઝેક્યુટેબલ તરીકે સ્ક્રિપ્ટને માર્ક કરીને અને સ્ક્રિપ્ટમાં પ્રથમ લીટી બનાવીને નોટેશન:
#! / usr / local / bin / expect -fઅલબત્ત, પાથ ચોક્કસપણે જ્યાં જીવન અપેક્ષા અપેક્ષા વર્ણન કરવું જ જોઈએ. / usr / local / bin માત્ર એક ઉદાહરણ છે.
-C ફ્લેગ સ્ક્રિપ્ટમાં કોઈપણ પહેલાં ચલાવવા માટેની આદેશને પ્રીફેસ કરે છે. શેલ દ્વારા ભાંગીને અટકાવવા માટે આદેશનો ઉલ્લેખ કરવો જોઈએ. આ વિકલ્પ ઘણી વખત ઉપયોગમાં લેવાય છે. બહુવિધ આદેશો એક -સીસી સાથે તેને સીમીકોલોન્સથી અલગ કરીને ચલાવી શકાય છે. આદેશો જે દેખાય તે ક્રમમાં ચલાવવામાં આવે છે Expectk વાપરી રહ્યા હોય ત્યારે, આ વિકલ્પ-આદેશ તરીકે સ્પષ્ટ થયેલ છે
-d ફ્લેગ કેટલાક ડાયગ્નોસ્ટિક આઉટપુટને સક્ષમ કરે છે, જે મુખ્યત્વે આદેશોની આંતરિક પ્રવૃત્તિની જેમ કે અપેક્ષા અને ક્રિયાપ્રતિક્રિયા કરે છે. આ ધ્વજને "Ex_internal 1" તરીકે અપેક્ષિત સ્ક્રિપ્ટની શરૂઆતમાં સમાન અસર છે, વત્તા સંસ્કરણનું સંસ્કરણ છપાય છે.
ધ -ડી ફ્લેગ એક ઇન્ટરેક્ટિવ ડિબગર સક્રિય કરે છે. એક પૂર્ણાંક મૂલ્ય અનુસરવા જોઈએ. ડિબગર આગામી Tcl કાર્યવાહી પહેલાં નિયંત્રણ લેશે જો મૂલ્ય બિન-શૂન્ય હોય અથવા જો ^ C દબાવવામાં આવે અથવા બ્રેકપોઇન્ટ હિટ થાય, અથવા અન્ય યોગ્ય ડિબગર આદેશ સ્ક્રિપ્ટમાં દેખાય છે. Expectk નો ઉપયોગ કરતી વખતે, આ વિકલ્પને - ડીબગ તરીકે સ્પષ્ટ કરેલ છે.
-f ફ્લેગ ફાઇલને પ્રીફેસ કરે છે જેમાંથી આદેશોને વાંચવા માટે ફ્લેગ પોતે વૈકલ્પિક છે કારણ કે તે # નો ઉપયોગ કરતી વખતે માત્ર ઉપયોગી છે! સંકેત, જેથી અન્ય દલીલો આદેશ વાક્ય પર પૂરી પાડવામાં આવી શકે છે. Expectk વાપરી રહ્યા હોય ત્યારે, આ વિકલ્પ -file તરીકે સ્પષ્ટ થયેલ છે
મૂળભૂત રીતે, આદેશ ફાઈલ મેમરીમાં વાંચી શકાય છે અને તેની સંપૂર્ણતામાં ચલાવવામાં આવે છે. તે એક સમયે એક રેખા ફાઈલો વાંચવા માટે ક્યારેક ઇચ્છનીય છે. મનસ્વી ફાઇલોને આ રીતે નિયંત્રિત કરવા માટે દબાણ કરવા માટે, -b ફ્લેગનો ઉપયોગ કરો. Expectk વાપરી રહ્યા હોય ત્યારે, આ વિકલ્પ -buffer તરીકે સ્પષ્ટ થયેલ છે
જો શબ્દમાળા ફાઇલનામ તરીકે પૂરુ પાડેલ હોય તો, પ્રમાણભૂત ઇનપુટ તેના બદલે "-" વાંચવામાં આવે છે. વાસ્તવમાં "-" નામવાળી ફાઇલમાંથી વાંચવા માટે "./-" નો ઉપયોગ કરો.
-i ફ્લેગ કારણો ફાઈલમાંથી વાંચવાને બદલે આદેશોની પૂછપરછ કરવા માટે ઈચ્છે છે. પ્રોમ્પ્ટિંગ એ બહાર નીકળો આદેશ દ્વારા અથવા EOF પર સમાપ્ત થાય છે. -i ધ્વજ ધારવામાં આવે છે જો ન તો આદેશ ફાઈલ કે -સી નો ઉપયોગ થાય છે. Expectk નો ઉપયોગ કરતી વખતે, આ વિકલ્પ -interactive તરીકે સ્પષ્ટ થયેલ છે.
- વિકલ્પોના અંતે સીમાંકન કરવા માટે ઉપયોગમાં લઇ શકાય છે. આ ઉપયોગી છે જો તમે તમારી સ્ક્રિપ્ટમાં કોઈ વિકલ્પ જેવા દલીલ પસાર કરવા માંગતા હોવ તો તે અપેક્ષા મુજબ વ્યાખ્યાયિત થયેલ નથી. આ ઉપયોગી રીતે # માં મૂકી શકાય છે! અપેક્ષિત દ્વારા કોઈપણ ધ્વજ જેવું અર્થઘટન રોકવા માટે લીટી. ઉદાહરણ તરીકે, નીચેના ચલ આર્જેવીમાં સ્ક્રિપ્ટ નામ સહિત મૂળ દલીલો છોડી દેશે.
#! / usr / local / bin / અપેક્ષા -નોંધ કરો કે સામાન્ય getopt (3) અને execve (2) સંમેલનો અવલોકન જ જોઈએ જ્યારે # માટે દલીલો ઉમેરી રહ્યા છે! રેખા
ફાઇલ $ exp_library / expect.rc આપમેળે ઉપલબ્ધ હોય તો હાજર હોય, જ્યાં સુધી- N ફ્લેગનો ઉપયોગ કરવામાં ન આવે. (Expectk વાપરી રહ્યા હોય ત્યારે, આ વિકલ્પ -NORC તરીકે સ્પષ્ટ થયેલ છે.) તેના પછી તરત જ, ફાઈલ ~ / .expect.rc આપોઆપ સ્ત્રોત છે, જ્યાં સુધી -n ફ્લેગ વાપરવામાં ન આવે ત્યાં સુધી. જો પર્યાવરણ ચલ DOTDIR વ્યાખ્યાયિત થયેલ છે, તે ડિરેક્ટરી તરીકે ગણવામાં આવે છે અને .expect.rc ત્યાંથી વાંચી શકાય છે. Expectk વાપરી રહ્યા હોય ત્યારે, આ વિકલ્પ -norc તરીકે સ્પષ્ટ થયેલ છે આ સ્ત્રોત કોઈપણ -સી ફ્લેગ ચલાવવા પછી જ થાય છે.
-v કારણો તેના સંસ્કરણ નંબરને છાપો અને બહાર નીકળો એક્સક્પાકમાં લગતી ધ્વજ, જે લાંબા ધ્વજ નામોનો ઉપયોગ કરે છે, તે છે-વિવરણ.
વૈકલ્પિક દલીલોની યાદીમાં નિર્માણ કરવામાં આવે છે અને નામવાળી ચલણમાં સંગ્રહિત થાય છે. argc એ આરજીવીની લંબાઈને આરંભ કરવામાં આવે છે.
જો કોઈ સ્ક્રિપ્ટનો ઉપયોગ થતો નથી, તો Argv0 ને સ્ક્રિપ્ટ અથવા બાઈનરીનું નામ તરીકે વ્યાખ્યાયિત કરવામાં આવે છે. ઉદાહરણ તરીકે, નીચેના સ્ક્રિપ્ટનું નામ અને પહેલા ત્રણ દલીલો છાપે છે:
send_user "$ argv0 [લેન્ટો $ argv 0 2] \ n"આદેશો
સાધન કમાન્ડ ભાષાનો ઉપયોગ કરવાની અપેક્ષા રાખીએ Tcl નિયંત્રણ ફ્લો (જો, માટે, વિરામ), અભિવ્યક્તિ મૂલ્યાંકન અને રિકરિઝન અને પ્રક્રિયા વ્યાખ્યા જેવી કેટલીક અન્ય સુવિધાઓ પૂરી પાડે છે. આદેશો અહીં વપરાય છે પરંતુ વ્યાખ્યાયિત થયેલ નથી (સેટ, જો, exec) Tcl આદેશો છે અપેક્ષા વધારાના આદેશો આધાર આપે છે જ્યાં સુધી ઉલ્લેખિત ન હોય ત્યાં સુધી, આદેશો ખાલી શબ્દમાળા પાછી આપે છે.
આદેશો મૂળાક્ષરોના ક્રમમાં ગોઠવવામાં આવે છે જેથી તેઓ ઝડપથી સ્થિત થઈ શકે. જો કે, નવા વપરાશકર્તાઓને તે ક્રમમાં, સ્પાનના વર્ણન, મોકલવા, અપેક્ષા અને ક્રિયાપ્રતિક્રિયાઓ વાંચવાનું શરૂ કરવું સહેલું લાગશે.
બંધ કરો [-સ્લેવ] [-onexec 0 | 1] [-i spawn_id]વર્તમાન પ્રક્રિયાના જોડાણ બંધ કરે છે. મોટાભાગના અરસપરસ પ્રોગ્રામ્સ તેમના સ્ટુડિન અને બહાર નીકળતા EOF ને શોધી કાઢશે; આમ સામાન્ય રીતે પ્રક્રિયાને તેમજ મારવા પૂરતા પ્રમાણમાં બંધ થાય છે . -i ફ્લેગ નામની spawn_id ને અનુરૂપ બંધ કરવાની પ્રક્રિયા જાહેર કરે છે.
બંને અપેક્ષા અને ક્રિયાપ્રતિક્રિયા જ્યારે વર્તમાન પ્રક્રિયા બહાર નીકળે અને સર્વથા બંધ કરે ત્યારે શોધવામાં આવશે, પરંતુ જો તમે આ પ્રક્રિયાને મારી નાંખશો તો, "exec exec $ pid" મારવા, તમારે સ્પષ્ટ રીતે બંધ કરવાની જરૂર છે
-ઓક્સેક ધ્વજ એવો નિર્ધારિત કરે છે કે spawn id કોઈપણ નવી બનાવતી પ્રક્રિયામાં બંધ છે અથવા જો પ્રક્રિયા ઓવરલે કરવામાં આવે છે. એક spawn id ખોલવા માટે, મૂલ્ય 0 નો ઉપયોગ કરો. એક નોન-શૂન્ય પૂર્ણાંક મૂલ્ય કોઈપણ નવી પ્રક્રિયામાં સ્પાન બંધ કરે છે.
સ્લેવ ધ્વજ બોલાવેલા સ્વેન આઈડી સાથે સંકળાયેલ ગુલામને બંધ કરે છે. જ્યારે કનેક્શન બંધ હોય, ત્યારે ગુલામ આપમેળે બંધ થાય છે જો તે હજી ખુલ્લું છે.
કનેક્શન બંધ અથવા સ્પષ્ટ રીતે બંધ છે કે કેમ તે ભલે ગમે તે હોય, તમારે અનુરૂપ કર્નલ પ્રક્રિયા સ્લોટને સાફ કરવા માટે રાહ જોવી જોઈએ. ક્લોઝ કમાન્ડ રાહ જોતા નથી કારણ કે કોઈ ગેરેંટી નથી કે કોઈ પ્રક્રિયા કનેક્શન બંધ કરવાથી તેને બહાર નીકળવા માટેનું કારણ મળશે.
ડિબગ [[-now] 0 | 1]એક Tcl ડિબગર નિયંત્રિત કરે છે જે તમને નિવેદનો દ્વારા પગલું અને બ્રેકપોઇન્ટ્સ સેટ કરવા દે છે.
કોઈ દલીલો વગર, જો ડીબગર ચાલી રહ્યું ન હોય તો 1 પરત થાય છે, અન્યથા 0 પરત થાય છે
1 દલીલ સાથે, ડીબગર શરૂ થાય છે. 0 દલીલ સાથે, ડિબગર બંધ થઈ ગયું છે. જો 1 દલીલ પહેલા -લો ધ્વજ દ્વારા આગળ આવે છે, તો ડિબગર તુરંત જ શરૂ થાય છે. નહિંતર, ડિબગર આગામી Tcl નિવેદન સાથે શરૂ થાય છે.
ડિબગ આદેશ કોઈ ફાંસો બદલતા નથી. આ સાથે સરખામણી કરવા માટે શરૂ કરો- D ધ્વજ.
ડિસ્કનેક્ટ આદેશ ટર્મિનલમાંથી ફોર્ક કરેલ પ્રક્રિયા ડિસ્કનેક્ટ કરે છે. તે પૃષ્ઠભૂમિમાં ચાલુ રહે છે. પ્રક્રિયા તેના પોતાના પ્રક્રિયા જૂથ આપવામાં આવે છે. ધોરણ I / O ને / dev / null પર રીડાયરેક્ટ કરવામાં આવે છે
નીચેના ટુકડો પૃષ્ઠભૂમિમાં સ્ક્રિપ્ટ ચલાવવાનું ચાલુ રાખવા માટે ડિસ્કનેક્ટનો ઉપયોગ કરે છે.
જો {[કાંટો]! = 0} બહાર નીકળો ડિસ્કનેક્ટ કરો. . .નીચેની સ્ક્રિપ્ટ પાસવર્ડ વાંચે છે અને પછી દર કલાકે પ્રોગ્રામને ચલાવે છે જે તે ચલાવે છે તે વખતે પાસવર્ડની માંગણી કરે છે. સ્ક્રિપ્ટ પાસવર્ડ પૂરો પાડે છે જેથી તમે તેને ફક્ત એક વાર ટાઇપ કરી શકો.
send_user "password? \" expect_user -re "(. *) \ n" માટે {} 1 {} {if {[fork]! = 0} {ઊંઘ 3600; ચાલુ રાખો} સ્પન ખાનગી જોડાણની ડિસ્કનેક્ટ કરો પાસવર્ડ: "$ expect_out" મોકલો 1, શબ્દમાળા) \ r ". . . બહાર નીકળો}શેલ અસુમેળ પ્રક્રિયા લક્ષણ (અને) પર ડિસ્કનેક્ટ વાપરવાનો ફાયદો એ છે કે અપેક્ષિત ટાંકણની પહેલાં ટર્મિનલ પરિમાણોને બચાવશે અને તે પછી તેને નવી પીટીય્સ પર લાગુ કરી શકે છે. સાથે &, અપેક્ષા ટર્મિનલના પરિમાણોને વાંચવાની તક નથી કારણ કે ટર્મિનલ પહેલેથી જ સમયથી જોડાણ તૂટી ગયું છે.
exit [-opts] [સ્થિતિ]કારણો બહાર નીકળવા માટે અપેક્ષા અથવા તો આવું કરવા માટે તૈયાર.
-ઓક્સિડ ધ્વજ આગળની દલીલ બહાર નીકળવાની સંભાળનાર તરીકે ઉપયોગ કરવા માટેનું કારણ બને છે. એક દલીલ વિના, વર્તમાન બહાર નીકળો સંભાળનાર પરત આવે છે.
નો- નૉએક્સ ધ્વજ કારણો બહાર નીકળવા માટે તૈયાર થવાની ઇચ્છા રાખે છે પરંતુ વાસ્તવમાં ઑપરેટિંગ સિસ્ટમ પર નિયંત્રણ પાછું મેળવવાનું બંધ કરે છે. વપરાશકર્તા-નિર્ધારિત આઉટસ્ટેન્ડિંગ હેન્ડલર ચાલે છે તેમજ અપેક્ષિત પોતાના આંતરિક હેન્ડલર્સ કોઈ વધુ Expect આદેશો ચલાવવા જોઈએ. આ ઉપયોગી છે જો તમે અન્ય Tcl એક્સ્ટેન્શન્સ સાથે અપેક્ષા રાખી રહ્યા છો. પ્રવર્તમાન દુભાષિયો (અને મુખ્ય વિંડો જો એક વાતાવરણમાં હોય તો) તે રહે છે જેથી અન્ય Tcl એક્સ્ટેન્શન્સ સાફ થઈ શકે. જો ઈચ્છો તો બહાર નીકળો ફરી કહેવામાં આવે છે (જો કે આ થઇ શકે છે), તો હેન્ડલર્સ ફરીથી ચલાવતા નથી.
બહાર નીકળવા પર, પેદા થયેલ તમામ પ્રબંધકોને બંધ કરવામાં આવે છે. ઉત્ખનિત પ્રક્રિયાઓ દ્વારા ક્લોઝને ઇઓએફ તરીકે ઓળખવામાં આવશે. બહાર નીકળો સામાન્ય _ એક્સટ (2) પ્રક્રિયા શું કરે છે તેનાથી આગળ કોઈ અન્ય ક્રિયાઓ લેતું નથી આ રીતે, પેદા થયેલી પ્રક્રિયાઓ કે જે EOF માટે ચકાસતા નથી તે ચાલવાનું ચાલુ રાખી શકે છે. (વિવિધ પરિસ્થિતિઓ નક્કી કરવા માટે મહત્વપૂર્ણ છે, ઉદાહરણ તરીકે, એક પ્રયાપ્ત કાર્યવાહી કઈ સંકેતો મોકલવામાં આવશે, પરંતુ તે સિસ્ટમ-આધારિત છે, ખાસ કરીને બહાર નીકળો (3) હેઠળ દસ્તાવેજો.) પેદા થયેલ પ્રક્રિયાઓ જે ચાલુ રાખવા માટે ચાલુ છે init દ્વારા વારસાગત થશે.
સ્થિતિ (અથવા 0 જો ઉલ્લેખિત નથી) અપેક્ષા પ્રમાણેની બહાર નીકળવાની સ્થિતિ તરીકે પરત કરવામાં આવે છે. જો સ્ક્રિપ્ટનો અંત આવે તો બહાર નીકળો સર્વથા ચલાવવામાં આવે છે.
exp_continue [-continue_timer]
આ આદેશ exp_continue સામાન્ય રીતે પરત ફરવાની જગ્યાએ પોતાને ચલાવવાની અપેક્ષા રાખે છે. મૂળભૂત રીતે exp_continue સમયસમાપ્તિ ટાઈમર રીસેટ કરે છે. -continue_timer ધ્વજ ફરીથી શરૂ થવાથી ટાઇમરને અટકાવે છે (વધુ માહિતી માટે અપેક્ષા જુઓ.)
exp_internal [-f ફાઈલ] મૂલ્ય
મૂલ્ય બિન-શૂન્ય હોય તો stderr માગીએ માટે ડાયગ્નોસ્ટિક માહિતી આંતરિક મોકલવા માટે વધુ આદેશોનું કારણ બને છે. મૂલ્ય 0 હોય તો આ આઉટપુટ અક્ષમ કરેલું છે. નિદાન માહિતીમાં દરેક અક્ષર પ્રાપ્ત થાય છે, અને દાખલાની વિરુદ્ધના વર્તમાન આઉટપુટને મેચ કરવા માટેના દરેક પ્રયત્નો છે.
જો વૈકલ્પિક ફાઇલ પૂરી પાડવામાં આવે છે, તો તમામ સામાન્ય અને ડિબગીંગ આઉટપુટ તે ફાઇલમાં લખાયેલ છે (મૂલ્ય મૂલ્યની અનુલક્ષીને). કોઈપણ પહેલાંની ડાયગ્નોસ્ટિક આઉટપુટ ફાઇલ બંધ છે.
-વિન્ડો ધ્વજને કારણે આપવામાં આવેલા સૌથી તાજેતરના બિન-માહિતી દલીલોનું વર્ણન પરત કરવા માટે exp_internal નો ઉપયોગ કરે છે.
exp_open [args] [-i spawn_id]
એક Tcl ફાઇલ ઓળખકર્તા આપે છે જે મૂળ સ્પન આઈડી સાથે સંબંધિત છે ફાઇલ આઇડેન્ટીફાયર પછી તે Tcl ઓપન કમાન્ડ દ્વારા ખોલવામાં આવી હતી, જેમ કે વાપરી શકાય છે. (સ્પૅન આઈડી લાંબા સમય સુધી ઉપયોગમાં લેવાતો હોવો જોઈએ નહીં.
એક્સ્પેક કમાન્ડ્સ દ્વારા એક્સેસ કરવા માટે -લોવેઓપેન ફ્લેગ સ્પન આઇડી ખોલે છે. સ્પૅન આઈડી પર રાહ જોવી જોઈએ.
exp_pid [-i spawn_id]
હાલમાં પેદા કરેલી પ્રક્રિયાને અનુરૂપ પ્રક્રિયા ID ને આપે છે. જો -i ફ્લેગનો ઉપયોગ થાય છે, તો pid એ આપેલ 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 ભૂલ આપે છે.
બીજું એ નાનો નંબર છે. વર્તમાન સંસ્કરણની તુલનામાં વધુ નાના નંબર સાથે સંસ્કરણ માટે લખાયેલ સ્ક્રિપ્ટ્સ કેટલીક નવી સુવિધા પર આધારિત હોઇ શકે છે અને તે કદાચ ચાલશે નહીં. જો મોટી સંખ્યાઓ મેળ ખાતી હોય તો એક્સ_વર્સન ભૂલ આપે છે, પરંતુ સ્ક્રિપ્ટ નાની સંખ્યા ચાલી રહેલી અપેક્ષા કરતા વધારે છે.
ત્રીજું એ સંખ્યા છે જે વર્ઝન સરખામણીમાં કોઈ ભાગ ભજવે છે. જો કે, જ્યારે સોફ્ટવેર સૉફ્ટવેર વિતરણ કોઈ પણ રીતે બદલાય છે, જેમ કે વધારાના દસ્તાવેજો અથવા ઓપ્ટિમાઇઝેશન દ્વારા, તે વધે છે. દરેક નવા નાના વર્ઝન પર તે 0 પર રીસેટ થાય છે.
-exit ધ્વજ સાથે, એક ભૂલ છાપે છે અને બહાર નીકળે છે જો સંસ્કરણ જૂનું છે
[[-opts] pat1 body1] અપેક્ષા છે ... [-પટ્ટા] patn [bodyn]
ત્યાં સુધી એક પેટર્ન એક પેદા પ્રક્રિયાના આઉટપુટને બંધબેસે નહીં ત્યાં સુધી રાહ જોવામાં આવે છે, એક સ્પષ્ટ સમયગાળો પસાર થયો છે, અથવા ફાઇલની અંતમાં જોવા મળે છે. અંતિમ શરીર ખાલી હોય તો, તે અવગણી શકાય છે.
સૌથી તાજેતરનાં આવશ્યક ઉદાહરણોમાંથી - દાખલા તરીકે, કોઈપણ અન્ય પેટર્ન પહેલાં ઉપયોગ કરવામાં આવે છે. સૌથી વધુ તાજેતરના અપેક્ષા પ્રમાણેના દાખલાઓનો ઉપયોગ કોઈપણ અન્ય દાખલાઓ પછી કરવામાં આવે છે.
જો સમગ્ર અપેક્ષા નિવેદનમાં દલીલો એકથી વધુ રેખાની જરૂર હોય, તો બધી દલીલો એક "બજાવેલી" થઈ શકે છે જેથી દરેક લીટી બેકસ્લેશથી બંધ કરી શકાય. આ એક કિસ્સામાં, કૌંસ હોવા છતાં, સામાન્ય Tcl બદલાવો થાય છે.
જો પેટર્ન એ મુખ્ય શબ્દ છે, તો લાગતાવળગતા શરીરને એક્સ્ટ ઑફ ફાઇલ પર એક્ઝિક્યુટ કરવામાં આવે છે. જો પેટર્ન એ મુખ્ય શબ્દ સમયસમાપ્તિ છે , તો લાગતાવળગતા શરીરને સમયસમાપ્તિ પર ચલાવવામાં આવે છે. કોઈ સમયસમાપ્તિ કીવર્ડનો ઉપયોગ થતો નથી, તો એક અંતર્ગત નલ ક્રિયા સમયસમાપ્તિ પર ચલાવવામાં આવે છે ડિફૉલ્ટ સમયસમાપ્તિ સમયગાળો 10 સેકન્ડ છે પરંતુ "સેટ સમય સમાપ્તિ 30" આદેશ દ્વારા, ઉદાહરણ તરીકે 30 માટે, સેટ કરી શકાય છે. એક અનંત સમયસમાપ્તિ કિંમત -1 દ્વારા નિયુક્ત કરી શકાય છે. જો પેટર્ન કીવર્ડ ડિફોલ્ટ છે , તો લાગતાવળગતા શરીર ક્યાં તો સમયસમાપ્તિ અથવા ઓવરને ઓફ ફાઈલ પર ચલાવવામાં આવે છે.
જો પેટર્ન મેળ ખાય છે, તો પછી અનુરૂપ શરીર ચલાવવામાં આવે છે. અપેક્ષિત વળતર શરીરના પરિણામ (અથવા ખાલી શબ્દમાળા જો કોઈ પેટર્ન મેળ ખાતી નથી) આપે છે ઘટનામાં કે ઘણા દાખલાઓ મેળ ખાય છે, જે પ્રથમ દેખાય છે તે શરીરને પસંદ કરવા માટે વપરાય છે.
દરેક સમયે નવા આઉટપુટ આવે છે, તે દરેક સૂચિની સરખામણીમાં તે ક્રમાંકિત છે. આ રીતે, જો તમે પ્રોમ્પ્ટ જેવી છેલ્લી પેટર્ન કંઈક બતાવવાની ખાતરી આપીને મેચની ગેરહાજરી માટે પરીક્ષણ કરી શકો છો. એવી પરિસ્થિતિઓમાં કે જ્યાં કોઈ પ્રોમ્પ્ટ નથી, તમારે સમયસમાપ્તિનો ઉપયોગ કરવો પડશે (જેમ કે તમે જાતે જ ક્રિયાપ્રતિક્રિયા કરતા હોત તો).
દાખલાઓ ત્રણ રીતે સ્પષ્ટ થયેલ છે ડિફૉલ્ટ રૂપે, Tcl ની સ્ટ્રિંગ મેચ કમાન્ડ તરીકે પેટર્નને સ્પષ્ટ કરેલ છે. (આવા પેટર્ન સી-શેલ નિયમિત સમીકરણો સમાન છે જે સામાન્ય રીતે "ગ્લોબ" પેટર્ન તરીકે ઓળખાય છે) ધ -ગ્લે ધ્વજનો ઉપયોગ પેટર્નને સુરક્ષિત કરવા માટે થઈ શકે છે, જે કદાચ ફ્લેગને આમ કરવાથી મેળવવામાં આવે. "-" થી શરૂ થતો કોઈ પણ પેટર્ન આ રીતે સંરક્ષિત થવો જોઈએ. ("-" થી શરૂ થતાં તમામ શબ્દમાળા ભાવિ વિકલ્પો માટે આરક્ષિત છે.)
ઉદાહરણ તરીકે, નીચેનું ટુકડો સફળ પ્રવેશ માટે જુએ છે. (નોંધ કરો કે ગર્ભપાતને સ્ક્રીપ્ટમાં બીજે ક્યાંય પ્રક્રિયાની કાર્યવાહી કરવામાં આવે છે.)
અપેક્ષા {વ્યસ્ત {વ્યસ્ત મૂકે છે \ n; exp_continue} નિષ્ફળ "અમાન્ય પાસવર્ડ" abort સમયસમાપ્તિ બંધ અડધેથી બંધ}ચોથા પેટર્ન પર ખર્ચ જરૂરી છે કારણ કે તેમાં જગ્યા છે, જે અન્યથા ક્રિયામાંથી પેટર્ન અલગ કરશે એ જ ક્રિયા (જેમ કે 3 જી અને 4 થા) સાથેનાં પાત્રોને ફરીથી ક્રિયાઓની સૂચિની જરૂર છે. આ regexp- શૈલી પેટર્ન ઉપયોગ કરીને ટાળવા કરી શકાય છે (નીચે જુઓ) ગ્લોબલ-સ્ટાઇલ પેટર્ન બનાવવાની વધુ માહિતી Tcl મેન્યુઅલમાં મળી શકે છે.
Regexp- શૈલીના પેટર્ન Tcl માતાનો regexp (ટૂંકા "નિયમિત અભિવ્યક્તિ") આદેશ દ્વારા વ્યાખ્યાયિત વાક્યરચના અનુસરો. regexp પેટર્ન ફ્લેગ -રે સાથે રજૂ કરવામાં આવે છે અગાઉના ઉદાહરણને regexp નો ઉપયોગ કરીને ફરીથી લખી શકાય છે:
અપેક્ષા {વ્યસ્ત {વ્યસ્ત મૂકે છે \ n; exp_continue} -re "નિષ્ફળ | અમાન્ય પાસવર્ડ" સમાપ્ત સમયસમાપ્તિ બંધ થયો હતો}બંને પ્રકારની પેટર્ન "અનચેકરેડ" છે આનો અર્થ એ છે કે પેટર્નને સમગ્ર સ્ટ્રિંગથી મેળ ખાતો નથી, પરંતુ શબ્દમાળામાં ગમે ત્યાંથી મેચ શરૂ કરી શકાય છે (જ્યાં સુધી બાકીનું બધું મેચ થાય ત્યાં સુધી). શબ્દનો પ્રારંભ કરવા માટે ^ નો ઉપયોગ કરો, અને અંતની મેચ કરવા માટે $. નોંધ કરો કે જો તમે સ્ટ્રિંગના અંતની રાહ જોતા નથી, તો તમારા પ્રતિસાદ સરળતાથી શબ્દમાળાના મધ્યમાં અંત લાવી શકે છે કારણ કે તે પેદા થયેલ પ્રક્રિયામાંથી દેખાતો હોય છે. હજુ પણ યોગ્ય પરિણામો ઉત્પન્ન કરતી વખતે, આઉટપુટ અકુદરતી દેખાઈ શકે છે આ રીતે, જો તમે સ્ટ્રિંગના અંતે અક્ષરોનું બરાબર વર્ણન કરી શકો તો $ નો ઉપયોગ કરવામાં આવે છે.
નોંધ કરો કે ઘણા સંપાદકોમાં, ^ અને $ અનુક્રમે લીટીઓની શરૂઆત અને અંત સાથે મેળ ખાય છે. જો કે, કારણ કે અપેક્ષા વાક્ય લક્ષી નથી, આ અક્ષરો હાલમાં મેળ ખાતા બફરની અપેક્ષા મુજબ ડેટાના શરૂઆત અને અંતે (લીટીઓની વિરુદ્ધ) મેળ ખાય છે. (આ ઉપરાંત, "સિસ્ટમ અપચો." પર નીચે નોંધ જુઓ)
-એક્સ ફ્લેગ એક "ચોક્કસ" શબ્દમાળા તરીકે મેળ ખાતી પેટર્નનું કારણ બને છે. *, ^, વગેરેનો કોઈ અર્થઘટન કરવામાં આવે છે (જો કે સામાન્ય Tcl સંમેલનો હજુ પણ જોઇ શકાશે). ચોક્કસ પેટર્ન હંમેશા અનચેક કરવામાં આવે છે.
-નોકઝ ફ્લેગ આઉટપુટનાં મોટા અક્ષરોને તુલના કરવા માટે કરે છે જો તેઓ લોઅરકેસ અક્ષરો હતા. પેટર્ન અસર કરતું નથી.
આઉટપુટ વાંચતી વખતે, 2000 થી વધુ બાઇટ્સ અગાઉ બાઈટને "વિસ્મૃત" થવા માટે દબાણ કરી શકે છે. આ ફંક્શન મેચ_મેક્સ સાથે બદલાઈ શકે છે (નોંધો કે વધુ પડતા મોટા મૂલ્યો પેટર્ન matcher ધીમું કરી શકે છે.) જો પૅસલીસ્ટ ફુલ_ બફર છે , તો મેચ_મેક્સ બાઇટ્સ પ્રાપ્ત થઈ છે અને કોઈ અન્ય પેટર્ન મેળ ખાતા નથી ત્યારે લાગતાવળગતા શરીરને એક્ઝિક્યુટ કરવામાં આવે છે. જો full_buffer કીવર્ડનો ઉપયોગ કરવામાં આવે કે ન હોય, તો ભૂલી પામેલ અક્ષરો expect_out (બફર) પર લખવામાં આવે છે.
જો પૅસલિસ્ટ એ કીવર્ડ નલ છે , અને નલ (માન્ય remove_nulls આદેશ દ્વારા) માન્ય છે, તો અનુરૂપ શરીર એક્ઝેક્યુટ થાય છે જો એક ASCII 0 મેળ ખાતી હોય. ગ્લોબ અથવા રીજેક્સપ પેટર્ન દ્વારા 0 બાઇટ્સ સાથે મેચ કરવું શક્ય નથી.
પેટર્ન (અથવા ઈઓફ અથવા ફુલ_ બફર) ના મેળ સાથે, કોઈપણ મેળ ખાતા અને અગાઉની મેળ ન ખાતી આઉટપુટ વેરિયેબલ expect_out (બફર) માં સાચવવામાં આવે છે. Up to 9 regexp સબસ્ટિંગ મેચો expect_out (9, સ્ટ્રિંગ) દ્વારા expect_out ( 1, શબ્દમાળા) ચલોમાં સાચવવામાં આવે છે. જો -સંદેશોનો ધ્વજ પેટર્ન પહેલાં ઉપયોગમાં લેવાય છે, તો 10 શબ્દમાળાઓનો પ્રારંભ અને સમાપ્ત થતી સૂચકાંકો ( લૅરેજ માટે યોગ્ય સ્વરૂપમાં) વેરિયેબલ્સને expect_out (X, start) અને expect_out (X, end) માં સંગ્રહિત થાય છે જ્યાં X એ છે અંક, બફરમાં સ્થાન બદલવાની પધ્ધતિને અનુલક્ષે છે. 0 એ શબ્દમાળાને સંદર્ભિત કરે છે જે સમગ્ર પેટર્ન સાથે મેળ ખાય છે અને ગ્લોબ પેટર્ન તેમજ રેજક્ષ્પ પેટર્ન માટે પેદા થાય છે. ઉદાહરણ તરીકે, જો કોઈ પ્રક્રિયા "abcdefgh \ n" નું ઉત્પાદન નિર્માણ કરે છે, તો તેનું પરિણામ:
અપેક્ષા "સીડી"તે પ્રમાણે નીચે મુજબના નિવેદનોનો અમલ કરવામાં આવ્યો છે:
set_out (0, સ્ટ્રિંગ) સીડી સેટ expect_out (બફર) એબીસીડી સેટ કરોઅને "એક્ગ \ n" આઉટપુટ બફરમાં બાકી છે. જો પ્રક્રિયા દ્વારા આઉટપુટ "abbbcabkkkka \ n" બનાવવામાં આવ્યું, તો તેનું પરિણામ:
અપેક્ષા -ઈન્ડ્સ-આર "બી (બી *). * (કે +)"તે પ્રમાણે નીચે મુજબના નિવેદનોનો અમલ કરવામાં આવ્યો છે:
set_out (0, પ્રારંભ) 1 set expect_out (0, end) 10 set expect_out (0, string) bbbcabkkkk set expect_out (1, પ્રારંભ) 2 set expect_out (1, end) 3 set expect_out (1, string) bb set_out (2, શરૂઆત) 10 સેટ અપેક્ષા_આઉટ (2, અંત) 10 સેટ અપેક્ષા_આઉટ (2, સ્ટ્રિંગ) k set expect_out (બફર) abbbcabkkkkઅને "a \ n" આઉટપુટ બફરમાં બાકી છે. પેટર્ન "*" (અને -રે ". *") પ્રક્રિયામાંથી કોઈ વધુ આઉટપુટ વાંચ્યા વગર આઉટપુટ બફરને ફ્લશ કરશે.
સામાન્ય રીતે, મેળ ખાતી આઉટપુટ અપેક્ષિતના આંતરિક બફરોમાંથી કાઢી નાખવામાં આવે છે. આ- નોટર્ન્સફેર ધ્વજથી પેટર્નને પ્રિફિક્સ કરીને અટકાવવામાં આવી શકે છે. આ ધ્વજ ખાસ કરીને પ્રયોગમાં ઉપયોગી છે (અને પ્રયોગ વખતે સુવિધા માટે "નહીં" માટે સંક્ષિપ્તમાં કરી શકાય છે).
મેચિંગ આઉટપુટ (અથવા ઇઓએફ અથવા ફુલ_ બફર) સાથે સંકળાયેલ સ્પૅન આઈડી અપેક્ષા_આઉટ (spawn_id) માં સંગ્રહિત થાય છે.
સમય- સમયની ચલણના મૂલ્યનો ઉપયોગ કરવાને બદલે સમયસમાપ્તિ તરીકે સમયની બહારની કિંમતનો ઉપયોગ કરવા માટેના આદેશની અપેક્ષા રહે છે.
મૂળભૂત રીતે, પેટર્ન વર્તમાન પ્રક્રિયામાંથી આઉટપુટ સાથે બંધબેસે છે, જો કે -i ફ્લેગ નામની spawn_id સૂચિમાંથી આઉટપુટ જાહેર કરે છે, નીચેની કોઈપણ પેટર્નની સાથે (આગળના -i સુધી ) મેળ ખાય છે. Spawn_id સૂચિ ક્યાં તો spawn_ids ની એક સફેદ જગ્યાથી અલગ કરેલી સૂચિ અથવા spawn_ids જેવી સૂચિનો ઉલ્લેખ કરતી ચલ હશે.
ઉદાહરણ તરીકે, નીચેના ઉદાહરણ $ proc2 નામના spawn_id માંથી વર્તમાન પ્રક્રિયામાંથી "જોડાયેલ" માટે રાહ જુએ છે, અથવા "વ્યસ્ત", "નિષ્ફળ" અથવા "અમાન્ય પાસવર્ડ".
{-i $ proc2 વ્યસ્ત રહે છે} વ્યસ્ત રહે છે \ n; exp_continue} -re "નિષ્ફળ | અમાન્ય પાસવર્ડ" સમાપ્ત સમયસમાપ્તિ બંધ થયો હતો}ગ્લોબલ વેરિયેબલના મૂલ્ય કોઈ પણ span__id નો ઉપયોગ વર્તમાન અપેક્ષિત આદેશમાંના તમામ -i ફ્લેગો સાથેના નામથી કરવામાં આવેલા પેટર્નને મેચ કરવા માટે થઈ શકે છે. કોઈ -આઇ ફ્લેગથી spawn_id કોઈ સંકળાયેલ પેટર્ન વિના (એટલે કે, બીજા દ્વારા તાત્કાલિક અનુસરવામાં આવે છે) એ કોઇપણ અન્ય દાખલાની કોઈપણ જ સ્પાર્ન_ઈડ સાથે સંકળાયેલ સમાન કમાન્ડમાં ઉપલબ્ધ છે.
-i ફ્લેગ એક વૈશ્વિક વેરિયેબલનું નામ પણ કરી શકે છે, જેમાં તે કિસ્સામાં ચલન સ્પૉન આઇડ્સની સૂચિ માટે વાંચવામાં આવે છે. આ ચલ ફરીથી જ્યારે તે બદલાય છે ફરી લાવો. આ આદેશ I / O સ્રોતને બદલવાનો માર્ગ પૂરો પાડે છે જ્યારે આદેશ અમલમાં છે. Spawn ID એ આ રીતને "પરોક્ષ" બોલાવે છે.
ક્રિયાઓ જેમ કે વિરામ અને ચાલુ નિયંત્રણ માળખાઓ (એટલે કે, માટે , proc ) સામાન્ય રીતે વર્તે છે. આ આદેશ exp_continue સામાન્ય રીતે પરત ફરવાની જગ્યાએ પોતાને ચલાવવાની અપેક્ષા રાખે છે.
આ સ્પષ્ટ લૂપ્સ અથવા પુનરાવર્તિત અપેક્ષા નિવેદનો ટાળવા માટે ઉપયોગી છે. નીચેનું ઉદાહરણ રૉગિનને આપમેળે બનાવવાની ટુકડીનો એક ભાગ છે. Exp_continue બીજું અપેક્ષા નિવેદન (પ્રોમ્પ્ટ ફરીથી જોવા માટે) લખવાનું ટાળે છે જો rlogin એ પાસવર્ડ માટે પૂછે છે
$ host પર $ {password: {stty -echo send_user} પાસવર્ડ ($ વપરાશકર્તા માટે): "expect_user -re" (. *) \ n "send_user" \ n "મોકલો" $ expect_out (1, શબ્દમાળા) \ r "stty હોસ્ટ કરવા માટેનું જોડાણ નિષ્ફળ થયું છે: $ expect_out (બફર) "બહાર નીકળો" - ખોટા {send_user} "અયોગ્ય પાસવર્ડ અથવા એકાઉન્ટ \ n" બહાર નીકળો} $ હોસ્ટનો સમય સમાપ્ત થઈ ગયો છે \ n "બહાર નીકળો} eof {send_user" ફરી પ્રોમ્પ્ટ}ઉદાહરણ તરીકે, નીચેના ટુકડો વપરાશકર્તા માર્ગદર્શિકાને એક ક્રિયાપ્રતિક્રિયા કરવામાં મદદ કરી શકે છે જે પહેલાથી જ સંપૂર્ણપણે સ્વચાલિત છે. આ કિસ્સામાં, ટર્મિનલને કાચી સ્થિતિમાં મુકવામાં આવે છે. જો વપરાશકર્તા "+" પ્રેસ કરે છે, તો ચલ વધે છે. જો "પી" દબાવવામાં આવે તો, ઘણાબધા વળતર પ્રક્રિયામાં મોકલવામાં આવે છે, કદાચ તેને કોઈ રીતે ઉતારી લેવા માટે, અને "હું" વપરાશકર્તા પ્રક્રિયા સાથે ક્રિયાપ્રતિક્રિયા કરવા દે છે, અસરકારક રીતે સ્ક્રિપ્ટમાંથી નિયંત્રણ દૂર કરી રહ્યું છે. દરેક કિસ્સામાં, exp_continue વર્તમાન ક્રિયાને અમલમાં મૂક્યા પછી હાલની પેટર્ન મેચિંગ ચાલુ રાખવાની અપેક્ષા રાખે છે.
stty raw -echo અપેક્ષા_પછી {-i $ user_spawn_id "p" {મોકલો "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {ક્રિયાપ્રતિક્રિયા કરવી; exp_continue} "બહાર નીકળો" બહાર નીકળો}મૂળભૂત રીતે, exp_continue સમયસમાપ્તિ ટાઈમર રીસેટ કરે છે. ટાઈમર પુનઃપ્રારંભ કરેલ નથી, જો exp_continue ને -continue_timer ફ્લેગ સાથે કહેવામાં આવે છે.
અપેક્ષા_પછી [expect_args]
અપેક્ષા કરતાં પહેલાં અપેક્ષા પ્રમાણે કાર્ય કરે છે - જો બંને અપેક્ષા અને અપેક્ષા કરતાં પેટર્ન મેળ કરી શકે, તો અપેક્ષા પેટર્નનો ઉપયોગ કરવામાં આવે છે વધુ માહિતી માટે expect_be આદેશ જુઓ
અપેક્ષા_બેકગ્રાઉન્ડ [અપેક્ષા_ગર્ગ]
અપેક્ષા મુજબ તે જ દલીલો લે છે, જો કે તે તરત જ આપે છે નવા ઇનપુટ આવે ત્યારે દાખલાઓ પરીક્ષણ કરવામાં આવે છે પેટર્ન સમયસમાપ્તિ અને ડિફોલ્ટ અપેક્ષિત છે _બેકગ્રાઉન્ડ અને ચુપચાપને છોડવામાં આવે છે. નહિંતર, expect_background આદેશ અપેક્ષા પ્રમાણે ઉપયોગ કરે છે અને અપેક્ષિત છે- દાખલા તરીકે જે અપેક્ષા કરે છે
જ્યારે અપેક્ષા_બેકગ્રાઉન્ડ ક્રિયાઓનું મૂલ્યાંકન થઈ રહ્યું હોય, ત્યારે સમાન સ્પૅન ID માટે પૃષ્ઠભૂમિ પ્રોસેસિંગ અવરોધિત થાય છે. ક્રિયા પૂર્ણ થાય ત્યારે પૃષ્ઠભૂમિ પ્રક્રિયાને અનાવરોધિત કરવામાં આવે છે જ્યારે બેકગ્રાઉન્ડ પ્રોસેસિંગ બ્લૉક કરવામાં આવે છે, ત્યારે શક્ય છે કે (ફોરગ્રાઉન્ડ) એ જ સ્પન આઇડી પર અપેક્ષા રાખવી .
જ્યારે અપેક્ષિત_ બેકગ્રાઉન્ડને અનાવરોધિત કરવામાં આવે ત્યારે અપેક્ષા રાખવી શક્ય નથી. ચોક્કસ spawn id માટે expect_background એ એક જ સ્પૉન આઈડી સાથે નવી અપેક્ષા_બેકગ્રાઉન્ડ જાહેર કરીને કાઢી નાખવામાં આવે છે. અપેક્ષિત_બેકગ્રાઉન્ડની કોઈ પેટર્ન ન હોવાને કારણે પૃષ્ઠભૂમિમાં પેટર્નને મેચ કરવાની ક્ષમતામાંથી આપેલ spawn id ને દૂર કરે છે.
[અપેક્ષા_ગૅસ] પહેલાં અપેક્ષા
અપેક્ષા મુજબ તે જ દલીલો લે છે, જો કે તે તરત જ આપે છે સૌથી વધુ તાજેતરના અપેક્ષાથી પેટર્ન-એક્શન જોડણીઓ , તે પહેલાંના સમાન આદેશો સાથેની એક જ સ્પૉન આઈડી સાથે સંકળાયેલી છે . જો કોઈ પેટર્ન મેળ ખાય છે, તો તેને માનવામાં આવે છે કે તે અપેક્ષિત આદેશમાં સ્પષ્ટ છે, અને સંકળાયેલ સંસ્થા અપેક્ષા આદેશના સંદર્ભમાં ચલાવવામાં આવે છે. જો બંને અપેક્ષાઓ પહેલાં પેટર્ન અને અપેક્ષા કરી શકો છો મેળ ખાતા હોય, તો અપેક્ષિત_ પહેલાં પેટર્નનો ઉપયોગ કરવામાં આવે છે.
જો કોઈ પેટર્ન સ્પષ્ટ કરેલ નથી, તો spawn id કોઈપણ પેટર્ન માટે ચકાસાયેલ નથી.
જ્યાં સુધી -i ફ્લેગ દ્વારા ઓવરરાઇડ નહીં થાય ત્યાં સુધી, અપેક્ષા_અનુકૂળ અગાઉની આદેશની અમલીકરણ સમયે (જેનો પેટર્ન મેળ ખાતો ન હોય) વ્યાખ્યાયિત થયેલ spawn id સામેની પેટર્ન મેચની અપેક્ષા છે .
આ -ઇન્વો ધ્વજને કારણે તે કયા પેટર્નને બંધબેસશે તે વર્તમાન સ્પષ્ટીકરણો પાછો લાવવાની અપેક્ષા રાખે છે. ડિફૉલ્ટ રૂપે, તે વર્તમાન સ્પન આઈડી પર અહેવાલ આપે છે તે spawn id પરની માહિતી માટે વૈકલ્પિક સ્પૅન આઈડી સ્પષ્ટીકરણ આપવામાં આવશે. દાખ્લા તરીકે
expect_before -info -i $ procમોટાભાગના એક સ્પૅન આઈડી સ્પષ્ટીકરણ આપવામાં આવે છે. ધ્વજ - સીધા સીધી બોરી ID ને દબાવે છે જે માત્ર પરોક્ષ સ્પષ્ટીકરણોથી આવે છે.
સ્પૅન આઈડી સ્પષ્ટીકરણની જગ્યાએ, "બધા" ધ્વજ "-ઇન્ફો" તમામ સ્પૅન આઇડ્સ પર રિપોર્ટ કરવા માટે કારણ આપશે.
-finfo ફ્લેગનું આઉટપુટ અપેક્ષા મુજબ દલીલ કરે છે
expect_tty [expect_args]
એવી અપેક્ષા છે પરંતુ તે / dev / tty (એટલે કે વપરાશકર્તા તરફથી કીસ્ટ્રોક) માંથી અક્ષરો વાંચે છે. મૂળભૂત રીતે, વાંચન રાંધેલા મોડમાં કરવામાં આવે છે. આમ, તેમને જોવાની અપેક્ષા માટે રેખાઓ વળતર સાથે અંત આવવો જ જોઇએ. આ STTY દ્વારા બદલાઈ શકે છે (નીચેનો સ્ટ્ટીક આદેશ જુઓ).
અપેક્ષા_જેર [અપેક્ષા_ગર્ગ]
અપેક્ષા જેવું છે પરંતુ તે stdin (એટલે કે વપરાશકર્તા તરફથી કીસ્ટ્રોક) માંથી અક્ષરો વાંચે છે. મૂળભૂત રીતે, વાંચન રાંધેલા મોડમાં કરવામાં આવે છે. આમ, તેમને જોવાની અપેક્ષા માટે રેખાઓ વળતર સાથે અંત આવવો જ જોઇએ. આ STTY દ્વારા બદલાઈ શકે છે (નીચેનો સ્ટ્ટીક આદેશ જુઓ).
કાંટો
એક નવી પ્રક્રિયા બનાવે છે નવી પ્રક્રિયા વર્તમાન અપેક્ષા પ્રક્રિયાની ચોક્કસ નકલ છે. સફળતા પર, કાંટો નવા (બાળક) પ્રક્રિયામાં 0 આપે છે અને બાળ પ્રક્રિયાની પ્રક્રિયા ID ને પિતૃ પ્રક્રિયામાં પાછું આપે છે. નિષ્ફળતા (સ્રોતોની અછત, દા.ત., સ્વેપ જગ્યા, મેમરી) ને લીધે, ફોર્ક વળતર -1 ને પિતૃ પ્રક્રિયામાં , અને કોઈ બાળ પ્રક્રિયા બનાવી નથી.
ફોર્ક્ડ પ્રોસેસ બહાર નીકળો આદેશ દ્વારા બહાર નીકળે છે , જેમ કે મૂળ પ્રક્રિયા . ફોર્ક્ડ પ્રક્રિયાઓ લોગ ફાઈલો લખવા માટે માન્ય છે. જો તમે મોટાભાગની પ્રક્રિયાઓમાં ડિબગીંગ અથવા લોગિંગને અક્ષમ ન કરો તો, પરિણામ ગૂંચવણમાં મૂકે છે.
કેટલાક PTY અમલીકરણો બહુવિધ વાચકો અને લેખકો દ્વારા મૂંઝવણમાં હોઈ શકે છે, ક્ષણભર પણ. આમ, ઝબૂકવાની પ્રક્રિયાઓ પહેલાં કાંટો માટે સૌથી સુરક્ષિત છે.
[string1 body1] સંચાર કરો ... [સ્ટ્રિંગ [bodyn]]
વર્તમાન પ્રક્રિયાને વપરાશકર્તાને નિયંત્રિત કરે છે, જેથી કીસ્ટ્રોકને વર્તમાન પ્રક્રિયામાં મોકલવામાં આવે છે, અને વર્તમાન પ્રક્રિયાના stdout અને stderr પરત કરવામાં આવે છે.
સ્ટ્રિંગ-બોડી જોડણીઓને દલીલો તરીકે સ્પષ્ટ કરી શકાય છે, જ્યારે તે સંજોગોમાં જ્યારે સંલગ્ન સ્ટ્રિંગ દાખલ કરવામાં આવે ત્યારે શરીરને એક્ઝિક્યુટ કરવામાં આવે છે. (મૂળભૂત રીતે, સ્ટ્રિંગ વર્તમાન પ્રક્રિયામાં મોકલવામાં આવતી નથી.) દુભાષિયો આદેશ ધારવામાં આવે છે, જો અંતિમ શરીર ખૂટે છે.
જો સમગ્ર ક્રિયાપ્રતિક્રિયા નિવેદનમાં દલીલો એકથી વધુ લીટીની જરૂર હોય, તો બધી દલીલો એક "બજાવેલી" થઈ શકે છે જેથી દરેક લીટી બેકસ્લેશથી બંધ કરી શકાય. આ એક કિસ્સામાં, કૌંસ હોવા છતાં, સામાન્ય Tcl બદલાવો થાય છે.
ઉદાહરણ તરીકે, નીચેનો આદેશ નીચે દર્શાવેલી સ્ટ્રિંગ-બોડી જોડીઓ સાથે ક્રિયાપ્રતિક્રિયા કરે છે: જ્યારે ^ Z દબાવવામાં આવે છે, અપેક્ષા સસ્પેન્ડ કરવામાં આવે છે. (ધ રીસેટ ધ્વજ ટર્મિનલ મોડ્સને પુનઃસ્થાપિત કરે છે.) જ્યારે ^ એ દબાયેલો છે , ત્યારે વપરાશકર્તા જુએ છે કે "તમે કંટ્રોલ-એ ટાઇપ કર્યું છે" અને પ્રક્રિયાને ^ એ મોકલવામાં આવે છે. જ્યારે $ દબાવવામાં આવે છે, ત્યારે વપરાશકર્તા તારીખ જુએ છે ^ સી દબાવવામાં આવે ત્યારે, એક્ઝિટ થાઓ. જો "foo" દાખલ કરવામાં આવે, તો વપરાશકર્તા "બાર" જુએ છે જ્યારે ~ ~ દબાવવામાં આવે છે, ત્યારે અપેક્ષા ઇન્ટરપ્રિટર ચાલે છે.
સેટ CTRLZ \ 032 ક્રિયાપ્રતિક્રિયા કરો {-Reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "તમે કંટ્રોલ-એ ટાઇપ કર્યું છે \ n"; "{001}" મોકલો $ {send_user} "તારીખ [ઘડિયાળ બંધારણ [ઘડિયાળ સેકન્ડ્સ]]."} \ 003 બહાર નીકળો foo {send_user "bar"} ~ ~}શબ્દમાળા-બોડી જોડીઓમાં, શબ્દમાળાઓ ક્રમમાં ગોઠવવામાં આવે છે જે તે દલીલો તરીકે સૂચિબદ્ધ છે. જે ભાગો આંશિક રૂપે મેળ ખાતા હોય તે બાકીની આવતી અપેક્ષાની વર્તમાન પ્રક્રિયામાં મોકલવામાં આવતા નથી. જો અક્ષરો પછી દાખલ કરવામાં આવે છે જેમ કે ત્યાં સુધી કોઈ મેચ શક્ય નથી, માત્ર શબ્દમાળાના ભાગને પ્રક્રિયામાં મોકલવામાં આવશે કે જે સંભવતઃ બીજી મેચ શરૂ કરી શકશે નહીં. આ રીતે, આંશિક મેચોની સબસ્ટ્રેઇંગ્સ શબ્દમાળાઓ પછીથી મેળ ખાય શકે છે, જો મૂળ શબ્દમાળાઓ જે મેળ ખાતી કરવાનો પ્રયાસ કરે છે તે છેવટે નિષ્ફળ જાય છે.
મૂળભૂત રીતે, કોઈ વાઇલ્ડ કાર્ડ્સ સાથે સ્ટ્રિંગ મેચિંગ બરાબર નથી. (તેનાથી વિપરીત, અપેક્ષા આદેશ મૂળભૂત રીતે ગ્લોબ-શૈલી પેટર્નનો ઉપયોગ કરે છે.) પેટા દાખલાઓના રક્ષણ માટે -એક્સ ફ્લેગનો ઉપયોગ થઈ શકે છે જે આમ કરવાથી અરસપરસ ફ્લેગને મેચ કરી શકે છે. "-" થી શરૂ થતો કોઈ પણ પેટર્ન આ રીતે સંરક્ષિત થવો જોઈએ. ("-" થી શરૂ થતાં તમામ શબ્દમાળા ભાવિ વિકલ્પો માટે આરક્ષિત છે.)
ધ-ફ્લેગ રેગેક્સપ-શૈલી પેટર્ન તરીકે અર્થઘટન કરવા માટેની શબ્દમાળાને દબાણ કરે છે. આ કિસ્સામાં, મેચિંગ સબસ્ટ્રીંગ ચલ interact_out માં સંગ્રહિત થાય છે તેવી જ રીતે તે અપેક્ષા કરે છે કે સ્ટોક્સ તેના આઉટપુટ વેરિયેબલ expect_out માં કરે છે . -વિન્ડોઝ ફ્લેગ એ જ આધારભૂત છે.
પેટર્ન eof એક ક્રિયા રજૂ કરે છે કે જે ફાઈલના અંત પર ચલાવવામાં આવે છે. અલગ ઇઓફ પેટર્ન -આઉટપુટ ફ્લેગને પણ અનુસરી શકે છે, જો તે આઉટપુટ લખતી વખતે જો ઇઓએફ શોધવામાં આવે તો તે મેળ ખાય છે. ડિફૉલ્ટ એઓએફ એક્શન એ "રીટર્ન" છે, જેથી તે ફક્ત EOF પર આપે છે.
પેટર્ન સમયસમાપ્તિ એક સમયસમાપ્તિ (સેકંડમાં) અને ક્રિયા કરે છે જે કોઈ અક્ષરોને આપેલ સમય માટે વાંચ્યા પછી ચલાવવામાં આવે છે. સમયસમાપ્તિ પેટર્ન સૌથી તાજેતરમાં સ્પષ્ટ થયેલ પ્રક્રિયા પર લાગુ થાય છે. કોઈ મૂળભૂત સમયસમાપ્તિ નથી વિશિષ્ટ ચલ "સમયસમાપ્તિ" ( અપેક્ષા આદેશ દ્વારા ઉપયોગમાં લેવાયેલ) આ સમયસમાપ્તિ પર કોઈ અસર થતો નથી.
ઉદાહરણ તરીકે, નીચે આપેલ નિવેદન, વપરાશકર્તાઓ માટે કે જે કલાક માટે કંઇપણ લખ્યું નથી, પરંતુ તેઓ હજી પણ વારંવારના સિસ્ટમ સંદેશાઓ મેળવવા માટે autolog
સંવાદ-ઇનપુટ $ user_spawn_id સમયસમાપ્તિ 3600 રીટર્ન આઉટપુટ \ $ spawn_idજો પેટર્ન કીવર્ડ નલ છે , અને nulls માન્ય છે ( remove_nulls આદેશ દ્વારા), લાગતાવળગતા શરીર ચલાવવામાં આવે છે જો એક ASCII 0 મેળ ખાતી હોય. ગ્લોબ અથવા રીજેક્સપ પેટર્ન દ્વારા 0 બાઇટ્સ સાથે મેચ કરવું શક્ય નથી.
ફ્લેગ- વેઇટ સાથેના પેટર્નને પસંદ કરવાથી ચલ ઇન્ટરએક્ટ_આઉટ (spawn_id) ને spawn_id પર સેટ કરવાની જરૂર છે જે પેટર્ન (અથવા ઇઓએફ) સાથે મેળ ખાતી હોય છે.
ક્રિયાઓ જેમ કે વિરામ અને ચાલુ નિયંત્રણ માળખાઓ (એટલે કે, માટે , proc ) સામાન્ય રીતે વર્તે છે. જો કે, તેના કોલ કરનાર પર પરત ફરવું કારણભૂત બને છે, જ્યારે ઇન્ટર-રેંટર્ન કારણો તેના કોલ કરનારમાં વળતર લાવવાનું કારણ બને છે. ઉદાહરણ તરીકે, જો "proc foo" તરીકે ક્રિયાપ્રતિક્રિયા તરીકે ઓળખવામાં આવે છે જે પછી ક્રિયા inter_return ચલાવવામાં આવે છે, proc foo પરત કરશે. (આનો અર્થ એ કે જો વાતચીત કરે છે તો ઈન્ટરપ્રીટરને ઇન્ટરપરિટિવ રીટર્ન ટાઇપ કરવાથી ક્રિયાપ્રતિક્રિયા ચાલુ રાખશે, જ્યારે ઇન્ટર-રેંટર્ન તેના કોલર પર પાછા ફરવાની ક્રિયા કરશે.)
ક્રિયાપ્રતિક્રિયા દરમિયાન, કાચા મોડનો ઉપયોગ કરવામાં આવે છે જેથી તમામ અક્ષરો વર્તમાન પ્રક્રિયામાં પસાર થઈ શકે. જો વર્તમાન પ્રક્રિયા કાર્ય નિયંત્રણ સંકેતોને પકડી ન કરે, તો સ્ટોપ સિગ્નલ મોકલવામાં આવે ત્યારે તે બંધ થઈ જશે (મૂળભૂત ^ ઝેડ). તેને પુનઃપ્રારંભ કરવા માટે, એક ચાલુ સંકેત મોકલો (જેમ કે "kill -CONT"). જો તમે ખરેખર આવી પ્રક્રિયામાં SIGSTOP (^ Z) દ્વારા મોકલવા માંગો છો, તો પ્રથમ સી.એસ.એસ. ગણો અને પછી તમારા પ્રોગ્રામ ચલાવતા વિચારો. પ્રશ્નની બીજી બાજુએ, જો તમે પોતે અપેક્ષા કરવા માટે એક SIGSTOP મોકલવા માંગો છો, પ્રથમ કોલ દુભાષિયો (કદાચ એક એસ્કેપ પાત્ર ઉપયોગ કરીને), અને પછી દબાવો ^ ઝેડ.
શબ્દમાળા-બોડી જોડીનો ઉપયોગ ઇન્ટરપ્રિટરમાં દાખલ થવા અને આદેશો પર ક્રિયાપ્રતિક્રિયાઓ ચલાવવાની ટાળવા માટેના લહેરાય તરીકે પણ થઈ શકે છે. પહેલાનાં ટર્મિનલ મોડનો ઉપયોગ થાય છે જ્યારે શબ્દમાળા-બોડી જોડીનું શરીર ચલાવવામાં આવી રહ્યું છે.
ઝડપ માટે, કાર્યો મૂળભૂત રીતે કાર્યોમાં કાર્ય કરે છે. -સેટ કરો ધ્વજને ટર્મિનલને સ્થિતિ પર પુન: સુયોજિત કરે છે જે પહેલાં ક્રિયાપ્રતિક્રિયા (મોટેભાગે, રાંધેલી સ્થિતિ) ચલાવવામાં આવી હતી. નોંધ કરો કે જ્યારે સ્થિતિને સ્વિચ કરવામાં આવે ત્યારે દાખલ કરેલ પાત્રો ગુમ થઇ શકે છે (કેટલીક સિસ્ટમો પર ટર્મિનલ ડ્રાઇવરનું કમનસીબ લક્ષણ). રીસેટ કરવાના એકમાત્ર કારણ એ છે કે જો તમારી ક્રિયા રાંધેલા મોડમાં ચાલી રહી છે.
-ચૂરા ધ્વજ અક્ષરોને મોકલે છે જે નીચે આપેલી પદ્ધતિને અનુસરતા પ્રક્રિયાને અનુસરતા હોય છે જે તેમને દરેક પાત્ર તરીકે વાંચે છે તે વાંચે છે. આ ઉપયોગી થઈ શકે છે જ્યારે વપરાશકર્તાએ આંશિક રીતે લખાયેલા દાખલાઓથી પ્રતિક્રિયા જોવાની જરૂર છે.
જો પેટર્ન એકીકૃત કરવામાં આવે છે પરંતુ આખરે મેચ થવામાં નિષ્ફળ જાય છે, તો અક્ષરો પેદા થયેલ પ્રક્રિયામાં મોકલવામાં આવે છે. જો પેદા કરેલી પ્રક્રિયા તે પછી તેમને પડઘા કરે છે, તો વપરાશકર્તા અક્ષરોને બે વાર જોશે. -ચી કદાચ એવી પરિસ્થિતિઓમાં જ યોગ્ય છે જ્યાં વપરાશકર્તા પેટર્નને પૂર્ણ ન કરી શકે. ઉદાહરણ તરીકે, નીચેનો અવતરણ એ rftp, પુનરાવર્તન-એફટીપી સ્ક્રિપ્ટ, માંથી છે, જ્યાં વપરાશકર્તાને ~ g, ~ p, અથવા ~ l દાખલ કરવા માટે સંકેત આપવામાં આવે છે, કે જે વર્તમાન ડિરેક્ટરીને વારંવાર યાદ કરે છે. આ સામાન્ય FTP આદેશોથી એટલી દૂર છે કે, વપરાશકર્તા કોઈ પ્રકારનું અનુસરવાની શક્યતા નથી, ભૂલથી, તે સિવાય, તેઓ કદાચ પરિણામને અવગણશે.
{-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -e ~ ~ ~ {putcurdirectory}} સંપર્ક કરો-નોબફર ધ્વજ અક્ષરોને મોકલે છે જે આઉટપુટ પ્રક્રિયા પર નીચેના પેટર્નને મેળ ખાય છે કારણ કે અક્ષરો વાંચવામાં આવે છે.
આ ઉપયોગી છે જ્યારે તમે પ્રોગ્રામને પેટર્ન પાછો વળવા દો. ઉદાહરણ તરીકે, કોઈ વ્યક્તિ ડાયલ કરે છે તે પર નજર રાખવા માટે નીચેનાનો ઉપયોગ કરી શકે છે (એક હેઈસ -શૈલી મોડેમ). પ્રત્યેક વખત "એડીડી" જોવા મળે છે જે સ્ક્રીપ્ટ બાકીના રેખાને લૉગ કરે છે.
proc lognumber {} {interact -nobuffer -re "(. *) \ r" રીટર્ન $ લોગ મૂકે છે "[ઘડિયાળ બંધારણ [ઘડિયાળ સેકન્ડ]]: ડાયલ કરેલા $ interact_out (1, શબ્દમાળા)"} ઇન્ટરએક્ટ-નોબફર "એડી" લોગ્નમ્બરક્રિયાપ્રતિક્રિયા દરમિયાન, log_user નો પહેલાના ઉપયોગને અવગણવામાં આવે છે. ખાસ કરીને, ક્રિયાપ્રતિક્રિયા તેના આઉટપુટને લોગ કરવા માટે (પ્રમાણભૂત આઉટપુટ પર મોકલવામાં) દબાણ કરશે કારણ કે તે ધારવામાં આવે છે કે વપરાશકર્તા અકારણ રીતે સંચાર કરવા ઈચ્છતો નથી.
-ઓ ફ્લેગ વર્તમાન પ્રક્રિયાના આઉટપુટને લાગુ કરવા માટે નીચેની કી-બોડી જોડીઓ લાગુ કરે છે. આ ઉપયોગી હોઈ શકે છે, ઉદાહરણ તરીકે, યજમાનો સાથે વ્યવહાર કરતી વખતે અનિચ્છિત અક્ષરોને ટેલેનેટ સત્ર દરમિયાન મોકલવામાં આવે છે.
ડિફૉલ્ટ રૂપે વપરાશકર્તાને અપેક્ષા છે કે સ્ટિડીન લખવાનું અને Expect પ્રક્રિયાની stdout વાંચી રહી છે. -યુ ફ્લેગ ("વપરાશકર્તા" માટે) તેના દલીલ દ્વારા નામની પ્રક્રિયા તરીકે વપરાશકર્તા માટે ક્રિયાપ્રતિક્રિયાત્મક દેખાવ કરે છે (જે એક પેદા આઈડી હોવી જોઈએ).
આ બે બિનસંબંધિત પ્રક્રિયાઓને સ્પષ્ટ લુપનો ઉપયોગ કર્યા વિના જોડવા માટે પરવાનગી આપે છે. ડિબગીંગમાં સહાય કરવા માટે, નિદાન હંમેશા stderr (અથવા ચોક્કસ લોગીંગ અને ડીબગિંગ માહિતી માટે stdout) પર જાય છે. આ જ કારણસર, ઈન્ટરપ્રીટર આદેશ stdin થી ક્રિયાપ્રતિક્રિયાત્મક રીતે વાંચશે.
ઉદાહરણ તરીકે, નીચેના ટુકડો લોગિન પ્રક્રિયા બનાવે છે. પછી તે વપરાશકર્તા (બતાવેલ નથી) ને ડાયલ્સ કરે છે, અને છેવટે બે જોડે જોડાય છે. અલબત્ત, લૉગિન માટે કોઈ પણ પ્રક્રિયાને બદલી શકાશે. એક શેલ, ઉદાહરણ તરીકે, વપરાશકર્તા ખાતું અને પાસવર્ડ આપ્યા વગર કામ કરવા દેશે.
spawn login set login $ spawn_id spawn ટિપ મોડેમ # વપરાશકર્તાને પાછા ડાયલ કરો # વપરાશકર્તા જોડે પ્રવેશ કરવા માટે સંપર્ક કરો- $$ લોગિનબહુવિધ પ્રક્રિયાઓ પર આઉટપુટ મોકલવા માટે, -આઉટપુટ ધ્વજ દ્વારા પસંદ કરેલ દરેક spawn id સૂચિને સૂચિબદ્ધ કરો . આઉટપુટ સ્પૅન આઇડ્સના જૂથ માટે ઇનપુટ, એક ઇનપુટ ફ્લેગ દ્વારા પ્રવેશેલ સ્પૅન આઈડી સૂચિ દ્વારા નિર્ધારિત થઈ શકે છે. (બંને ઇનપુટ અને આઉટપુટ એ જ ફોર્મમાં -i ફ્લેગની જેમ જ અપેક્ષા આદેશમાં લઇ શકે છે, સિવાય કે કોઇપણ_સ્વાન_આઇડી ક્રિયાપ્રતિક્રિયામાં અર્થપૂર્ણ નથી.) નીચેના બધા ફ્લેગ્સ અને શબ્દમાળાઓ (અથવા દાખલાઓ) આ ઇનપુટ પર અન્ય સુધી લાગુ પડે છે - ઇનપુટ ફ્લેગ દેખાય છે. જો કોઈ- ઇનપુટ દેખાય, તો -આઉટપુટ સૂચવે છે "-input $ user_spawn_id -output" (એ જ રીતે, દાખલાની જેમ કે- ઇનપુટ નથી .) જો એક- ઇનપુટ સ્પષ્ટ થયેલ હોય, તો તે $ user_spawn_id ને ફરીથી લખે છે. જો બીજું ઇનપુટ સ્પષ્ટ થયેલ છે, તો તે $ spawn_id ઓવરરાઇડ કરે છે વધારાના - ઇનપુટ ફ્લેગ સ્પષ્ટ કરી શકાય છે.
બે ગર્ભિત ઇનપુટ ડિફોલ્ટ રૂપે $ spawn_id અને $ user_spawn_id (રીવર્સમાં) તરીકે નિર્દિષ્ટ કર્યા છે. જો કોઈ- ઇનપુટ ધ્વજ નો- આઉટપુટ ધ્વજ સાથે દેખાય છે, તો તે પ્રક્રિયામાંથી અક્ષરો છોડવામાં આવે છે.
-i ફ્લેગ હાલના spawn_id માટે રિપ્લેસમેન્ટનો પરિચય આપે છે જ્યારે કોઈ અન્ય ઇનપુટ અથવા આઉટપુટ ફ્લેગનો ઉપયોગ થતો નથી. એ -આઇ ફ્લેગનો અર્થ છે -ઓ ફ્લેગ.
પરોક્ષ spawn id નો ઉપયોગ કરીને પ્રક્રિયા કરવામાં આવી રહી છે તે પ્રક્રિયાને બદલી શકાય છે. (અપેક્ષિત આદેશ પરના વિભાગમાં પરોક્ષ સ્વયંસંચાલિત આઇડીઝ વર્ણવવામાં આવે છે.) પરોક્ષ સ્વયંસંચાલિત આઇડી -i, -u, -input, અથવા -output flags સાથે સ્પષ્ટ કરી શકાય છે.
દુભાષિયો [દલીલ]
વપરાશકર્તાને ઈચ્છો અને Tcl આદેશો માટે ક્રિયાપ્રતિક્રિયા કરવા માટેનું કારણ બને છે દરેક આદેશનું પરિણામ છપાય છે.
ક્રિયાઓ જેમ કે વિરામ અને ચાલુ નિયંત્રણ માળખાઓ (એટલે કે, માટે , proc ) સામાન્ય રીતે વર્તે છે. જો કે, તેના કારણે કોલ કરનાર પર પાછા ફરેલા દુભાષિયોને કારણે થાય છે, જ્યારે ઇન્ટર-રેંટર્ન તેના કોલ કરનારમાં વળતરનું કારણ બને છે. ઉદાહરણ તરીકે, જો "proc foo" દુભાષિયા તરીકે ઓળખાય છે જે પછી ક્રિયા inter_return ચલાવે છે , proc foo પરત કરશે. કોઈપણ અન્ય આદેશ દુભાષિયાને નવા આદેશો માટે પ્રોમ્પ્ટ કરવાનું ચાલુ રાખે છે.
મૂળભૂત રીતે, પ્રોમ્પ્ટમાં બે પૂર્ણાંકો છે પ્રથમ પૂર્ણાંક મૂલ્યાંકન સ્ટેકની ઊંડાઈ (દાખલા તરીકે, કેટલી વખત Tcl_Eval કહેવાય છે) નું વર્ણન કરે છે. બીજો પૂર્ણાંક Tcl ઇતિહાસ ઓળખકર્તા છે. પ્રોમ્પ્ટને "prompt1" તરીકે ઓળખાતી પ્રક્રિયા વ્યાખ્યાયિત કરીને સેટ કરી શકાય છે, જેના વળતર મૂલ્ય આગામી પ્રોમ્પ્ટ બની જાય છે. જો નિવેદનમાં ખુલ્લા અવતરણ, કૌંસ, કૌંસ અથવા કૌંસ છે, તો એક સેકન્ડલ પ્રોમ્પ્ટ (ડિફૉલ્ટ "+>") નવી લાઇન પર આપવામાં આવે છે. "પ્રોમ્પ્ટ 2" નામની પદ્ધતિ વ્યાખ્યાયિત કરીને ગૌણ પ્રોમ્પ્ટ સેટ કરી શકાય છે
દુભાષિયા દરમિયાન, રાંધેલ મોડનો ઉપયોગ કરવામાં આવે છે, ભલે તે તેના કોલ કરનાર રોવ મોડનો ઉપયોગ કરે.
જો stdin બંધ હોય, તો દુભાષિયો પાછો જશે સિવાય કે ઍફ ફ્લેગનો ઉપયોગ કરવામાં આવે, જે કિસ્સામાં અનુગામી દલીલનો ઉપયોગ કરવામાં આવે.
log_file [આર્ગ્ઝ] [[-એ] ફાઇલ]
જો ફાઇલનામ પ્રદાન કરવામાં આવે, તો log_file ફાઇલમાં સત્રના ટ્રાન્સક્રિપ્ટ (તે સમયે શરૂ થશે) રેકોર્ડ કરશે. જો કોઈ દલીલ આપવામાં ન આવે તો log_file રેકોર્ડિંગ બંધ કરશે. કોઈપણ અગાઉની લોગ ફાઈલ બંધ છે.
ફાઇલનામની જગ્યાએ, એક Tcl ફાઇલ ઓળખકર્તા -ઓપન અથવા -લોવેન ફ્લેગનો ઉપયોગ કરીને પ્રદાન કરી શકાય છે. આ spawn આદેશ જેવું જ છે. (વધુ માહિતી માટે સ્પાન જુઓ.)
-a ફ્લેગ દળ આઉટપુટ લોગ કરવા માટે કે જે log_user આદેશ દ્વારા દબાવવામાં આવ્યું હતું.
ડિફૉલ્ટ રૂપે, log_file આદેશ જૂની ફાઇલોને જોડે છે, તેના બદલે તેમને કાપવાથી, એક સત્રમાં લૉગિંગને બંધ કરવામાં અને ઘણી વખત સત્રની સુવિધા માટે. ફાઇલોને ટૂંકાવીને, નો- ફ્લેન્ડ ફ્લેગનો ઉપયોગ કરો.
-વિન્ડો ધ્વજ log_file ને આપવામાં આવેલ સૌથી તાજેતરનાં બિન-માહિતી દલીલોનું વર્ણન આપવાનું કારણ આપે છે.
log_user-info | 0 | 1
મૂળભૂત રીતે, મોકલો / અપેક્ષા સંવાદ stdout (અને ખૂલ્લો હોય તો લોગફાઇલ) માં પ્રવેશેલ છે. Stdout માં લોગીંગ "log_user 0" આદેશ દ્વારા નિષ્ક્રિય કરેલ છે અને "log_user 1" દ્વારા reenabled. લોગફાઇલ પર લૉગિંગ યથાવત છે.
-વિજેટ ધ્વજ લોગ_ઉઝરને આપવામાં આવેલ સૌથી તાજેતરના બિન-માહિતી દલીલોનું વર્ણન પાછુ આપવા માટે કરે છે.
મેચ_મેક્સ [-ડ] [-i spawn_id] [કદ]
અપેક્ષા દ્વારા આંતરિક રીતે ઉપયોગમાં લેવાયેલા બફર (બાઇટ્સમાં) નું કદ વ્યાખ્યાયિત કરે છે. કોઈ કદ દલીલ વગર, વર્તમાન કદ પાછો આવે છે
-d ધ્વજ સાથે, ડિફૉલ્ટ કદ સેટ છે. (પ્રારંભિક મૂળભૂત 2000 છે.) -i ફ્લેગ સાથે, માપ નામના spawn id માટે સુયોજિત થયેલ છે, અન્યથા તે વર્તમાન પ્રક્રિયા માટે સુયોજિત થયેલ છે.
ઓવરલે [- # spawn_id] [- # spawn_id] [...] પ્રોગ્રામ [આરબ્સ]
વર્તમાન અપેક્ષિત પ્રોગ્રામના સ્થાને "પ્રોગ્રામ એલ્જિસ" અમલમાં મૂકે છે, જે સમાપ્ત થાય છે. એકદમ હાઇફિન દલીલ કમાન્ડ નામની સામે હાઇફનને દબાણ કરે છે, જો તે લોગિન શેલ છે. બધા spawn_ids દલીલો તરીકે નામ આપવામાં આવેલા સિવાય સિવાય બંધ છે. આ નામવાળી ફાઇલ આઇડેન્ટીફાયર પર મેપ કરવામાં આવે છે.
Spawn_ids ને બોલાવેલા નવા પ્રોગ્રામ માટે આઇડેન્ટીફાયર ફાઇલ કરવા માટે મેપ કરવામાં આવે છે. ઉદાહરણ તરીકે, નીચેની લીટી ચેસ ચાલે છે અને તેને વર્તમાન પ્રક્રિયા દ્વારા નિયંત્રિત કરવાની મંજૂરી આપે છે - કહો, ચેસ માસ્ટર.
ઓવરલે -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id ચેસઆ "ક્રિયાપ્રતિક્રિયા -યુ" કરતા વધુ કાર્યક્ષમ છે, જો કે, તે પ્રોગ્રામ ક્રિયાપ્રતિક્રિયા કરવાની ક્ષમતાને બલિદાન આપે છે કારણ કે અપેક્ષા પ્રક્રિયા હવે નિયંત્રણમાં નથી.
નોંધ કરો કે કોઈ નિયંત્રક ટર્મિનલ આપવામાં આવ્યું નથી. આ રીતે, જો તમે માનક ઇનપુટ ડિસ્કનેક્ટ કરો અથવા રિપૅપ કરો છો, તો પ્રોગ્રામ્સ જે જોબ કંટ્રોલ (શેલો, લોગિન, વગેરે) યોગ્ય રીતે કાર્ય કરશે નહીં.
પેરિટી [-ડી] [-i spawn_id] [મૂલ્ય]
વ્યાખ્યાયિત કરે છે કે શું પેરિતાને સ્પાઉન્ટેડ પ્રક્રિયાઓના ઉત્પાદનમાંથી જાળવી રાખવામાં કે તોડવામાં આવે છે. જો મૂલ્ય શૂન્ય છે, સમાનતા તોડવામાં આવે છે, અન્યથા તે તોડવામાં નથી. કોઈ મૂલ્ય દલીલ વગર, વર્તમાન મૂલ્ય પરત કરવામાં આવે છે.
-d ફ્લેગ સાથે, ડિફોલ્ટ સમાનતા મૂલ્ય સેટ કરેલું છે. (પ્રારંભિક મૂળભૂત 1 છે, એટલે કે, પેરિટી તોડવામાં આવતી નથી.) -i ફ્લેગ સાથે, પેરીટી વેલ્યુ નામ આપવામાં આવ્યું spawn id માટે સુયોજિત છે, અન્યથા તે વર્તમાન પ્રક્રિયા માટે સુયોજિત થયેલ છે.
remove_nulls [-d] [-i spawn_id] [મૂલ્ય]
વ્યાખ્યાયિત કરે છે કે નલને જાળવી રાખવામાં આવે છે અથવા સ્પાઉન્ટેડ પ્રક્રિયાઓના આઉટપુટમાંથી દૂર કરવામાં આવે છે. જો મૂલ્ય 1 છે, નલ દૂર કરવામાં આવે છે. જો મૂલ્ય 0 છે, નલ દૂર કરવામાં આવતી નથી કોઈ મૂલ્ય દલીલ વગર, વર્તમાન મૂલ્ય પરત કરવામાં આવે છે.
-d ફ્લેગ સાથે, ડિફોલ્ટ મૂલ્ય સેટ કરેલું છે. (પ્રારંભિક મૂળભૂત 1 છે, એટલે કે, નલ દૂર કરવામાં આવે છે.) -i ફ્લેગ સાથે, મૂલ્ય નામના spawn id માટે સેટ કરેલું છે, અન્યથા તે વર્તમાન પ્રક્રિયા માટે સુયોજિત થયેલ છે.
નલ દૂર કરવામાં આવે છે કે નહી, અપેક્ષા નળ બાઇટ્સને લોગ અને stdout માં રેકોર્ડ કરશે.
[-flags] શબ્દમાળા મોકલો
વર્તમાન પ્રક્રિયા માટે શબ્દમાળા મોકલે છે. ઉદાહરણ તરીકે, આદેશ
વર્તમાન પ્રક્રિયામાં અક્ષરો, હેલવૉરલ્ડ મોકલે છે. (Tcl એ printf- જેવી આદેશ ( ફોર્મેટ તરીકે ઓળખાય છે) શામેલ છે જે આપખુદ જટિલ શબ્દમાળાઓ બનાવી શકે છે.)
પાત્રોને તાત્કાલિક મોકલવામાં આવે છે, જો કે રીટર્ન અક્ષર મોકલવામાં ન આવે ત્યાં સુધી લાઇન-બફ્ફર ઇનપુટવાળા કાર્યક્રમો અક્ષર વાંચશે નહીં. વળતર અક્ષર "\ r" દર્શાવે છે.
ધ્વજ એક ધ્વજને બદલે સ્ટ્રિંગ તરીકે અર્થઘટન કરવા માટે આગામી દલીલને દબાણ કરે છે. કોઈપણ શબ્દમાળા પહેલાથી "-" કરી શકે છે જો તે ફ્લેગ જેવું દેખાય કે નહીં આનાથી વિશ્વસનીય મિકેનિઝમ નિર્દિષ્ટ કરે છે કે જે વેરીએબલ સ્ટ્રિંગ્સને સ્પષ્ટ કરે છે જેમ કે અકસ્માતે ફ્લેગ જેવા દેખાય છે. ("-" થી શરૂ થતાં તમામ શબ્દમાળા ભાવિ વિકલ્પો માટે આરક્ષિત છે.)
-i ફ્લેગ જાહેર કરે છે કે સ્ટ્રિંગ નામના spawn_id પર મોકલવામાં આવશે. જો spawn_id એ user_spawn_id છે , અને ટર્મિનલ કાચો મોડમાં છે, શબ્દમાળામાં નવી લાઇનો પરત નવી-નવીન સિક્વન્સમાં અનુવાદિત થાય છે જેથી તે દેખાશે કે જો ટર્મિનલ રાંધેલ મોડમાં હતું. ધ્વજ આ ભાષાંતરને અક્ષમ કરે છે
-મૂલ્ય ફ્લેગ નલ અક્ષરો મોકલે છે (0 બાઇટ્સ). ડિફૉલ્ટ રૂપે, એક નલ મોકલવામાં આવે છે. પૂર્ણાંક, કેટલા નલ મોકલવા તે સૂચવવા માટેનું માત્ર- અનુલક્ષીને અનુસરી શકે છે.
ધ-બ્રેક ધ્વજ બ્રેક શરત પેદા કરે છે. આ ફક્ત અર્થમાં જ છે જો spawn ID એ "spawn -open" દ્વારા ખોલવામાં આવેલા tty ઉપકરણને સંદર્ભિત છે. જો તમે કોઈ ટીપ જેવી પ્રક્રિયાની રચના કરી હોય, તો તમારે બ્રેક બનાવવા માટે ટીપના સંમેલનનો ઉપયોગ કરવો જોઈએ.
ધ્વજ ધ્વજને "ધીમે ધીમે" મોકલવા માટેનું આઉટપુટ, આમ સામાન્ય પરિસ્થિતિથી દૂર રહે છે જ્યાં એક કમ્પ્યુટર ઈનપુટ બફરનું રૂપાંતર કરે છે જે એક માનવી માટે રચાયેલ છે જે ક્યારેય તે જ બફરને ક્યારેય નકામું બનાવશે નહીં. આ આઉટપુટ વેરિયેબલ "send_slow" ની વેલ્યુ દ્વારા નિયંત્રિત થાય છે જે બે ઘટક સૂચિ ધરાવે છે. પ્રથમ ઘટક એક પૂર્ણાંક છે જે અણુ મોકલવા માટે બાઇટ્સની સંખ્યાને વર્ણવે છે. બીજો તત્વ એ વાસ્તવિક સંખ્યા છે જે અણુ મોકલે છે તે સેકંડની સંખ્યાને વર્ણવે છે. ઉદાહરણ તરીકે, "send send_slow {10 .001}" "મોકલો -s" ને દબાણ કરે છે, મોકલવામાં આવતી દરેક 10 અક્ષરોની વચ્ચે 1 મિલિસેકન્ડ સાથે શબ્દમાળાઓ મોકલવા માટે દબાણ કરશે.
-h ફ્લેગ દળો આઉટપુટ મોકલવા માટે (કંઈક અંશે) માનવ ખરેખર ટાઇપિંગ જેવું. માનવ જેવા વિલંબ અક્ષરો વચ્ચે દેખાય છે. (આ અલ્ગોરિધમનો વેબબુલ વિતરણ પર આધારિત છે, આ ચોક્કસ એપ્લિકેશનને અનુરૂપ ફેરફાર સાથે.) આ આઉટપુટ વેરિયેબલ "send_human" ની વેલ્યુ દ્વારા નિયંત્રિત થાય છે જે પાંચ ઘટક સૂચિ લે છે. પ્રથમ બે ઘટકો સેકંડમાં પાત્રોની સરેરાશ ઇન્ટરરવરેજ સમય છે. પ્રથમ મૂળભૂત દ્વારા ઉપયોગ થાય છે. બીજો શબ્દ શબ્દ અંતમાં ઉપયોગમાં લેવાય છે, સૂક્ષ્મ વિરામનો અનુકરણ કરે છે જે ક્યારેક આવા સંક્રમણોમાં થાય છે. ત્રીજા પરિમાણ ચલનનું માપ છે, જ્યાં 1 ઘણું ચલ છે, 1 વ્યાજબી રીતે ચલ છે, અને 10 એ તદ્દન અજેય છે. ચડિયાતા 0 અનંત છે. છેલ્લાં બે પરિમાણો, અનુક્રમે ઓછામાં ઓછા અને મહત્તમ ઇન્ટરરવેર્ન સમય છે. લઘુતમ અને વધુમાં વધુ છેલ્લો ઉપયોગ થાય છે અને અંતિમ સમય "ક્લિપ" થાય છે. અંતિમ એવરેજ આપેલ સરેરાશથી ઘણું અલગ હોઈ શકે છે જો લઘુત્તમ અને મહત્તમ ક્લિપ પર્યાપ્ત મૂલ્યો.
ઉદાહરણ તરીકે, નીચેનો આદેશ ઝડપી અને સાતત્યપૂર્ણ ટાઇપ્યુટનું અનુકરણ કરે છે:
મોકલો send_human {.1.3 1 .05 2} મોકલો- "હું ભૂખ્યા છું, ચાલો ભોજન કરીએ."જ્યારે હેંગઓવર પછી નીચેના વધુ યોગ્ય હોઈ શકે છે:
મોકલો send_human {.4.4 .2.5}} મોકલો "ગુડડ પાર્ટી ફટકો રાત!"નોંધ કરો કે ભૂલોને સિમ્યુલેટેડ નથી, છતાં તમે ભૂલોને એમ્બેડ કરીને અને મોકલવા દલીલમાં સુધારા દ્વારા ભૂલ સુધારવાની પરિસ્થિતિઓને જાતે સેટ કરી શકો છો.
નલ અક્ષરો મોકલવા, બ્રેક મોકલવા માટે, ધીમા આઉટપુટને રોકવા માટે અને માનવીય-શૈલીનું ઉત્પાદન કરવા માટેના ફ્લેગ પરસ્પર વિશિષ્ટ છે. ફક્ત છેલ્લે ઉલ્લેખિત એકનો ઉપયોગ કરવામાં આવશે. વળી, નલ અક્ષરો અથવા બ્રેક્સ મોકલવા માટે કોઈ શબ્દમાળા દલીલ ફ્લેગ સાથે સ્પષ્ટ કરી શકાતી નથી.
અપેક્ષા મુજબ પ્રક્રિયામાં પ્રથમ મોકલો પહેલા સારો વિચાર છે. અપેક્ષિત પ્રક્રિયા શરૂ થવાની રાહ જોવી પડશે, જ્યારે મોકલી શકાતું નથી. ખાસ કરીને, જો પ્રક્રિયા શરૂ થાય તે પહેલાં પ્રથમ મોકલવું પૂરું થાય, તો તમે તમારા ડેટાને અવગણના કર્યાના જોખમને ચલાવો છો. એવા પરિસ્થિતિઓમાં કે જ્યાં ઇન્ટરેક્ટિવ કાર્યક્રમો કોઈ પ્રારંભિક સંકેત આપતા નથી, તમે વિલંબ દ્વારા મોકલી શકો છો:
# હેકર્સને કેવી રીતે તોડવું તે અંગે સંકેતો આપવાનું ટાળો, # આ સિસ્ટમ બાહ્ય પાસવર્ડ માટે પૂછતી નથી. # Spawn telnet ને પૂર્ણ કરવા માટે exec માટે 5 સેકન્ડ માટે રાહ જુઓ .secure.gov ઊંઘ 5 પાસવર્ડ મોકલો \ rexp_send મોકલવા માટે ઉપનામ છે જો તમે પર્યાવરણમાં રોકાણની અપેક્ષા રાખતા અપેક્ષા અથવા અન્ય કોઇ પ્રકારનો ઉપયોગ કરતા હો તો, મોકલો સંપૂર્ણપણે અલગ હેતુસર રૂ. exp_send પર્યાવરણો વચ્ચે સુસંગતતા માટે આપવામાં આવે છે અન્ય ઉપભોગના અન્ય મોકલે આદેશો માટે સમાન ઉપનામો આપવામાં આવે છે.
send_error [-flags] શબ્દમાળા
મોકલવું જેવું છે, સિવાય કે આઉટપુટ વર્તમાન પ્રક્રિયાને બદલે stderr ને મોકલવામાં આવે છે.
send_log [-] શબ્દમાળા
મોકલવા જેવું છે, સિવાય કે શબ્દમાળા ફક્ત લોગ ફાઇલમાં જ મોકલવામાં આવે છે (જુઓ log_file .) જો કોઈ લોગ ફાઇલ ખુલ્લી ન હોય તો દલીલો અવગણવામાં આવે છે.
send_tty [-flags] શબ્દમાળા
મોકલવા જેવું છે, સિવાય કે આઉટપુટ વર્તમાન પ્રક્રિયાને બદલે / dev / tty ને મોકલવામાં આવે છે.
send_user [-flags] શબ્દમાળા
મોકલો જેવું છે, સિવાય કે આઉટપુટ વર્તમાન પ્રક્રિયાને બદલે સ્ટડઆઉટ પર મોકલવામાં આવે છે.
ઊંઘ સેકંડ
આપેલ સેકન્ડ માટે સ્ક્રિપ્ટ ઊંઘે છે . સેકન્ડ્સ દશાંશ નંબર હોઇ શકે છે. ઈન્ટ્રપ્ટ્સ (અને ટીકા ઇવેન્ટ્સ જો તમે એક્સપેકકનો ઉપયોગ કરી રહ્યા હો ત્યારે) ઊંઘે તેવી અપેક્ષા રાખવામાં આવે છે.
spawn [args] પ્રોગ્રામ [આર્ગ્ઝ]
"પ્રોગ્રામ એલ્જીસ" ચાલી રહેલ એક નવી પ્રક્રિયા બનાવે છે. તેના stdin, stdout અને stderr અપેક્ષા સાથે જોડાયેલ છે, જેથી તેઓ અન્ય Expect આદેશો દ્વારા વાંચી અને લખી શકાય. જોડાણ બંધ થઈ ગયું છે અથવા જો પ્રક્રિયા પોતે કોઈપણ ફાઇલ આઇડેન્ટીફાયરને બંધ કરે છે
સ્પન દ્વારા પ્રક્રિયા શરૂ થાય ત્યારે, ચલ spawn_id એ તે પ્રક્રિયાનો ઉલ્લેખ કરતી વર્ણનકર્તા પર સેટ છે. Spawn_id દ્વારા વર્ણવવામાં આવેલી પ્રક્રિયાને " વર્તમાન પ્રક્રિયા " ગણવામાં આવે છે. spawn_id અસરકારક રીતે કામ નિયંત્રણ પૂરી પાડવા, વાંચી અથવા લખી શકાય છે.
user_spawn_id એક વૈશ્વિક ચલ છે જે ડિસ્ક્રીપ્ટર ધરાવે છે જે વપરાશકર્તાને સંદર્ભ આપે છે. ઉદાહરણ તરીકે, જ્યારે spawn_id એ આ મૂલ્ય પર સેટ કરેલું હોય, તો અપેક્ષા_યુસરની જેમ વર્તે છે.
.હું 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 slave ઉપકરણના નામ પર સુયોજિત થયેલ છે.
મૂળભૂત રીતે, spawn આદેશ નામ અને દલીલોને જુએ છે. નો -ઓઇઓઇકો ફ્લેગ આને કરવાથી સ્પૅનને અટકાવે છે.
-console ફ્લેગ એ પેદા થયેલ પ્રક્રિયાને રીડાયરેક્ટ કરવા માટે કન્સોલ આઉટપુટનું કારણ બને છે. આ બધી સિસ્ટમો પર સપોર્ટેડ નથી
આંતરિક રીતે, spawn એ PTY નો ઉપયોગ કરે છે, તે જ રીતે વપરાશકર્તાના tty તરીકે પ્રારંભ થાય છે. આ વધુ પ્રારંભ થાય છે જેથી બધી સેટિંગ્સ "સેન" (સ્ટેટી (1) પ્રમાણે) જો ચલ stty_init વ્યાખ્યાયિત થયેલ છે, તો તે વધુ રૂપરેખાંકન તરીકે stty દલીલોની શૈલીમાં અર્થઘટન કરવામાં આવે છે. ઉદાહરણ તરીકે, "stty_init raw સેટ કરો" વધુ પેદા થયેલ પ્રક્રિયાઓના ટર્મિનલોને કાચો મોડમાં શરૂ કરવા માટે કારણ આપશે. નોટ્ટોકોપી વપરાશકર્તાની ટીટીટીના આધારે પ્રારંભિકતાને રદ કરે છે. -નિટિનિએટ "સેન" પ્રારંભને છોડી દે છે
સામાન્ય રીતે, ફળોને ચલાવવા માટે થોડો સમય લે છે જો તમે સ્પાન નો નોંધપાત્ર સમય લેતા નોંધ લો છો, તો તે કદાચ પીટીયઝનો સામનો કરી રહ્યું છે જે પાંખવાળા હોય છે. ભૂલભરેલી પ્રક્રિયાઓ સાથે ગૂંચવણો ટાળવા માટે સંખ્યાબંધ પરીક્ષણો ptys પર ચાલે છે. (આ wedged pty દીઠ 10 સેકન્ડ લાગે છે.) જો -d વિકલ્પ સાથે અપેક્ષિત ચાલવું જો અચ્છતા વિચિત્ર રાજ્યોમાં ઘણી પીટીય્ઝની અનુભવી રહ્યું હોય તો તે બતાવશે. જો તમે પ્રોસેસને નષ્ટ કરી શકતા નથી કે જે આ પીટીય્ઝ જોડાયેલ છે, તો તમારા એકમાત્ર રીસોર્ટ રીબુટ થઈ શકે છે.
જો પ્રોગ્રામ સફળતાથી પેદા કરી શકાતો નથી કારણ કે exec (2) નિષ્ફળ જાય છે (દા.ત. જ્યારે પ્રોગ્રામ અસ્તિત્વમાં નથી), તો પછીની ક્રિયાપ્રતિક્રિયા દ્વારા એક ભૂલ સંદેશો પરત કરવામાં આવશે અથવા આદેશની અપેક્ષા રાખવામાં આવશે જેમ કે કાર્યક્રમ આઉટ થયો છે અને આઉટપુટ તરીકે ભૂલ સંદેશો ઉત્પન્ન કરે છે. આ વર્તણૂક એ ફળોના અમલીકરણનો કુદરતી પરિણામ છે. આંતરિક, સ્પાન ફોર્કસ, જેના પછી spawn_id દ્વારા સંદેશાવ્યવહાર સિવાય મૂળ અપેક્ષિત પ્રક્રિયાની સાથે વાતચીત કરવાની કોઈ પ્રક્રિયા નથી.
-ઓપ્પન ધ્વજ આગામી દલીલને Tcl ફાઇલ ઓળખકર્તા તરીકે ઓળખાવા માટેનું કારણ બને છે (એટલે કે, ખુલ્લા દ્વારા પાછો ફર્યો છે.) Spawn id પછી તે પ્રવેશેલી પ્રક્રિયા તરીકે ઉપયોગમાં લઈ શકાય છે (ફાઇલ ઓળખકર્તા લાંબા સમય સુધી ઉપયોગમાં ન જવો જોઈએ.) તે તમને pty નો ઉપયોગ કર્યા વગર રોકેલા ઉપકરણો, ફાઇલો અને પાઇપલાઇન્સને સ્પાઇન્ડ પ્રક્રિયાઓ તરીકે ઉપયોગમાં લઈ જવા દે છે. 0 કોઈ સંકળાયેલ પ્રક્રિયા ન હોવાનું સૂચવવા માટે પરત કરવામાં આવે છે જ્યારે પેદા થયેલ પ્રક્રિયાનું જોડાણ બંધ થઈ ગયું છે, ત્યારે પણ તે Tcl ફાઇલ ઓળખકર્તા છે. -લોવેઓપ્લેન ધ્વજ તે સિવાયના-જેવું જ છે - સ્પ્લેટ આઇએનડી બંધ થયા પછી પણ -લોવપેન ફાઇલ આઇડેન્ટીફાયરને ખોલવા માટેનું કારણ બને છે.
ખાલી ફ્લેગ ખોલવા માટે pty થાય છે, પરંતુ કોઈ પ્રક્રિયા પેદા નથી. 0 કોઈ સંકળાયેલ પ્રક્રિયા ન હોવાનું સૂચવવા માટે પરત કરવામાં આવે છે Spawn_id એ હંમેશાં સેટ છે
ચલ spawn_out (ગુલામ, એફડી) એ pty slave ને અનુરૂપ ફાઇલ ઓળખકર્તા પર સેટ છે. તેને "બંધ-સ્લેવ" નો ઉપયોગ કરીને બંધ કરી શકાય છે
પ્રજનનક્ષમ પ્રણાલીમાં સંકેત આપનારનું નામનિશાનુસાર છે . અન્યથા, સિગ્નલો ડિફૉલ્ટ વર્તન મેળવે છે સંકેતોને છટકું આદેશ તરીકે નામ આપવામાં આવ્યું છે, સિવાય કે દરેક સંકેતને અલગ ધ્વજની જરૂર છે.
સ્ટ્રેસ સ્તર
નીચેની વિધાનોનો અમલ થતાં પહેલાં છાપવાનું કારણ બને છે. (Tcl નું ટ્રેસ આદેશ ચલોનું નિશાન કરે છે.) સ્તર સૂચવે છે કે કૉલ સ્ટેકમાં કેટલી દૂર છે. ઉદાહરણ તરીકે, નીચેના આદેશ કોલ્સના પ્રથમ 4 સ્તરોને ટ્રેસીંગ કરતી વખતે અપેક્ષા રાખવામાં આવે છે , પરંતુ તે પછી કોઈ નહીં.
-વિન્ડો ધ્વજ સ્ટ્રેસને આપવામાં આવેલ સૌથી તાજેતરના બિન-માહિતી દલીલોનું વર્ણન પરત કરવા માટે કરે છે.
stty args
બાહ્ય સ્ટર્ટી આદેશની જેમ ટર્મિનલ મોડ્સ બદલે છે.
મૂળભૂત રીતે, નિયંત્રિત ટર્મિનલ એક્સેસ થાય છે. અન્ય ટર્મિનલ્સને "સ્થિતિ માટેની વિનંતીઓના આદેશના પરિણામે તે રીસેટ કરીને ઍક્સેસ કરી શકાય છે. જો કોઈ સ્થિતિની વિનંતી કરવામાં ન આવે અને નિયંત્રક ટર્મિનલનો ઉપયોગ થતો હોય, તો કાચા અને પડઘો લક્ષણોની પાછલી સ્થિતિ પરત કરવામાં આવે છે, જે પાછળથી આદેશ દ્વારા ઉપયોગમાં
ઉદાહરણ તરીકે, કાચા અથવા -કોક્કની દલીલોને ટર્મિનલને કાચો મોડમાં મુકો. ટર્મિનલને રાંધેલ મોડમાં મૂકી દલીલ- ભરવા અથવા રાંધવામાં આવે છે. દલીલો પડઘો અને -echo ટર્મિનલને અનુક્રમે ઇકો અને નોઇચી મોડમાં મુકો.
નીચેનું ઉદાહરણ સમજાવે છે કે કેવી રીતે અયોગ્ય રીતે ઇકોઇંગને અક્ષમ કરવું. આનો ઉપયોગ અન્યથા સ્વયંસંચાલિત સ્ક્રિપ્ટ્સમાં તેમનામાં પાસવર્ડ્સને એમ્બેડ કરવાનું ટાળવા માટે થઈ શકે છે. (નીચેની બાબતોની અપેક્ષા મુજબ આ અંગે વધુ ચર્ચા કરો.)
stty -echo send_user "પાસવર્ડ:" expect_user -re "(. *) \ n" પાસવર્ડ સેટ કરો $ expect_out (1, શબ્દમાળા) stty echo સિસ્ટમ દલીલો
ઇન્સેપ્ટ તરીકે sh (1) એ અર્જીસ આપે છે, જેમ કે તે ટર્મિનલમાંથી કમાન્ડ તરીકે ટાઇપ કરેલ છે. શેલ સમાપ્ત થાય ત્યાં સુધી રાહ જોવી રાહ જોવી. Sh માંથી વળતરની સ્થિતિને તે જ રીતે નિયંત્રિત કરવામાં આવે છે જે exec તેની વળતર સ્થિતિ સંભાળે છે.
Exec જે વિપરીત સ્ક્રિપ્ટમાં stdin અને stdout ને રીડાયરેક્ટ કરે છે, સિસ્ટમ કોઈ પુનર્નિર્દેશન (શબ્દમાળા દ્વારા સૂચવાયેલ કરતાં અન્ય) કરે છે. આમ, તે પ્રોગ્રામ્સનો ઉપયોગ કરવો શક્ય છે, જે / dev / tty પર સીધા જ વાત કરવું જોઈએ. આ જ કારણસર, સિસ્ટમના પરિણામો લોગમાં રેકોર્ડ નથી થયાં.
ટાઇમસ્ટેમ્પ [એલ્જ]
ટાઇમસ્ટેમ્પ આપે છે કોઈ દલીલો વગર, યુગ પાછો ફર્યો ત્યારથી સેકંડની સંખ્યા.
-ફોર્મેટ ફ્લેગ એક સ્ટ્રિંગ રજૂ કરે છે જે પરત આવે છે પરંતુ સ્ફોટાઇમ માટે POSIX નિયમો અનુસાર બદલાયેલ ઉપાયો છે. ઉદાહરણ તરીકે,% એ સંક્ષિપ્ત સપ્તાહ ડે (એટલે કે, સત) દ્વારા બદલવામાં આવે છે. અન્ય લોકો છે:
% સંક્ષિપ્ત અઠવાડિયાનો દિવસ% એક સંપૂર્ણ અઠવાડિયાનો નામ% b સંક્ષિપ્ત મહિનો નામ% બી સંપૂર્ણ મહિનો નામ% સી તારીખ સમય જેમ: બુધ ઑક્ટોબર 6 11:45:56 1993% મહિનાના% ડી દિવસ (01-31% એચ કલાક (00-23)% I કલાક (01-12)% જે દિવસ (001-366)% મી મહિનો (01-12)% એમ મિનિટ (00-59)% પી એએમ અથવા PM પર% S સેકન્ડ (00-61) % u દિવસ (1-7, સોમવાર સપ્તાહનો પ્રથમ દિવસ છે)% યુ અઠવાડિયે (00-53, પ્રથમ રવિવાર અઠવાડિયાના પ્રથમ દિવસ છે)% વી સપ્તાહ (01-53, ISO 8601 શૈલી)% w દિવસ (0- 6)% W સપ્તાહ (00-53, પ્રથમ સોમવાર અઠવાડિયાના પ્રથમ દિવસ છે)% x તારીખ સમય જેમ કે: બુધ ઑક્ટોબર 6 1993% X સમય: 23: 59: 59% વાય વર્ષ (00-99) % વાય વર્ષ આ પ્રમાણે: 1993% ઝેડ ટાઈમઝોન (અથવા કંઇ નિર્ધારિત નહીં હોય તો) %% એકદમ ટકા સાઇનઅન્ય% વિશિષ્ટતાઓ અવ્યાખ્યાયિત છે. અન્ય અક્ષરો છવાયેલી વગર પસાર થશે. ફક્ત C લોકેલ સપોર્ટેડ છે.
આ -સેકન્ડ્સ ધ્વજ સંખ્યાબંધ સેકંડનો પરિચય આપે છે કારણ કે યુગનો ઉપયોગ ફોર્મેટમાંથી સ્ત્રોત તરીકે થાય છે. નહિંતર, વર્તમાન સમય વપરાય છે.
GMT ટાઈમઝોનનો ઉપયોગ કરવા માટે- GMT ફ્લેગ ટાઇમસ્ટેમ્પ આઉટપુટને દબાવે છે . કોઈ ધ્વજ વગર, સ્થાનિક ટાઇમઝોનનો ઉપયોગ કરવામાં આવે છે.
છટકું [[આદેશ] સંકેતો]
આપેલ કોઈપણ સંકેતની ભાવિ રસીદ પર આપેલ કમાન્ડને એક્ઝિક્યુટ કરવાની જરૂર છે. આદેશ વૈશ્વિક અવકાશમાં ચલાવવામાં આવે છે. જો આદેશ ગેરહાજર હોય, તો સંકેત ક્રિયા પરત કરવામાં આવે છે. જો આદેશ શબ્દમાળા SIG_IGN છે, સંકેતોને અવગણવામાં આવે છે. જો આદેશ શબ્દમાળા SIG_DFL છે, સંકેતો સિસ્ટમ મૂળભૂત તરીકે પરિણમે છે. સિગ્નલો ક્યાં તો એક સિગ્નલ અથવા સંકેતોની સૂચિ છે. સિગ્નલો સંકેત મુજબ (3) આંકડાકીય અથવા સાંકેતિક રીતે સ્પષ્ટ થઈ શકે છે. "SIG" ઉપસર્ગ અવગણી શકાય છે.
કોઈ દલીલો (અથવા દલીલ-નંબર) સાથે, છટકું હાલમાં ચાલી રહેલ છટકું આદેશની સંકેત નંબર આપે છે.
-કોડ ધ્વજ આદેશની રીટર્ન કોડનો ઉપયોગ કરે છે, જ્યાં કોડ મૂળથી શરૂ થવાનું શરૂ થયું ત્યારે Tcl જે કાંઈ કોડ હતું તે સ્થાને આવવા અંગે હતું.
ઇન્ટરફ્પ ધ્વજ એ આદેશને જ્યારે ઇંટરપ્રીટર સક્રિય કરે છે ત્યારે મૂલ્યાંકન કરે છે કે જ્યારે છટકું જાહેર કરવામાં આવ્યું હતું તેના બદલે કમાન્ડ શરૂ થતું હતું.
-name ફ્લેગ છટકું કમાન્ડને વર્તમાનમાં ચલાવવામાં આવેલ છટકું આદેશના સિગ્નલ નામ પરત કરવા માટેનું કારણ બને છે.
સૌથી મોટું ધ્વજ છટકું કમાન્ડને સૌથી મોટો સંકેત નંબર પાછો આપે છે જે સેટ કરી શકાય છે.
ઉદાહરણ તરીકે, આદેશ "છટકું {મોકલો" ઓઉચર! "} SIGINT" છાપશે "આઉચ!" દરેક વખતે વપરાશકર્તા દબાયેલો ^ સી.
મૂળભૂત રીતે, SIGINT (જે સામાન્ય રીતે ^ C પર દબાવીને પેદા કરી શકાય છે) અને SIGTERM કારણ Expect to exit આ નીચેના છટકુંને કારણે છે, જ્યારે અપેક્ષિત પ્રારંભ થાય ત્યારે ડિફૉલ્ટ દ્વારા બનાવવામાં આવે છે.
છટકું બહાર નીકળો {SIGINT SIGTERM}જો તમે ડિબગર શરૂ કરવા માટે -D ફ્લેગનો ઉપયોગ કરો છો, તો ઇન્ટરેક્ટિવ ડિબગર શરૂ કરવા માટે SIGINT ફરીથી નિર્ધારિત છે આ નીચેના છટકું કારણે છે:
છટકું {exp_debug 1} SIGINTએન્જીનિયર વેરીએબલ EXPECT_DEBUG_INIT ને નવા ટ્રેપ કમાન્ડમાં સુયોજિત કરીને ડિબગર ટ્રેપને બદલી શકાય છે.
તમે, અલબત્ત, આ બંનેને તમારી સ્ક્રિપ્ટમાં છટકું આદેશો ઉમેરીને ઓવરરાઇડ કરી શકો છો. ખાસ કરીને, જો તમારી પાસે તમારી "છટકું બહાર નીકળો SIGINT" હોય, તો તે ડીબગર ફાંટાને ઓવરરાઇડ કરશે. આ ઉપયોગી છે જો તમે વપરાશકર્તાઓને ડીબગર પર મેળવવાથી અટકાવી શકો છો.
જો તમે SIGINT પર તમારા પોતાના ટ્રેપને વ્યાખ્યાયિત કરવા માંગો છો, પરંતુ તે ચાલી રહ્યું હોય ત્યારે ડિબગરને ફાંદો પણ લગાવી શકો છો, તેનો ઉપયોગ કરો:
જો {! [exp_debug]} {ફાંસી માસ્ટફ SIGINT}વૈકલ્પિક રીતે, તમે કેટલાક અન્ય સિગ્નલનો ઉપયોગ કરીને ડિબગર પર ફાંદો કરી શકો છો.
ફાંસો તમે SIGALRM માટે ક્રિયા ઓવરરાઇડ ન દો કરશે કારણ કે તે અપેક્ષિત આંતરિક રીતે ઉપયોગ થાય છે ડિસ્કનેક્ટ આદેશ SIGALRM ને SIG_IGN (અવગણો) માં સુયોજિત કરે છે તમે જ્યાં સુધી અનુગામી spawn આદેશો દરમિયાન તેને નિષ્ક્રિય કરશો ત્યાં સુધી તમે આને ફરીથી સક્ષમ કરી શકો છો.
સિગ્નલ જુઓ (3) વધુ માહિતી માટે
રાહ જુઓ [આરબ્સ]
વિલંબિત પ્રક્રિયા સુધી વિલંબ (અથવા જો કોઇને નામ આપવામાં આવ્યું ન હોય તો વર્તમાન પ્રક્રિયા ) સમાપ્ત થાય છે.
રાહ જુઓ સામાન્ય રીતે ચાર પૂર્ણાંકોની સૂચિ આપે છે. પ્રથમ પૂર્ણાંક એ પ્રક્રિયાની પદ્દત છે જે પર રાહ જોવામાં આવી હતી. બીજું પૂર્ણાંક અનુરૂપ બોન આઈડી છે ત્રીજી પૂર્ણાંક -1 છે જો ઓપરેટિંગ સિસ્ટમની ભૂલ આવી હોય, અથવા 0 અન્યથા. જો ત્રીજા પૂર્ણાંક 0 હતો, તો ચોથા પૂર્ણાંક એ પેદા થયેલ પ્રક્રિયા દ્વારા પાછો આવવાની સ્થિતિ છે. જો ત્રીજા પૂર્ણાંક -1 હતી, તો ચોથા પૂર્ણાંક એ ઓપરેટિંગ સિસ્ટમ દ્વારા સેટ કરેલ errno નું મૂલ્ય છે. વૈશ્વિક વેરિયેબલ errorCode પણ સેટ કરેલ છે.
રાહ જોવાથી વળતર મૂલ્યના અંતે વધારાની ઘટકો દેખાઈ શકે છે. વૈકલ્પિક પાંચમી તત્વ માહિતીનો વર્ગ ઓળખે છે. હાલમાં, આ તત્વ માટે એકમાત્ર શક્ય મૂલ્ય ચિલ્ડિક્લીલ્ડ છે, તે સ્થિતિમાં આગામી બે મૂલ્યો સી-સ્ટાઇલ સંકેત નામ અને ટૂંકા પાઠય વર્ણન છે.
-i ફ્લેગ નામની spawn_id (નહિં કે પ્રક્રિયા ID) ને અનુરૂપ રાહ જોવાની પ્રક્રિયાનું ઘોષણા કરે છે. એક SIGCHLD હેન્ડલરની અંદર, spawn id-1 નો ઉપયોગ કરીને કોઈપણ પેદા પ્રક્રિયા માટે રાહ જોવી શક્ય છે.
આ રાહ જોઈ રહ્યું હતુ ધ્વજ સફળ રાહના સંકેત સાથે તુરંત જ પાછા જવાનું કારણ બને છે. જ્યારે પ્રક્રિયા બહાર નીકળે છે (પાછળથી), તે સ્પષ્ટ રૂપે રાહ જોયા વિના આપમેળે અદૃશ્ય થઈ જશે
રાહ આદેશનો ઉપયોગ પણ દલીલો "-i -1" નો ઉપયોગ કરીને ફોર્ક્ડ પ્રક્રિયાની રાહ જોવામાં આવે છે. પેદા પ્રક્રિયાઓ સાથે તેના ઉપયોગથી વિપરીત, આ આદેશ કોઈ પણ સમયે ચલાવી શકાય છે. પ્રક્રિયાને કાપે છે તે ઉપર કોઈ નિયંત્રણ નથી. જો કે, રીટર્ન વેલ્યુ પ્રક્રિયા આઈડી માટે ચકાસાયેલ છે.
LIBRARIES
અપેક્ષિત સ્ક્રિપ્ટ્સ માટે બે બિલ્ટ-ઇન લાઇબ્રેરીઓ વિશે આપોઆપ જાણે છે. આ વેરીએબલ્સ exp_library અને exp_exec_library માં નામવાળી ડિરેક્ટરીઓ દ્વારા વ્યાખ્યાયિત થયેલ છે. બંને ઉપયોગિતા ફાઇલો ધરાવતી હોય છે જેનો ઉપયોગ અન્ય સ્ક્રિપ્ટો દ્વારા કરી શકાય છે.
exp_library આર્કીટેક્ચર-સ્વતંત્ર ફાઈલો સમાવે છે. exp_exec_library આર્કીટેક્ચર-આધારિત ફાઈલો સમાવે છે. તમારી સિસ્ટમ પર આધાર રાખીને, બંને ડિરેક્ટરીઓ તદ્દન ખાલી હોઈ શકે છે. $ Exp_exec_library / cat-buffers ફાઇલનું અસ્તિત્વ વર્ણન કરે છે કે શું તમારી / bin / cat બફરો મૂળભૂત રીતે છે.
પ્રીટિ-પ્રિન્ટિંગ
એક vgrind વ્યાખ્યા પ્રીટિ-પ્રિન્ટીંગ અપેક્ષા સ્ક્રિપ્ટ્સ માટે ઉપલબ્ધ છે. અપેક્ષિત વિતરણ સાથે પૂરી પાડવામાં આવેલી vgrind વ્યાખ્યા ધારી રહ્યા છીએ યોગ્ય રીતે સ્થાપિત થયેલ છે, તમે તેને આ રીતે ઉપયોગ કરી શકો છો:
vgrind -lexpect fileઉદાહરણો
તે ઘણાં લોકો સ્પષ્ટતા કરતા નથી કે બધું કઈ રીતે એકસાથે મૂકવું કે જે મેન પેજ વર્ણવે છે. હું તમને અપેક્ષિત ડિસ્ટ્રિબ્યુશનની ઉદાહરણ ડિરેક્ટરીમાં ઉદાહરણો વાંચવા અને અજમાવવા માટે પ્રોત્સાહિત કરું છું. તેમાંના કેટલાક વાસ્તવિક કાર્યક્રમો છે. અન્ય કેટલીક ટેકનિક્સની માત્ર દૃષ્ટાંતરૂપ છે, અને અલબત્ત, દંપતિ ફક્ત ઝડપી હેક્સ છે. ઇન્સ્ટોલ ફાઇલમાં આ પ્રોગ્રામ્સનો ઝડપી ઝાંખી છે.
અપેક્ષિત કાગળો (જુઓ પણ જુઓ) પણ ઉપયોગી છે. જ્યારે કેટલાક કાગળો અપેક્ષાના અગાઉના વર્ઝનને અનુરૂપ સિન્ટેક્સનો ઉપયોગ કરે છે, ત્યારે સાથેના કારણો હજુ પણ માન્ય છે અને આ મેન પેજ કરતાં ઘણું વધારે વિગતવાર છે.
CAVEATS
એક્સટેન્શન્સ અપેક્ષાઓના આદેશ નામો સાથે અથડાઈ શકે છે. ઉદાહરણ તરીકે, મોકલો સંપૂર્ણપણે અલગ હેતુ માટે રૂ. આ કારણોસર, મોટા ભાગના Expect આદેશો "exp_XXXX" તરીકે પણ ઉપલબ્ધ છે. "એક્સપ", "ઇન્ટર", "સ્પાન" અને "ટાઇમઆઉટ" થી શરૂ થતી આદેશો અને ચલો ઉપનામો નથી. વિસ્તૃત આદેશ નામોનો ઉપયોગ કરો જો તમને વાતાવરણ વચ્ચેની સુસંગતતાની જરૂર હોય તો.
અપેક્ષા સ્કોપિંગના બદલે ઉદાર દેખાવ ધરાવે છે. વિશિષ્ટ રીતે, અપેક્ષિત પ્રોગ્રામ માટે વિશિષ્ટ આદેશો દ્વારા વાંચવામાં આવતી ચલો સ્થાનિક સમક્ષેત્રમાંથી સૌ પ્રથમ માંગવામાં આવશે, અને વૈશ્વિક અવકાશમાં જો મળ્યું ન હોય તો. ઉદાહરણ તરીકે, આ તમને અપેક્ષા છે કે ઉપયોગમાં લેવાતી દરેક પ્રક્રિયામાં "વૈશ્વિક સમયસમાપ્તિ" મૂકવાની જરૂર છે. બીજી બાજુ, લખેલા ચલો હંમેશા સ્થાનિક અવકાશમાં રહે છે (જ્યાં સુધી "વૈશ્વિક" આદેશ જારી ન હોય). પ્રક્રિયામાં જ્યારે સ્પૉન ચલાવવામાં આવે ત્યારે આ સૌથી સામાન્ય સમસ્યા છે. કાર્યપ્રણાલીની બહાર, spawn_id હવે અસ્તિત્વમાં નથી, તેથી ઝેરની પ્રક્રિયા માત્ર સ્કોપિંગને કારણે સુલભ નથી. આવી પ્રક્રિયા માટે "વૈશ્વિક spawn_id" ઉમેરો.
જો તમે મલ્ટિસપેન્ડિંગ ક્ષમતાને સક્ષમ કરી શકતા નથી (એટલે કે, તમારી સિસ્ટમ ન તો પસંદ કરો (બીએસડી *. *), પોલ (એસવીઆર> 2), અથવા કંઇક સમકક્ષ) ને સપોર્ટ કરે છે, અપેક્ષા માત્ર એક જ સમયે કોઈ એક પ્રક્રિયાને નિયંત્રિત કરવામાં સક્ષમ હશે. આ કિસ્સામાં, spawn_id સેટ કરવાનો પ્રયાસ કરશો નહીં, ન તો સ્પાઇન્ડ પ્રક્રિયા ચાલી રહી હોય ત્યારે તમારે એક્ઝેક્યુલ્સ દ્વારા એક્ઝિક્યુટ એક્ઝિક્યુટ કરવું જોઈએ. વધુમાં, તમે એક જ સમયે બહુવિધ પ્રક્રિયાઓ (એક સહિત વપરાશકર્તા સહિત) થી અપેક્ષા કરી શકશો નહીં.
સ્ક્રિપ્ટ પર ટર્મિનલ પરિમાણોનો મોટો પ્રભાવ હોઈ શકે છે. ઉદાહરણ તરીકે, જો કોઈ સ્ક્રિપ્ટ લખવા માટે જોવા માટે લખવામાં આવે છે, તો તે અયોગ્ય છે જો ઇકોઈંગ બંધ છે આ કારણોસર, સૈનિકો મૂળભૂત રીતે માનવામાં આવે છે. કમનસીબે, આ અન્ય કાર્યક્રમો માટે વસ્તુઓ અપ્રિય બનાવી શકે છે. ઉદાહરણ તરીકે, ઇમૅક્સ શેલ "સામાન્ય" મેપિંગ્સ બદલવાની ઇચ્છા ધરાવે છે: નવી લાઇન્સ વાહન-રીટર્ન નવી લાઇન્સની જગ્યાએ નવી લાઇન પર મેપ થયેલ છે, અને એકો કરવાનું અક્ષમ છે. આ ઇનપુટ લાઇનને સંપાદિત કરવા માટે emacs નો ઉપયોગ કરવાની મંજૂરી આપે છે દુર્ભાગ્યવશ, આ અનુમાન કદાચ સંભવ નથી.
તમે તે વિનંતી કરી શકો છો કે જે ટર્મિનલ પરિમાણોની તેની ડિફૉલ્ટ સેટિંગને ઓવરરાઇડ ન કરવાની અપેક્ષા રાખે છે, પરંતુ આવા વાતાવરણ માટે સ્ક્રિપ્ટ્સ લખતી વખતે તમારે ખૂબ કાળજી રાખવી જોઈએ. ઇએક્સ્સના કિસ્સામાં, ઇકોઇંગ અને એન્ડ-ઓફ-લાઇન મેપિંગ્સ જેવી બાબતો પર આધારિત ટાળવા
આદેશો જે સ્વીકૃત દલીલોને એક સૂચિમાં જકડી રાખ્યા છે ( અપેક્ષિત ચલો અને ક્રિયાપ્રતિક્રિયા ) તે નક્કી કરવા માટે એક સંશોધનાત્મક ઉપયોગ કરે છે કે શું સૂચિ વાસ્તવમાં એક દલીલ અથવા ઘણા છે સંશોધનાત્મક માત્ર કિસ્સામાં નિષ્ફળ થઈ શકે છે જ્યારે સૂચિ વાસ્તવમાં એક જ દલીલ રજૂ કરે છે જે બહુવિધ એમ્બેડેડ હોય છે જે \ n તેમની વચ્ચેના બિન-સફેદ જગ્યા અક્ષરો સાથે છે. આ પૂરતા પ્રમાણમાં અસંભવ લાગે છે, જો કે દલીલ "-નોબ્રેસ" એક દલીલને નિયંત્રિત કરવા માટે એક દલીલને નિયંત્રિત કરવા માટે વાપરી શકાય છે. મશીનની જનરેટેડ અપેક્ષા કોડ સાથે આનો ઉપયોગ કલ્પનાયોગ્ય રીતે થઈ શકે છે. એ જ રીતે, -બ્રેસ એક જ દલીલને ઘણા પેટર્ન / ક્રિયાઓ તરીકે હેન્ડલ કરવા દબાણ કરે છે
બગ્સ
તે પ્રોગ્રામ "સેક્સ" (ક્યાં તો "સ્માર્ટ એક્સીક" અથવા "સેન્ડ-એક્સેટ") માટે નામ આપવાનું ખરેખર આકર્ષિત હતું, પરંતુ સારા અર્થમાં (અથવા કદાચ માત્ર પ્રાકૃતિકવાદ) પ્રચલિત છે.
કેટલીક સિસ્ટમો પર, જ્યારે શેલ ઉત્પન્ન થાય છે, તે ટીટીને ઍક્સેસ કરવામાં સક્ષમ ન હોવા વિશે ફરિયાદ કરે છે પરંતુ કોઈપણ રીતે ચાલે છે. આનો મતલબ તમારી સિસ્ટમમાં નિયંત્રણાત્મક tty મેળવવા માટેની પદ્ધતિ છે જે અપેક્ષા રાખતા નથી. તે શું છે તે શોધો અને મને આ માહિતી પાછા મોકલો.
અલ્ટીક્સ 4.1 (ઓછામાં ઓછું અહીંની તાજેતરની આવૃત્તિઓ) 1000000 થી વધુના સમયગાળાને 0 ની સમકક્ષ હોવાની ધારણા રાખે છે.
ડિજિટલ UNIX 4.0A (અને સંભવિત અન્ય આવૃત્તિઓ) જો તમે SIGCHLD હેન્ડલર વ્યાખ્યાયિત કરો છો તો પીટીસ ફાળવવાનો ઇનકાર કરે છે. વધુ માહિતી માટે ગ્રાન્ટ પૃષ્ઠ જુઓ.
IRIX 6.0 એ pty પરવાનગીઓને યોગ્ય રીતે હેન્ડલ કરી નથી તેથી જો કોઈ અન્ય વ્યક્તિ દ્વારા અગાઉ ઉપયોગમાં લેવાતી PTY ને ફાળવવાના પ્રયાસોની અપેક્ષા હોય, તો તે નિષ્ફળ જાય છે. IRIX 6.1 માં અપગ્રેડ કરો.
ટેલેનેટ (SunOS 4.1.2 હેઠળ ચકાસાયેલ) અટકી જાય છે જો TERM સેટ નથી. આ ક્રોન હેઠળ અને Cgi સ્ક્રિપ્ટ્સમાં એક સમસ્યા છે, જે TERM ને વ્યાખ્યાયિત કરતી નથી. આ રીતે, તમારે તેને સ્પષ્ટ રીતે સેટ કરવું પડશે - જે પ્રકાર સામાન્ય રીતે અપ્રસ્તુત છે. તે માત્ર કંઈક પર સુયોજિત કરી શકાય છે! મોટાભાગનાં કેસો માટે નીચેના કદાચ પૂરતા છે
સેટ એનવી (ટર્મ) vt100ટીપ (BSDI BSD / OS 3.1 i386 હેઠળ ચકાસાયેલ) અટકે છે જો SHELL અને હોમ સેટ નથી. આ ક્રેન હેઠળ અને CGI સ્ક્રિપ્ટ્સમાં એક સમસ્યા છે, જે આ પર્યાવરણ ચલોને વ્યાખ્યાયિત કરતી નથી. આ રીતે, તમારે તેને સ્પષ્ટ રીતે સેટ કરવો પડશે - જે પ્રકાર સામાન્ય રીતે અપ્રસ્તુત છે. તે માત્ર કંઈક પર સુયોજિત કરી શકાય છે! મોટાભાગનાં કેસો માટે નીચેના કદાચ પૂરતા છે
સેટ એનવી (SHELL) / bin / sh સેટ env (HOME) / usr / local / binપીઓટીઝના કેટલાક અમલીકરણો તૈયાર કરવામાં આવ્યા છે જેથી પ્રક્રિયામાં ફાઇલ વર્ણનકર્તા બંધ થઈ ગયા પછી કર્નેલ 10 થી 15 સેકંડ (વાસ્તવિક સંખ્યા અમલીકરણ-આધારિત હોય) પછી કોઈપણ ન વાંચેલા આઉટપુટને ફેંકી દે છે. આમ કાર્યક્રમો જેમ કે અપેક્ષા
spawn date sleep 20 અપેક્ષાનિષ્ફળ જશે. આને અવગણવા માટે, અજાણ્યા વગર બિન-અરસપરસ કાર્યક્રમો ચલાવો . આ પ્રકારની પરિસ્થિતિઓ કલ્પનાશીલ હોવા છતાં, વ્યવહારમાં, મને એવી પરિસ્થિતિનો ક્યારેય સામનો કરવો પડ્યો નથી કે જેમાં આ વર્તનને કારણે ખરેખર અરસપરસ પ્રોગ્રામના અંતિમ ઉત્પાદન ખોવાઈ જશે.
બીજી તરફ, ક્રે યુનિકોસ પીટીયસે પ્રક્રિયાને ફાઇલ ડિસ્ક્રીપ્ટર બંધ કર્યા પછી તરત જ કોઈ ન વાંચેલ આઉટપુટ ફેંકી દીધું છે. મેં ક્રેને આની જાણ કરી છે અને તેઓ ઠીક પર કામ કરી રહ્યા છે.
પ્રોમ્પ્ટ અને પ્રતિક્રિયા વચ્ચે ક્યારેક વિલંબ જરૂરી છે, જેમ કે જ્યારે ટીએટીઆઇ ઇન્ટરફેસ શરૂઆત / સ્ટોપ બિટ્સની શોધ દ્વારા યુઆરએર્ટ સેટિંગ્સ અથવા બંધબેસતા બૉડ દરો બદલી રહી હોય. સામાન્ય રીતે, આ બધાને સેકંડ કે બે માટે ઊંઘવાની જરૂર છે. વધુ મજબૂત ટેકનિક એ છે કે જ્યાં સુધી હાર્ડવેર ઇનપુટ પ્રાપ્ત કરવા માટે તૈયાર ન થાય ત્યાં સુધી ફરી પ્રયાસ કરો. નીચેના ઉદાહરણ બંને વ્યૂહરચનાઓનો ઉપયોગ કરે છે:
"ઝડપ 9600 \ r" મોકલો; ઊંઘ 1 અપેક્ષા {સમયસમાપ્તિ {મોકલવા "\ r"; exp_continue} $ પ્રોમ્પ્ટ}trap -code કોઈપણ આદેશ સાથે કામ કરશે નહીં જે Tcl ના ઇવેન્ટ લૂપમાં આવે છે, જેમ કે ઊંઘ. સમસ્યા એ છે કે ઇવેન્ટ લૂપમાં, Tcl એ async ઇવેન્ટ હેન્ડલર્સના વળતર કોડને કાઢી નાંખે છે. એક ઉકેલ એ છટકું કોડમાં ધ્વજ સેટ કરવાનો છે. પછી તરત જ આદેશ (એટલે કે, ઊંઘ) પછી ધ્વજ તપાસો.
અપેક્ષા_બેકગ્રાઉન્ડ કમાન અવગણશે-સમયસમાપ્તિ દલીલો અને સામાન્ય રીતે સમય સમાપ્તિની કોઈ ખ્યાલ નથી.
& # 34; અપેક્ષિત સંકેતો & # 34;
અપેક્ષિત વિશે કેટલીક વસ્તુઓ છે કે જે બિન-સાહજિક હોઈ શકે છે. આ વિભાગ કેટલાક સૂચનો સાથે આમાંની કેટલીક બાબતોને સંબોધિત કરવાનો પ્રયાસ કરે છે
સામાન્ય અપેક્ષા સમસ્યા એ છે કે શેલ પ્રોમ્પ્ટ્સને કેવી રીતે ઓળખવું. કારણ કે આ અલગ અલગ લોકો અને જુદા જુદા શેલ્સ દ્વારા અલગથી બદલાય છે, પ્રોમ્પ્ટને જાણ્યા વિના પોર્ટેબલ સ્વયંસંચાલિત રૉગ્ઝીન મુશ્કેલ બની શકે છે. વાજબી સંમેલન એ છે કે વપરાશકર્તાઓ પર્યાય ચલ EXPECT_PROMPT માં તેમના પ્રોમ્પ્ટ (ખાસ કરીને, તે ઓવરને) વર્ણવતા નિયમિત સમીકરણ સંગ્રહિત કરે. નીચેની જેમ કોડનો ઉપયોગ કરી શકાય છે. જો EXPECT_PROMPT અસ્તિત્વમાં નથી, તો કોડને યોગ્ય રીતે કાર્ય કરવાની એક સારી તક છે.
સેટ પ્રોમ્પ્ટ "(% | | | | | $ $ $ $) $ #; # ડિફૉલ્ટ પ્રોમ્પ્ટ કેચ {સેટ પ્રોમ્પ્ટ $ env (EXPECT_PROMPT)} અપેક્ષા -re $ પ્રોમ્પ્ટહું તમને એવી અપેક્ષાઓ લખી આપવા પ્રોત્સાહિત કરું છું કે જેમાં તમે જે અપેક્ષા રાખશો તેને સમાપ્ત કરો. આ સમગ્ર વસ્તુને જોતાં પહેલાં પ્રશ્નનો જવાબ આપવાની શક્યતા ટાળે છે. વધુમાં, જ્યારે તમે તેમને સંપૂર્ણપણે જોતાં પહેલાં પ્રશ્નોના જવાબ આપવા સક્ષમ થઈ શકો છો, જો તમે પ્રારંભમાં જવાબ આપો છો, તો તમારો જવાબ પ્રશ્નના મધ્ય ભાગમાં દેખાશે. અન્ય શબ્દોમાં, પરિણામી સંવાદ યોગ્ય હશે પરંતુ મૂંઝાયેલું જુઓ.
સૌથી પ્રોમ્પ્ટ્સમાં અંતમાં એક જગ્યા પાત્રનો સમાવેશ થાય છે ઉદાહરણ તરીકે, એફટીપીમાંથી પ્રોમ્પ્ટ 'એફ', 'ટી', 'પી', '>' અને છે. આ પ્રોમ્પ્ટને મેચ કરવા માટે, તમારે આ દરેક અક્ષરો માટે એકાઉન્ટ કરવું આવશ્યક છે. આ એક સામાન્ય ભૂલ છે કે ખાલી જગ્યાને શામેલ ન કરવી. સ્પષ્ટપણે ખાલી જગ્યા મૂકો.
જો તમે ફોર્મ X * ના પેટર્નનો ઉપયોગ કરો છો, તો * X ના અંતે પ્રાપ્ત થયેલી છેલ્લી વસ્તુથી મળેલ તમામ આઉટપુટને મેચ કરશે. આ સાહજિક લાગે છે પરંતુ કંઈક અંશે ગૂંચવણભર્યું હોઇ શકે છે કારણ કે કર્નલ અને ઉપકરણ ડ્રાઇવર દ્વારા કમ્પ્યુટરની ઝડપ અને I / O ની પ્રક્રિયાને આધારે "છેલ્લા વસ્તુ પ્રાપ્ત થઈ" શબ્દસમૂહ અલગ અલગ હોઈ શકે છે.
ખાસ કરીને, મોટા ભાગની પ્રોગ્રામ્સ એક સમયે એક રેખા ઉત્પાદન કરે છે ત્યારે મોટાભાગની હિસ્સામાં (એટોમલી) પહોંચે છે તેવો માનવો જોવા મળે છે. એમ ધારી રહ્યા છીએ કે આ કેસ છે, * અગાઉના ફકરોની પેટર્નમાં * વર્તમાન રેખાના અંતની મેચ થઈ શકે છે, જોકે તે વધુ લાગે છે, કારણ કે મેચ સમયે તે પ્રાપ્ત થઈ છે તે તમામ આઉટપુટ છે.
અપેક્ષા એ નથી જાણવાની કોઈ રીત નથી કે વધુ ઉત્પાદન આવી રહ્યું છે જ્યાં સુધી તમારી પેટર્ન ખાસ રીતે તે માટે જવાબદાર નથી.
રેખા-લક્ષી બફરીંગ પર પણ નિર્વિવાદ છે. કાર્યક્રમોમાં ભાગ્યે જ બફરીંગના પ્રકાર વિશે વચનો આપતા નથી, પરંતુ સિસ્ટમ અપચો આઉટપુટ લાઇનોને તોડી શકે છે જેથી લીટીઓ મોટે ભાગે રેન્ડમ સ્થાનોમાં ભંગ કરે છે. આમ, જો તમે પેટર્ન લખતા પ્રોમ્પ્ટના છેલ્લા કેટલાંક અક્ષરોને વ્યક્ત કરી શકો છો, તો આવું કરવું શાણા છે.
જો તમે પ્રોગ્રામનાં છેલ્લા આઉટપુટમાં પેટર્નની રાહ જોતા હો અને પ્રોગ્રામ તેના બદલે કંઈક બીજું ઉત્સર્જન કરે છે, તો તમે તે સમયના કીવર્ડ સાથે શોધી શકશો નહીં. કારણ એ છે કે અપેક્ષા સમયસમાપ્તિ નથી - તેના બદલે તેને એક ઇઓઈડ સંકેત મળશે. તેનો ઉપયોગ તેના બદલે. વધુ સારું, બન્નેનો ઉપયોગ કરો. એ રીતે જો તે રેખા ક્યારેય આસપાસ ખસેડવામાં આવી છે, તો તમારે વાક્ય પોતે સંપાદિત કરવું પડશે નહીં.
ન્યૂલાઇન્સ સામાન્ય રીતે વાહન વળતરમાં રૂપાંતરિત થાય છે, લાઇનફિડ સિક્વન્સ જ્યારે ટર્મિનલ ડ્રાઇવર દ્વારા આઉટપુટ થાય છે. આ રીતે, જો તમે એક પેટર્ન ઇચ્છતા હોવ, જે સ્પષ્ટપણે બે રેખાઓ સાથે મેળ ખાય છે, કહે છે, printf ("foo \ nbar"), તો તમારે પેટર્ન "foo \ r \ nbar" નો ઉપયોગ કરવો જોઈએ.
એક સમાન ભાષાંતર ત્યારે થાય છે જ્યારે વપરાશકર્તા દ્વારા વાંચવામાં આવે છે , expect_user દ્વારા. આ કિસ્સામાં, જ્યારે તમે રીટર્ન દબાવો છો, તેનો અનુવાદ એક નવી લાઇનમાં કરવામાં આવશે. જો ઇચ્છા હોય તો તે પ્રોગ્રામને પસાર થાય છે જે તેના ટર્મિનલને કાચી સ્થિતિમાં (જેમ કે ટેલનેટ) સુયોજિત કરે છે, ત્યાં એક સમસ્યા થવાની શક્યતા છે, કારણ કે પ્રોગ્રામ સાચા વળતરની અપેક્ષા રાખે છે. (કેટલાક પ્રોગ્રામ ખરેખર માફ કરવામાં આવે છે કે તેઓ આપોઆપ નવી લાઇન્સને રીટર્નમાં અનુવાદિત કરશે, પરંતુ મોટાભાગના નથી.) દુર્ભાગ્યપણે, કોઈ પ્રોગ્રામ તેના ટર્મિનલને કાચી સ્થિતિમાં મૂકવા માટે કોઈ રીત નથી.
નવી લાઇનોને જાતે વળતર સાથે જાતે બદલે, ઉકેલ "stty raw" આદેશનો ઉપયોગ કરવો, જે અનુવાદને બંધ કરશે. નોંધ, તેમછતાં, તેનો અર્થ એ કે તમે રાંધેલા રેખા-સંપાદન સુવિધાઓ પ્રાપ્ત કરશો નહીં.
ક્રિયાપ્રતિક્રિયા કરીને તમારા ટર્મિનલને કાચી સ્થિતિમાં સુયોજિત કરે છે તેથી આ સમસ્યા ઊભી થશે નહીં.
સ્ક્રિપ્ટ્સની અપેક્ષા રાખવામાં પાસવર્ડ્સ (અથવા અન્ય ખાનગી માહિતી) સંગ્રહવા માટે ઘણીવાર ઉપયોગી છે. આને ભલામણ કરવામાં આવતી નથી કારણ કે કમ્પ્યુટર પર સંગ્રહિત કોઈપણ વસ્તુ કોઈને પણ એક્સેસ કરવા માટે શંકાસ્પદ છે. આ રીતે, સ્ક્રીપ્ટમાંથી પાસવર્ડ્સ માટે ક્રિયાપ્રતિક્રિયાપૂર્વક સંકેત આપવી એ શાબ્દિક રીતે એમ્બેડ કરવા કરતાં એક સ્માર્ટ વિચાર છે તેમ છતાં, કેટલીકવાર આવા એમ્બેડિંગ એ એકમાત્ર શક્યતા છે.
કમનસીબે, UNIX ફાઇલસિસ્ટમ પાસે સ્ક્રિપ્ટ્સ બનાવવાનું કોઈ સીધો માર્ગ નથી કે જે એક્ઝેક્યુટેબલ છે પરંતુ વાંચવા યોગ્ય નથી. સિસ્ટમ્સ જે setgid શેલ સ્ક્રિપ્ટોને આધાર આપે છે આડકતરી રીતે નીચે પ્રમાણે આનું અનુકરણ કરી શકે છે:
હંમેશની જેમ ઈચ્છો સ્ક્રિપ્ટ (જેમાં ગુપ્ત ડેટા છે) બનાવો. તેની પરવાનગીઓ 750 (-આરડબલ્યુ-એક્સ -400) હોવી જોઇએ અને વિશ્વાસુ સમૂહની માલિકી છે, એટલે કે, તે જૂથને તે વાંચવાની મંજૂરી છે. જો જરૂરી હોય, તો આ હેતુ માટે એક નવું જૂથ બનાવો. આગળ, પરવાનગીઓ 2751 (-rwxr -s -x) સાથેની એક / bin / sh સ્ક્રિપ્ટ બનાવો જે પહેલા સમાન ગ્રુપની માલિકીની છે.
પરિણામ એ સ્ક્રીપ્ટ છે જે કોઈપણ દ્વારા ચલાવવામાં (અને વાંચી) થઈ શકે છે. જ્યારે બોલાવવામાં આવે, ત્યારે તે Expect script ચલાવે છે.
& # 34; પણ જુઓ & # 34;
Tcl (3), libexpect (3)
ડોન લિબ્સ, પીપી. 602, આઇએસબીએન 1-56592-090-2, ઓ'રેઈલી એન્ડ એસોસિએટ્સ, 1995 દ્વારા "એક્સપ્લોરીંગ ઇમ્પેક્ટ: એ ટીસીએલ-આધારિત ટૂલકીટ ફોર ઓટોમેટીંગ ઇન્ટરેક્ટિવ પ્રોગ્રામ્સ" .
ડોન લબ્સ દ્વારા "અપેક્ષિત છે: ઇન્ટરએક્ટિવિટીના તે અનિયંત્રિત ફીટસનો ઉપચાર", સમર 1990 ની સંભાવનાની કાર્યવાહી, અનાહેમ, કેલિફોર્નિયા, જૂન 11-15, 1990.
.હું ડોન લબ્સ દ્વારા "સિસ્ટમ એડમિનિસ્ટ્રેશન ટર્મ્સ સ્વયંસંચાલિત થવાની અપેક્ષા વાપરીને", 1990 ની યુનિટિક્સ મોટી ઇન્સ્ટોલેશન સિસ્ટમ્સ એડમિનિસ્ટ્રેશન કોન્ફરન્સ, કોલોરાડો સ્પ્રિંગ્સ, કોલોરાડો, ઓક્ટોબર 17-19, 1990 ની કાર્યવાહી.
.હું "ટીસીએલ: એન એમ્બેડેબલ કમાન્ડ લેન્ગવેજ" જેન ઓસ્ટરહૌટ દ્વારા, શિયાળુ 1990 ની યુએસએનક્સ પરિષદની કાર્યવાહીઓ, વોશિંગ્ટન, ડીસી, જાન્યુઆરી 22-26, 1990. હું "અપેક્ષા: ઇન્ટરેક્ટિવ પ્રોગ્રામ્સ પર નિયંત્રણ માટે સ્ક્રિપ્ટો" ડોન લિબ્સ, કમ્પ્યુટિંગ સિસ્ટમ્સ દ્વારા , વોલ્યુમ. 4, નં. 2, યુનિવર્સિટી ઓફ કેલિફોર્નિયા પ્રેસ જર્નલ્સ, નવેમ્બર 1991 .. હું "રીગ્રેસન ટેસ્ટિંગ એન્ડ કોનફોર્મન્સ ટેસ્ટિંગ ઇન્ટરેક્ટિવ પ્રોગ્રામ્સ", ડોન લબ્સ દ્વારા, સમર 1992 ની કાર્યવાહી, યુએસએનિક્સ પરિષદ, પીપી. 135-144, સાન એન્ટોનિયો, ટેક્સાસ, જૂન 12-15, 1992 .. હું "કિબિત્ઝ - કનેક્ટીંગ મલ્ટીપલ ઇન્ટરેક્ટિવ પ્રોગ્રામ્સ એકઠું", ડોન લિબ્સ દ્વારા, સોફ્ટવેર - પ્રેક્ટિસ એન્ડ એક્સપિરિયન્સ, જ્હોન વિલે એન્ડ સન્સ, વેસ્ટ સસેક્સ, ઈંગ્લેન્ડ, વોલ્યુમ.
23, નંબર 5, મે, 1993 .. હું "ડબ્લ્યુજીર ફોર ટીક્લલ એપ્લીકેશન્સ", ડોન લબ્સ દ્વારા, 1993 ટીસીએલ / ટીએચ વર્કશોપની કાર્યવાહી, બર્કલી, સીએ, જૂન 10-11, 1993.
AUTHOR
ડોન લિબ્સ, નેશનલ ઇન્સ્ટિટ્યૂટ ઑફ સ્ટાન્ડર્ડ્સ એન્ડ ટેકનોલોજી
સ્વીકાર્યાં
પ્રેરણાદાયી માટે જ્હોન ઓસ્ટરહૌટ ફોર ટીક્લ, અને સ્કોટ પેઝલી માટે આભાર. અપેક્ષિતના સ્વતઃરૂપરેખાંકન કોડ માટે રોબ સેવોયને આભાર.
હિસ્ટરી ફાઇલ મોટાભાગની ઉત્ક્રાંતિની અપેક્ષા કરે છે . તે રસપ્રદ વાંચન કરે છે અને તમને આ સૉફ્ટવેર પર વધુ માહિતી આપી શકે છે તેમાં ઉલ્લેખ કરનારા લોકોનો આભાર કે જેમણે મને બગ ફિક્સેસ મોકલ્યું અને અન્ય સહાય આપી.
યુ.એસ. સરકાર દ્વારા ભાગમાં ભાગ લેવા માટે ડિઝાઇન અને અમલીકરણનું અમલીકરણ કરવામાં આવ્યું હતું અને તેથી તે જાહેર ડોમેનમાં છે. જો કે લેખક અને NIST ક્રેડિટ જો ઈચ્છે તો આ પ્રોગ્રામ અને દસ્તાવેજીકરણ અથવા તેના ભાગનો ઉપયોગ કરવામાં આવે છે.