ఆశించే ఒక స్క్రిప్ట్ ప్రకారం ఇతర ఇంటరాక్టివ్ కార్యక్రమాలు మాట్లాడే కార్యక్రమం. స్క్రిప్ట్ తర్వాత, ఎక్స్పెక్టరు ఒక కార్యక్రమంలో ఏది చేయగలదో తెలుసుకోగలదు మరియు సరైన స్పందన ఏమిటో తెలుసుకోవాలి. ఒక వివరణాత్మక భాష డైలాగ్ దర్శకత్వం కోసం శాఖలు మరియు ఉన్నత-స్థాయి నియంత్రణ నిర్మాణాలను అందిస్తుంది. అదనంగా, వినియోగదారు నియంత్రణలోకి రావడం మరియు నేరుగా స్క్రిప్ట్కు నియంత్రణను తిరిగి పొందడం ద్వారా నేరుగా సంకర్షణ చేయవచ్చు.
ఎక్స్పెక్టెక్ అనేది ఎక్స్పెక్ట్ అండ్ టికె యొక్క మిశ్రమం. ఇది ఎక్స్పెక్ట్ మరియు TK కోరికల వలె ప్రవర్తిస్తుంది. ఆశించటం నేరుగా T లేదా T లేకుండా C లేదా C ++ లో ఉపయోగించవచ్చు.
Uucp, kermit మరియు ఇతర మోడెమ్ నియంత్రణ కార్యక్రమాలు ద్వారా ప్రాచుర్యం పొందిన సీక్వెన్సులను పంపు / ఆశించే ఆలోచన నుండి "ఆశించటం" అనే పేరు వచ్చింది. అయితే Uucp వలె కాకుండా, ఆశించినది సాధారణమైనది, తద్వారా అది ఏదైనా ప్రోగ్రామ్ మరియు పనిలో మనసులో ఉన్న వినియోగదారు స్థాయి ఆదేశం వలె అమలు చేయబడుతుంది. అదే సమయంలో అనేక కార్యక్రమాలు మాట్లాడవచ్చు.
ఏమి చేయగలరో ఆశించవచ్చు
ఉదాహరణకు, ఆశించే ఆదేశం చేయగల కొన్ని విషయాలు ఇక్కడ ఉన్నాయి:
- మీ కంప్యూటర్ను తిరిగి కాల్చడానికి మీ కంప్యూటర్ను సృష్టించండి, అందువల్ల మీరు కాల్ కోసం చెల్లించకుండా లాగ్ ఇన్ చేయవచ్చు.
- ఒక ఆట ప్రారంభించండి మరియు ఆప్టిమల్ ఆకృతీకరణ కనిపించకపోతే, అది మరలా మరలా పునఃప్రారంభించబడుతుంది), ఆపై మీకు నియంత్రణను అప్పగించండి.
- Fsck రన్ మరియు దాని ప్రశ్నలకు ప్రతిస్పందనగా, ముందుగా నిర్ణయించిన ప్రమాణాల ఆధారంగా, "అవును" లేదా "లేదు" లేదా మీకు నియంత్రణను ఇవ్వండి.
- మరొక నెట్వర్క్కి కనెక్ట్ అవ్వండి మరియు స్వయంచాలకంగా మీ మెయిల్ను తిరిగి అందుకోండి అందువల్ల ఇది మీ స్థానిక సిస్టమ్కు మొదట పంపినట్లుగా కనిపిస్తుంది.
- ఎన్విరాన్మెంట్ వేరియబుల్స్, కరెంట్ డైరెక్టరీ లేదా రాంగ్లైన్, టెల్నెట్, టిప్, su , లేదా chgrp
షెల్ ఈ పనులను ఎందుకు చేయలేకపోతుందనే అనేక కారణాలు ఉన్నాయి. అన్ని ఆశించే తో సాధ్యమే.
సాధారణంగా, ప్రోగ్రాం మరియు వినియోగదారు మధ్య పరస్పర చర్య అవసరమయ్యే ఏదైనా ప్రోగ్రామ్ను అమలు చేయడానికి ఉపయోగపడుతుంది. అవసరమైన అన్ని పరస్పర programmatically కలిగి ఉంటుంది. ఆశించే కార్యక్రమం నియంత్రణను నిలిపివేయకుండా వినియోగదారుకు నియంత్రణను కూడా ఇవ్వవచ్చు. అదేవిధంగా, వినియోగదారు ఎప్పుడైనా స్క్రిప్ట్కు నియంత్రణను తిరిగి పొందవచ్చు.
వాడుక
నిర్వహించడానికి ఆదేశాల జాబితా కోసం cmdfile చదువుతాము. # మద్దతివ్వగల వ్యవస్థలపై అనుమానాస్పదంగా ఉండవచ్చు! లిపి స్క్రిప్ట్ ను ఎక్జిక్యూటబుల్గా గుర్తించి స్క్రిప్టులో మొదటి పంక్తిని చేస్తూ:
#! usr / local / bin / expect -fవాస్తవానికి, జీవితాలను ఆశించే ఎక్కడ ఖచ్చితంగా మార్గం వివరించాలి. / usr / local / bin ఒక ఉదాహరణ.
-c ఫ్లాగ్ స్క్రిప్ట్లో ఏదైనా ముందు అమలు చేయవలసిన ఆదేశాన్ని ప్రస్తావిస్తుంది. షెల్ విచ్ఛిన్నం చేయకుండా నిరోధించడానికి ఆదేశం కోట్ చేయాలి. ఈ ఐచ్చికము చాలా సార్లు వాడవచ్చు. పలు ఆదేశాలను సెమికోలన్లతో వేరు చేసి ఒకే-సితో అమలు చేయవచ్చు. ఆదేశాలు కనిపించే క్రమంలో అమలు చేయబడతాయి. Expectk ను వాడుతున్నప్పుడు, ఈ ఐచ్ఛికం -command గా తెలుపబడుతుంది.
-d జెండా కొన్ని విశ్లేషణ అవుట్పుట్ను ప్రారంభిస్తుంది, ఇది ప్రధానంగా ఆశించే మరియు సంకర్షణ వంటి ఆదేశాల అంతర్గత కార్యాచరణను నివేదిస్తుంది. ఈ ఫ్లాగ్ ఒక ఎక్స్ప్ట్ స్క్రిప్ట్ ప్రారంభంలో "exp_internal 1" వలె అదే ప్రభావాన్ని కలిగి ఉంటుంది, అంతేకాక ఆశించిన సంస్కరణ ముద్రించబడుతుంది.
-D ఫ్లాగ్ ఇంటరాక్టివ్ డీబగ్గర్ను ప్రారంభిస్తుంది. పూర్ణాంకం విలువ అనుసరించాలి. విలువ సున్నా కానిది లేదా ఒక ^ సి నొక్కినప్పుడు లేదా బ్రేక్పాయింట్ని కొట్టినట్లయితే లేదా ఇతర తగిన డీబగ్గర్ ఆదేశం స్క్రిప్ట్లో కనిపిస్తే డీబగ్గర్ తదుపరి Tcl విధానానికి ముందు నియంత్రణలోకి వస్తుంది. Expectk ను ఉపయోగించినప్పుడు, ఈ ఐచ్చికము డీబగ్ గా పేర్కొనబడింది.
-f ఫ్లాగ్ ఆదేశాలను చదివిన ఒక ఫైల్ను ఇష్టపడుతోంది. # ఉపయోగించినప్పుడు ఇది ఉపయోగకరంగా ఉన్నందున జెండా కూడా ఐచ్ఛికం! సంజ్ఞామానం, కాబట్టి ఇతర వాదనలు ఆదేశ పంక్తిలో సరఫరా చేయబడతాయి. Expectk ను ఉపయోగించినప్పుడు, ఈ ఐచ్చికం -ఫైల్ గా పేర్కొనబడింది.
అప్రమేయంగా, కమాండ్ ఫైలు మెమొరీ లోకి చదవబడుతుంది మరియు దాని మొత్తంలో అమలు అవుతుంది. ఇది ఒక సమయంలో ఒక లైన్ ఫైల్లను చదవడానికి అప్పుడప్పుడూ అవసరం. ఏకపక్ష ఫైళ్ళను ఈ విధంగా నిర్వహించటానికి, -b జెండాని వాడండి. Expectk ను ఉపయోగిస్తున్నప్పుడు, ఈ ఐచ్ఛికం -బఫర్గా పేర్కొనబడింది.
స్ట్రింగ్ "-" ఒక ఫైల్ పేరుగా సరఫరా చేయబడితే, ప్రామాణిక ఇన్పుట్ బదులుగా చదవబడుతుంది. వాస్తవానికి "-" అనే ఫైల్ నుండి చదవటానికి "./-" ఉపయోగించండి.
-i ఫ్లాగ్ కారణమవుతుంది ఆదేశాలకు ఇంటరాక్టివ్గా ప్రాంప్ట్ చేయడమే కాకుండా ఫైల్ను చదవటానికి బదులుగా. నిష్క్రమణ ఆదేశం లేదా EOF ద్వారా ప్రాంప్ట్ చేయబడుతుంది. కమాండ్ ఫైల్ లేదా -c ఉపయోగించబడకపోతే -i ఫ్లాగ్ ఊహిస్తుంది. Expectk ను వాడుతున్నప్పుడు, ఈ ఐచ్చికము -ఇంటర్నటివ్ గా తెలుపబడును.
- ఎంపికల ముగింపుని డీలిమిట్ చేయడానికి ఉపయోగించవచ్చు. మీ లిపికి ఎక్స్ప్రెస్ ద్వారా వ్యాఖ్యానించకుండా ఒక ఐచ్ఛికం వంటి ఆర్గ్యుమెంట్ను మీరు పాస్ చేయాలనుకుంటే ఇది ఉపయోగపడుతుంది. ఈ ఉపయోగకరమైన # లో ఉంచవచ్చు! ఎక్స్పెక్ట్ ద్వారా ఏవిధమైన ఫ్లాగ్లాగ్ అన్వయింపును నివారించడానికి. ఉదాహరణకు, కింది వాల్యూమ్ argv లో స్క్రిప్ట్ పేరుతో అసలు వాదనలు వదిలి.
#! usr / local / bin / expect -వాదనలు జోడించడం ఉన్నప్పుడు సాధారణ getopt (3) మరియు అమలు (2) కన్వెన్షన్లు గమనించండి గమనించండి #! లైన్.
$ Exp_library / expect.rc ఫైలు -N జెండా ఉపయోగించకపోతే, స్వయంచాలకంగా అందించబడుతుంది. (Expectk ని వాడుతున్నప్పుడు, ఈ ఐచ్ఛికం -NORC గా పేర్కొనబడింది.) వెంటనే దీని తర్వాత, -n. జెండా ఉపయోగించబడకపోతే, ఫైల్ ~ ~ / .expect.rc స్వయంచాలకంగా మూలం అవుతుంది. ఎన్విరాన్మెంట్ వేరియబుల్ DOTDIR నిర్వచించబడితే, అది ఒక డైరెక్టరీగా పరిగణించబడుతుంది మరియు అక్కడ నుండి ఎక్స్పెక్టరేట్. Expectk ను ఉపయోగించినప్పుడు, ఈ ఐచ్చికం -norc గా పేర్కొనబడింది. ఈ సోర్సింగ్ ఏ-సి ఫ్లాగ్లను అమలు చేసిన తర్వాత మాత్రమే జరుగుతుంది.
-v కారణమవుతుంది దాని వెర్షన్ సంఖ్య మరియు నిష్క్రమణ ప్రింట్ భావిస్తున్నారు. దీర్ఘ జెండా పేర్లను ఉపయోగించే ఎక్స్పెక్టక్లో సంబంధిత జెండా, -వెర్షన్.
Optional args ఒక జాబితాలో నిర్మించబడ్డాయి మరియు varv అనే పేరుతో నిల్వ చేయబడతాయి. argc సున్నా పొడవున ప్రారంభించబడుతుంది.
స్క్రిప్ట్ లేదా బైనరీ పేరు స్క్రిప్ట్ ఉపయోగించబడకపోతే Argv0 నిర్వచించబడింది. ఉదాహరణకు, క్రింది స్క్రిప్ట్ పేరు మరియు మొదటి మూడు వాదనలు ముద్రిస్తుంది:
send_user "$ argv0 [lrange $ argv 0 2] \ n"ఆదేశాలు
టూల్ కమాండ్ లాంగ్వేజ్ను ఉపయోగించుకోవచ్చని ఆశించండి. TCL నియంత్రణ ప్రవాహాన్ని అందిస్తుంది (ఉంటే, విరామం కోసం), వ్యక్తీకరణ మూల్యాంకనం మరియు పునరావృత ప్రక్రియ నిర్వచనం వంటి అనేక ఇతర లక్షణాలు. ఇక్కడ ఉపయోగించిన ఆదేశాలు కానీ నిర్వచించబడలేదు (సెట్, ఉంటే, ఎగ్నిషన్) టికెసి ఆదేశాలు. అదనపు ఆదేశాలను మద్దతిస్తుంది. పేర్కొనకపోతే తప్ప, ఆదేశాలు ఖాళీ స్ట్రింగ్ను తిరిగి పంపుతాయి.
కమాండ్లు అక్షర క్రమంలో జాబితా చేయబడ్డాయి, తద్వారా అవి త్వరగా ఉంటున్నాయి. అయినప్పటికీ, ఆ క్రమంలో, స్పాన్ యొక్క వర్ణనలను చదవడం, పంపడం, ఆశించడం మరియు పరస్పర చర్య చేయడం ద్వారా కొత్త వినియోగదారులు ప్రారంభించడం సులభం కావచ్చు.
దగ్గరగా [-slave] [-onexec 0 | 1] [-i spawn_id]ప్రస్తుత ప్రక్రియకు కనెక్షన్ను మూసివేస్తుంది. చాలా ఇంటరాక్టివ్ ప్రోగ్రామ్లు EOF ను వారి స్టాండ్ మరియు నిష్క్రమణలో గుర్తించాయి; అందువల్ల సాధారణంగా ప్రక్రియను చంపడానికి సంతృప్తి పరుస్తుంది. పేరు- spin_id కు అనుగుణంగా మూసివేసే ప్రక్రియను -i ఫ్లాగ్ ప్రకటించింది.
ప్రస్తుత ప్రక్రియ నిష్క్రియాత్మకమైనప్పుడు మరియు సంపూర్ణంగా సన్నిహితంగా ఉన్నప్పుడు గుర్తించి, పరస్పరం సంభవిస్తుంది, కానీ మీరు ప్రక్రియను చంపినట్లయితే, "exec $ kill" చంపడానికి, మీరు స్పష్టంగా దగ్గరగా కాల్ చేయాలి .
స్పాన్ ఐ id మూసివేయబడినా లేదా ప్రక్రియ అతివ్యాప్తి చేయబడినా లేదో -onxec జెండా నిర్ణయిస్తుంది. ఒక స్పాన్ ఐడిని తెరిచి ఉంచడానికి, విలువ 0 ను ఉపయోగించండి. ఏ కొత్త ప్రక్రియల్లో స్పాన్ మూసివేయబడిన సున్నా-కాని పూర్ణసంఖ్య విలువను బలవంతం చేస్తుంది.
స్పాన్ ఐడితో అనుబంధించబడిన బానిసను స్లావ్ జెండా మూసిస్తుంది. కనెక్షన్ మూసివేయబడినప్పుడు, బానిస అది ఇంకా తెరిస్తే స్వయంచాలకంగా మూసివేయబడుతుంది.
కనెక్షన్ నిశ్శబ్దంగా లేదా స్పష్టంగా మూసివేయబడినా, మీరు కెర్నల్ ప్రాసెస్ స్లాట్ను క్లియర్ చేయడానికి వేచి ఉండండి. ప్రాసెస్ కనెక్షన్ మూసివేయడం వలన అది నిష్క్రమించడానికి కారణం లేనందున సమీప ఆదేశం వేచి ఉండదు.
డీబగ్ [[-now] 0 | 1]మీరు Tcl డీబగ్గర్ని ప్రకటనలు మరియు సెట్ బ్రేక్ పాయింట్స్ ద్వారా వెళ్ళడానికి అనుమతిస్తుంది.
డీబగ్గర్ రన్ చేయకపోతే వాదనలు లేకుండా, ఒక 1 తిరిగి ఉంటే, లేకపోతే 0 తిరిగి వస్తుంది.
1 వాదనతో డీబగ్గర్ ప్రారంభమైంది. 0 వాదనతో డీబగ్గర్ నిలిపివేయబడింది. ఒక 1 వాదన ముందే -ఇతర జెండా చేస్తే, డీబగ్గర్ వెంటనే ప్రారంభమవుతుంది. లేకపోతే, డీబగ్గర్ తదుపరి Tcl స్టేట్మెంట్తో ప్రారంభించబడుతుంది.
డీబగ్ ఆదేశం ఏ ఉచ్చులను మార్చదు. -D జెండాతో ఆశించటం మొదలు పెట్టండి.
డిస్కనెక్ట్ కమాండ్ టెర్మినల్ నుండి ఫోర్క్డ్ ప్రాసెస్ను డిస్కనెక్ట్ చేస్తుంది. ఇది నేపథ్యంలో కొనసాగుతూనే ఉంది. ప్రక్రియ తన సొంత ప్రక్రియ సమూహం ఇవ్వబడుతుంది. ప్రామాణిక I / O ను / dev / null కు మళ్ళించబడుతుంది.
నేపథ్యంలో స్క్రిప్ట్ను కొనసాగించడం కొనసాగించడానికి క్రింది భాగం ఉపసంహరించుకుంటుంది.
{[ఫోర్క్] ఉంటే! = 0} డిస్కనెక్ట్ నిష్క్రమించండి. . .కింది స్క్రిప్ట్ పాస్ వర్డ్ ను చదువుతుంది మరియు ప్రతి సారి ఇది నడుపుతున్న ప్రతిసారీ పాస్ వర్డ్ ను డిమాండ్ చేసే ఒక ప్రోగ్రామ్ను నడుపుతుంది. స్క్రిప్ట్ పాస్ వర్డ్ ను అందిస్తుంది, తద్వారా మీరు దానిని ఒకసారి మాత్రమే టైప్ చేయాలి.
send_user "password? \" expect_user -re "(. *) \ n" {{fork] = {fork] = = "{నిద్ర 3600; కొనసాగించు} స్పాన్ priv_prog ను డిస్కనెక్ట్ చేస్తాను. 1, స్ట్రింగ్) \ r ". . . నిష్క్రమణషెల్ ఎసిన్క్రోనస్ ప్రాసెస్ విశేషణం (&) పై డిస్కనెక్ట్ను ఉపయోగించడం అనేది ఒక ప్రయోజనం, అనగా ముందుగా టెర్మినల్ పారామితులను టెలికమ్యూనికేషన్స్ సేవ్ చేయగలదు మరియు తర్వాత వాటిని కొత్త ptys కు వర్తిస్తాయి. & తో, టెర్మినల్ అప్పటికే డిస్కనెక్ట్ అయినందున టెర్మినల్ యొక్క పారామితులను చదవటానికి అవకాశం లేదు.
నిష్క్రమించండి [-ఓట్లు] [స్థితి]కారణాలు నిష్క్రమించడానికి లేదా అలా చేయటానికి సిద్ధం కావాలని ఆశించటం.
-ఎక్స్క్సిట్ జెండా తరువాతి వాదనను నిష్క్రమించే హ్యాండ్లర్గా ఉపయోగించుకుంటుంది. ఒక వాదన లేకుండా, ప్రస్తుత నిష్క్రమణ హ్యాండ్లర్ తిరిగి పొందబడుతుంది.
అనారోగ్య పతాకం కారణమౌతుంది, బయటకు వెళ్లడానికి సిద్ధం కావాలి, కాని వాస్తవానికి ఆపరేటింగ్ సిస్టమ్కు నియంత్రణను తిరిగి స్వీకరిస్తుంది . యూజర్ నిర్వచించిన నిష్క్రమణ హ్యాండ్లర్ అలాగే ఎక్స్ప్ట్ యొక్క సొంత అంతర్గత హ్యాండ్లర్లు అమలు. ఇకపై ఆదేశాలను అమలు చేయరాదు. మీరు ఇతర TCL పొడిగింపులతో ఆశించేలా ఉంటే ఇది ఉపయోగకరంగా ఉంటుంది. ప్రస్తుత ఇంటర్ప్రెటర్ (మరియు TK పర్యావరణంలో ప్రధాన విండో ఉంటే) ఇతర TCL ఎక్స్టెన్షన్స్ను శుభ్రపరుస్తుంది కాబట్టి ఉంటాయి. ఆశించిన నిష్క్రమణ మళ్లీ పిలవబడినా (అయితే ఇది సంభవించవచ్చు), హ్యాండ్లర్లు తిరిగి మారవు.
నిష్క్రమించేటప్పుడు, స్పాన్డ్ ప్రక్రియలకు అన్ని కనెక్షన్లు మూసివేయబడతాయి. మూసివేయడం ప్రక్రియ ద్వారా EOF గా గుర్తించబడుతుంది. నిష్క్రమణ సాధారణ _exit (2) విధానానికి మించి ఏ ఇతర చర్యలను తీసుకోదు. అందువలన, EOF కోసం తనిఖీ చేయని ప్రక్రియలు అమలులో కొనసాగవచ్చు. (ఉదాహరణకు, ఎటువంటి సంకేతాలు ఏవంటాయో గుర్తించదగ్గ విషయాలను గుర్తించటం చాలా ముఖ్యమైనవి, కానీ ఇవి సిస్టమ్-ఆధారమైనవి, సాధారణంగా నిష్క్రమణ (3) కింద డాక్యుమెంట్ చేయబడతాయి.) అమలు చేయబడుతున్న స్ప్రెడ్డ్ ప్రక్రియలు init ద్వారా వారసత్వంగా ఉంటాయి.
స్థితి (లేదా 0 పేర్కొనకపోతే) తిరిగి ఆశించిన స్థితికి తిరిగి వస్తుంది. స్క్రిప్ట్ యొక్క ముగింపు చేరుకున్నట్లయితే నిష్క్రమణ పరిపూర్ణంగా అమలు అవుతుంది.
exp_continue [-continue_timer]
ఆదేశాన్ని exp_continue అనునది యథాతథంగా కొనసాగుతుందని అనుకుంటుంది. డిఫాల్ట్గా exp_continue ని సమయము టైమర్ రీసెట్ చేస్తుంది. -continue_timer flag పునఃప్రారంభం నుండి టైమర్ నిరోధిస్తుంది. (మరింత సమాచారం కోసం ఎదురుచూడండి .)
exp_internal [-f ఫైల్] విలువ
విలువ సున్నా కానిది కాకపోతే stderr ను ఊహించటానికి అంతర్గత విశ్లేషణ సమాచారం అంతర్గత పంపుటకు మరింత ఆదేశాలను కలిగిస్తుంది. విలువ 0 ఉంటే ఈ అవుట్పుట్ నిలిపివేయబడుతుంది. విశ్లేషణ సమాచారం ప్రతి పాత్రను కలిగి ఉంటుంది మరియు నమూనాలను వ్యతిరేకంగా ప్రస్తుత అవుట్పుట్కు సరిపోయే ప్రతి ప్రయత్నం కూడా ఉంటుంది.
ఐచ్చిక ఫైల్ సరఫరా చేయబడితే, అన్ని సాధారణ మరియు డీబగ్గింగ్ అవుట్పుట్ ఆ ఫైల్కు (విలువ యొక్క విలువతో సంబంధం లేకుండా) వ్రాయబడుతుంది. ఏదైనా మునుపటి విశ్లేషణ అవుట్పుట్ ఫైల్ మూసివేయబడింది.
ఇ- ఇన్ఫో జెండా exp.internal కారణమవుతుంది ఇటీవలి సమాచారం సమాచారం ఇచ్చిన వాదనలు ఇచ్చిన.
exp_open [args] [-i spawn_id]
అసలైన స్పాన్ ఐడికి సంబంధించిన TCL ఫైల్ ఐడెంటిఫైయర్ను తిరిగి అందిస్తుంది. అప్పుడు ఫైల్ ఐడెంటిఫైయర్ దానిని Tcl ఓపెన్ కమాండ్ ద్వారా తెరిచినట్లుగా ఉపయోగించబడుతుంది. (స్పాన్ ఐడి ఇకపై ఉపయోగించబడదు.ఒక వేచి ఉండరాదు.
ఆశించే ఆదేశాల ద్వారా యాక్సెస్ కోసం స్పాన్ ఐడి తెరిచిన- ఫ్లేవర్పోన్ ఫ్లాగ్ వదిలివేస్తుంది. స్పాన్ id లో వేచి ఉండండి .
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 ఒక లోపాన్ని తిరిగి పంపుతుంది, కాని స్క్రిప్ట్ చిన్న సంఖ్య నడుస్తున్న ఆశించే దాని కంటే ఎక్కువగా ఉంటుంది.
మూడోది సంస్కరణ పోలికలో ఎటువంటి పాత్ర పోషిస్తున్న సంఖ్య. ఏదేమైనా, ఎక్స్పెక్ట్ సాప్ట్వేర్ డిస్ట్రిబ్యూషన్ ఏ విధంగానైనా మారుతుంది, అదనపు డాక్యుమెంటేషన్ లేదా ఆప్టిమైజేషన్ వంటిది. ఇది ప్రతి కొత్త మైనర్ వెర్షన్ మీద 0 కు రీసెట్ చేయబడుతుంది.
-exit జెండాతో, ఎక్స్పెక్ట్ ఒక లోపం ముద్రిస్తుంది మరియు వెర్షన్ గడువు ముగిసినట్లయితే నిష్క్రమిస్తుంది.
[[-ఓట్లు] pat1 body1] ... [-ఓట్లు] పాట్ [శరీర]
నమూనాలలో ఒకదానిని ఒక స్పాన్డ్ ప్రక్రియ యొక్క అవుట్పుట్తో సరిపోయే వరకు, పేర్కొన్న కాల వ్యవధి గడువు ముగిసే వరకు లేదా ముగింపు-ఫైల్ కనిపిస్తుంది. తుది శరీరం ఖాళీగా ఉంటే, అది తొలగించబడవచ్చు.
ఇటీవలి అంచనాల నుండి ఉన్న నమూనాలు ఏ ఇతర నమూనాలకు ముందు పరిపూర్ణంగా ఉపయోగించబడతాయి. ఇటీవలి pred_after ఆదేశం నుండి నమూనాలు ఏ ఇతర నమూనాల తర్వాత పరిపూర్ణంగా ఉపయోగించబడతాయి.
మొత్తం అంచనాలకు వాదనలు ఒకటి కంటే ఎక్కువ లైన్లకు అవసరమైతే, ప్రతి పంక్తిని ఒక భంగిమను తొలగించకుండా నివారించడానికి అన్ని వాదనలు ఒకే విధంగా ఉంటాయి. ఈ సందర్భంలో, సాధారణ TCL ప్రత్యామ్నాయాలు జంట కలుపులు ఉన్నప్పటికీ జరుగుతాయి.
ఒక నమూనా కీవర్డ్ eof ఉంటే , సంబంధిత శరీరం ముగింపు ఫైలు మీద అమలు. ఒక నమూనా కీవర్డ్ గడువు ముగిసినట్లయితే , సంబంధిత శరీరం గడువు ముగిసిన తరువాత అమలు అవుతుంది. గడువు ముగిసే కీవర్డ్ ఉపయోగించనట్లయితే, గడువు ముగింపులో ఒక అవ్యక్త శూన్య చర్య అమలు అవుతుంది. డిఫాల్ట్ గడువు వ్యవధి 10 సెకన్లు అయితే సెట్ చేయబడవచ్చు, ఉదాహరణకి 30 వ కమాండ్ "సెట్ టైమ్అవుట్ 30". అనంత సమయం ముగిసే విలువ -1 ద్వారా నిర్దేశించబడుతుంది. ఒక నమూనా కీవర్డ్ డిఫాల్ట్ అయితే , సంబంధిత శరీరం గడువు ముగిసే లేదా చివరికి-ఫైల్లో అమలు అవుతుంది.
ఒక నమూనా సరిపోతుంది ఉంటే, అప్పుడు సంబంధిత శరీరం అమలు. శరీర ఫలితాన్ని (లేదా ఏ నమూనా సరిపోలిస్తే ఖాళీ స్ట్రింగ్) తిరిగి ఆశించే . బహుళ నమూనాలు సరిపోయే సందర్భంలో, మొదటి కనిపించే ఒక శరీరం ఎంచుకోవడానికి ఉపయోగిస్తారు.
ప్రతిసారీ కొత్త అవుట్ పుట్ వస్తుంది, అవి ప్రతి క్రమంలో వారు జాబితా చేయబడిన క్రమంలో పోలి ఉంటాయి. అందువల్ల, ఒక ప్రాంప్ట్ వంటి కనిపించే హామీనిచ్చిన చివరి నమూనాను తయారు చేయడం ద్వారా మీరు ఒక మ్యాచ్ లేకపోవటం కోసం పరీక్షించవచ్చు. ఏవైనా ప్రాంప్ట్ లేనప్పుడు, మీరు గడువును ఉపయోగించాలి (మీరు మానవీయంగా పరస్పరం సంభాషించేలా చేస్తే).
పద్ధతులు మూడు విధాలుగా పేర్కొనబడ్డాయి. డిఫాల్ట్గా, Tcl స్ట్రింగ్ మ్యాచ్ ఆదేశంతో నమూనాలు పేర్కొనబడ్డాయి. (ఇలాంటి నమూనాలు C- షెల్ రెగ్యులర్ వ్యక్తీకరణలను సాధారణంగా "గ్లోబ్" నమూనాలుగా సూచిస్తాయి). జెండా జెండాలు జరపడం ద్వారా జెండాలు జరగడానికి సరిపోయే విధంగా నమూనాలను రక్షించడానికి ఉపయోగించవచ్చు. "-" తో ప్రారంభమయ్యే ఏదైనా నమూనా ఈ విధంగా భద్రపరచబడాలి. ("-" తో ప్రారంభమయ్యే అన్ని తీగలను భవిష్యత్ ఎంపికల కోసం కేటాయించారు.)
ఉదాహరణకు, క్రింది భాగం విజయవంతమైన లాగిన్ కోసం చూస్తుంది. ( విస్మరణను స్క్రిప్ట్లో మరెక్కడా నిర్వచించిన విధానానికి అనుకోవడం గమనించండి.)
{బిజీయి {బిజీలు} బిజీగా ఉంచుతుందా? exp_continue} విఫలమైనది "చెల్లని సంకేతపదము" గడువు ముగియడము రద్దుచేయబడిందినాలుగవ నమూనాలో ఉల్లేఖనాలు అవసరం ఎందుకంటే ఇది ఖాళీని కలిగి ఉంటుంది, ఇది చర్య నుండి నమూనాను వేరు చేస్తుంది. అదే చర్యతో ఉన్న పద్ధతులు (3 వ మరియు 4 వ వంటివి) మళ్లీ చర్యలను జాబితా చేయవలసి ఉంటుంది. ఇది regexp- శైలి నమూనాలను ఉపయోగించడం ద్వారా నివారించవచ్చు (క్రింద చూడండి). గ్లోబ్-శైలి నమూనాలను రూపొందించడానికి మరింత సమాచారం Tcl మాన్యువల్లో లభిస్తుంది.
Regexp- శైలి నమూనాలు Tcl యొక్క regexp ("రెగ్యులర్ ఎక్స్ప్రెషన్" కోసం సంక్షిప్తవి) ద్వారా నిర్వచించబడిన సింటాక్స్ను అనుసరిస్తాయి. జెండా-రెగ్తో regexp నమూనాలు ప్రవేశపెడతారు. మునుపటి ఉదాహరణ ఒక regexp ఉపయోగించి తిరిగి వ్రాయబడుతుంది:
{బిజీయి {బిజీలు} బిజీగా ఉంచుతుందా? exp_continue} -re "విఫలమైంది | చెల్లని సంకేతపదంరెండు రకాలైన నమూనాలు "ఉద్భవించాయి". దీని అర్థం, మొత్తం స్ట్రింగ్తో సరిపోలడం లేదు, కానీ స్ట్రింగ్లో ఎక్కడైనా మ్యాచ్ను ముగించవచ్చు మరియు ముగించవచ్చు (అన్నిటికీ సరిపోలినంత వరకు). స్ట్రింగ్ యొక్క ఆరంభానికి సరిపోలడానికి ^ ను ఉపయోగించుము మరియు చివరికి $ ఆటకు సరిపోలడం. స్ట్రింగ్ యొక్క ముగింపుకు మీరు వేచి ఉండకపోతే, స్ట్రింగ్ యొక్క మధ్యలో మీ ప్రతిస్పందనలు సులభంగా ముగుస్తాయి, ఎందుకంటే అవి తెరిచిన ప్రక్రియ నుండి ప్రతిధ్వనిస్తాయి. ఇప్పటికీ సరైన ఫలితాలను ఉత్పత్తి చేస్తున్నప్పుడు, అవుట్పుట్ అసహజంగా కనిపిస్తుంది. అందువల్ల, $ స్ట్రింగ్ యొక్క చివర ఉన్న పాత్రలను సరిగ్గా వివరిస్తే మీరు ఉపయోగించడం ప్రోత్సహిస్తుంది.
చాలామంది సంపాదకులలో, ^ మరియు $ వరుసగా వరుసల ప్రారంభం మరియు చివరికి సరిపోలడం గమనించండి. అయినప్పటికీ, ఆశించకుండా లైన్ ఆధారిత కాదు, ఈ అక్షరాలు ప్రస్తుతం సరిపోలే బఫర్ ఆశించిన డేటా యొక్క ప్రారంభ మరియు ముగింపు (పంక్తులు వ్యతిరేకంగా) సరిపోలడం. (అలాగే, "సిస్టమ్ అజీర్తి" పై ఈ క్రింది గమనిక చూడండి)
ఈ - ఫ్లాగ్ నమూనాను "ఖచ్చితమైన" స్ట్రింగ్గా సరిపోల్చడానికి కారణమవుతుంది. *, ^, Etc యొక్క వివరణ లేదు (సాధారణ TCL సమావేశాలు ఇప్పటికీ పరిశీలించబడాలి). ఖచ్చితమైన నమూనాలు ఎల్లప్పుడూ ఉద్దీపనము.
-నొకేజ్ ఫ్లాగ్ అవుట్పుట్ యొక్క పెద్ద అక్షరాలను చిన్న అక్షరాలుగా సరిపోల్చడానికి కారణమవుతుంది. నమూనా ప్రభావితం కాదు.
అవుట్పుట్ చదివినప్పుడు, 2000 కంటే ఎక్కువ బైట్లు ముందుగా బైట్లు "మర్చిపోయి" చేయగలవు. ఇది ఫంక్షన్ match_max తో మార్చబడవచ్చు . (అతి పెద్ద విలువలు నమూనా జతకు వేగాన్ని తగ్గించవచ్చని గమనించండి.) పేటలిస్ట్ full_buffer అయితే , match_max బైట్లు స్వీకరించబడి ఉంటే మరియు సంబంధిత పధ్ధతులు సరిపోలని ఉంటే సంబంధిత శరీరం అమలు అవుతుంది. Full_buffer కీవర్డ్ ఉపయోగించబడుతుందో లేదో, మరచిపోయిన అక్షరాలు expect_out (బఫర్) కు వ్రాయబడతాయి.
పేట్రిస్ట్ కీవర్డ్ శూన్యమైతే మరియు నల్లు అనుమతించబడతాయి ( remove_nulls ఆదేశం ద్వారా), ఒకే ASCII 0 సరిపోలినట్లయితే సంబంధిత శరీరం అమలు అవుతుంది. గ్లోబ్ లేదా రీజెక్స్ నమూనాల ద్వారా 0 బైట్లు సరిపోలడం సాధ్యం కాదు.
ఒక నమూనా (లేదా ఎఫ్ఓ లేదా పూర్తి_బఫర్) సరిపోయేటప్పుడు, సరిపోలే మరియు గతంలో సరిపోని అవుట్పుట్ వేరియబుల్ expect_out (బఫర్) లో సేవ్ చేయబడుతుంది. 9 regexp substring matches వరకు expect_out (9, స్ట్రింగ్) ద్వారా వేరియబుల్స్ expect_out (1, స్ట్రింగ్) లో సేవ్ చేయబడతాయి. ఒక నమూనాకు ముందు -ఐటి జెండా ఉపయోగించినట్లయితే, 10 స్ట్రింగ్స్ యొక్క ప్రారంభ మరియు ముగింపు సూచికలు వేరియబుల్స్లో నిల్వ చేయబడతాయి expect_out (X, ప్రారంభం) మరియు expect_out (X, end) అంకెల, బఫర్లో సబ్జెక్ట్ స్థానంకు అనుగుణంగా ఉంటుంది. 0 మొత్తం నమూనాతో సరిపోయే తీగలను సూచిస్తుంది మరియు గ్లోబ్ నమూనాలు అలాగే రీగెక్స్ నమూనాలతో ఉత్పత్తి చేయబడుతుంది. ఉదాహరణకు, ఒక ప్రక్రియ "abcdefgh \ n" యొక్క ఉత్పత్తిని ఉత్పత్తి చేస్తే, ఫలితంగా:
ఆశ "cd"ఈ క్రింది ప్రకటనలు అమలు చేయబడినట్లు:
set_out (0, స్ట్రింగ్) cd set expect_out (బఫర్) abcdమరియు "efgh \ n" అవుట్పుట్ బఫర్లో మిగిలిపోతుంది. ఒక ప్రక్రియ అవుట్పుట్ "abbbcabkkkka \ n" ను ఉత్పత్తి చేస్తే, ఫలితంగా:
ఆశలు -ఇవి "బి (బి *). * (k +)"ఈ క్రింది ప్రకటనలు అమలు చేయబడినట్లు:
(1, ముగింపు) 2 సెట్ expect_out (1, ముగింపు) 3 సెట్ expect_out (1, స్ట్రింగ్) bb setcout (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" అవుట్పుట్ బఫర్లో మిగిలిపోతుంది. ప్రక్రియ "*" (మరియు -ఆర్ ". *") అవుట్పుట్ బఫర్ను ప్రక్రియ నుండి ఏ అవుట్పుట్ను చదవకుండానే ఫ్లష్ చేస్తుంది.
సాధారణంగా, సరిపోలిన అవుట్పుట్ ఎక్స్పెక్ట్స్ అంతర్గత బఫర్ల నుండి విస్మరించబడుతుంది. -ప్రదర్శన జెండాతో నమూనాను పూర్వం పూయడం ద్వారా దీనిని నిరోధించవచ్చు. ఈ జెండా ముఖ్యంగా ప్రయోగాత్మకంగా ఉపయోగకరంగా ఉంటుంది (మరియు ప్రయోగాలు చేస్తున్నప్పుడు సౌలభ్యం కోసం "-కాదు" కు సంక్షిప్తీకరించబడుతుంది).
సరిపోలే అవుట్పుట్తో అనుబంధించబడిన స్పాన్ id (లేదా eof లేదా full_buffer) expected_out (spawn_id) లో నిల్వ చేయబడుతుంది.
గడువు వేరియబుల్ యొక్క విలువను వాడటానికి బదులు ఈ విలువను కింది విలువను గడువుగా ఉపయోగించుటకు ప్రస్తుత- కాలమానం పతాకం కారణమవుతుంది.
అప్రమేయంగా, నమూనాలు ప్రస్తుత విధానంలో అవుట్పుట్కు వ్యతిరేకంగా సరిపోతాయి, అయినప్పటికీ - -i ఫ్లాగ్ అనే పేరుతో ఉన్న spawn_id జాబితా నుండి అవుట్పుట్ ఏ కింది విధానాలతో (తదుపరి -i వరకు ) సరిపోలుతుంది. Spawn_id జాబితా స్పాన్_ఐడ్ యొక్క తెల్లని విభజన జాబితాగా లేదా స్పాన్_ఐడ్స్ యొక్క జాబితాను సూచించే వేరియబుల్గా ఉండాలి.
ఉదాహరణకు, ఈ క్రింది ఉదాహరణ ప్రస్తుత ప్రాసెస్ నుండి "కనెక్ట్" కోసం వేచి ఉంటుంది లేదా $ proc2 పేరుతో ఉన్న spawn_id నుండి "బిజీ", "విఫలమైంది" లేదా "చెల్లని పాస్వర్డ్" ను వేచి ఉంటుంది.
{-i $ proc2 బిజీగా {n} బిజీని ఉంచుతుంది \ n; exp_continue} -re "విఫలమైంది | చెల్లని సంకేతపదంప్రస్తుత భవిష్య ఆదేశాల్లో ఇతర అన్ని-ఫ్లాగ్ల పేర్లతో పిలువబడే ఏదైనా spawn_ids కు నమూనాలను సరిపోల్చడానికి ప్రపంచ వేరియబుల్ any_spawn_id యొక్క విలువను ఉపయోగించవచ్చు. ఏదైనా _spawn_id తో అనుబంధించబడిన అదే ఆదేశాములో ఏ ఇతర పద్దతులకు అనుబంధిత నమూనా (అనగా, మరొక -i చేత వెనువెంటనే) తో a -i జెండా నుండి spawn_id అందుబాటులోకి వస్తుంది.
-i జెండా కూడా ప్రపంచ వేరియబుల్ పేరును కలిగి ఉంటుంది, ఈ సందర్భంలో స్పాన్ ఐడిల జాబితా కోసం వేరియబుల్ చదువుతుంది. ఇది మారినప్పుడు వేరియబుల్ చదవబడుతుంది. కమాండ్ అమలులో ఉన్నప్పుడు I / O మూలాన్ని మార్చటానికి ఇది ఒక మార్గాన్ని అందిస్తుంది. ఈ విధంగా అందించబడిన స్పాన్ ఐడిలు "పరోక్ష" స్పాన్ ఐడిలు అంటారు.
విచ్ఛిన్నం మరియు కొనసాగుతున్న చర్యలు సాధారణ పద్ధతిలో ప్రవర్తించే నియంత్రణ వ్యవస్థలు (అంటే, proc కోసం ) కారణమవుతాయి. ఆదేశాన్ని exp_continue అనునది యథాతథంగా కొనసాగుతుందని అనుకుంటుంది.
ఇది స్పష్టమైన ఉచ్చులు లేదా పదేపదే ఆశించే ప్రకటనలు లేకుండా ఉండటానికి ఉపయోగపడుతుంది. కింది ఉదాహరణ rlogin స్వయంచాలనం చేయడానికి ఒక భాగాన్ని భాగం. Rlogin సంకేతపదము కొరకు ప్రాంప్ట్ చేయితే, exp_continue రెండవ ఆశించిన ప్రకటనను వ్రాయుటకు ప్రయత్నించును (మళ్ళీ ప్రాంప్ట్ కొరకు చూడండి).
$ హోస్ట్: {expect_user -re "(. *) \ n" send_user "\ n" expect_out (1, string) \ r "stty" పంపించు {host: {password: {stty -echo send_user "password ($ వినియోగదారు కోసం) echo exp_continue} సరికాని {send_user "చెల్లని పాస్వర్డ్ లేదా ఖాతా \ n" నిష్క్రమణ} గడువు ముగిసింది {host_user "కనెక్షన్ గడువు ముగిసింది \ n" exit} eof {send_user \ "కనెక్షన్ హోస్ట్ విఫలమైంది: $ expect_out (బఫర్)" నిష్క్రమణ " తిరిగి $ prompt}ఉదాహరణకు, కింది భాగం ఇప్పటికే పూర్తిగా ఆటోమేటెడ్ అయిన పరస్పర చర్యకు ఒక యూజర్ గైడ్కు సహాయపడవచ్చు. ఈ సందర్భంలో, టెర్మినల్ ముడి మోడ్లో ఉంచబడుతుంది. వినియోగదారు "+" ప్రెస్ చేస్తే, ఒక వేరియబుల్ పెరుగుతుంది. ఒకవేళ "p" నొక్కినట్లయితే, అనేక రిటర్న్లు ఈ ప్రక్రియకు పంపబడతాయి, బహుశా ఏదో విధంగా అది దెబ్బతీస్తాయి, మరియు "i" వినియోగదారుని ప్రక్రియతో ఇంటరాక్ట్ చేయడానికి, స్క్రిప్ట్ నుండి నియంత్రణను సమర్థవంతంగా దొంగిలిస్తుంది. ప్రతి సందర్భంలో, ప్రస్తుత చర్యను అమలు చేసిన తర్వాత, ఎక్స్-కాంటెన్యువల్ ప్రస్తుత నమూనా సరిపోలికను కొనసాగించటానికి అనుమతిస్తుంది.
stty raw -echo expect_after {-i $ user_spawn_id "p" {పంపించు \ r \ r \ r "; exp_continue} "+" {incr foo; exp_continue} "i" {ఇంటరాక్ట్; exp_continue} "నిష్క్రమించు" నిష్క్రమణ}అప్రమేయంగా, exp_continue పునఃఅమర్పులకు సమయం ముగిసింది టైమర్. Exp_continue -continue_timer జెండాతో పిలువబడితే టైమర్ పునఃప్రారంభం కాదు.
expect_after [expect_args]
ఆశించే రెండు అంచనాలు మరియు అంచనా_ఎంపికలు సరిపోలగలవని అంచనా వేయడానికి ముందుగానే పనిచేస్తుంది , ఆశించిన నమూనా ఉపయోగించబడుతుంది. మరింత సమాచారం కోసం expect_before ఆదేశం చూడండి.
expect_background [expect_args]
ఆశించే అదే వాదనలు పడుతుంది, అయితే అది వెంటనే తిరిగి. కొత్త ఇన్పుట్ వచ్చినప్పుడు నమూనాలు పరీక్షించబడతాయి. నమూనా గడువు మరియు డిఫాల్ట్ అనేవి అర్థరహితంగా ఉండి , నిశ్శబ్దంగా విస్మరించబడతాయి. లేకపోతే, expect_background ఆదేశం expect_before ఉపయోగిస్తుంది మరియు expect_after నమూనాలు ఆశించే వంటి.
Expect_background చర్యలు విశ్లేషించబడుతున్నప్పుడు, అదే స్పాన్ ఐడి కోసం నేపథ్య ప్రాసెసింగ్ బ్లాక్ చేయబడుతుంది. చర్య పూర్తి అయినప్పుడు నేపధ్య ప్రాసెసింగ్ అన్బ్లాక్ అవుతుంది. నేపథ్య ప్రాసెసింగ్ బ్లాక్ అయినప్పటికీ, అదే స్పాన్ ఐడిలో (ముందుభాగం) ఆశించడం సాధ్యమవుతుంది.
ఆశించని రీతిలో అన్బ్లాక్ అయినప్పుడు ఆశించలేము . ఒక spawn id తో కొత్త expect_background ప్రకటించడం ద్వారా ఒక ప్రత్యేక స్పాన్ ID కోసం ఆశించే_మద్దతు తొలగించబడుతుంది. ఏ విధమైన నమూనా లేకుండా ఎదురుచూడని ఎదురుదాడి ప్రకటిస్తే ఇచ్చిన స్పాన్ ఐడిని నేపథ్యంలో నమూనాలతో సరిపోయే సామర్ధ్యం నుండి తీసివేస్తుంది.
expect_before [expect_args]
ఆశించే అదే వాదనలు పడుతుంది, అయితే అది వెంటనే తిరిగి. అదే స్పాన్ id తో ముందుగానే అంచనా వేసే నుండి సరళి-చర్య జతలు ఏ క్రింది ఆదేశాలను ఆశాజనకంగా జోడించబడతాయి. ఒక నమూనా సరిపోలితే, అది ఆదేశానికే ఆశించినట్లు పేర్కొనబడినట్లుగా పరిగణించబడుతుంది మరియు అనుబంధిత ఆదేశం సందర్భంలో సంబంధిత శరీరాన్ని అమలు చేయబడుతుంది. రెండింటి నుండి అంచనాలు ఆశించిన మరియు అంచనా వేయవచ్చును ఉంటే, అంచనా_పెచ్చే నమూనా ఉపయోగించబడుతుంది.
ఏ నమూనా పేర్కొనకపోతే, ఏ నమూనాలకు స్పాన్ id తనిఖీ చేయబడదు.
Ai ఫ్లాగ్ ద్వారా ఓవర్రీడ్ చేయకపోతే , expect_before ఆదేశం అమలు చేయబడిన సమయంలో నిర్వచించిన స్పాన్ ఐడికి వ్యతిరేకంగా సరిపోయే నమూనాలు సరిపోతాయి (దాని నమూనా సరిపోలినప్పుడు కాదు).
-ఇన్ఫో పతాకం అంచనా వేయడానికి కారణాలు ఏమిటంటే , అది ఎలాంటి ఆకృతులను కలిగి ఉండాలో ప్రస్తుత వివరణలను తిరిగి పొందడం . అప్రమేయంగా, ఇది ప్రస్తుత స్పాన్ id పై నివేదిస్తుంది. స్పాన్ ఐడిపై సమాచారం కోసం ఐచ్ఛిక స్పాన్ ఐడి వివరణ ఇవ్వవచ్చు. ఉదాహరణకి
expect_before -info -i $ procచాలా వరకు ఒక స్పాన్ ID స్పెసిఫికేషన్ ఇవ్వబడుతుంది. పరోక్ష వివరణల నుండి వచ్చిన ప్రత్యక్ష స్పాన్ ఐడిలను అప్రధానంగా అణచివేస్తుంది.
స్పాన్ ఐడి వివరణకు బదులుగా, అన్ని స్పాన్ ఐడిలపై రిపోర్టు చేయడానికి "-ఎన్" అనే "ఫ్లాట్" ఫ్లాగ్ కారణమవుతుంది.
-info జెండా యొక్క అవుట్పుట్ను ఆశించటానికి వాదనగా పునఃప్రారంభించబడుతుంది.
expect_tty [expect_args]
ఆశించిన విధంగా ఉంటుంది కానీ అది / dev / tty (అంటే యూజర్ నుండి కీస్ట్రోక్స్) నుండి అక్షరాలు చదువుతుంది. డిఫాల్ట్గా, వండిన మోడ్లో పఠనం చేయబడుతుంది. ఈ విధంగా, పంక్తులు వాటిని చూడాలని ఆశించే క్రమంలో తిరిగి రావాలి. ఇది స్టాటిక్ ద్వారా మారవచ్చు (దిగువ Stty కమాండ్ను చూడండి).
expect_user [expect_args]
ఆశించే లాగా ఉంటుంది కానీ అది stdin (అంటే యూజర్ నుండి కీస్ట్రోక్స్) నుండి అక్షరాలు చదువుతుంది. డిఫాల్ట్గా, వండిన మోడ్లో పఠనం చేయబడుతుంది. ఈ విధంగా, పంక్తులు వాటిని చూడాలని ఆశించే క్రమంలో తిరిగి రావాలి. ఇది స్టాటిక్ ద్వారా మారవచ్చు (దిగువ Stty కమాండ్ను చూడండి).
ఫోర్క్
కొత్త ప్రక్రియను సృష్టిస్తుంది. కొత్త ప్రక్రియ ప్రస్తుతపు ఆశించే ప్రక్రియ యొక్క ఖచ్చితమైన కాపీ. విజయానికి, ఫోర్క్ కొత్త (బాల) విధానానికి 0 గా తిరిగి వస్తాడు మరియు పిల్లల ప్రక్రియ యొక్క ప్రక్రియ ID యొక్క మాతృ ప్రక్రియకు తిరిగి వస్తాడు. వైఫల్యం (వనరుల లేకపోవటం వలన స్థిరముగా, ఉదా., స్వాప్ స్పేస్, మెమొరీ), ఫోర్క్ ప్రక్రియ -1 కు తిరిగి చెల్లింపు, మరియు చైల్డ్ ప్రాసెస్ సృష్టించబడదు.
ఫోర్క్డ్ ప్రక్రియలు నిష్క్రమణ ఆదేశం ద్వారా నిష్క్రమించబడతాయి , అసలు ప్రక్రియ లాగే. Forked ప్రక్రియలు లాగ్ ఫైళ్ళకు వ్రాయడానికి అనుమతించబడతాయి. మీరు డీబగ్గింగ్ను లేదా చాలా ప్రక్రియలలో లాగింగ్ చేయకపోతే, ఫలితం గందరగోళంగా ఉంటుంది.
కొంతమంది నలుగురు అమలులు బహుళ పాఠకులు మరియు రచయితలచే అయోమయమవుతాయి. అందువల్ల, అభివృద్ధి చెందుతున్న ప్రక్రియల ముందు ఇది గోచరించేది.
సంకర్షణ [స్ట్రింగ్ 1 బాడీ 1] ... [స్ట్రింగ్ [శరీర]
ప్రస్తుత ప్రక్రియను యూజర్కు ప్రస్తుత నియంత్రణను ఇస్తుంది, తద్వారా కీస్ట్రోక్లు ప్రస్తుత విధానానికి పంపబడతాయి మరియు ప్రస్తుత విధానానికి సంబంధించిన స్టాండ్ మరియు స్టెర్డర్ తిరిగి వస్తాయి.
స్ట్రింగ్-బాడీ జతల వాదనలుగా పేర్కొనవచ్చు, ఈ సందర్భంలో సంబంధిత స్ట్రింగ్ ప్రవేశించినప్పుడు శరీరాన్ని అమలు చేయబడుతుంది. (డిఫాల్ట్గా, స్ట్రింగ్ ప్రస్తుత ప్రాసెస్కు పంపబడదు.) అంతిమ శరీరం తప్పిపోయినట్లయితే, ఇంటర్ప్రెటర్ ఆదేశం ఊహించబడుతుంది.
మొత్తం ఇంటరాక్ట్ స్టేట్మెంట్కు వాదనలు ఒకటి కంటే ఎక్కువ లైన్లకు అవసరమైతే, ప్రతి వాక్యం బ్యాక్స్లాష్తో ముగించకుండా ఉండటానికి అన్ని వాదనలు ఒకదానిలో ఒకటిగా మారతాయి. ఈ సందర్భంలో, సాధారణ TCL ప్రత్యామ్నాయాలు జంట కలుపులు ఉన్నప్పటికీ జరుగుతాయి.
ఉదాహరణకు, క్రింది కమాండ్ నిర్వచించిన కింది స్ట్రింగ్-బాడీ జంటలతో సంకర్షణ చెందుతుంది: ఎప్పుడు ^ Z నొక్కినప్పుడు, ఎక్స్పెక్ట్ సస్పెండ్ చేయబడింది. ( రీసెట్ ఫ్లాగ్ టెర్మినల్ మోడ్లను పునరుద్ధరిస్తుంది.) ఎ ఎప్పుడు నొక్కినప్పుడు, వినియోగదారు "మీరు కంట్రోల్-A ని టైప్ చేస్తారు" మరియు ప్రక్రియ A ^ A ని పంపబడుతుంది. $ నొక్కినప్పుడు, వినియోగదారు తేదీని చూస్తారు. ^ C నొక్కినప్పుడు, నిష్క్రమిస్తుంది. "Foo" ఎంటర్ చేస్తే, వినియోగదారు "bar" ను చూస్తారు. ~ ~ నొక్కినప్పుడు, ఎక్స్పెక్ట్ ఇంటర్ప్రెటర్ ఇంటరాక్టివ్గా నడుస్తుంది.
సెట్ CTRLZ \ 032 {-reset $ CTRLZ {exec kill-STOP [pid]} \ 001 {send_user "మీరు ఒక నియంత్రణ- A \ n" టైప్ చేసారు; "001"} $ {send_user "తేదీ [గడియారం ఆకృతి [క్లాక్ సెకన్లు]]."} \ 003 exit foo {send_user "bar"} ~~}స్ట్రింగ్-బాడీ జంటలలో, తీగలను వారు వాదనలుగా జాబితా చేయబడిన క్రమంలో సరిపోతాయి. పాక్షికంగా సరిపోయే స్ట్రింగ్లు ప్రస్తుత ప్రక్రియకు పంపబడవు, మిగిలిన వాటిలో ఊహించిన దాని ఫలితంగా వస్తుంది. అక్షరాలు ఇకపై ఒక మ్యాచ్ అయిపోయి ఉంటే, స్ట్రింగ్ యొక్క భాగాన్ని మాత్రమే మరొక పోటీని ప్రారంభించలేని విధానంలోకి పంపబడుతుంది. అందువల్ల, పాక్షిక మ్యాచ్ల యొక్క substrings అని స్ట్రింగ్స్ తరువాత మ్యాచ్ చేయవచ్చు, ఆ మ్యాచ్ ప్రయత్నిస్తున్న అసలు తీగలను చివరికి విఫలమైతే.
డిఫాల్ట్గా, స్ట్రింగ్ సరిపోలిక వైల్డ్ కార్డులతో ఖచ్చితమైనది కాదు. (దీనికి విరుద్ధంగా, ఊహ ఆదేశాన్ని డిఫాల్ట్గా గ్లోబ్-శైలి నమూనాలను ఉపయోగిస్తుంది.) ఫ్లాగ్లను సంకర్షణ చెందడానికి ఉపయోగించే నమూనాలను రక్షించడానికి ఈ - ఫ్లాగ్ ఉపయోగించవచ్చు. "-" తో ప్రారంభమయ్యే ఏదైనా నమూనా ఈ విధంగా భద్రపరచబడాలి. ("-" తో ప్రారంభమయ్యే అన్ని తీగలను భవిష్యత్ ఎంపికల కోసం కేటాయించారు.)
స్ట్రింగ్ను regexp- శైలి నమూనాగా అర్థం చేసుకోవటానికి-ఫ్లాగ్ జెండా బలపడుతుంది. ఈ సందర్భంలో, సరిపోలే substrings వేరియబుల్ interact_out లో నిల్వ చేయబడతాయి విధంగా మార్గం దాని అవుట్పుట్ వేరియబుల్ expect_out నిల్వ . ఆ సూచికల జెండా అదేవిధంగా మద్దతిస్తుంది.
నమూనా eof ముగింపు ఫైల్పై అమలు చేయబడే ఒక చర్యను పరిచయం చేస్తుంది. అవుట్పుట్ వ్రాసేటప్పుడు ఒక eof గుర్తించబడితే అది సరిపోలిన సందర్భంలో ఒక ప్రత్యేక eof నమూనా కూడా- అవుట్పుట్ జెండాని అనుసరించవచ్చు. డిఫాల్ట్ eof చర్య "రిటర్న్", తద్వారా ఏ EOF పైన తిరిగి ఇచ్చిపుచ్చుకోవడం.
నమూనా గడువు ముగిసింది (సెకన్లలో) మరియు ఇచ్చిన సమయానికి అక్షరాలు ఏవీ చదివిన తర్వాత అమలు చేయబడిన చర్య. సమయం ముగిసింది నమూనా ఇటీవల పేర్కొన్న విధానానికి వర్తిస్తుంది. డిఫాల్ట్ సమయం ముగిసింది లేదు. ప్రత్యేకమైన వేరియబుల్ "సమయం ముగిసింది" ( ఆశ ఆదేశం ద్వారా ఉపయోగించబడుతుంది) ఈ సమయం ముగిసిపోతుంది.
ఉదాహరణకు, ఒక గంట కోసం ఏదైనా టైప్ చేయని వినియోగదారులకు ఆటోగోట్అవుట్ వినియోగదారులకు ఈ క్రింది ప్రకటన ఉపయోగించబడుతుంది, అయితే తరచూ సిస్టమ్ సందేశాలను పొందుతారు:
ఇంటరాక్ట్ -ఇన్పుట్ $ user_spawn_id సమయం ముగిసింది 3600 తిరిగి-అవుట్పుట్ \ $ spawn_idనమూనా కీవర్డ్ శూన్యమైతే , మరియు నల్లు అనుమతించబడతాయి ( remove_nulls ఆదేశం ద్వారా), ఒకే ASCII 0 సరిపోలినట్లయితే సంబంధిత శరీరం అమలు అవుతుంది. గ్లోబ్ లేదా రీజెక్స్ నమూనాల ద్వారా 0 బైట్లు సరిపోలడం సాధ్యం కాదు.
జెండా -వాటితో నమూనాను పూరించడం , నమూనా (లేదా ఇఫ్) కు సరిపోయే spawn_id కు సెట్ చేయటానికి వేరియబుల్ ఇంటరాక్ట్_అట్ (spawn_id) ను కలిగిస్తుంది.
విచ్ఛిన్నం మరియు కొనసాగుతున్న చర్యలు సాధారణ పద్ధతిలో ప్రవర్తించే నియంత్రణ వ్యవస్థలు (అంటే, proc కోసం ) కారణమవుతాయి. అయితే రిటర్న్ కారకాలు దాని కాలర్కు తిరిగి రావడానికి సంకర్షణ చెందుతాయి, అయితే ఇంటర్_ రిటర్న్ దాని కాలర్లో తిరిగి రావడానికి సంకర్షణ చెందుతుంది . ఉదాహరణకు, "proc foo" సంకర్షణ అని పిలిచినట్లయితే అప్పుడు చర్య inter_return ను అమలు చేస్తే , proc foo తిరిగి వస్తుంది. (అనగా కాల్స్ ఇంటర్ప్రిటర్ ఇంటరాక్టివ్గా టైపింగ్ రిటర్న్ ఇంటరాక్ట్ చేస్తే ఇంటరాక్ట్ కొనసాగించటానికి కారణమవుతుంది, అయితే inter_return దాని కాలర్కు తిరిగి రావడానికి సంకర్షణ కలిగించేలా చేస్తుంది.)
ఇంటరాక్ట్ సమయంలో, ముడి మోడ్ ఉపయోగించబడుతుంది, తద్వారా అన్ని అక్షరాలు ప్రస్తుత విధానానికి పంపబడతాయి. ప్రస్తుత ప్రక్రియ ఉద్యోగ నియంత్రణ సంకేతాలను పొందలేకపోతే, ఒక స్టాప్ సిగ్నల్ (డిఫాల్ట్గా Z) పంపినట్లయితే అది నిలిపివేయబడుతుంది. దీన్ని పునఃప్రారంభించడానికి, కొనసాగింపు సిగ్నల్ను పంపండి ("చంపడానికి -CONT" వంటిది). మీరు నిజంగా ఒక సిగ్స్టోప్ను ఒక ప్రాసెస్ (Z ద్వారా) పంపించాలనుకుంటే, మొదట csh ఆరంభించి, మీ ప్రోగ్రామ్ను నడుపుతున్నట్లు భావిస్తారు. ఇంకొక వైపు, మీరు ఒక SIGSTOP ను కూడా ఆశించేలా పంపించాలనుకుంటే, మొదటి కాల్ వ్యాఖ్యాత (బహుశా తప్పించుకునే పాత్రను ఉపయోగించి), ఆపై ^ Z ను నొక్కండి.
స్ట్రింగ్-బాడీ జంటలు ఇంటరాప్టర్లోకి ప్రవేశించడం మరియు పరస్పరం అమలు చేసే ఆదేశాలను అమలు చేయకుండా ఒక షార్ట్హాండ్గా ఉపయోగించవచ్చు. మునుపటి టెర్మినల్ మోడ్ ఉపయోగించబడుతుంది, ఇది స్ట్రింగ్-బాడీ జంట యొక్క శరీరాన్ని అమలు చేయబడుతుంది.
వేగం కోసం, చర్యలు అప్రమేయంగా ముడి రీతిలో అమలు. పరస్పర చర్యకు ముందు (రీడర్లీ, వండిన మోడ్) అమలు చేయబడిన రీతిలో-రీసెట్ ఫ్లాగ్ టెర్మినల్ను రీసెట్ చేస్తుంది. మోడ్ స్విచ్ చేయబడినప్పుడు అక్షరాలు నమోదు చేయబడవచ్చని గమనించండి (కొన్ని వ్యవస్థలపై టెర్మినల్ డ్రైవర్ యొక్క దురదృష్టకరమైన లక్షణం). మీ చర్య వండిన మోడ్లో అమలవుతున్నట్లయితే, దాన్ని ఉపయోగించడానికి మాత్రమే కారణం ఉంది.
ప్రతిచోటా చదివేటప్పుడు వాటిని ఉత్పత్తి చేసే ప్రక్రియకు కింది విధానాన్ని సరిపోల్చే అక్షరాలను -సెకో జెండా పంపుతుంది. వినియోగదారు పాక్షికంగా టైప్ చేయబడిన నమూనాల నుండి అభిప్రాయాన్ని చూసేటప్పుడు ఇది ఉపయోగపడుతుంది.
ఒక నమూనా ప్రతిధ్వనించే అయితే చివరకు మ్యాచ్ విఫలమైతే, అక్షరాలు అక్షర క్రమంలో పంపబడతాయి. తెరిచిన ప్రక్రియ అప్పుడు వాటిని ప్రతిబింబిస్తుంది ఉంటే, యూజర్ అక్షరాలు రెండుసార్లు చూస్తారు. -చెయో బహుశా నమూనా పూర్తి చేయలేకుండే అవకాశం ఉన్న సందర్భాల్లో మాత్రమే సరిపోతుంది. ఉదాహరణకు, కింది సారాంశం rftp, recursive-ftp స్క్రిప్టు నుండి, వాడుకదారుడు ~ g, ~ p, లేదా ~ l, ఎంటర్, ప్రాంప్ట్, లేదా ప్రస్తుత డైరెక్టరీ పునరావృతంగా జాబితా చేయమని ప్రాంప్ట్ చేయబడతాడు. ఇవి సాధారణ FTP ఆదేశాల నుండి ఇప్పటివరకు దూరంగా ఉన్నాయి, వినియోగదారు తప్పుగా తప్ప, వేరే ఏదైనా తరువాత టైప్ చేసే అవకాశం లేదు, ఈ సందర్భంలో, వారు ఏమైనప్పటికీ ఫలితాన్ని విస్మరిస్తారు.
ఇంటరాక్ట్ {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}పాత్రలు చదివేటప్పుడు అవుట్పుట్ ప్రాసెస్లో కింది విధానాన్ని సరిపోల్చే అక్షరపాద జెండా అక్షరాలు పంపుతుంది.
మీరు ప్రోగ్రామ్ను తిరిగి వెనక్కి తీసుకురావాలని అనుకుంటే ఇది ఉపయోగకరంగా ఉంటుంది. ఉదాహరణకు, ఒక వ్యక్తి డయలింగ్ చేస్తున్నప్పుడు (హేస్-స్టైల్ మోడెమ్) పర్యవేక్షించడానికి ఈ క్రిందివి ఉపయోగించబడవచ్చు. "ATD" ప్రతిసారి లిపి మిగిలిన పంక్తిని లాగ్ చేస్తుంది.
(1, స్ట్రింగ్) "} ఇంటరాక్ట్-నోబఫెర్" atd "లాగ్ నంబర్ (డీకోడ్ లాగ్నోంబెర్ {} {interact -nobuffer -re" (. *) \ r "రిటర్న్ $ లాగ్ను ఉంచుతుంది" [గడియారం ఆకృతి [గడియారం సెకన్లు]ఇంటరాక్ట్ సమయంలో, log_user యొక్క మునుపటి వినియోగం విస్మరించబడుతుంది. ప్రత్యేకంగా, ఇంటరాక్ట్ దాని అవుట్పుట్ లాగ్ చేయబడటానికి బలవంతం చేస్తుంది (స్టాండర్డ్ అవుట్పుట్కి పంపబడుతుంది) వినియోగదారుడు గుడ్డిగా ఇంటరాక్ట్ చేయకూడదని భావించినందున.
ప్రస్తుత పధ్ధతి యొక్క అవుట్పుట్కు దరఖాస్తు చేయటానికి ఏవైనా కీ-బాడీ జతలు ఈ-ఫ్లాగ్ కారణమవుతాయి. ఉదాహరణకు, ఒక టెలీనెట్ సెషన్లో అవాంఛిత అక్షరాలను పంపే అతిధేయలతో వ్యవహరించేటప్పుడు ఇది ఉపయోగపడుతుంది.
డిఫాల్ట్గా, ఇంటరాక్ట్ స్టాండ్ ను స్టాండింగ్ రాయడం మరియు ఎక్స్ప్ట్ ప్రాసెస్ యొక్క స్టాంట్ను చదవమని యూజర్ భావిస్తాడు. -ఉన్న జెండా ("వినియోగదారు" కొరకు) వాడుకదారుని దాని వాదన ద్వారా పేరు పెట్టబడిన విధానాన్ని (ఇది ఒక ఆరంభ ఐడిగా ఉండాలి) సంకర్షణ చేస్తుంది.
ఇది ఒక అసమానమైన లూప్ని ఉపయోగించకుండా రెండు సంబంధం లేని ప్రక్రియలు కలిసి చేరడానికి అనుమతిస్తుంది. డీబగ్గింగ్ లో సహాయపడటానికి, ఎక్స్ప్లోప్ డయాగ్నొస్టిక్స్ ఎల్లప్పుడూ stderr (లేదా కొన్ని లాగింగ్ మరియు డీబగ్గింగ్ సమాచారం కోసం స్టాండ్) వెళ్ళండి. ఇదే కారణంతో, ఇంటర్ప్రిటర్ ఆదేశం stdin నుండి ఇంటరాక్టివ్గా చదువుతుంది.
ఉదాహరణకు, క్రింది భాగం ఒక లాగిన్ ప్రక్రియను సృష్టిస్తుంది. అప్పుడు అది వినియోగదారుని (చూపబడదు) డయల్ చేస్తుంది మరియు చివరకు కలిసి రెండు కలుపుతుంది. అయితే, లాగిన్ ప్రక్రియ కోసం ఏదైనా ప్రక్రియ ప్రత్యామ్నాయం కావచ్చు. ఉదాహరణకు, షెల్ ఒక ఖాతా మరియు పాస్ వర్డ్ ను అందించకుండా పని చేయటానికి అనుమతిస్తుంది.
స్పాన్ లాగిన్ సెట్ లాగిన్ $ spawn_id స్పాన్ చిట్కా మోడెమ్ # వినియోగదారుకు తిరిగి డయల్ # ఇంటరాక్ట్ లాగిన్ యూజర్ కనెక్ట్ చేయండి -u $ లాగిన్బహుళ విధానాలకు అవుట్పుట్ పంపడానికి, ప్రతి- స్పాట్ ఐడి జాబితాను ఒక- ఔట్పుట్ పతాకంతో కలుపుతుంది . అవుట్పుట్ స్పాన్ ఐడిల గుంపుకు ఇన్పుట్ ఒక-ఇన్పుట్ జెండా చేత ఒక స్పాన్ ఐడి జాబితా ద్వారా నిర్ణయించబడుతుంది. (రెండు- ఇన్పుట్ మరియు అవుట్పుట్ ఒకే రూపంలో -i ఫ్లాగ్ను ఆశించే కమాండ్లో తీసుకుంటాయి, ఏవైనా_స్పాన్_సిడ్ ఇంటరాక్ట్లో అర్ధంకానిదికాదు.) క్రింది క్రింది ఫ్లాగ్లు మరియు తీగలను (లేదా నమూనాలు) ఈ ఇన్పుట్కు మరొక వరకు వర్తిస్తాయి - ఇన్పుట్ ఫ్లాగ్ కనిపిస్తుంది. ఏ- ఇన్పుట్ కనిపించకపోతే, అవుట్పుట్ సూచిస్తుంది "-ఇన్పుట్ $ user_spawn_id -output". (అదేవిధంగా, లేని పద్దతులతో - ఇన్పుట్ .) ఒక -ఇన్పుట్ పేర్కొనబడితే, ఇది $ user_spawn_id ను అధిగమించింది. రెండో- ఇన్పుట్ పేర్కొనబడినట్లయితే, అది $ spawn_id ను అధిగమించింది. అదనపు- ఇన్పుట్ ఫ్లాగ్లను పేర్కొనవచ్చు.
డిఫాల్ట్గా రెండు ఇన్పుట్ విధానాలు డిఫాల్ట్గా $ spawn_id మరియు $ user_spawn_id (రివర్స్లో) గా పేర్కొనబడ్డాయి. ఏ- అవుట్పుట్ జెండాతో ఒక- ఇన్పుట్ పతాకం కనిపిస్తే, ఆ ప్రక్రియ నుండి అక్షరాలు విస్మరించబడతాయి.
ఇతర- ఇన్పుట్ లేదా అవుట్పుట్ జెండాలు ఉపయోగించినప్పుడు -i జెండా ప్రస్తుత స్పాన్_ఐడ్ కోసం భర్తీ చేస్తోంది . A -i జెండా a -o జెండా సూచిస్తుంది.
పరోక్ష స్పాన్ ఐడిల ద్వారా సంకర్షణ చెందుతున్న ప్రక్రియలను మార్చడం సాధ్యపడుతుంది. (పరోక్ష స్పాన్ ఐడిలు ఆశించిన కమాండ్లో విభాగంలో వివరించబడ్డాయి.) పరోక్ష స్పాన్ ఐడిలు -i, -u, -ఇన్పుట్, లేదా-అవుట్పుట్ ఫ్లాగ్లతో నిర్దేశించవచ్చు.
వ్యాఖ్యాత [వాదనలు]
వినియోగదారుడు ఇంటరాక్ట్ మరియు Tcl ఆదేశాల కోసం ప్రాంప్ట్ చేయబడతాడు. ప్రతి కమాండ్ ఫలితంగా ముద్రించబడుతుంది.
విచ్ఛిన్నం మరియు కొనసాగుతున్న చర్యలు సాధారణ పద్ధతిలో ప్రవర్తించే నియంత్రణ వ్యవస్థలు (అంటే, proc కోసం ) కారణమవుతాయి. అయితే ఇంటెర్ప్రెటర్ దాని కాలర్కు తిరిగి రావడానికి కారణమవుతుంది, ఇంటర్ కాలరాన్ని దాని కాలర్లో తిరిగి రావడానికి ఇంటర్ప్రెటర్ కారణాన్ని కలిగిస్తుంది. ఉదాహరణకు, "proc foo" interpreter అని పిలిచినట్లయితే అప్పుడు చర్య inter_return ను అమలు చేస్తే , proc foo తిరిగి వస్తుంది. ఏదైనా ఇతర ఆదేశం కొత్త కమాండ్ల కోసం ప్రాంప్టర్ను కొనసాగించటానికి కారణమవుతుంది.
అప్రమేయంగా, ప్రాంప్ట్ రెండు పూర్ణాంకాలని కలిగి ఉంటుంది. మొదటి పూర్ణాంకం మూల్యాంకనం స్టాక్ యొక్క లోతును (అంటే, ఎన్ని సార్లు Tcl_Eval అని పిలుస్తారు) వివరిస్తుంది. రెండవ పూర్ణాంకం TCL చరిత్ర ఐడెంటిఫైయర్. "ప్రాంప్ట్ 1" అని పిలవబడే విధానాన్ని నిర్వచించడం ద్వారా ప్రాంప్ట్ అమర్చవచ్చు, దీని తిరిగి విలువ తదుపరి ప్రాంప్ట్ అవుతుంది. ఒక ప్రకటనలో తెరిచిన ఉల్లేఖనాలు ఉంటే, బ్రాకెట్లు, బ్రాకెట్లు, బ్రాకెట్లు, సెకండరీ ప్రాంప్ట్ (డిఫాల్ట్గా "+>") కొత్త లైన్పై జారీ చేయబడుతుంది. "ప్రాంప్ట్ 2" అని పిలవబడే విధానాన్ని నిర్వచించడం ద్వారా ద్వితీయ ప్రాంప్ట్ అమర్చవచ్చు.
వ్యాఖ్యాత సమయంలో, వండిన మోడ్ను ఉపయోగిస్తారు, దాని కాలర్ ముడి మోడ్ను ఉపయోగిస్తున్నప్పటికీ.
Stdin మూసివేసినట్లయితే, -ఇప్పుడు జెండాను ఉపయోగించినట్లయితే వ్యాఖ్యాత తిరిగి రాబడుతుంది , ఈ సందర్భంలో తరువాతి వాదన ప్రస్తావించబడింది.
log_file [args] [[-a] ఫైలు]
ఒక ఫైల్ పేరు అందించబడితే, log_file ఫైలులో సెషన్ యొక్క ట్రాన్స్క్రిప్ట్ (ఆ సమయంలో మొదలవుతుంది) రికార్డ్ చేస్తుంది. log_file ఎటువంటి వాదన ఇవ్వకపోతే రికార్డింగ్ ఆగిపోతుంది. ఏదైనా మునుపటి లాగ్ ఫైల్ మూసివేయబడింది.
ఫైల్ పేరుకు బదులుగా, ఒక Tcl ఫైలు ఐడెంటిఫైయర్ -ఓపెన్ లేదా- లియోపోప్న్ జెండాలను ఉపయోగించడం ద్వారా అందించబడుతుంది. ఇది స్పాన్ కమాండ్కు సమానంగా ఉంటుంది. (మరింత సమాచారం కోసం స్పాన్ చూడండి.)
Log-user ఆదేశం ద్వారా అణగదొక్కబడిన -a జెండా దళాల అవుట్పుట్ లాగ్ అవుతుంది.
అప్రమేయంగా, log_file ఆదేశం పాత ఫైళ్ళకు వాటిని త్రిప్పికొట్టకుండా కాకుండా లాగింగ్ చేయగలుగుతుంది మరియు ఒక సెషన్లో చాలాసార్లు అందుబాటులో ఉంటుంది. ఫైళ్లను ఖండించుటకు , -నప్పడం జెండాని వాడండి .
ఇ- ఇన్ఫో పతాకం log_file ఇచ్చిన ఇటీవలి సమాచారం లేని వాదనలు వివరణను తిరిగి ఇవ్వటానికి కారణమవుతుంది.
log_user -info | 0 | 1
డిఫాల్ట్గా, డైలాగ్ stdout (మరియు ఒక లాఫ్ఫైల్ ఓపెన్ ఉంటే) కు లాగ్ చేయబడాలని అనుకుందాం. "Log_user 0" ఆదేశము ద్వారా "log_user 1" చేత పునఃప్రారంభించబడిన stdout కు లాగింగ్ అచేతనం చేయబడినది. లాగ్ఫైల్కు లాగిన్ చేయడం మారకుండా ఉంటుంది.
ఇ- ఇన్ఫో పతాకం 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 చదరంగంఇది "ఇంటరాక్ట్ -u" కంటే మరింత సమర్థవంతంగా ఉంటుంది, అయితే, ఆశించిన ప్రక్రియ ఇకపై నియంత్రణలో లేనందున ఇది ప్రోగ్రామ్ పరస్పర చర్య చేసే సామర్థ్యాన్ని త్యాగం చేస్తుంది.
ఏ నియంత్రణ టెర్మినల్ అందించబడిందో గమనించండి. మీరు డిస్కనెక్ట్ లేదా ప్రామాణిక ఇన్పుట్, ఉద్యోగ నియంత్రణ (షెల్లు, లాగిన్, etc) చేసే కార్యక్రమాలు సరిగా పనిచేయవు.
పారిటీ [-d] [-i spawn_id] [విలువ]
ఉద్భవించిన ప్రక్రియల అవుట్పుట్ నుండి పారిటీని నిలిపివేయాలా లేదా తొలగించాలా అనే విషయాన్ని వివరిస్తుంది. విలువ సున్నా అయితే, పారిటీ తొలగించబడింది, లేకుంటే అది తీసివేయబడదు. విలువ వాదన లేకుండా, ప్రస్తుత విలువ తిరిగి వస్తుంది.
-d జెండాతో, డిఫాల్ట్ పారిటీ విలువ అమర్చబడుతుంది. (ప్రారంభ డిఫాల్ట్ 1, అంటే, పారిటీ కత్తిరించబడదు.) -i జెండాతో, ప్రస్తుత స్పాన్ కోసం సెట్ చేయబడిన పేర్ ఐడి కోసం పారిటీ విలువ సెట్ చేయబడుతుంది .
remove_nulls [-d] [-i spawn_id] [విలువ]
వేరియబుల్ expect_out లేదా ఇంటరాక్ట్_ఔట్ లో నమూనా సరిపోలుతుండటం లేదా భద్రపరచడం ముందు పొరలు ఉన్న ప్రక్రియల అవుట్పుట్ నుండి నల్లను నిలుపుకోవచ్చా లేదా లేదో అని నిర్వచిస్తుంది. విలువ 1 అయితే, నల్లు తీసివేయబడతాయి. విలువ 0 అయితే, nulls తొలగించబడవు. విలువ వాదన లేకుండా, ప్రస్తుత విలువ తిరిగి వస్తుంది.
-d జెండాతో, డిఫాల్ట్ విలువ సెట్ చేయబడింది. (ప్రారంభ డిఫాల్ట్ 1, అనగా, nulls తొలగిస్తారు.) -i జెండాతో, విలువ అనే పేరున్న స్పాన్ ఐడి కోసం అమర్చబడుతుంది, లేకుంటే ఇది ప్రస్తుత ప్రక్రియకు సెట్ చేయబడుతుంది .
Nulls తొలగించాలా లేదా లేదో, ఆశ లాగ్ మరియు stdout కు శూన్య బైట్లు రికార్డ్ చేస్తుంది.
[-ఫ్లగ్స్] స్ట్రింగ్ను పంపండి
ప్రస్తుత ప్రాసెస్కు స్ట్రింగ్ పంపుతుంది. ఉదాహరణకు, కమాండ్
ప్రస్తుత విధానానికి అక్షరాలు, helloworld పంపుతుంది. (Tcl ఒక printf -like ఆదేశం ( ఫార్మాట్ అని పిలుస్తారు) కలిగి ఉంటుంది, ఇది ఏకపక్ష సంక్లిష్ట తీగలను నిర్మించవచ్చు.)
అక్షరాలను తిరిగి పంపుతుంది, అయితే తిరిగి-బఫర్ ఇన్పుట్ ఉన్న ప్రోగ్రామ్లు తిరిగి పాత్రను పంపించేవరకు అక్షరాలు చదవవు. తిరిగి అక్షరం "\ r" అని సూచించబడుతుంది.
జెండా కంటే తరువాతి వాదనను స్ట్రింగ్గా అన్వయించటానికి జెండా చేస్తుంది. ఎటువంటి స్ట్రింగ్ "-" ముందుగానే జెండాగా కనిపిస్తుందో లేదో. అనుకోకుండా ఫ్లాగ్స్ లాగా కనిపించే వాటి ద్వారా జరగకుండా వేరియబుల్ తీగలను పేర్కొనడానికి ఇది విశ్వసనీయ యాంత్రిక విధానాన్ని అందిస్తుంది. ("-" తో ప్రారంభమయ్యే అన్ని తీగలను భవిష్యత్ ఎంపికల కోసం కేటాయించారు.)
స్ట్రింగ్ను పేరు పెట్టబడిన spawn_id కు పంపించాలని -i ఫ్లాగ్ ప్రకటించింది. Spawn_id user_spawn_id , మరియు టెర్మినల్ ముడి రీతిలో ఉంటే, టెర్మినల్ వండిన మోడ్లో ఉన్నట్లు కనిపిస్తాయి, తద్వారా స్ట్రింగ్లోని క్రొత్త లైన్లు తిరిగి-క్రొత్త లైన్ సన్నివేశాలకు అనువదించబడతాయి. ఈ - పతాకం ఈ అనువాదాన్ని నిలిపివేస్తుంది.
-నాల్ ఫ్లాగ్ శూన్య అక్షరాలను (0 బైట్లు) పంపుతుంది. అప్రమేయంగా, ఒక శూన్య పంపబడుతుంది. ఒక పూర్ణాంకం -null ను ఎన్ని నలుసులు పంపించాలో సూచించవచ్చు.
బ్రేక్ జెండా విరామం పరిస్థితిని సృష్టిస్తుంది. స్పాన్ ఐడి "స్పాన్ -ఓపెన్" ద్వారా తెరవబడిన ఒక tty పరికరాన్ని సూచిస్తే ఇది అర్ధమే. మీరు చిట్కా వంటి ప్రక్రియను కలిగి ఉంటే, మీరు విరామ చిహ్నాన్ని రూపొందించడానికి చిట్కా యొక్క కన్వెన్షన్ను ఉపయోగించాలి.
ఈ - జెండా బలగాలు ఉత్పత్తిని "నెమ్మదిగా" పంపించాయి, అందుచే ఒక కంప్యూటర్లో ఒక ఇన్పుట్ బఫర్ను అధిగమించే సాధారణ పరిస్థితిని నివారించండి, ఇది ఒకే బఫర్ను ఎప్పటికీ బయటికి పంపని వ్యక్తికి రూపకల్పన చేయబడింది. ఈ అవుట్పుట్ నియంత్రిత వేరియబుల్ "send_slow" విలువను నియంత్రిస్తుంది, ఇది రెండు ఎలిమెంట్ జాబితాను తీసుకుంటుంది. మొదటి మూలకం పరమాణువుగా పంపటానికి బైట్ల సంఖ్యను వివరించే పూర్ణాంకం. రెండవ మూలకం, అణు పంక్తులు వేరు చేయవలసిన సెకనుల సంఖ్యను వివరించే వాస్తవ సంఖ్య. ఉదాహరణకు, "10 send_slow సెట్ చేయండి" 10 పంక్తుల మధ్య 1 మిల్లిసెకండ్తో స్ట్రింగ్లను పంపుటకు "send-s" ను బలవంతం చేస్తుంది.
-h జెండా దళాలు ఉత్పాదకతను వాస్తవంగా టైప్ చేస్తున్నట్లుగా (కొంతవరకు) పంపించబడతాయి. పాత్రల మధ్య మానవ లాంటి జాప్యాలు కనిపిస్తాయి. (అల్గోరిథం ఒక ప్రత్యేకమైన దరఖాస్తుకు అనుగుణంగా మార్పులతో ఒక వీబుల్ పంపిణీపై ఆధారపడి ఉంటుంది.) ఈ అవుట్పుట్ అనేది ఐదు మూలకం జాబితాను తీసుకునే వేరియబుల్ "send_human" యొక్క విలువచే నియంత్రించబడుతుంది. మొదటి రెండు అంశాల్లో సెకండ్లలో అక్షరాల సగటు మధ్యస్థమైన సమయం. ముందుగా డిఫాల్ట్గా ఉపయోగించబడుతుంది. రెండో పదాల ముగింపులో ఉపయోగించబడుతుంది, అటువంటి మార్పులలో అప్పుడప్పుడు సంభవించే నిగూఢ అంతరాయాలను అనుకరించడానికి. మూడవ పరామితి వేరియబుల్స్ యొక్క కొలత. ఇక్కడ చాలా వేరియబుల్ ఉంది, 1 సహేతుకంగా వేరియబుల్, మరియు 10 చాలా తేలికైనది. అనంతంకు అన్యాయాలు 0 ఉన్నాయి. గత రెండు పారామితులు వరుసగా కనీస మరియు గరిష్ట మధ్యతరగతి సమయం. గరిష్ట మరియు గరిష్ట చివరి మరియు "క్లిప్" చివరిసారి ఉపయోగిస్తారు. గరిష్ట మరియు గరిష్ట క్లిప్ తగినంత విలువలు ఉంటే అంతిమ సగటు ఇచ్చిన సగటు భిన్నంగా ఉంటుంది.
ఉదాహరణకు, కింది కమాండ్ వేగవంతమైన మరియు స్థిరమైన టైపిస్ట్ను అనుసరిస్తుంది:
సెట్ send_human {.1 .0 1 .05 2} send -h "నేను ఆకలితో ఉన్నాను, లెట్ యొక్క లీన్ చేయండి."క్రిందికి హ్యాంగోవర్ తర్వాత మరింత అనుకూలంగా ఉండవచ్చు:
సెట్ send_human {.4 .4 .2 .5 100} send -h "గుడ్ పార్టీ పార్టీ lash night!"దోషాలు అనుకరణ కాదు, అయితే దోషాలను మరియు సవరణలను పొందుపరచడం ద్వారా వాదన దిద్దుబాటు పరిస్థితులను మీరే ఏర్పరుచుకోవచ్చు, అయితే పంపే వాదనలో.
విరామాలు పంపడం కోసం శూన్య అక్షరాలను పంపడానికి జెండాలు, నెమ్మదిగా అవుట్పుట్ను బలవంతంగా మరియు మానవ-శైలి అవుట్పుట్ కోసం పరస్పరం ప్రత్యేకమైనవి. చివరిది మాత్రమే ఉపయోగించబడుతుంది. ఇంకా, శూన్య వాదనను శూన్య అక్షరాలు లేదా విరామాలు పంపడం కోసం జెండాలతో పేర్కొనవచ్చు.
ఇది ఒక అంచనా ద్వారా ఒక ప్రక్రియ మొదటి పంపండి మంచి ఆలోచన. వేచి ఉండదు, ఆ ప్రక్రియను ప్రారంభించటానికి వేచి ఉండండి. ప్రత్యేకంగా, ప్రాసెస్ మొదలవుతుంది ముందు మొదట పూర్తయితే, మీరు మీ డేటాను నిర్లక్ష్యం చేసే ప్రమాదం ఉంది. ఇంటరాక్టివ్ కార్యక్రమాలు ప్రాధమిక ప్రాంప్ట్ ఇవ్వని సందర్భాల్లో, మీరు వీటిని ఆలస్యం ద్వారా పంపవచ్చు :
# ఎలా విచ్ఛిన్నం చేయాలో హాకర్లు సూచనలు ఇవ్వకుండా, # ఈ వ్యవస్థ బాహ్య సంకేతపదం కోసం ప్రాంప్ట్ చేయదు. # Spawn telnet ను పూర్తి చేయడానికి 5 సెకన్ల పాటు వేచి ఉండండి very.secure.gov నిద్ర 5 పాస్ వర్డ్ ను పంపండి \ rexp_send పంపేందుకు మారుపేరు . మీరు Expectk ను లేదా TK పర్యావరణంలో ఆశించదగిన వేరొక రూపాన్ని ఉపయోగిస్తుంటే, Tk పూర్తిగా భిన్న ప్రయోజనం కోసం పంపబడుతుంది. exp_send పరిసరాలకు అనుగుణ్యత కొరకు అందించబడుతుంది. ఇలాంటి మారుపేర్లు ఇతర ఆశించే ఇతర పంపే ఆదేశాలకు అందించబడతాయి.
send_error [-flags] స్ట్రింగ్
ప్రస్తుత విధానం కంటే అవుట్డెంట్ను stderr కు పంపించటం తప్ప, పంపులా ఉంటుంది.
send_log [-] స్ట్రింగ్
లాగ్ ఫైల్కు మాత్రమే స్ట్రింగ్ పంపబడుతుంది తప్ప ( log_file చూడండి.) లాగ్ ఫైల్ తెరిచి ఉంటే వాదనలు విస్మరించబడతాయి.
send_tty [-flags] స్ట్రింగ్
అవుట్పుట్ను ప్రస్తుత ప్రక్రియ కంటే / dev / tty కి పంపించటం తప్ప, పంపులా ఉంటుంది .
send_user [-flags] స్ట్రింగ్
ప్రస్తుత ప్రక్రియ కంటే స్టాండ్ అవుట్పుట్ పంపబడుతుంది తప్ప, పంపులా ఉంటుంది.
నిద్ర సెకన్లు
ఇవ్వబడిన సంఖ్య సెకనుల కొరకు స్క్రిప్ట్ నిద్రకు కారణమవుతుంది. సెకనుల దశాంశ సంఖ్య కావచ్చు. నిద్రిస్తున్నట్లు ఎదురుచూసే సమయంలో ఆటంకాలు (మరియు మీరు Expectk ను ఉపయోగిస్తున్నట్లయితే Tk ఈవెంట్స్) ప్రాసెస్ చేయబడతాయి.
spons [args] కార్యక్రమం [వాదనలు]
"ప్రోగ్రామ్ ఆర్గ్స్" నడుస్తున్న ఒక కొత్త ప్రక్రియను సృష్టిస్తుంది. దీని యొక్క stdin, stdout మరియు stderr అనుకోకు అనుసంధానించబడి ఉంటాయి, తద్వారా వారు ఇతర ఆదేశాలను చదివి, వ్రాయవచ్చు. కనెక్షన్ దగ్గరికి విరిగిపోతుంది లేదా ప్రాసెస్ అయినా ఫైల్ ఐడెంటిఫైయర్లను ముగుస్తుంది.
ఒక ప్రక్రియ స్పాన్ చేత ప్రారంభించబడినప్పుడు, వేరియబుల్ spawn_id ఆ విధానాన్ని సూచించే ఒక వివరణకు సెట్ చేయబడింది. 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 exists} else {# / dev / tty # బహుశా క్రోన్, బ్యాచ్ లేదా స్క్రిప్ట్లో ఉనికిలో లేదు}స్పాన్ UNIX ప్రాసెస్ ఐడిని తిరిగి పంపుతుంది. ఎటువంటి ప్రక్రియ లేనట్లయితే, 0 తిరిగి వస్తుంది. వేరియబుల్ spawn_out (బానిస, పేరు) pty బానిస పరికరం యొక్క పేరుకు సెట్ చేయబడింది.
అప్రమేయంగా, స్పాన్ కమాండ్ పేరు మరియు వాదనలు ప్రతిబింబిస్తుంది. నయోచా జెండా దీన్ని చేయకుండా స్పాన్ ఆపివేస్తుంది.
కన్సోల్ పతాకము కన్సోల్ అవుట్పుట్ ఏర్పడటానికి కారణమవుతుంది. ఇది అన్ని సిస్టమ్లకు మద్దతు లేదు.
అంతర్గతంగా, స్పాన్ ఒక pty ఉపయోగిస్తుంది, యూజర్ యొక్క tty అదే విధంగా ప్రారంభించారు. ఇది అన్ని సెట్టింగులు "సేన్" (స్టట్టి (1) ప్రకారం) మరింత ప్రారంభమవుతుంది. వేరియబుల్ stty_init నిర్వచించబడితే, ఇది మరింత ఆకృతీకరణకు స్టట్టి వాదాల యొక్క శైలిలో అన్వయించబడుతుంది. ఉదాహరణకు, "సెట్ stty_init ముడి" ముడి మోడ్లో ప్రారంభించటానికి మరింత విరుద్ధమైన ప్రక్రియల టెర్మినల్స్కు కారణం అవుతుంది. -నోటటీకోపీ యూజర్ యొక్క tty ఆధారంగా ప్రారంభంలో skips. -నాటీటీని "సేన్" ప్రారంభంలో వదలివేస్తుంది .
సాధారణంగా, స్పాన్ అమలు చేయడానికి తక్కువ సమయం పడుతుంది. మీరు గణనీయమైన సమయాన్ని కేటాయించడం గమనించినట్లయితే, ఇది బహుశా wtged అయిన ptys ను ఎదుర్కోవచ్చు. సంచరించే ప్రక్రియలతో కలవరపడకుండా ఉండటానికి అనేక పరీక్షలు ptys లో అమలు అవుతాయి. (వీటిని పర్పుల్ pty కు 10 సెకన్లు తీసుకోండి.) ఊహించని రీతిలో డీడ్ స్టేట్స్ లో అనేక ptys ను ఎదుర్కొంటే, -d ఎంపికతో ఆశించాను. మీరు ఈ ptys అటాచ్ చేసిన ప్రక్రియలను మీరు చంపలేకుంటే, మీ మాత్రమే రీబూట్ రీబూట్ కావచ్చు.
కార్యక్రమం విజయవంతం కాకపోతే, ఎగ్జిక్యూట్ (2) విఫలమైతే (ఉదా. ప్రోగ్రామ్ లేనప్పుడు), తరువాతి పరస్పర చర్య ద్వారా ఒక లోపం సందేశము తిరిగి ఇవ్వబడుతుంది లేదా కార్యక్రమం నడుపుతున్నట్లుగా ఆదేశమును ఆపివేసి దోష సందేశాన్ని అవుట్పుట్గా ఉత్పత్తి చేస్తుంది. ఈ ప్రవర్తన స్పాన్ అమలు యొక్క ఒక సహజ పరిణామం. అంతర్గతంగా, spawn_id ద్వారా కమ్యూనికేషన్ ద్వారా మినహా ప్రాధమిక ఆశించే ప్రక్రియ కమ్యూనికేట్ ఎటువంటి మార్గం తరువాత, స్పాన్ ఫోర్కులు.
-తొక్క జెండా తరువాతి వాదనను టిక్లె ఫైలు ఐడెంటిఫైయర్గా (అంటే, ఓపెన్ ద్వారా తిరిగి వస్తుంది) వ్యాఖ్యానించడానికి కారణమవుతుంది. అప్పుడు స్పాన్ ఐడిని అది ఎదిగిన ప్రక్రియగా ఉపయోగించబడుతుంది . (ఫైల్ ఐడెంటిఫైయర్ ఇకపై ఉపయోగించకూడదు.) ఇది ముడి పరికరాలను, ఫైళ్ళను మరియు పైప్లైన్లను ఒక pty ను ఉపయోగించకుండా అభివృద్ధి చేయబడిన ప్రక్రియలుగా పరిగణించటానికి మిమ్మల్ని అనుమతిస్తుంది. ఏ సంబంధం ప్రక్రియ లేదు సూచించడానికి 0 తిరిగి. తెరిచిన ప్రక్రియకు కనెక్షన్ మూసివేయబడినప్పుడు, కాబట్టి Tcl ఫైలు ఐడెంటిఫైయర్. -ఎనేవోపోన్ జెండా లాగానే -ఒక మినహా -ఒక మినహాయింపు - స్పాన్ ఐడి మూసివేయబడిన తర్వాత కూడా ఫైల్ ఐడెంటిఫైయర్ను తెరిచి ఉంచడానికి కారణమవుతుంది.
తెల్లజాతి జెండా ఒక తెరుచుటకు తెరవటానికి కారణమౌతుంది కానీ ఏ ప్రక్రియ అయినా పోయేది కాదు . ఏ సంబంధం ప్రక్రియ లేదు సూచించడానికి 0 తిరిగి. Spawn_id ఎప్పటిలాగే సెట్ చేయబడింది.
వేరియబుల్ spawn_out (బానిస, fd) pty బానిసకు అనుగుణంగా ఒక ఫైల్ ఐడెంటిఫైయర్కు సెట్ చేయబడింది. ఇది "క్లోస్-స్లేవ్" ఉపయోగించి మూసివేయబడుతుంది.
ఆగ్నేయ జెండా పేరిట ప్రక్రియలో నిర్లక్ష్యం చేయటానికి ఒక సిగ్నల్ పేర్లు. లేకపోతే, సిగ్నల్స్ డిఫాల్ట్ ప్రవర్తన పొందండి. ప్రతి సిగ్నల్కు ప్రత్యేక జెండా అవసరమవుతుంది తప్ప, ట్రాక్కు ఆదేశాలలో సిగ్నల్స్ పేరు పెట్టబడ్డాయి.
స్ట్రాస్ స్థాయి
ఉరితీయడానికి ముందు ప్రస్తావించిన క్రింది ప్రకటనలు కారణమవుతాయి. (Tcl యొక్క ట్రేస్ కమాండ్ ట్రేసేస్ వేరియబుల్స్.) లెవెల్ స్టోక్లో ఎంత దూరం దిగజారిందో సూచిస్తుంది. ఉదాహరణకు, కింది ఆదేశం మొదటి నాలుగు స్థాయిలు కాల్స్ వెతుకుతున్నప్పుడు ఆశించేది , కానీ క్రింద ఏదీ లేదు.
ఇ- ఇన్ఫో పతాకం ఇచ్చిన ఇటీవలి సమాచారం కాని వాదనలు యొక్క వివరణను తిరిగి ఇవ్వడానికి స్ట్రెస్ కారణమవుతుంది.
stty args
బాహ్య స్టెప్ కమాండ్కు సమానంగా టెర్మినల్ మోడ్లను మారుస్తుంది.
అప్రమేయంగా, నియంత్రణ టెర్మినల్ యాక్సెస్. ఇతర టెర్మినల్స్ను "కమాండ్ ఫలితంగా దానిని స్థితికి పంపుట ద్వారా అభ్యర్ధించడం ద్వారా ప్రాప్తి చెయ్యవచ్చు.ఏ స్థితి అభ్యర్థించబడకపోయినా మరియు నియంత్రణ టెర్మినల్ ఆక్సెస్ చెయ్యబడితే, ముడి మరియు ప్రతిధ్వని గుణముల యొక్క మునుపటి స్థితి తిరిగి తరువాత రూపొందిస్తుంది కమాండ్ ఉపయోగించబడుతుంది.
ఉదాహరణకు, వాదనలు ముడి లేదా -కట్టించిన టెర్మినల్ను ముడి మోడ్లో ఉంచుతాయి. వాదనలు -వా లేదా వండిన టెర్మినల్ను వండిన రీతిలో ఉంచండి. వాదనలు echo మరియు -oo టెర్మినల్ను వరుసగా echo మరియు నోచో మోడ్ లోకి ఉంచాయి.
ఈ కింది ఉదాహరణ తాత్కాలికంగా ఏకాభిప్రాయాన్ని ఎలా నిలిపివేస్తుంది వివరిస్తుంది. వీటిలో పాస్వర్డ్లు పొందుపరచడాన్ని నివారించడానికి లేకపోతే స్వయంచాలకంగా స్క్రిప్ట్స్లో ఉపయోగించబడతాయి. (క్రింద ఉన్న మరిన్ని EXPECT సూచనలు క్రింద మరింత చర్చ చూడండి.)
stty -echo send_user "పాస్వర్డ్:" expect_user -re "(. *) \ n" సెట్ చెయ్యండి $ expected_out (1, స్ట్రింగ్) stty echo వ్యవస్థ వాదిస్తుంది
టెర్మినల్ నుండి కమాండ్గా టైప్ చేస్తేనే ఇన్పుట్గా sh (1) కు args ఇస్తుంది. షెల్ ముగుస్తుంది వరకు వేచి భావిస్తున్నారు. Sh నుండి రిటర్న్ స్థితి నిర్వర్తించబడుతోంది, అది దాని రిటర్న్ స్థితిని నిర్వహిస్తుంది.
కార్యనిర్వాహణానికి విరుద్దంగా, ఇది స్క్రిప్ట్కు స్టడిన్ మరియు స్టాండులను దారి మళ్లించటంతో, సిస్టమ్ రీడైరెక్షన్ (స్ట్రింగ్ ద్వారా సూచించిన దాని కంటే ఇతర) ను అమలు చేస్తుంది. అందువలన, కార్యక్రమాలు నేరుగా / dev / tty కు మాట్లాడాలి. అదే కారణాల వలన, వ్యవస్థ యొక్క ఫలితాలు లాగ్లో నమోదు చేయబడలేదు.
స్టాంప్ [వాదనలు]
ఒక స్టాంప్ రిటర్న్. ఎటువంటి వాదనలు లేకుండా, యుగం నుండి సెకన్ల సంఖ్య తిరిగి వస్తుంది.
ఫార్మాట్ జెండా తిరిగి ఒక స్ట్రింగ్ను పరిచయం చేసింది, కానీ Stiftime కోసం POSIX నియమాల ప్రకారం ప్రత్యామ్నాయాలతో తయారు చేయబడింది. ఉదాహరణకు% ఒక సంక్షిప్త వారపు పేరు (అంటే, సాట్) చేత భర్తీ చేయబడుతుంది. ఇతరులు:
% ఒక పూర్తి వారం రోజు పేరు% A పూర్తి వారపు పేరు% b క్లుప్తంగా నెల పేరు% B పూర్తి నెల పేరు% c తేదీ-సమయం లో: అక్టోబర్ 6 11:45:56 1993% d రోజు (01-31% H గంట (00-23)% నేను గంట (01-12)% j రోజు (001-366)% m నెల (01-12)% M నిముషం (00-59)% p లేదా pm% S రెండవ (00-61) % వ రోజు (1-7, సోమవారం వారం మొదటి రోజు)% U వారం (00-53, మొదటి ఆదివారం వారానికి మొదటి రోజు)% V వారం (01-53, ISO 8601 శైలి)% w రోజు (0- 6)% W వారానికి (00-53, మొదటి సోమవారం వారానికి మొదటి రోజు)% x తేదీ-సమయంగా: అక్టోబర్ 6, 1993 1993 లో X సమయం: 23:59:59% y సంవత్సరం (00-99) % Y సంవత్సరానికి గాను: 1993% Z టైమ్జోన్ (లేదా ఏదీ నిర్ణయించలేనిది) %% ఒక బేర్ శాతం సంకేతంఇతర% వివరణలు నిర్వచించబడలేదు. ఇతర పాత్రలు తాకబడని ద్వారా పంపబడతాయి. మాత్రమే సి లొకేల్కు మద్దతు ఉంది.
శకలం నుండి ఫార్మాట్ చేయడానికి మూలంగా ఉపయోగించేందుకు సెకన్ల సెకన్ల సెకనులని పరిచయం చేస్తుంది. లేకపోతే, ప్రస్తుత సమయం ఉపయోగించబడుతుంది.
GMT టైమ్జోన్ను ఉపయోగించడానికి GMAT ఫ్లాగ్ ఫోర్స్ టైమ్స్టాంప్ అవుట్పుట్. ఏ జెండా లేకుండా, స్థానిక సమయమండలిని ఉపయోగిస్తారు.
ట్రాప్ [[ఆదేశం] సంకేతాలు]
ఇవ్వబడిన సిగ్నల్స్ యొక్క భవిష్యత్తు రశీదు మీద అమలు చేయబడిన ఆదేశం అమలులోకి వస్తుంది. ఆదేశం ప్రపంచ పరిధిలో అమలు అవుతుంది. ఆదేశం లేకపోతే, సిగ్నల్ చర్య తిరిగి వస్తుంది. కమాండ్ స్ట్రింగ్ SIG_IGN అయితే, సంకేతాలు విస్మరించబడతాయి. కమాండ్ స్ట్రింగ్ SIG_DFL అయితే, సంకేతాలు సిస్టమ్ డిఫాల్ట్కు ఫలితంగా ఉంటాయి. సిగ్నల్స్ ఒకే సిగ్నల్ లేదా సిగ్నల్స్ జాబితా. సిగ్నల్ (3) ప్రకారం సిగ్నల్స్ సంఖ్యాపరంగా లేదా సంకేతంగా పేర్కొనవచ్చు. "SIG" ఆదిప్రత్యయం తొలగించబడవచ్చు.
ఏ వాదనలు లేకుండా (లేదా వాదన-సంఖ్య), ట్రాప్ ప్రస్తుతం అమలు చేయబడుతున్న ట్రాప్ కమాండ్ యొక్క సిగ్నల్ సంఖ్యను అందిస్తుంది.
ఆదేశాన్ని మొదట ప్రారంభించినప్పుడు Tcl తిరిగి రాబోతున్నదేమోనైనా ఆ కోడ్ యొక్క తిరిగి కోడ్ను ఆ కోడ్-కోడ్ ఫ్లాగ్ ఉపయోగిస్తుంది.
ట్రాప్ ప్రకటించబడినప్పుడు కంటే ఆ కమాండ్ నడుస్తున్న సమయంలో, ఇంటెర్ప్రెర్ట్ చురుకుగా వాడటం ద్వారా ఆ- టైప్ జెండా కమాండ్ను కలిగిస్తుంది.
ట్రాప్ కమాండ్ ప్రస్తుతం అమలు చేయబడుతున్న ట్రాప్ కమాండ్ యొక్క సిగ్నల్ పేరును తిరిగి ఇవ్వడానికి ఆ -పేరు ఫ్లాగ్ కారణమవుతుంది.
మాక్స్ జెండా ట్రాప్ కమాండ్ను సెట్ చేయగల అతిపెద్ద సిగ్నల్ సంఖ్యను తిరిగి అందిస్తుంది.
ఉదాహరణకు, ట్రాప్ {send_user "Ouch!"} SIGINT "ఆదేశం" Ouch! " ప్రతిసారి యూజర్ ప్రెస్సెస్ సి.
అప్రమేయంగా, SIGINT (ఇది సాధారణంగా C ^ ను నొక్కడం ద్వారా ఉత్పత్తి అవుతుంది) మరియు SIGTERM కారణం నిష్క్రమించడానికి ఆశించటం. ఎక్స్పెక్ట్ మొదలవుతున్నప్పుడు డిఫాల్ట్గా సృష్టించబడిన క్రింది ట్రాప్ కారణంగా ఇది జరుగుతుంది.
ట్రాప్ నిష్క్రమణ {SIGINT SIGTERM}డీబగ్గర్ను ప్రారంభించడానికి మీరు -D ఫ్లాగ్ను ఉపయోగిస్తే, ఇంటరాక్టివ్ డీబగ్గర్ను ప్రారంభించడానికి SIGINT పునఃస్థాపించబడింది. ఈ క్రింది ట్రాప్ కారణంగా:
trap {exp_debug 1} SIGINTడీబగ్గర్ ట్రాప్ను పర్యావరణ వేరియబుల్ EXPECT_DEBUG_INIT ను కొత్త ట్రాప్ కమాండ్కు మార్చడం ద్వారా మార్చవచ్చు.
మీ స్క్రిప్కి ట్రాప్ ఆదేశాలను జోడించడం ద్వారా వీటిని రెండింటినీ ఓవర్రైడ్ చెయ్యవచ్చు. ప్రత్యేకంగా, మీకు మీ స్వంత "ట్రాప్ నిష్క్రమణ SIGINT" ఉంటే, ఇది డీబగ్గర్ ట్రాప్ను భర్తీ చేస్తుంది. మీరు డీబగ్గర్ను పొందకుండా వినియోగదారులను నిరోధించాలనుకుంటే ఇది ఉపయోగపడుతుంది.
మీరు SIGINT లో మీ స్వంత ట్రాప్ను నిర్వచించాలనుకుంటే, అది నడుస్తున్నప్పుడు డీబగ్గర్కు ట్రాప్ చేయాల్సిన అవసరం ఉంది:
{! [exp_debug]} {trap mystuff SIGINT}ప్రత్యామ్నాయంగా, మీరు డీబగ్గర్కు కొన్ని ఇతర సిగ్నల్ ను ఉపయోగించి ట్రాప్ చేయవచ్చు.
మీరు ఆశించేలా అంతర్గతంగా ఉపయోగించడం వలన ట్రాప్ SIGALRM కోసం చర్యను మీరు ఓవర్రైడ్ చేయనివ్వదు. డిస్కనెక్ట్ కమాండ్ SIGALRM ను SIG_IGN (విస్మరించు) కు అమర్చుతుంది. తరువాతి స్పాన్ ఆదేశాలలో మీరు డిసేబుల్ అయినంత కాలం ఈ మీరు తిరిగి ప్రారంభించవచ్చు.
మరింత సమాచారం కోసం సిగ్నల్ (3) చూడండి.
వేచి ఉండండి
ఎదిగిన ప్రక్రియ వరకు (లేదా ప్రస్తుత ప్రక్రియను ఎవరూ పిలువకపోతే) ఆలస్యం అవుతుంది.
సాధారణంగా నాలుగు పూర్ణాంకాల జాబితాను రిటర్న్ చేయండి. మొట్టమొదటి పూర్ణాంకం వేచి ఉన్న ప్రక్రియ యొక్క పిడ్. రెండవ పూర్ణాంకం సంబంధిత స్పాన్ ఐడి. ఆపరేటింగ్ సిస్టమ్ లోపం సంభవించినట్లయితే మూడవ పూర్ణాంకం -1 లేదా 0 లేకపోతే. మూడవ పూర్ణాంకం 0 అయితే, నాల్గవ పూర్ణాంకం ఆరంభ ప్రక్రియ ద్వారా తిరిగి పొందబడిన స్థితి. మూడవ పూర్ణాంకం -1 అయితే, నాల్గవ పూర్ణాంకం ఆపరేటింగ్ సిస్టమ్చే సెట్ చేయబడిన తప్పు యొక్క విలువ. గ్లోబల్ వేరియబుల్ errorCode కూడా అమర్చబడింది.
వేచి నుండి తిరిగి విలువ చివరిలో అదనపు అంశాలు కనిపించవచ్చు. ఐచ్చిక ఐదవ మూలక సమాచారం యొక్క తరగతి గుర్తిస్తుంది. ప్రస్తుతం, ఈ మూలకం కోసం మాత్రమే సాధ్యమయ్యే విలువ CHILDKILLED, ఈ సందర్భంలో తదుపరి రెండు విలువలు C- శైలి సిగ్నల్ పేరు మరియు ఒక చిన్న పాఠ్య వివరణ.
-i ఫ్లాగ్ అనే పేరును Spawn_id ( ప్రాసెస్ ఐడి కాదు) అనే పేరుతో వేచి ఉండాల్సిన పనిని ప్రకటించింది. ఒక SIGCHLD హ్యాండ్లర్ లోపల, స్పాన్ ID -1 ను ఉపయోగించడం ద్వారా ఎటువంటి అభివృద్ధి చెందుతున్న ప్రక్రియ కోసం వేచి ఉండడం సాధ్యమవుతుంది.
విజయవంతమైన పతాకం సూచనను వెంటనే వెనక్కి తీసుకురావడానికి వేచి ఉంచుతుంది . ప్రక్రియ (తరువాత) నిష్క్రమిస్తున్నప్పుడు, ఇది స్పష్టమైన వెయిట్ అవసరం లేకుండా స్వయంచాలకంగా అదృశ్యమవుతుంది.
"-i -1" వాదనలు ఉపయోగించి ఫోర్క్డ్ ప్రాసెస్ కోసం వేచి ఉన్న కమాండ్ను కూడా వాడవచ్చు. అభివృద్ధి చెందుతున్న ప్రక్రియలతో దాని ఉపయోగం కాకుండా, ఈ ఆదేశం ఎప్పుడైనా అమలు చేయబడుతుంది. ప్రక్రియ ఏంటంటే దానిపై నియంత్రణ లేదు. అయితే, ప్రాసెస్ ఐడి కోసం తిరిగి విలువను తనిఖీ చేయవచ్చు.
లైబ్రరీలు
ఆటోమేటిక్ గా ఊహించని స్క్రిప్ట్స్ కోసం రెండు అంతర్నిర్మిత లైబ్రరీల గురించి తెలుసు. వీటిని వేరియబుల్స్ exp_library మరియు exp_exec_library లో పేరు పెట్టబడిన డైరెక్టరీలు నిర్వచించబడతాయి. రెండూ ఇతర స్క్రిప్ట్స్ ఉపయోగించగల ప్రయోజన ఫైళ్ళను కలిగి ఉండటమే.
exp_library నిర్మాణ-స్వతంత్ర ఫైళ్ళను కలిగి ఉంది. exp_exec_library ఆకృతి-ఆధారిత ఫైళ్ళను కలిగివుంటుంది. మీ సిస్టమ్పై ఆధారపడి, రెండు డైరెక్టరీలు పూర్తిగా ఖాళీగా ఉండవచ్చు. ఫైలు యొక్క ఉనికి $ exp_exec_library / cat-buffers అప్రమేయంగా మీ / bin / cat buffers లేదో వివరిస్తుంది.
Pretty-printing
అందంగా-ముద్రణ కోసం ఒక vgrind నిర్వచనం అందుబాటులో ఉంది స్క్రిప్ట్లను ఊహించు. పంపిణీ ఆశించిన పంపిణీ చేయబడిన vgrind నిర్వచనం సరిగ్గా ఇన్స్టాల్ చేయబడితే, దానిని మీరు దీన్ని ఉపయోగించవచ్చు:
vgrind -lexpect ఫైలుఉదాహరణలు
ఇది మనిషి పేజీ వివరిస్తుంది కలిసి ప్రతిదీ ఉంచాలి ఎలా స్పష్టమైన కాదు. పంపిణీని ఆశించే ఉదాహరణ డైరెక్టరీలో ఉదాహరణలను చదవడానికి మరియు ప్రయత్నించడానికి నేను మిమ్మల్ని ప్రోత్సహిస్తున్నాను. వాటిలో కొన్ని నిజమైన కార్యక్రమములు. ఇతరులు కేవలం కొన్ని పద్ధతులు స్పష్టంగా ఉదహరించారు, మరియు కోర్సు యొక్క, ఒక జంట కేవలం శీఘ్ర హక్స్ ఉంటాయి. INSTALL ఫైలు ఈ కార్యక్రమాల శీఘ్ర వివరణను కలిగి ఉంది.
ఆశించే పత్రాలు (చూడండి కూడా చూడండి) కూడా ఉపయోగకరంగా ఉన్నాయి. కొన్ని పత్రాలు ఆశించిన పూర్వపు సంస్కరణలకు అనుగుణంగా సింటాక్స్ ను ఉపయోగిస్తున్నప్పటికీ, సహేతుకమైన తర్కములు ఇప్పటికీ చెల్లుబాటు అయ్యేవి మరియు ఈ మాన్ పేజ్ కన్నా చాలా వివరంగా ఉంటాయి.
షరతులు
ఎక్స్పెక్ట్స్ కమాండ్ పేర్లతో పొడిగింపులు గుద్దుతాయి. ఉదాహరణకు, పూర్తిగా వేర్వేరు ప్రయోజనం కోసం Tk ద్వారా పంపుతుంది . ఈ కారణంగా, "ఎక్స్ -XXXX" గా కూడా ఆశిస్తున్న ఆదేశాలను కూడా అందుబాటులో ఉన్నాయి. "Exp", "inter", "spawn", మరియు "timeout" మొదలగున ఆదేశాలు మరియు వేరియబుల్స్ మారుపేర్లను కలిగి లేవు. మీరు వాతావరణాల మధ్య ఈ అనుకూలత అవసరమైతే పొడిగించిన కమాండ్ పేర్లను ఉపయోగించండి.
ఆశించటం దర్శిని కాకుండా ఉదారవాద అభిప్రాయాన్ని తీసుకుంటుంది. ప్రత్యేకంగా, ఆశించిన కార్యక్రమాలకు సంబంధించిన ఆదేశాలచే చదివే వేరియబుల్స్ స్థానిక పరిధి నుండి మొదట కోరబడతాయి మరియు ప్రపంచ పరిధిలో కనుగొనబడకపోవచ్చు. ఉదాహరణకు, ఇది మీరు ఆశించే వాడుతున్న ప్రతి ప్రక్రియలో "ప్రపంచ గడువు ముగిసే" అవసరాన్ని నివారిస్తుంది. మరొక వైపు, రాయబడిన వేరియబుల్స్ ఎల్లప్పుడూ స్థానిక పరిధిలో ఉంటాయి (ఒక "గ్లోబల్" ఆదేశం జారీ చేయకపోతే). స్పాన్ ఒక ప్రక్రియలో అమలు చేయబడినప్పుడు ఇది చాలా సాధారణ సమస్య. విధానం వెలుపల, spawn_id ఇకపై ఉండదు, అందువల్ల స్కాప్ చేయడం వలన ఏర్పడిన విధానం ఇకపై అందుబాటులో ఉండదు. అటువంటి విధానానికి "global spawn_id" ను జోడించండి.
మీరు multispawning సామర్ధ్యం (అంటే, BSD *. *), పోల్ (SVR> 2), లేదా ఏదో సమానమైనది) ఎన్నుకోలేకుంటే , ఒక సమయంలో ఒకే ప్రాసెస్ని మాత్రమే నియంత్రించవచ్చు. ఈ సందర్భంలో, spawn_id ని సెట్ చేయటానికి ప్రయత్నించవద్దు, లేదా ఎర్నెస్ట్ ప్రక్రియ నడుస్తున్నప్పుడు మీరు కార్యనిర్వహణలను ఎగ్జిక్యూట్ చేయాలి. అంతేకాకుండా, మీరు ఒకే సమయంలో బహుళ ప్రక్రియల నుండి (ఒకదానితో సహా) ఆశించలేరు .
టెర్మినల్ పారామితులు స్క్రిప్ట్స్ మీద పెద్ద ప్రభావాన్ని కలిగి ఉంటాయి. ఉదాహరణకు, ఒక స్క్రిప్ట్ ప్రతిధ్వని కోసం చూస్తున్నట్లయితే, ప్రతిధ్వని నిలిపివేయబడితే అది తప్పుగా ప్రవర్తిస్తుంది. ఈ కారణంగా, అప్రమేయంగా శక్తులు టెర్మినల్ పారామితులను బలపరుస్తాయి. దురదృష్టవశాత్తూ, ఇది ఇతర కార్యక్రమాలకు అసహ్యకరమైన విషయాలు చేయగలదు. ఉదాహరణకు, emacs షెల్ "సాధారణ" మ్యాపింగ్లను మార్చాలని కోరుకుంటుంది: క్యారేజ్-రిటర్న్ న్యూలైన్స్కు బదులుగా క్రొత్తరకాలకు కొత్త లైన్లకు మ్యాప్ చేయబడుతుంది మరియు ప్రతిధ్వని నిలిపివేయబడుతుంది. ఇన్పుట్ పంక్తిని సవరించడానికి ఇది emacs ను ఉపయోగించడానికి అనుమతిస్తుంది. దురదృష్టవశాత్తు, ఊహించడం బహుశా ఊహించలేము.
టెర్మినల్ పారామితుల యొక్క దాని డిఫాల్ట్ సెట్టింగును ఓవర్రైడ్ చేయవద్దని మీరు కోరుకోవచ్చు, కాని అలాంటి ఎన్విరాన్మెంట్ల కొరకు స్క్రిప్ట్లను వ్రాసేటప్పుడు మీరు చాలా జాగ్రత్తగా ఉండాలి. Emacs విషయంలో, ప్రతిధ్వని మరియు ముగింపు-ముగింపు మ్యాపింగ్ల వంటి అంశాలపై ఆధారపడి ఉండండి.
ఒక జాబితా (నిజానికి వేరియంట్లు మరియు ఇంటరాక్ట్ లను ) గా అంగీకరించిన ఆదేశాలను ఆదేశాల జాబితాలో ఒక వాదన లేదా చాలామైనా నిర్ణయించటానికి ఒక పరిష్కారాన్ని ఉపయోగిస్తారు. జాబితా వాస్తవానికి ఒకే వివాదానికి ప్రాతినిధ్యం వహిస్తున్నప్పుడు మాత్రమే విఫలమవుతుంది, వీటిలో బహుళ ఎంబెడెడ్ \ n యొక్క తెల్లటి మధ్య ఖాళీలు ఉంటాయి. ఇది సరిగ్గా అసంభవమైనదనిపిస్తుంది, అయినప్పటికీ వాదన "నబ్రస్" ఒక వాదనగా ఒకే వాదనగా వ్యవహరించడానికి వాడటానికి ఉపయోగించవచ్చు. యంత్రం సృష్టించిన ఆశించే కోడ్తో ఇది గర్వంగా ఉపయోగించబడుతుంది. అదేవిధంగా, -ఒక బహుళ వాదనలు / చర్యలను నిర్వహించడానికి ఒక వాదనను వదలివేస్తుంది.
బగ్స్
కార్యక్రమం "సెక్స్" ("స్మార్ట్ ఎక్స్కే" లేదా "సెంటెప్-ఎక్స్పెక్ట్" గాని) పేరు పెట్టడానికి నిజంగా ఉత్సాహంగా ఉంది, కానీ మంచి అర్ధము (లేదా కేవలం ప్యూరిటనిజం) కొనసాగింది.
కొన్ని వ్యవస్థలలో, ఒక షెల్ ఎదిగినప్పుడు, ఇది tty ను యాక్సెస్ చేయలేకపోయినా ఏమైనప్పటికీ నడుస్తుంది. దీని అర్థం మీ కంప్యూటరు గురించి తెలియదు అని అంచనా వేసే నియంత్రణ టైటిని పొందటానికి ఒక విధానం ఉంది. దయచేసి ఇది ఏమిటో తెలుసుకోండి మరియు ఈ సమాచారాన్ని నాకు తిరిగి పంపించండి.
Ultrix 4.1 (ఇక్కడ దాదాపుగా తాజా వెర్షన్లు) 1000000 కంటే ఎక్కువ సమయాల సమయాన్ని 0 కు సమానంగా పరిగణిస్తుంది.
మీరు ఒక SIGCHLD హ్యాండ్లర్ను నిర్వచించినట్లయితే, డిజిటల్ UNIX 4.0A (మరియు బహుశా ఇతర సంస్కరణలు) ptys ను కేటాయించటానికి నిరాకరిస్తుంది. మరింత సమాచారం కోసం గ్రాంట్ట్ పేజీ చూడండి.
IRIX 6.0 సరిగ్గా pty అనుమతులను నిర్వహించదు, తద్వారా అది మరొకరికి ఉపయోగించిన ఒక pty ను కేటాయించాలనే ప్రయత్నాలను ఆశించినట్లయితే అది విఫలమవుతుంది. IRIX 6.1 కు అప్గ్రేడ్ చేయండి.
TERM సెట్ చేయబడకపోతే టెల్నెట్ (SunOS 4.1.2 క్రింద మాత్రమే ధృవీకరించబడింది) వేలాడుతోంది. ఇది TRAN ను నిర్వచించని cgi స్క్రిప్టులలో, క్రాన్ కింద ఉన్న సమస్య. అందువలన, మీరు తప్పనిసరిగా దీన్ని స్పష్టంగా సెట్ చేయాలి - ఏ రకమైన సాధారణంగా అసంబద్ధం. ఇది కేవలం ఏదో సెట్ చేయాలి! కింది సందర్భాలలో చాలా సందర్భాలలో సరిపోతుంది.
సెట్ env (TERM) vt100షెల్ మరియు హోమ్ సెట్ చేయకపోతే చిట్కా (BSDI BSD / OS 3.1 i386 క్రింద మాత్రమే ధృవీకరించబడింది) హ్యాంగ్ చేస్తుంది. Cgi స్క్రిప్ట్ లలో క్రాన్ కింద ఉన్న సమస్య, ఇది ఈ ఎన్విరాన్మెంట్ వేరియబుల్స్ని నిర్వచించలేదు. అందువలన, మీరు వాటిని స్పష్టంగా సెట్ చేయాలి - ఏ రకమైన సాధారణంగా సంబంధం లేదు. ఇది కేవలం ఏదో సెట్ చేయాలి! కింది సందర్భాలలో చాలా సందర్భాలలో సరిపోతుంది.
set env (SHELL) / bin / sh సెట్ env (HOME) / usr / local / binPtys యొక్క కొన్ని అమలులు రూపొందించబడ్డాయి, తద్వారా కెర్నల్ ఫైల్ సూచికను మూసివేసిన తరువాత 10 నుండి 15 సెకన్ల తర్వాత (అసలు సంఖ్య అమలు-ఆధారపడి ఉంటుంది) తర్వాత ఏవైనా చదవని అవుట్పుట్ విసురుతాడు. అందువలన వంటి కార్యక్రమాలు ఆశించే
స్పాన్ తేదీ నిద్ర 20 ఆశవిఫలమవుతుంది. దీన్ని నివారించుటకు, కాని ఇంటరాక్టివ్ ప్రోగ్రామ్స్ ను ప్రాయోగికం కాకుండా కార్యనిర్వహణతో ఆహ్వానించండి. అలాంటి పరిస్థితులు గర్వించదగినవి అయినప్పటికీ, ఆచరణలో నేను ఈ ప్రవర్తన కారణంగా నిజమైన ఇంటరాక్టివ్ ప్రోగ్రామ్ యొక్క తుది ఫలితం కోల్పోయే పరిస్థితిని ఎన్నడూ ఎదుర్కొనలేదు.
మరోవైపు, క్రెడిట్ UNICOS ptys ప్రక్రియ డేటా వివరణని మూసివేసిన వెంటనే ఏ చదవని అవుట్పుట్ త్రో. నేను దీన్ని క్రాక్కి నివేదించాను మరియు వారు ఒక పరిష్కారంలో పని చేస్తున్నారు.
కొన్నిసార్లు ప్రాంప్ట్ మరియు స్పందన మధ్య కొన్నిసార్లు ఆలస్యం అవసరమవుతుంది, ప్రారంభంలో / స్టాప్ బిట్స్ కోసం చూస్తున్నప్పుడు tART ఇంటర్ఫేస్ UART సెట్టింగులను లేదా సరిపోలే బాడ్ రేట్లను మారుస్తుంది. సాధారణంగా, ఈ రెండో లేదా రెండు కోసం నిద్ర అవసరం. హార్డ్వేర్ ఇన్పుట్ను స్వీకరించడానికి సిద్ధంగా ఉన్నంత వరకు మరింత శక్తివంతమైన టెక్నిక్ తిరిగి ప్రయత్నించాలి. కింది ఉదాహరణ రెండు వ్యూహాలను ఉపయోగిస్తుంది:
"వేగం 9600 \ r" పంపు; నిద్ర 1 ఆశించే {సమయం ముగిసింది {\ r "; exp_continue} $ prompt}ట్రాప్-కోడ్ Tcl యొక్క ఈవెంట్ లూప్లో ఉండే ఏదేనితో పనిచేయదు, ఇటువంటి నిద్ర వంటిది. సమస్య ఏమిటంటే ఈవెంట్ లూప్ లో, TCL అసిక్ ఈవెంట్ కార్యనిర్వాహక హ్యాండ్లర్స్ నుండి తిరిగి సంకేతాలు తొలగిస్తుంది. ట్రాప్ కోడ్లో జెండాను సెట్ చేయడం ఒక ప్రత్యామ్నాయం. అప్పుడు ఆదేశానికి వెంటనే జెండాను తనిఖీ చేయండి (అనగా, నిద్ర).
Expect_background కమాండ్ నిర్లక్ష్యం-వాట్ అవుట్ వాట్ అవుట్ కామెంట్స్ మరియు ఎప్పటికప్పుడు సమయాల భావన లేదు.
& # 34; EXPECT సూచనలు & # 34;
ఊహించని విషయాలను ఊహించని కొన్ని విషయాలు ఉన్నాయి. ఈ విభాగం కొన్ని విషయాలను కొన్ని సలహాలతో పరిష్కరించడానికి ప్రయత్నిస్తుంది.
షెల్ ప్రాంప్ట్లను ఎలా గుర్తించాలో ఒక సాధారణ అంచనా సమస్య. ఇవి భిన్నంగా ప్రజలు మరియు విభిన్న షెల్లు ద్వారా భిన్నంగా నిర్దేశించబడతాయి కాబట్టి, rlogin ను స్వయంచాలకంగా ఆటోమేట్ చేయటం ప్రాంప్ట్ తెలియకుండా కష్టం అవుతుంది. పర్యావరణ వేరియబుల్ EXPECT_PROMPT లో వారి ప్రాంప్ట్ (ప్రత్యేకంగా, దాని ముగింపు) ను వివరించే ఒక సాధారణ వ్యక్తీకరణను వినియోగదారులను కలిగి ఉండటం ఒక సహేతుకమైన సమావేశం. కింది వంటి కోడ్ ఉపయోగించవచ్చు. EXPECT_PROMPT ఉనికిలో లేకపోతే, కోడ్ ఇప్పటికీ సరిగ్గా పనిచేయడానికి మంచి అవకాశం ఉంది.
సెట్ ప్రాంప్ట్ "(% | # | \\ $) $"; # డిఫాల్ట్ ప్రాంప్ట్ క్యాచ్ {సెట్ ప్రాంప్ట్ $ env (EXPECT_PROMPT)} -re $ promptనేను మీరు ఆశించే సంసార ముగింపును కలిగి ఉన్న ఆకృతులను అంచనా వేయమని నేను ప్రోత్సహిస్తాను. ఇది మొత్తం విషయం చూసిన ముందు ఒక ప్రశ్నకు సమాధానమిచ్చే అవకాశాన్ని తొలగిస్తుంది. అదనంగా, మీరు పూర్తిగా వాటిని చూసిన ముందుగానే ప్రశ్నలకు సమాధానాలు ఇవ్వవచ్చు, మీరు మొదట్లో సమాధానం చెప్పినట్లయితే, మీ సమాధానం ప్రశ్న మధ్యలో ప్రతిధ్వనిస్తుంది. మరో మాటలో చెప్పాలంటే, సంభాషణ సంభాషణ సరైనదే కానీ గిలకొట్టింది.
చాలా ప్రాంప్ట్లలో ఖాళీ పాత్ర ఉంటుంది. ఉదాహరణకు, FTP నుండి ప్రాంప్ట్ 'f', 't', 'p', '>' మరియు. ఈ ప్రాంప్ట్కు సరిపోలడానికి, మీరు ఈ ప్రతి అక్షరాలకు లెక్కించాలి. ఖాళీని చేర్చకూడదని ఒక సాధారణ తప్పు. ఖాళీగా ఉంచండి.
ఫారం X * యొక్క నమూనాను మీరు ఉపయోగిస్తే, X చివరి నుండి అందుకున్న మొత్తం ఉత్పత్తికి అంతిమ విషయంతో సరిపోతుంది. ఇది సహజమైన ధ్వనులు కాని కొంతవరకు గందరగోళంగా ఉండవచ్చు, ఎందుకంటే కంప్యూటర్ యొక్క వేగం మరియు కెర్నెల్ మరియు పరికరం డ్రైవర్ రెండింటికీ I / O ప్రాసెసింగ్ ద్వారా "చివరి విషయం అందుకున్న" తేడాలు ఉంటాయి.
ప్రత్యేకంగా, మానవులు ప్రోగ్రామ్ అవుట్పుట్లను భారీ రాళ్లలో (అణువిషయంలో) చేరుకోవడం చూస్తారు, వాస్తవానికి చాలా కార్యక్రమాలు ఉత్పత్తి సమయంలో ఒక లైన్ను ఉత్పత్తి చేస్తాయి. ఇదే భావన, మునుపటి పేరా నమూనాలో * ప్రస్తుత పంక్తి చివరిలో మాత్రమే సరిపోతుంది, అయినప్పటికీ ఆటగాడిలో ఉన్న మొత్తం అవుట్పుట్ అయినందున ఇది మరింత ఉన్నట్లు కనిపిస్తోంది.
మీ నమూనా ప్రత్యేకంగా ఖాతాలను తప్ప, మరింత అవుట్పుట్ వస్తున్నట్లు తెలుసుకునే మార్గం లేదు.
లైన్ ఆధారిత బఫరింగ్ బట్టి కూడా తెలివితక్కువతనం. కార్యక్రమాలు అరుదుగా వారు బఫరింగ్ రకం గురించి వాగ్దానం చేస్తాయి, కానీ సిస్టమ్ అజీర్ణం అవుట్పుట్ లైన్లను విచ్ఛిన్నం చేస్తుంది, తద్వారా పంక్తులు అంతమయినట్లుగా కనిపిస్తాయి. కాబట్టి, నమూనాలను వ్రాసేటప్పుడు ఒక ప్రాంప్ట్ యొక్క చివరి కొన్ని అక్షరాలను మీరు వ్యక్తం చేయగలిగితే, అలా చేయడం చాలా తెలివైనది.
మీరు ప్రోగ్రామ్ యొక్క చివరి అవుట్పుట్లో నమూనా కోసం ఎదురు చూస్తున్నట్లయితే మరియు ప్రోగ్రామ్ బదులుగా వేరొక దాన్ని వెలిగించుకుంటుంది, మీరు గడువు ముగిసిన కీవర్డ్తో గుర్తించలేరు. దీనికి కారణం సమయం ముగియదు - బదులుగా అది ఒక eof సూచన పొందుతారు. బదులుగా దాన్ని ఉపయోగించండి. ఇంకా బాగా, రెండింటినీ ఉపయోగించుకోండి. ఆ మార్గం ఎప్పుడూ చుట్టూ తరలించబడింది ఉంటే, మీరు లైన్ కూడా సవరించడానికి ఉండదు.
టెర్మినల్ డ్రైవర్ ద్వారా అవుట్పుట్ చేసినప్పుడు న్యూ లైన్లను సాధారణంగా క్యారేజ్ రిటర్న్, లైన్ఫేడ్ సన్నివేశాలుగా మార్చబడతాయి. కాబట్టి, మీరు printf ("foo \ nbar") నుండి రెండు పంక్తులను స్పష్టంగా సూచించే నమూనా కావాలనుకుంటే, మీరు "foo \ r \ nbar" ను ఉపయోగించాలి.
వినియోగదారు నుండి చదివినప్పుడు, expect_user ద్వారా అదే విధమైన అనువాదం సంభవిస్తుంది. ఈ సందర్భంలో, మీరు తిరిగి నొక్కితే, ఇది క్రొత్త లైన్ కు అనువదించబడుతుంది. ఒకవేళ ఆశిస్తే అది దాని టెర్మినల్ను ముడి మోడ్కు (టెల్నెట్ వంటిది) అమర్చుతుంది, ప్రోగ్రామ్ ఒక నిజమైన రిటర్న్ ఆశించటం వలన, సమస్య కానుంది. (కొన్ని కార్యక్రమాలు వాస్తవానికి మన్నించే ఉంటాయి, అవి ఆటోమేటిక్గా తిరిగి క్రొత్త లైన్లను అనువదిస్తాయి, కానీ చాలామంది చేయలేరు.) దురదృష్టవశాత్తూ, ప్రోగ్రామ్ దాని ముడి మోడ్లో ముడి మోడ్లో ఉందని తెలుసుకునేందుకు మార్గం లేదు.
బదులుగా మాన్యువల్గా కొత్త లైన్లను రిటర్న్స్తో భర్తీ చేస్తే, ఈ పరిష్కారం "స్టాటిక్ ముడి" ఆదేశాన్ని ఉపయోగించడం, ఇది అనువాదం మానివేస్తుంది. అయితే, దీని అర్థం మీరు వండిన లైన్-ఎడిటింగ్ ఫీచర్లను పొందలేరని అర్థం.
పరస్పర చర్యను ముడి మోడ్కు మీ టెర్మినల్ సెట్ చేస్తుంది కాబట్టి ఈ సమస్య తలెత్తుతుంది.
స్క్రిప్ట్లను ఊహించడంలో పాస్వర్డ్లను (లేదా ఇతర వ్యక్తిగత సమాచారం) నిల్వ చేయడానికి ఇది తరచుగా ఉపయోగపడుతుంది. ఒక కంప్యూటర్లో భద్రపరచబడిన ఏదైనా ఎవ్వరూ ప్రాప్తి చేయబడటానికి అవకాశం ఉన్నందున ఇది సిఫార్సు చేయబడదు. కాబట్టి, స్క్రిప్ట్ నుండి పాస్వర్డ్లను పరస్పరం ప్రోత్సహిస్తూ వాచ్యంగా వాటిని చొప్పించడం కంటే తెలివిగా ఆలోచన. అయినప్పటికీ, కొన్నిసార్లు అలాంటి చొప్పించేది మాత్రమే అవకాశం.
దురదృష్టవశాత్తు, UNIX ఫైల్ వ్యవస్థ ఎగ్జిక్యూట్ కాని చదవదగిన స్క్రిప్టులను రూపొందించడానికి ఎటువంటి ప్రత్యక్ష మార్గం లేదు. సెట్జిడ్ షెల్ స్క్రిప్ట్లకు మద్దతిచ్చే సిస్టమ్స్ పరోక్షంగా ఈ క్రింది విధంగా అనుకరించవచ్చు:
మామూలుగా స్క్రిప్ట్ ను ఊహించు (రహస్య సమాచారాన్ని కలిగి ఉంటుంది) సృష్టించండి. దీని అనుమతులను 750 (-rwxr-x ---) అని మరియు ఒక విశ్వసనీయ సమూహం సొంతం చేసుకోండి, అనగా, చదవటానికి అనుమతించబడే ఒక సమూహం. అవసరమైతే, ఈ ప్రయోజనం కోసం కొత్త సమూహాన్ని సృష్టించండి. తరువాత, ఒక సమూహం / అంతకంటే ముందు ఉన్న సమూహం యొక్క అనుమతులు 2751 (-rwxr-s - x) తో ఒక / బిన్ / ష స్క్రిప్టును సృష్టించండి.
ఫలితంగా ఎవరిచేత అమలు చేయబడిన స్క్రిప్ట్ (మరియు చదవవచ్చు). దీనిని ప్రారంభించినప్పుడు, ఎక్స్పెక్ట్ లిపిని అమలు చేస్తుంది.
& # 34; ఇంకా చూడండి & # 34;
Tcl (3), libexpect (3)
"ఎక్స్ప్లోరింగ్ ఎక్స్పెక్ట్: ఏ టిక్క్-బేస్డ్ టూల్కిట్ ఫర్ ఆటోమేటింగ్ ఇంటరాక్టివ్ ప్రోగ్రామ్స్" బై డాన్ లిబెస్, pp. 602, ISBN 1-56592-090-2, ఓ'రైల్లీ అండ్ అసోసియేట్స్, 1995.
"ఆశిస్తున్నాము: డాన్ లిబెస్, ప్రోసిడింగ్స్ ఆఫ్ ది సమ్మర్ 1990 USENIX కాన్ఫరెన్స్, అనాహీమ్, కాలిఫోర్నియా, జూన్ 11-15, 1990.
డాన్ లిబెస్, 1990 USENIX పెద్ద ఇన్స్టాలేషన్ సిస్టమ్స్ అడ్మినిస్ట్రేషన్ కాన్ఫెరెన్స్, కొలరాడో స్ప్రింగ్స్, కొలరాడో, అక్టోబర్ 17-19, 1990 యొక్క ప్రొసీడింగ్స్ ద్వారా "సిస్టమ్ నిర్వహణ విధులను ఆటోమేట్ చేయడానికి ఉపయోగించడం".
జాన్ Ousterhout, 1990 యొక్క USENIX కాన్ఫరెన్స్, వాషింగ్టన్, DC, జనవరి 22-26, 1990 యొక్క ప్రొసీడింగ్స్ ద్వారా "Tcl: ఒక పొందుపర్చగల కమాండ్ భాష". నేను "ఆశ: డాన్ లిబెస్, కంప్యూటింగ్ సిస్టమ్స్ ద్వారా కంట్రోలరింగ్ ఇంటరాక్టివ్ కార్యక్రమాలు కోసం స్క్రిప్ట్స్" , వాల్యూమ్. యూనివర్సిటీ ఆఫ్ కాలిఫోర్నియా ప్రెస్ జర్నల్స్, నవంబరు 1991 .. యూనివర్సిటీ ఆఫ్ కాలిఫోర్నియా ప్రెస్ జర్నల్స్, నవంబరు 1991 .. డాన్ లిబెస్, ప్రొసీడింగ్స్ ఆఫ్ ది సమ్మర్ 1992 USENIX కాన్ఫరెన్స్, పేజి. 135-144, శాన్ అంటోనియో, TX, డాన్ లిబెస్, సాఫ్ట్వేర్ - ప్రాక్టీస్ & ఎక్స్పీరియన్స్, జాన్ విలే & సన్స్, వెస్ట్ సస్సెక్స్, ఇంగ్లాండ్, వాల్యూమ్, జూన్ 12-15, 1992. నేను "కిబిట్జ్ - కనెక్ట్ బహుళ ఇంటరాక్టివ్ ప్రోగ్రామ్స్ టుగెదర్"
23, నం. 5, మే, 1993. నాన్ "ఎ డీబగ్గర్ ఫర్ Tcl అప్లికేషన్స్", డాన్ లిబెస్, ప్రొసీడింగ్స్ ఆఫ్ ది 1993 Tcl / TK వర్క్షాప్, బర్కిలీ, CA, జూన్ 10-11, 1993.
AUTHOR
డాన్ లిబెస్, నేషనల్ ఇన్స్టిట్యూట్ ఆఫ్ స్టాండర్డ్స్ అండ్ టెక్నాలజీ
రసీదులు
Tcl కోసం జాన్ ఓస్టర్హాట్ మరియు స్కాట్ పైస్లీ ధన్యవాదాలు ప్రేరణ కోసం. ఆశ యొక్క స్వీయ ఆకృతీకరణ కోడ్ కోసం రాబ్ సవోయ్ ధన్యవాదాలు.
ఊహించిన పరిణామ చరిత్రలో చాలావరకు చరిత్ర పత్రాలు ఉన్నాయి. ఇది ఆసక్తికరమైన పఠనం చేస్తుంది మరియు మీరు ఈ సాఫ్ట్ వేర్కు మరింత అంతర్దృష్టిని అందించవచ్చు. నాకు బగ్ పరిష్కారాలను పంపిన వ్యక్తులకు ధన్యవాదాలు మరియు ఇతర సహాయం అందించింది.
అమెరికా ప్రభుత్వంచే కొంత భాగాన్ని సంపాదించి, పబ్లిక్ డొమైన్లో ఆశించిన రూపకల్పన మరియు అమలు చేయడం జరిగింది. అయినప్పటికీ రచయిత మరియు NIST ఈ కార్యక్రమం మరియు డాక్యుమెంటేషన్ లేదా వాటి యొక్క భాగాలను ఉపయోగించినట్లయితే క్రెడిట్ను ఇష్టపడతారు.