រំពឹងថាជាកម្មវិធីមួយដែលនិយាយទៅកាន់កម្មវិធីអន្តរកម្មផ្សេងទៀតតាមស្គ្រីប។ បន្ទាប់ពីស្គ្រីបរំពឹងថាដឹងពីអ្វីដែលអាចរំពឹងទុកពីកម្មវិធីនិងចម្លើយដែលត្រឹមត្រូវ។ ភាសាដែលបានបកប្រែផ្តល់នូវរចនាសម្ព័ន្ធវត្ថុបញ្ជាកម្រិតខ្ពស់និងខ្ពស់ដើម្បីដឹកនាំប្រអប់។ លើសពីនេះទៀតអ្នកប្រើអាចគ្រប់គ្រងនិងធ្វើអន្តរកម្មដោយផ្ទាល់នៅពេលដែលអ្នកចង់បានការត្រួតពិនិត្យត្រឡប់មកវិញទៅស្គ្រីប។
Expectk គឺជាល្បាយនៃការរំពឹងទុកនិង Tk ។ វាមានឥរិយាបថដូចបំណងនិងតំរូវការរបស់ធីខេ។ រំពឹងថាអាចត្រូវបានប្រើដោយផ្ទាល់នៅក្នុង C ឬ C ++ ដោយមិនចាំបាច់ Tcl ។
ឈ្មោះ "រំពឹង" មកពីគំនិតនៃការបញ្ជូន / រំពឹងលំដាប់ដែលត្រូវបានប្រជាប្រិយភាពដោយ uucp, kermit និងកម្មវិធីបញ្ជាម៉ូដឹមផ្សេងទៀត។ ទោះជាយ៉ាងណាមិនដូច uucp, រំពឹងថាត្រូវបាន generalized ដូច្នេះវាអាចត្រូវបានរត់ជាពាក្យបញ្ជាកម្រិតអ្នកប្រើជាមួយនឹងកម្មវិធីនិងភារកិច្ចណាមួយនៅក្នុងចិត្ត។ គេអាចនិយាយជាមួយកម្មវិធីជាច្រើនក្នុងពេលតែមួយ។
អ្វីដែលអាចរំពឹងបាន
ឧទហរណ៍នៅទីនេះមានចំនុចខ្លះដែលរំពឹងទុកថាអាចធ្វើបាន:
- បណ្តាលឱ្យកុំព្យូទ័ររបស់អ្នកទូរស័ព្ទមកអ្នកវិញដូច្នេះអ្នកអាចចូលបានដោយមិនចាំបាច់បង់ប្រាក់សម្រាប់ការហៅ។
- ចាប់ផ្តើមល្បែងមួយហើយបើការកំណត់រចនាសម្ព័ន្ធល្អប្រសើរមិនលេចឡើងចាប់ផ្ដើមវាម្តងហើយម្តងទៀត) រហូតដល់វាធ្វើហើយប្រគល់វត្ថុបញ្ជាទៅអ្នក។
- រត់ fsck ហើយឆ្លើយតបទៅនឹងសំនួររបស់វាឆ្លើយ "បាទ / ចាស" ឬ "ទេ" ឬប្រគល់ការគ្រប់គ្រងត្រលប់ទៅអ្នកវិញដោយផ្អែកលើលក្ខណៈវិនិច្ឆ័យដែលបានកំណត់ទុកជាមុន។
- ភ្ជាប់ទៅបណ្តាញផ្សេងទៀតនិងទាញយកសំបុត្ររបស់អ្នកដោយស្វ័យប្រវត្តិដើម្បីបង្ហាញថាវាហាក់បីដូចជាវាត្រូវបានបញ្ជូនទៅប្រព័ន្ធមូលដ្ឋានរបស់អ្នក។
- អនុវត្តអថេរបរិស្ថានថតបច្ចុប្បន្នឬប្រភេទពត៌មានណាមួយនៅទូទាំង rlogin telnet, tip, su , ឬ chgrp
មានមូលហេតុជាច្រើនដែល សែល មិនអាចធ្វើការងារទាំងនេះបាន។ ទាំងអស់អាចធ្វើទៅបានជាមួយរំពឹង។
ជាទូទៅការរំពឹងគឺមានប្រយោជន៍សម្រាប់ដំណើរការកម្មវិធីណាមួយដែលតម្រូវឱ្យមានអន្តរកម្មរវាងកម្មវិធីនិងអ្នកប្រើ។ អ្វីដែលចាំបាច់នោះគឺថាអន្តរកម្មអាចត្រូវបានកំណត់លក្ខណៈជាកម្មវិធី។ ការរំពឹងទុកក៏អាចផ្តល់ការត្រួតពិនិត្យត្រឡប់មកវិញដល់អ្នកប្រើដោយមិនបញ្ឈប់កម្មវិធីដែលត្រូវបានគ្រប់គ្រង។ ដូចគ្នានេះដែរអ្នកប្រើអាចត្រឡប់ការគ្រប់គ្រងទៅស្គ្រីបបានគ្រប់ពេល។
ការប្រើប្រាស់
រំពឹងអាន cmdfile សម្រាប់បញ្ជីពាក្យបញ្ជាដែលត្រូវប្រតិបត្តិ។ រំពឹងអាចត្រូវបានហៅដោយ implicitly លើប្រព័ន្ធដែលគាំទ្រ #! កំណត់ដោយសម្គាល់ស្គ្រីបថាអាចប្រតិបត្តិបាននិងបង្កើតបន្ទាត់ទីមួយនៅក្នុងស្គ្រីប:
#! / usr / local / bin / expect-fជាការពិតណាស់ផ្លូវត្រូវតែរៀបរាប់ឱ្យបានត្រឹមត្រូវពីកន្លែងដែលរំពឹងរស់។ / usr / local / bin គ្រាន់តែជាឧទាហរណ៍ប៉ុណ្ណោះ។
ទង់ -c ចាប់ផ្តើមពាក្យបញ្ជាដែលត្រូវប្រតិបត្តិមុនពេលណាមួយក្នុងស្គ្រីប។ ពាក្យបញ្ជាគួរត្រូវបានដកស្រង់ដើម្បីការពារមិនឱ្យខូចដោយសែល។ ជម្រើសនេះអាចត្រូវបានប្រើច្រើនដង។ ពាក្យបញ្ជាច្រើនអាចត្រូវបានប្រតិបត្តិដោយ single -c ដោយបំបែកពួកវាដោយសញ្ញាចំណុចក្បៀស។ ពាក្យបញ្ជាត្រូវបានប្រតិបត្តិតាមលំដាប់ដែលវាលេចឡើង។ នៅពេលប្រើ Expectk ជម្រើសនេះត្រូវបានបញ្ជាក់ជាពាក្យបញ្ជា។
ទង់ -d អនុញ្ញាតឱ្យមានលទ្ធផលវិភាគរោគវិនិច្ឆ័យដែលរាយការណ៍ជាចម្បងនូវសកម្មភាពខាងក្នុងនៃពាក្យបញ្ជាដូចជារំពឹងទុកនិងមានអន្តរកម្ម។ ទង់នេះមានប្រសិទ្ធិភាពដូចគ្នានឹង "exp_internal 1" នៅដើមស្គ្រីបរំពឹងបូកនឹងកំណែរំពឹងទុកត្រូវបានបោះពុម្ព។
ទង់ -D បើកដំណើរការកម្មវិធីបំបាត់កំហុសអន្តរកម្ម។ តម្លៃចំនួនគត់គួរតែធ្វើតាម។ កម្មវិធីបំបាត់កំហុសនឹងគ្រប់គ្រងមុនពេលនីតិវិធី Tcl បន្ទាប់ប្រសិនបើតម្លៃមិនសូន្យឬប្រសិនបើចុច ^ C ឬនៅពេលដែលចំណុចឈប់ត្រូវបានចុចឬពាក្យបញ្ជាបំបាត់កំហុសសមស្របផ្សេងទៀតលេចឡើងក្នុងស្គ្រីប។ នៅពេលប្រើ Expectk ជម្រើសនេះត្រូវបានបញ្ជាក់ជា - បំបាត់កំហុស។
ទង់ -f គឺចាប់ផ្តើមឯកសារដែលត្រូវអានពាក្យបញ្ជា។ ទង់ជាតិរបស់វាគឺស្រេចចិត្តព្រោះវាមានប្រយោជន៍តែនៅពេលប្រើលេខ #! កំណត់ដូច្នេះអាគុយម៉ង់ផ្សេងទៀតអាចត្រូវបានផ្គត់ផ្គង់នៅលើបន្ទាត់ពាក្យបញ្ជា។ នៅពេលប្រើ Expectk ជម្រើសនេះត្រូវបានបញ្ជាក់ជា -file ។
តាមលំនាំដើមឯកសារពាក្យបញ្ជាត្រូវបានអានចូលទៅក្នុង អង្គចងចាំ និងប្រតិបត្តិទាំងស្រុង។ វាជួនកាលចង់អានឯកសារមួយបន្ទាត់ក្នុងមួយពេល។ ដើម្បីបង្ខំឯកសារដែលបំពានលើវិធីនេះប្រើទង់ -b ។ នៅពេលប្រើ Expectk ជម្រើសនេះត្រូវបានបញ្ជាក់ជា - ឧបករណ៍ផ្ទុក។
ប្រសិនបើខ្សែអក្សរត្រូវបានផ្គត់ផ្គង់ជាឈ្មោះឯកសារនោះការបញ្ចូល "" ស្តង់ដារត្រូវបានអានជំនួសវិញ។ ប្រើ "./-" ដើម្បីអានពីឯកសារមួយដែលមានឈ្មោះថា "-" ពិតប្រាកដ។
ទង់អ៊ី -i បណ្តាលឱ្យមានការសួររកពាក្យបញ្ជាជំនួសដោយអានពីឯកសារ។ ការណែនាំត្រូវបានបញ្ចប់តាមរយៈពាក្យបញ្ជាចេញឬលើ EOF ។ ទង់ -i ត្រូវបានសន្មត់ប្រសិនបើមិនប្រើឯកសារបញ្ជានិងគ -c ឡើយ។ នៅពេលប្រើ Expectk ជម្រើសនេះត្រូវបានបញ្ជាក់ជា - អន្តរកម្ម។
- អាចត្រូវបានប្រើដើម្បីកំណត់ព្រំដែនចុងបញ្ចប់នៃជម្រើស។ វាមានប្រយោជន៍ប្រសិនបើអ្នកចង់ហុចអាគុយម៉ង់ដូចទៅនឹងស្គ្រីបរបស់អ្នកដោយមិនចាំបាច់ត្រូវបានបកប្រែដោយរំពឹងទុក។ នេះអាចប្រើបានយ៉ាងល្អនៅក្នុង #! ដើម្បីទប់ស្កាត់ការបកប្រែទង់ជាតិតាមការរំពឹងទុក។ ឧទាហរណ៍ដូចខាងក្រោមនឹងទុកអាគុយម៉ង់ដើមរួមទាំងឈ្មោះស្គ្រីបក្នុងអថេរ argv ។
#! / usr / local / bin / expect -ចំណាំថា អនុគមន៍ getopt (3) និង execve ធម្មតា (2) ត្រូវតែត្រូវបានសង្កេតនៅពេលបន្ថែមអាគុយម៉ង់ទៅ #! បន្ទាត់។
ឯកសារ $ exp_library / expect.rc ត្រូវបានប្រភពដោយស្វ័យប្រវត្តិប្រសិនបើមានវត្តមានលុះត្រាតែទង់ជាតិត្រូវបានប្រើ។ (នៅពេលប្រើ Expectk ជម្រើសនេះត្រូវបានបញ្ជាក់ជា -NORC ។ ) ភ្លាមៗបន្ទាប់ពីនោះឯកសារ ~ / .expect .rc ត្រូវបានប្រភពដោយស្វ័យប្រវត្តិលុះត្រាតែទង់ជាតិ -n ត្រូវបានប្រើ។ ប្រសិនបើអថេរបរិស្ថាន DOTDIR ត្រូវបានកំណត់វាត្រូវបានចាត់ទុកថាជាថតហើយ .expect .rc ត្រូវបានអានពីទីនោះ។ នៅពេលប្រើ Expectk ជម្រើសនេះត្រូវបានបញ្ជាក់ជា -norc ។ ប្រភពនេះកើតឡើងតែបន្ទាប់ពីបានអនុវត្តទង់ជាតិណាមួយ -c ។
។ -v បណ្តាលឱ្យសង្ឃឹមបោះពុម្ពលេខកំណែរបស់វាហើយចេញ។ ទង់ដែលត្រូវគ្នានៅក្នុង Expectk ដែលប្រើឈ្មោះទង់វែងគឺ - វិវឌ្ឍន៍។
អាគុយម៉ង់ស្រេចចិត្តត្រូវបានបង្កើតទៅជាបញ្ជីនិងរក្សាទុកក្នុងអថេរដែលមានឈ្មោះថា argv និង។ អាគុយម៉ង់ត្រូវបានចាប់ផ្ដើមទៅប្រវែងរបស់ argv ។
Argv0 ត្រូវបានកំណត់ជាឈ្មោះស្គ្រីបឬប្រព័ន្ធគោលពីរប្រសិនបើមិនប្រើស្គ្រីបទេ។ ឧទាហរណ៍ឯកសារខាងក្រោមបោះពុម្ពចេញឈ្មោះរបស់ស្គ្រីបនិងអាគុយម៉ង់បីដំបូង:
send_user "$ argv0 [lrange $ argv 0 2] \ n"ពាក្យបញ្ជា
រំពឹងថានឹងប្រើភាសាពាក្យបញ្ជាឧបករណ៍។ Tcl ផ្តល់នូវលំហូរត្រួតពិនិត្យ (ប្រសិនបើសម្រាប់ការបំបែក) ការវាយតម្លៃការបញ្ចេញមតិនិងលក្ខណៈពិសេសជាច្រើនផ្សេងទៀតដូចជាការកំណត់ពេលវេលានិងនីតិវិធី។ ពាក្យបញ្ជាដែលបានប្រើនៅទីនេះប៉ុន្តែមិនត្រូវបានកំណត់ (កំណត់, ប្រសិនបើ, exec) គឺជាពាក្យបញ្ជា Tcl ។ រំពឹងគាំទ្រពាក្យបញ្ជាបន្ថែម។ លុះត្រាតែបានបញ្ជាក់បើមិនដូច្នេះទេពាក្យបញ្ជាត្រឡប់ខ្សែអក្សរទទេ។
ពាក្យបញ្ជាត្រូវបានរាយតាមលំដាប់អក្សរក្រមដូច្នេះពួកគេអាចមានទីតាំងស្ថិតនៅយ៉ាងឆាប់រហ័ស។ ទោះជាយ៉ាងណាក៏ដោយអ្នកប្រើថ្មីអាចមានភាពងាយស្រួលក្នុងការចាប់ផ្តើមដោយការអានការពិពណ៌នាអំពីការបង្កកំណើត, ការផ្ញើ, ការរំពឹងទុក, និងការធ្វើអន្តរកម្មនៅក្នុងលំដាប់នោះ។
បិទ [-slave] [-onexec 0 | 1] [-i spawn_id]បិទការភ្ជាប់ទៅនឹង ដំណើរការ បច្ចុប្បន្ន។ កម្មវិធីអន្តរកម្មភាគច្រើននឹងរកឃើញ EOF នៅលើ stdin និងការចេញរបស់ពួកគេ។ ដូច្នេះ ជិតស្និទ្ធ ជាធម្មតាគ្រប់គ្រាន់ដើម្បីសំលាប់ ដំណើរការ ផងដែរ។ ទង់ -i ប្រកាស ដំណើរការ ដើម្បីបិទដែលត្រូវគ្នានឹងឈ្មោះ spawn_id ។
ទាំងពីររំពឹងថានិងអន្តរកម្មនឹងរកឃើញនៅពេល ដំណើរការ បច្ចុប្បន្នចេញនិងបញ្ចប់ទាំងស្រុងប៉ុន្តែប្រសិនបើអ្នកសំលាប់ ដំណើរការ ដោយនិយាយថា "exec kill $ pid" អ្នកត្រូវហៅយ៉ាងច្បាស់ ។
ទង់ទោល - singlexec កំណត់ថាតើលេខសំអាងពងបែកត្រូវបានបិទនៅក្នុងដំណើរការ បង្កើតពងក្រពើ ថ្មីឬប្រសិនបើ ដំណើរការ នេះហួសប្រមាណ។ ដើម្បីទុកលេខសំគាល់ពងកូនមួយបើកតម្លៃ 0 ។ តម្លៃចំនួនគត់មិនមែនសូន្យបង្ខំអោយពងពងមាន់បិទក្នុងដំណើរការថ្មីណាមួយ។
ទង់ - slave បានបិទម៉ាស៊ីនបម្រើដែលភ្ជាប់ជាមួយលេខសម្គាល់ពងក្រពើ។ នៅពេលការភ្ជាប់ត្រូវបានបិទម៉ាស៊ីនកូនត្រូវបានបិទដោយស្វ័យប្រវត្តិផងដែរប្រសិនបើវានៅតែបើក។
មិនថាការភ្ជាប់ត្រូវបានបិទទាំងស្រុងឬជាក់លាក់ក៏ដោយអ្នកគួរតែហៅការរង់ចាំដើម្បីសម្អាតរន្ធ ដំណើរការ ខឺណែលដែលត្រូវគ្នា។ ពាក្យបញ្ជាបិទមិនហៅការរង់ចាំទេព្រោះគ្មានការធានាថាបិទ ការ តភ្ជាប់ ដំណើរការ នឹងធ្វើឱ្យវាចាកចេញ។
បំបាត់កំហុស [[-now] 0 | 1]គ្រប់គ្រងកម្មវិធីបំបាត់កំហុស Tcl ដែលអនុញ្ញាតឱ្យអ្នកកាត់សេចក្ដីថ្លែងការណ៍និងកំណត់ចំណុចឈប់។
ដោយគ្មានអាគុយម៉ង់, 1 នឹងត្រូវបានត្រឡប់ប្រសិនបើកម្មវិធីបំបាត់កំហុសមិនដំណើរការទេបើមិនដូច្នោះទេ 0 ត្រូវបានត្រឡប់។
ជាមួយអាគុយម៉ង់ 1 កម្មវិធីបំបាត់កំហុសត្រូវបានចាប់ផ្ដើម។ ជាមួយអាគុយម៉ង់ 0 ឧបករណ៍បំបាត់កំហុសត្រូវបានបញ្ឈប់។ ប្រសិនបើអាគុយម៉ង់ 1 ត្រូវបានដាក់ទង់ដោយទង់ជាតិ - ឥឡូវនេះទំរង់បំបាត់កំហុសត្រូវបានចាប់ផ្តើមភ្លាមៗ។ បើមិនដូច្នោះទេកម្មវិធីបំបាត់កំហុសត្រូវបានចាប់ផ្ដើមដោយសេចក្តីថ្លែងការណ៍ Tcl បន្ទាប់។
ពាក្យបញ្ជាបំបាត់កំហុសមិនផ្លាស់ប្ដូរអន្ទាក់ណាមួយទេ។ ប្រៀបធៀបនេះដើម្បីចាប់ផ្តើមរំពឹងទុកជាមួយនឹងទង់ -D ។
ពាក្យបញ្ជាផ្ដាច់ផ្តាច់ ដំណើរការសម ពីបំពង់។ វាបន្តរត់ក្នុងផ្ទៃខាងក្រោយ។ ដំណើរការនេះត្រូវបានផ្តល់ឱ្យក្រុមដំណើរការរបស់ខ្លួន។ ស្តង់ដា I / O ត្រូវបានប្ដូរទិសទៅ / dev / null ។
បំណែកខាងក្រោមប្រើផ្តាច់ដើម្បីបន្តដំណើរការស្គ្រីបក្នុងផ្ទៃខាងក្រោយ។
ប្រសិនបើ {[fork]! = 0} ផ្តាច់ចេញ។ ។ ។ស្គ្រីបខាងក្រោមអានពាក្យសម្ងាត់ហើយបន្ទាប់មកដំណើរការកម្មវិធីរៀងរាល់ម៉ោងដែលទាមទារពាក្យសម្ងាត់រាល់ពេលដែលវាដំណើរការ។ ស្គ្រីបផ្តល់ពាក្យសម្ងាត់ដូច្នេះអ្នកគ្រាន់តែវាយវាម្តង។
ផ្ញើ "ពាក្យសម្ងាត់? \" expect_user -re "(។ *) សម្រាប់ {} 1 {} {ប្រសិនបើ {[fork]) = 0} {ដេក 3600 បន្តបន្ត} 1, ខ្សែអក្សរ) \ r "។ ។ ។ ចេញ}គុណសម្បត្តិក្នុងការប្រើផ្តាច់លើលក្ខណៈដំណើរការអសមកាលសែល (&) គឺរំពឹងថាអាចរក្សាទុកប៉ារ៉ាម៉ែត្រស្ថានីយមុនពេលផ្ដាច់ហើយបន្ទាប់មកអនុវត្តវាទៅ ptys ថ្មី។ ជាមួយនឹង, រំពឹងថានឹងមិនមានឱកាសដើម្បីអានប៉ារ៉ាម៉ែត្ររបស់ស្ថានីយចាប់តាំងពីស្ថានីយត្រូវបានផ្ដាច់រួចទៅហើយដោយពេលវេលារំពឹងថានឹងទទួលបានវត្ថុបញ្ជា។
ចេញ [-opts] [ស្ថានភាព]មូលហេតុរំពឹងថានឹងចាកចេញឬបើមិនដូច្នេះទេត្រៀមខ្លួនដើម្បីធ្វើដូច្នេះ។
ទង់ - និមិត្តសញ្ញា បណ្តាលឱ្យអាគុយម៉ង់បន្ទាប់ត្រូវបានប្រើជាកម្មវិធីដោះស្រាយការចាកចេញ។ ដោយគ្មានអាគុយម៉ង់ឧបករណ៍ដោះស្រាយការចាកចេញបច្ចុប្បន្នត្រូវបានត្រឡប់។
ទង់ជាតិ គ្មានសុពលភាព បណ្តាលឱ្យត្រៀមខ្លួនចេញប៉ុន្តែបញ្ឈប់ការត្រួតពិនិត្យវិលត្រឡប់មកប្រព័ន្ធប្រតិបត្តិការវិញ។ កម្មវិធីដោះស្រាយការចេញដែលបានកំណត់ដោយអ្នកប្រើត្រូវបានដំណើរការក៏ដូចជាកម្មវិធីដោះស្រាយខាងក្នុងរបស់ Expect ។ គ្មានពាក្យបញ្ជារំពឹងទុកបន្ថែមទៀតគួរត្រូវបានប្រតិបត្តិ។ វាមានប្រយោជន៍ប្រសិនបើអ្នកកំពុងដំណើរការរំពឹងថានឹងកម្មវិធីបន្ថែម Tcl ផ្សេងទៀត។ អ្នកបកប្រែបច្ចុប្បន្ន (និងបង្អួចមេប្រសិនបើនៅក្នុងបរិយាកាស Tk) នៅដដែលដូច្នេះផ្នែកបន្ថែម Tcl ផ្សេងទៀតអាចសម្អាត។ ប្រសិនបើ ច្រកចេញ រំពឹងត្រូវបានហៅម្តងទៀត (ទោះជាយ៉ាងណានេះអាចកើតឡើង) អ្នកដោះស្រាយមិនដំណើរការទេ។
នៅពេលចេញ, ការតភ្ជាប់ទាំងអស់ទៅដំណើរការពងកូនគឺត្រូវបានបិទ។ ការបិទនឹងត្រូវបានរកឃើញថាជា EOF មួយដោយដំណើរការពង។ ការចាកចេញ មិនត្រូវការសកម្មភាពណាមួយក្រៅពីអ្វីដែលដំណើរការ _exit (2) ធម្មតាឡើយ។ ដូច្នេះដំណើរការបង្កើតកូនដែលមិនពិនិត្យរក EOF អាចបន្តដំណើរការបាន។ (ភាពខុសគ្នានៃលក្ខខណ្ឌមានសារៈសំខាន់ក្នុងការកំណត់ឧទាហរណ៍នូវអ្វីដែលសញ្ញាដែលបង្កើតពងនឹងត្រូវបានផ្ញើប៉ុន្តែទាំងនេះជាប្រព័ន្ធដែលពឹងផ្អែកជាទូទៅត្រូវបានចងក្រងជាឯកសារនៅក្រោមការចាកចេញ (3) ។ ដំណើរការបង្កើតដែលបន្តដំណើរការនឹងត្រូវបានទទួលដោយអារេ។
ស្ថានភាព (ឬ 0 ប្រសិនបើមិនបានបញ្ជាក់) ត្រូវបានត្រឡប់ជាស្ថានភាពចាកចេញរបស់ រំពឹង ។ ចេញ ត្រូវបានប្រតិបត្តិយ៉ាងជាក់លាក់ប្រសិនបើបញ្ចប់នៃស្គ្រីប។
exp_continue [-continue_timer]
ពាក្យបញ្ជា exp_continue អនុញ្ញាតឱ្យ រំពឹងថា ខ្លួនវានឹងបន្តប្រតិបត្តិជាជាងការត្រលប់មកដូចធម្មតាវិញ។ តាមលំនាំដើម exp_continue កំណត់កម្មវិធីកំណត់ពេលវេលាអស់ពេល។ ទង់ទង់ --continue_timer ការពារកម្មវិធីកំណត់ពេលវេលាពីការចាប់ផ្តើមឡើងវិញ។ (សូមមើលការ រំពឹងទុក សម្រាប់ព័ត៌មានបន្ថែម។ )
តម្លៃ exp_internal [-f file]
បណ្តាលឱ្យបញ្ជាបន្ថែមទៀតដើម្បីបញ្ជូនព័ត៌មានរោគវិនិច្ឆ័យខាងក្នុង រំពឹងទុក stderr ប្រសិនបើ តម្លៃ មិនមែនសូន្យ។ ទិន្នផលនេះត្រូវបានបិទប្រសិនបើ តម្លៃ គឺ 0 ។ ព័ត៌មានរោគវិនិច្ឆ័យរួមបញ្ចូលរាល់តួអក្សរដែលទទួលបានហើយនិងការព្យាយាមទាំងអស់ដើម្បីផ្គូផ្គងលទ្ធផលបច្ចុប្បន្នប្រឆាំងនឹងលំនាំ។
ប្រសិនបើ ឯកសារ ស្រេចចិត្តត្រូវបានផ្គត់ផ្គង់រាល់លទ្ធផលធម្មតានិងបំបាត់កំហុសត្រូវបានសរសេរទៅឯកសារនោះ (មិនគិតពីតម្លៃនៃ តម្លៃ ) ។ ឯកសារលទ្ធផលរោគវិនិច្ឆ័យពីមុនត្រូវបានបិទ។
ទង់ -info បណ្តាលឱ្យ exp_internal ដើម្បីត្រឡប់ការពិពណ៌នានៃអាគុយម៉ង់មិនមែនព័ត៌មានថ្មីបំផុតដែលបានផ្តល់។
exp_open [args] [-i spawn_id]
ត្រឡប់លេខសម្គាល់ឯកសារ Tcl ដែលត្រូវនឹងលេខសម្គាល់ពងកូនដើម។ អ្នកកំណត់អត្តសញ្ញាណឯកសារអាចត្រូវបានប្រើនៅពេលវាត្រូវបានបើកដោយពាក្យបញ្ជា បើក របស់ Tcl ។ (លេខសម្គាល់ពងបែកមិនគួរប្រើទៀតទេ។ ការ រង់ចាំ មិនគួរត្រូវបានអនុវត្តទេ។
ទង់ជាតិនេះទុកឱ្យលេខសម្គាល់ពងមាន់បើកសម្រាប់ការចូលប្រើតាមរយៈពាក្យបញ្ជារំពឹងទុក។ ការ រង់ចាំ ត្រូវតែត្រូវបានប្រតិបត្តិនៅលើលេខសម្គាល់ពង។
exp_pid [-i spawn_id]
ត្រឡប់លេខសម្គាល់ដំណើរការដែលត្រូវគ្នាទៅនឹងដំណើរដែលបង្កើតកូនបច្ចុប្បន្ន។ បើសិនជាទង់ -i ត្រូវបានគេប្រើ pid បាន ត្រឡប់មកវិញដែលត្រូវគ្នាទៅនឹងលេខសម្គាល់ spawn ដែលបានផ្តល់ឱ្យ។
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] version]
មានប្រយោជន៍សម្រាប់ធានាថាស្គ្រីបគឺឆបគ្នាជាមួយកំណែបច្ចុប្បន្ននៃរំពឹង។
ដោយមិនមានអាគុយម៉ង់ទេកំណែ រំពឹងទុក បច្ចុប្បន្នត្រូវបានត្រឡប់។ ជំនាន់នេះអាចត្រូវបានអ៊ិនកូដក្នុងស្គ្រីបរបស់អ្នក។ ប្រសិនបើអ្នកពិតជាដឹងថាអ្នកមិនប្រើលក្ខណៈពិសេសនៃកំណែថ្មីទេអ្នកអាចបញ្ជាក់ពីកំណែមុន។
កំណែមានលេខបីដែលបំបែកដោយចំណុច។ ទីមួយគឺជាលេខធំ។ ស្គ្រីបដែលបានសរសេរសម្រាប់កំណែនៃការ រំពឹងទុក ជាមួយនឹងចំនួនដ៏សំខាន់មួយផ្សេងទៀតនឹងស្ទើរតែមិនដំណើរការ។ exp_version ត្រឡប់កំហុសប្រសិនបើលេខធំមិនត្រូវគ្នា។
ទីពីរគឺជាចំនួនអនីតិជន។ ស្គ្រីបដែលបានសរសេរសម្រាប់កំណែដែលមានចំនួនតិចតួចជាងកំណែបច្ចុប្បន្នអាចពឹងផ្អែកលើលក្ខណៈពិសេសថ្មីមួយចំនួនហើយប្រហែលជាមិនអាចដំណើរការបាន។ exp_version ត្រឡប់កំហុសប្រសិនបើលេខធំ ៗ ផ្គូផ្គងប៉ុន្តែលេខ សូន្យ របស់ស្គ្រីបគឺធំជាងចំនួន រំពឹងទុក ដែល រំពឹងទុក ។
ទីបីគឺជាចំនួនដែលដើរតួមិននៅក្នុងការប្រៀបធៀប។ ទោះជាយ៉ាងណាក៏ដោយវាត្រូវបានបង្កើននៅពេលដែលការ រំពឹងទុក កម្មវិធីចែកចាយត្រូវបានផ្លាស់ប្តូរតាមវិធីណាមួយដូចជាឯកសារបន្ថែមឬការបង្កើនប្រសិទ្ធភាព។ វាត្រូវបានកំណត់ទៅ 0 លើកំណែអនីតិជននីមួយៗ។
ជាមួយនឹងទង់ - Exit , សង្ឃឹមថានឹង បោះពុម្ពកំហុសមួយហើយចេញប្រសិនបើកំណែហួសសម័យ។
រំពឹងទុក [[-opts] pat1 body1] ... [-opts] patn [bodyn]
រង់ចាំរហូតទាល់តែមួយនៃលំនាំផ្គូផ្គងលទ្ធផលនៃដំណើរការបង្កើតពងមួយរយៈពេលជាក់លាក់បានកន្លងផុតឬចុងបញ្ចប់ត្រូវបានគេមើលឃើញ។ ប្រសិនបើរាងកាយចុងក្រោយគឺទទេវាអាចត្រូវបានលុបចោល។
លំនាំពីពាក្យបញ្ជាថ្មី រំពឹងទុកមុន គឺត្រូវបានប្រើទាំងស្រុងមុនគំរូណាមួយផ្សេងទៀត។ លំនាំពីពាក្យបញ្ជា expect_after ថ្មីៗបំផុតត្រូវបានប្រើទាំងស្រុងបន្ទាប់ពីគំរូផ្សេងទៀត។
ប្រសិនបើអាគុយម៉ង់ចំពោះសេចក្តីថ្លែងការណ៍ដែល រំពឹងទុក ទាំងមូលតម្រូវឱ្យមានច្រើនបន្ទាត់មួយអាគុយម៉ង់ទាំងអស់អាចត្រូវបានកំណត់ទៅជាមួយដើម្បីចៀសវាងការបញ្ចប់បន្ទាត់នីមួយៗដោយសញ្ញាឆូត។ ក្នុងករណីមួយនេះការផ្លាស់ប្តូរ Tcl ធម្មតានឹងកើតឡើងទោះបីជាដង្កៀបក៏ដោយ។
ប្រសិនបើគំរូគឺជាពាក្យគន្លឹះ eof រាងកាយត្រូវគ្នាត្រូវបានប្រតិបត្តិនៅចុងបញ្ចប់នៃឯកសារ។ ប្រសិនបើលំនាំគឺ អស់ពេលកំណត់ ពាក្យគន្លឹះរាងកាយដែលត្រូវគ្នាត្រូវបានប្រតិបត្តិនៅពេលអស់ពេល។ ប្រសិនបើគ្មានពាក្យសម្ងាត់ពេលផុតកំណត់ត្រូវបានប្រើនោះសកម្មភាព null implicit ត្រូវបានប្រតិបត្តិនៅពេលអស់ពេល។ រយៈពេលផុតកំណត់លំនាំដើមគឺ 10 វិនាទីប៉ុន្តែប្រហែលជាត្រូវបានកំណត់ឧទាហរណ៍ទៅ 30 ដោយពាក្យបញ្ជា "កំណត់អស់ពេល 30" ។ ពេលវេលាអស់មិនអាចកំណត់បានដោយតម្លៃ -1 ។ ប្រសិនបើលំនាំជា លំនាំដើម ពាក្យគន្លឹះតួអង្គត្រូវគ្នាត្រូវបានប្រតិបត្តិនៅពេលសម្រាកឬបញ្ចប់នៃឯកសារ។
ប្រសិនបើលំនាំផ្គូផ្គងបន្ទាប់មករាងកាយដែលត្រូវគ្នាត្រូវបានប្រតិបត្តិ។ រំពឹងថានឹង ត្រឡប់លទ្ធផលនៃរាងកាយ (ឬខ្សែអក្សរទទេប្រសិនបើគ្មានលំនាំដែលត្រូវគ្នា) ។ នៅក្នុងព្រឹត្តិការណ៍ដែលផ្គូផ្គងលំនាំច្រើនដែលមួយលេចឡើងដំបូងត្រូវបានប្រើដើម្បីជ្រើសរាងកាយមួយ។
រាល់ពេលដែលលទ្ធផលថ្មីមកដល់វាត្រូវបានគេប្រៀបធៀបទៅនឹងលំនាំនីមួយៗតាមលំដាប់លំដោយ។ ដូច្នេះអ្នកអាចសាកល្បងអវត្តមានល្បែងដោយធ្វើឱ្យលំនាំចុងក្រោយដែលបានធានាបង្ហាញដូចជាប្រអប់បញ្ចូលជាដើម។ ក្នុងស្ថានភាពដែលមិនមានប្រអប់បញ្ចូលអ្នកត្រូវតែប្រើ ពេលសម្រាក (ដូចអ្នកនឹងប្រសិនបើអ្នកកំពុងធ្វើអន្តរកម្មដោយដៃ) ។
លំនាំត្រូវបានបញ្ជាក់តាមបីវិធី។ តាមលំនាំដើមលំនាំត្រូវបានបញ្ជាក់ដូចពាក្យបញ្ជា ផ្គូផ្គងខ្សែអក្សរ របស់ Tcl ។ (បែបបទបែបនេះគឺស្រដៀងទៅនឹងកន្សោមធម្មតា C-shell ធម្មតាដែលគេហៅថា "glob") ។ ទង់ -gl អាចត្រូវបានប្រើដើម្បីការពារលំនាំដែលអាចនឹងផ្គូរផ្គង នឹង ទង់ជាតិពីការធ្វើដូច្នេះ។ លំនាំណាមួយដែលចាប់ផ្ដើមដោយ "-" ត្រូវបានការពារដោយវិធីនេះ។ (ខ្សែអក្សរទាំងអស់ដែលចាប់ផ្ដើមដោយ "-" ត្រូវបានបម្រុងសម្រាប់ជម្រើសនាពេលអនាគត។ )
ឧទាហរណ៍បំណែកខាងក្រោមស្វែងរកការចូលដោយជោគជ័យ។ (ចំណាំថាការ បោះបង់ ត្រូវបានសន្មតថាជានីតិវិធីដែលត្រូវបានកំណត់នៅកន្លែងផ្សេងទៀតនៅក្នុងស្គ្រីប។ )
រំពឹង {busy {ដាក់រវល់ \ n; exp_continue} បានបរាជ័យក្នុងការបោះបង់ "ពាក្យសម្ងាត់មិនត្រឹមត្រូវ" បញ្ឈប់ការបោះបង់ចោលពេលកំណត់ត្រូវបានភ្ជាប់}សម្រង់ចាំបាច់នៅលើលំនាំទីបួនព្រោះថាវាមានចន្លោះដែលអាចបំបែកលំនាំពីសកម្មភាព។ លំនាំដែលមានសកម្មភាពដូចគ្នា (ដូចជាទី 3 និងទី 4) តម្រូវឱ្យរាយបញ្ជីសកម្មភាពម្តងទៀត។ នេះអាចជៀសវាងដោយប្រើលំនាំរចនាប័ទ្ម regexp (សូមមើលខាងក្រោម) ។ ព័ត៌មានបន្ថែមស្តីពីការបង្កើតគំរូរចនាបថរួមអាចរកបាននៅក្នុងសៀវភៅដៃ Tcl ។
លំនាំរចនាប័ទ្ម Regexp ធ្វើតាមវាក្យសម្ព័ន្ធដែលបានកំណត់ដោយ regexp របស់ Tcl (ខ្លីសម្រាប់ពាក្យ "កន្សោមធម្មតា") ។ លំនាំ regexp ត្រូវបានណែនាំជាមួយ flag -re ។ ឧទាហរណ៍មុនអាចត្រូវបានសរសេរដោយប្រើ regexp ដូចជា:
រំពឹង {busy {ដាក់រវល់ \ n; exp_continue} -re "បានបរាជ័យ | ពាក្យសម្ងាត់មិនត្រឹមត្រូវ" បោះបង់ចោលអស់ពេលបោះបង់ចោល}ប្រភេទគំរូទាំងពីរគឺ "មិនត្រូវបានរារាំង" ។ នេះមានន័យថាលំនាំមិនត្រូវផ្គូផ្គងខ្សែអក្សរទាំងមូលទេប៉ុន្តែអាចចាប់ផ្តើមនិងបញ្ចប់ការប្រកួតគ្រប់ទីកន្លែងនៅក្នុងខ្សែអក្សរ (ដរាបណាអ្វីៗផ្សេងទៀតត្រូវគ្នា) ។ ប្រើ ^ ដើម្បីផ្គូផ្គងចាប់ផ្តើមខ្សែអក្សរនិង $ ដើម្បីផ្គូផ្គងចុង។ សូមកត់សម្គាល់ថាប្រសិនបើអ្នកមិនរង់ចាំការបញ្ចប់នៃខ្សែអក្សរទេការឆ្លើយតបរបស់អ្នកអាចបញ្ចប់បានយ៉ាងងាយស្រួលនៅពាក់កណ្តាលខ្សែអក្សរនៅពេលដែលវាត្រូវបានតំណាងពីដំណើរការបង្កើត។ ខណៈពេលដែលនៅតែផលិតលទ្ធផលត្រឹមត្រូវលទ្ធផលអាចមើលទៅខុសពីធម្មជាតិ។ ដូច្នេះការប្រើ $ ត្រូវបានលើកទឹកចិត្តប្រសិនបើអ្នកអាចពិពណ៌នាយ៉ាងច្បាស់អំពីតួអង្គនៅចុងខ្សែអក្សរ។
ចំណាំថានៅក្នុងកម្មវិធីនិពន្ធជាច្រើន ... និង $ ផ្គូផ្គងចាប់ផ្តើមនិងបញ្ចប់បន្ទាត់រៀង ៗ ខ្លួន។ ទោះជាយ៉ាងណាក៏ដោយដោយសារតែរំពឹងថានឹងមិនតម្រង់ជួរនោះតួអក្សរទាំងនេះត្រូវគ្នានឹងការចាប់ផ្តើមនិងបញ្ចប់នៃទិន្នន័យ (ផ្ទុយពីបន្ទាត់) ដែលបច្ចុប្បន្នរំពឹងទុកនៅក្នុងសតិបណ្ដោះអាសន្ន។ (សូមមើលផងដែរនូវចំណាំខាងក្រោមស្តីពីការមិនរំលាយអាហាររបស់ប្រព័ន្ធ។ )
ទង់ -ex បាន ធ្វើឱ្យលំនាំត្រូវបានផ្គូផ្គងជាខ្សែអក្សរ "ពិតប្រាកដ" ។ គ្មានការបកស្រាយ *, ^ ។ ល។ ត្រូវបានធ្វើឡើង (ទោះបីជាអនុសញ្ញា Tcl ធម្មតាត្រូវតែគោរពតាម) ។ លំនាំពិតប្រាកដត្រូវបានបិទជានិច្ច។
ទង់ - nocase បណ្តាលឱ្យតួអក្សរធំនៃលទ្ធផលត្រូវបានប្រៀបធៀបជាតួអក្សរតូច។ គំរូមិនត្រូវបានប៉ះពាល់ទេ។
ខណៈពេលអានលទ្ធផលច្រើនជាង 2000 bytes អាចបង្ខំឱ្យបៃដើមត្រូវបានបំភ្លេចចោល។ នេះអាចត្រូវបានផ្លាស់ប្តូរជាមួយមុខងារ match_max ។ (ចំណាំថាតម្លៃធំលើសអាចបន្ថយលំនាំ Matcher ។ ) ប្រសិនបើ បញ្ជីប័ណ្ណសារ មាន full_buffer នោះ តួអក្សរ ដែលត្រូវគ្នាត្រូវបានប្រតិបត្តិប្រសិនបើ match_max bytes ត្រូវបានទទួលហើយគ្មានលំនាំផ្សេងទៀតត្រូវបានផ្គូផ្គង។ ថាតើពាក្យគន្លឹះ full_buffer ត្រូវបានប្រើឬអត់នោះតួអក្សរដែលភ្លេចត្រូវបានសរសេរទៅ expect_out (buffer) ។
ប្រសិនបើ បញ្ជីពាក្យសម្ងាត់ គឺពាក្យគន្លឹះ null និង nulls ត្រូវបានអនុញ្ញាត (តាមរយៈពាក្យ remove_nulls ) នោះ តួអក្សរ ឆ្លើយតបត្រូវបានប្រតិបត្តិប្រសិនបើ ASCII 0 តែមួយត្រូវបានផ្គូផ្គង។ វាមិនអាចផ្គូផ្គង 0 បៃតាមរយៈគំរូ glob ឬ regexp ទេ។
នៅពេលផ្គូផ្គងលំនាំ (ឬ eof ឬ full_buffer) លទ្ធផលផ្គូផ្គងដែលមិនផ្គូផ្គងណាមួយពីមុនត្រូវបានរក្សាទុកក្នុងអថេរ expect_out (សតិបណ្ដោះអាសន្ន) ។ រហូតដល់ 9 ការផ្គូផ្គងខ្សែអក្សរ regexp ត្រូវបានរក្សាទុកក្នុងអថេរ expect_out (1, string) តាមរយៈ expect_out (9, string) ។ បើសិនជាទង់ជាតិត្រូវបានប្រើមុនគំរូមួយនោះសូចនាករចាប់ផ្តើមនិងបញ្ចប់ (ក្នុងសំណុំបែបបទដែលសមស្របសម្រាប់ lrange ) នៃខ្សែអក្សរចំនួន 10 ត្រូវបានរក្សាទុកនៅក្នុងអថេរ expect_out (X ចាប់ផ្ដើម) និង expect_out (X នៅចុង) ដែល X ជា ខ្ទង់ទាក់ទងទៅនឹងទីតាំងរងនៅក្នុងសតិបណ្ដោះអាសន្ន។ 0 សំដៅទៅខ្សែអក្សរដែលផ្គូផ្គងលំនាំទាំងមូលហើយត្រូវបានបង្កើតសម្រាប់លំនាំសកលក៏ដូចជាលំនាំ regexp ។ ឧទាហរណ៍ប្រសិនបើដំណើរការបានបង្កើតលទ្ធផលនៃ "abcdefgh \ n" នោះលទ្ធផលនៃ:
រំពឹងថានឹង "ស៊ីឌី"គឺដូចជាសេចក្តីថ្លែងការណ៍ដូចខាងក្រោមបានប្រតិបត្តិ:
កំណត់ expect_out (0, string) cd set expect_out (buffer) abcdនិង "efgh \ n" ត្រូវបានទុកនៅក្នុងសតិបណ្ដោះអាសន្ន។ ប្រសិនបើដំណើរការមួយបង្កើតលទ្ធផល "abbbcbkkkka \ n", លទ្ធផលនៃ:
expect -indices -re "b (b *) ។ * (k +)"គឺដូចជាសេចក្តីថ្លែងការណ៍ដូចខាងក្រោមបានប្រតិបត្តិ:
កំណត់ expect_out (0, បញ្ចប់) 10 set expect_out (0, string) bbbcabkkkk កំណត់ expect_out (1, ចាប់ផ្តើម) 2 កំណត់ expect_out (1, ចុង) 3 កំណត់ expect_out (1, string) bb set expect_out (2, ចាប់ផ្តើម) 10 កំណត់ expect_out (2, ចុងក្រោយ) 10 set expect_out (2 string) k set expect_out (buffer) abbbcabkkkkនិង "\ n" ត្រូវបានទុកនៅក្នុងសតិបណ្ដោះអាសន្ន។ លំនាំ "*" (និង -re "។ *") នឹងពន្លាសតិបណ្ដោះអាសន្នលទ្ធផលដោយមិនអានទិន្នផលបន្ថែមទៀតពីដំណើរការ។
ជាទូទៅលទ្ធផលដែលផ្គូផ្គងត្រូវបានបោះបង់ចោលពីសតិបណ្តោះអាសន្នខាងក្នុងរបស់ Expect ។ នេះអាចត្រូវបានរារាំងដោយដាក់បុព្វបទជាមួយទង់ -notransfer ។ ទង់ជាតិនេះមានសារៈសំខាន់ជាពិសេសនៅក្នុងការពិសោធ (ហើយអាចត្រូវបានកាត់សម្រាប់ "មិនមែន" សម្រាប់ភាពងាយស្រួលក្នុងពេលសាកល្បង) ។
លេខសម្គាល់ពងបែកដែលមានទំនាក់ទំនងជាមួយលទ្ធផលដែលផ្គូផ្គង (ឬ eof ឬ full_buffer) ត្រូវបានទុកក្នុង expect_out (spawn_id) ។
ទង់ ពេលវេលា -timeout បណ្តាលឱ្យពាក្យបញ្ជារំពឹងទុកបច្ចុប្បន្នប្រើពាក្យខាងក្រោមជាការអស់ពេលជំនួសឱ្យប្រើអថេរពេលវេលា។
តាមលំនាំដើមលំនាំត្រូវបានផ្គូផ្គងជាមួយលទ្ធផលពីដំណើរការបច្ចុប្បន្នទោះបីជាទង់ -i ប្រកាសទិន្នផលពីបញ្ជីឈ្មោះ spawn_id ដែលត្រូវបានផ្គូផ្គងប្រឆាំងនឹងលំនាំខាងក្រោមណាមួយ (រហូតដល់ទៅ -i ) ។ បញ្ជី spawn_id គួរតែជាបញ្ជីដែលបំបែកដោយចន្លោះនៃ spawn_ids ឬអថេរយោងទៅដូចជាបញ្ជីនៃ spawn_ids មួយ។
ឧទាហរណ៍ឧទាហរណ៍ខាងក្រោមរង់ចាំសម្រាប់ "បានភ្ជាប់" ពីដំណើរការបច្ចុប្បន្នឬ "រវល់" "បានបរាជ័យ" ឬ "ពាក្យសម្ងាត់មិនត្រឹមត្រូវ" ពី spawn_id ដែលត្រូវបានដាក់ឈ្មោះដោយ $ proc2 ។
រំពឹង {-i $ proc2 រវល់ {ដាក់រវល់ \ n; exp_continue} -re "បានបរាជ័យ | ពាក្យសម្ងាត់មិនត្រឹមត្រូវ" បោះបង់ចោលអស់ពេលបោះបង់ចោល}តម្លៃនៃអថេរសកល any_spawn_id អាចត្រូវបានប្រើដើម្បីផ្គូផ្គងលំនាំទៅនឹង spawn_ids ណាមួយដែលត្រូវបានដាក់ឈ្មោះជាមួយនឹងទង់ - i ទាំងអស់នៅក្នុងពាក្យបញ្ជាដែល រំពឹងទុក បច្ចុប្បន្ន។ spawn_id ពីទង់ -i ដោយគ្មានលំនាំដែលជាប់ទាក់ទង (មានន័យថាតាមធម្មតាដោយមួយ -i ) ត្រូវបានធ្វើឱ្យមានលំនាំផ្សេងទៀតនៅក្នុងពាក្យបញ្ជា រំពឹងទុក ដូចគ្នាដែលជាប់ទាក់ទងជាមួយ any_spawn_id ។
ទង់ -i ក៏អាចដាក់ឈ្មោះអថេរសកលក្នុងករណីដែលអថេរត្រូវបានអានសម្រាប់បញ្ជីនៃអាយផូដ។ អថេរត្រូវបានអានឡើងវិញនៅពេលដែលវាផ្លាស់ប្តូរ។ នេះផ្តល់នូវវិធីនៃការផ្លាស់ប្តូរប្រភព I / O ខណៈពេលដែលពាក្យបញ្ជាត្រូវបានគេប្រតិបត្តិ។ អព្ភូតហេតុស្បូនដែលត្រូវបានគេហៅថានេះត្រូវបានគេហៅថា "អាយ៉ង" ទឹកដោះគោ។
សកម្មភាពដូចជា ការបំផ្លាញ និង បន្ត បណ្តាលឱ្យរចនាសម្ព័ន្ធគ្រប់គ្រង (ឧ។ សម្រាប់ proc ) ដើម្បីធ្វើតាមឥរិយាបទធម្មតា។ ពាក្យបញ្ជា exp_continue អនុញ្ញាតឱ្យ រំពឹងថា ខ្លួនវានឹងបន្តប្រតិបត្តិជាជាងការត្រលប់មកដូចធម្មតាវិញ។
នេះមានប្រយោជន៍សម្រាប់ជៀសវាង រង្វិលជុំ ជាក់លាក់ឬសេចក្តីថ្លែងការណ៍ដែលរំពឹងទុកម្តងហើយម្តងទៀត។ ឧទាហរណ៍ខាងក្រោមនេះគឺជាផ្នែកនៃបំណែកដែលត្រូវប្រើ rlogin ស្វ័យប្រវត្តិ។ exp_continue ចៀសវាងសរសេរសេចក្តីថ្លែងការណ៍ រំពឹងទុក ទីពីរ (ដើម្បីស្វែងរកប្រអប់បញ្ចូលម្តងទៀត) ប្រសិនបើ rlogin សួររកពាក្យសម្ងាត់។
រំពឹង {ពាក្យសម្ងាត់: {stty -echo send_user "ពាក្យសម្ងាត់: (សម្រាប់ $ user) លើ $ host:" expect_user -re "(។ *) \ n" send_user "\ n" ផ្ញើ "$ expect_out (1, string) \ r" stty echo exp_continue} មិនត្រឹមត្រូវ {send_user} "ពាក្យសម្ងាត់ឬគណនីគ្មានសុពលភាព \ n" ពេលចេញ} អស់ពេល "{send_user") ទៅ $ host អស់ពេល \ n "out} នៃ {send_user}" ទៅម៉ាស៊ីនដែលបានបរាជ័យ: $ expect_out (buffer) "exit} ឡើងវិញ $ prompt}ឧទាហរណ៍បំណែកខាងក្រោមអាចជួយអ្នកប្រើនាំផ្លូវអន្តរកម្មដែលមានរួចរាល់ដោយស្វ័យប្រវត្តិ។ ក្នុងករណីនេះស្ថានីយត្រូវបានបញ្ចូលទៅក្នុងរបៀបឆៅ។ ប្រសិនបើអ្នកប្រើចុច "+" អថេរនឹងត្រូវបានបង្កើន។ ប្រសិនបើ "p" ត្រូវបានចុចត្រឡប់មួយចំនួនត្រូវបានផ្ញើទៅដំណើរការប្រហែលជាចំនុចនេះតាមវិធីមួយចំនួនហើយ "i" អនុញ្ញាតឱ្យអ្នកប្រើធ្វើអន្តរកម្មជាមួយដំណើរការដែលអាចលួចយកការត្រួតពិនិត្យពីស្គ្រីប។ ក្នុងករណីនីមួយៗការ exp_continue អនុញ្ញាតឱ្យបច្ចុប្បន្ន រំពឹងថា នឹងបន្តការផ្គូផ្គងគំរូបន្ទាប់ពីអនុវត្តសកម្មភាពបច្ចុប្បន្ន។
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_forethough លើកលែងតែថាប្រសិនបើគំរូពីទាំងពីរ រំពឹងទុក និង រំពឹងទុក បន្ទាប់ អាចផ្គូផ្គងលំនាំ រំពឹងទុក ត្រូវបានប្រើ។ សូមមើលពាក្យបញ្ជា expect_for command សម្រាប់ព័ត៌មានបន្ថែម។
expect_background [expect_args]
យកអាគុយម៉ង់ដូចគ្នានឹង រំពឹងទុក ទោះយ៉ាងណាវាត្រលប់មកភ្លាមៗ។ លំនាំត្រូវបានសាកល្បងរាល់ពេលបញ្ចូលថ្មី។ អស់រយៈពេលជា លំនាំដើម និង លំនាំដើម គឺគ្មានន័យ ទាល់តែរំពឹងទុក និងត្រូវបានបោះបង់ចោលដោយស្ងៀមស្ងាត់។ បើមិនដូច្នោះទេពាក្យបញ្ជា expect_ បំរុង នៃការ បម្រុងទុក ប្រើ expect_foreetime និង expect_after patterns ដូចដែល រំពឹងចង់បាន ។
នៅពេល រំពឹងថា សកម្មភាព បម្រុងទុក ត្រូវបានវាយតម្លៃដំណើរការផ្ទៃខាងក្រោយសម្រាប់លេខសម្គាល់ spawn ដូចគ្នាត្រូវបានហាមឃាត់។ ដំណើរការផ្ទៃខាងក្រោយត្រូវបានដោះសោនៅពេលដែលសកម្មភាពបានបញ្ចប់។ ខណៈពេលដែលដំណើរការផ្ទៃខាងក្រោយត្រូវបានទប់ស្កាត់វាអាចធ្វើទៅបាន (ផ្ទៃខាងមុខ) ដែល រំពឹង លើលេខដដែល។
វាមិនអាចធ្វើទៅបាន ទេ ខណៈដែល រំពឹងទុកថា ផ្ទៃខាងក្រោយ រំពឹងទុក ត្រូវបានឈប់។ expect_background សម្រាប់លេខសំគាល់កូនពងបែកជាក់លាក់មួយនឹងត្រូវបានលុបដោយការប្រកាសទីតាំងរំពឹងទុកថ្មីជាមួយនឹងលេខកូនគោដូចគ្នា។ ការប្រកាស expect_background ដោយគ្មានគំរូដកយកលេខសម្គាល់ spawn ដែលបានផ្តល់ឱ្យពីសមត្ថភាពក្នុងការផ្គូផ្គងលំនាំនៅផ្ទៃខាងក្រោយ។
expect_fore [expect_args]
យកអាគុយម៉ង់ដូចគ្នានឹង រំពឹងទុក ទោះយ៉ាងណាវាត្រលប់មកភ្លាមៗ។ គូគំរូសកម្មភាពពីការ រំពឹងទុក ថ្មីបំផុតជាមួយ លេខសំយោគ ពងកូនដូចគ្នាត្រូវបានបញ្ចូលទៅក្នុងពាក្យបញ្ជាដែល រំពឹងទុក ដូចខាងក្រោម។ ប្រសិនបើលំនាំផ្គូផ្គងវាត្រូវបានចាត់ទុកថាវាត្រូវបានបញ្ជាក់នៅក្នុងពាក្យបញ្ជាដែល រំពឹងទុក ខ្លួនវាហើយតួដែលពាក់ព័ន្ធត្រូវបានប្រតិបត្តិក្នុងបរិបទនៃពាក្យបញ្ជាដែល រំពឹងទុក ។ ប្រសិនបើគំរូពីទាំង រំពឹងទុក និង រំពឹងទុក អាចត្រូវគ្នាលំនាំ រំពឹងទុកមុន ត្រូវបានគេប្រើ។
ប្រសិនបើគ្មានលំនាំត្រូវបានបញ្ជាក់ទេនោះលេខសម្គាល់ពងមាន់មិនត្រូវបានធីកសម្រាប់លំនាំណាមួយទេ។
លុះត្រាតែដណ្ដើមដោយទង់ -i , expect_ លំនាំ មុននឹង ផ្គូផ្គងនឹងលេខសម្គាល់ spawn ដែលបានកំណត់នៅពេលដែលពាក្យបញ្ជា expect_for ត្រូវបានប្រតិបត្តិ (មិនមែននៅពេលដែលលំនាំរបស់វាត្រូវបានផ្គូផ្គង) ។
ទង់ - ព័ត៌មានដែលបណ្តាលឱ្យមាន សង្ឃឹមរំពឹងទុក ដើម្បីត្រឡប់មកវិញនូវការបញ្ជាក់បច្ចុប្បន្ននៃលំនាំដែលវានឹងផ្គូផ្គង។ តាមលំនាំដើមវារាយការណ៍អំពីលេខសម្គាល់ស្បូនបច្ចុប្បន្ន។ ការបញ្ជាក់អត្តសញ្ញាណនៃការបង្កកំណើតអាចត្រូវបានផ្តល់ជូនសម្រាប់ព័ត៌មានអំពីលេខសម្គាល់ស្ប៉ានោះ។ ឧទាហរណ៍
expect_fore -info -i $ procយ៉ាងហោចណាស់អ្នកអាចបញ្ជាក់អំពីការបញ្ជាក់លេខសម្គាល់មួយ។ ទង់ជាតិ - ដោយស្វ័យប្រវត្តិទប់ស្កាត់អាយផេតដោយផ្ទាល់ដែលមានប្រភពមកពីការកំណត់ដោយប្រយោល។
ជំនួសឱ្យការបញ្ជាក់អត្តសញ្ញាណពងកូនពណ្តុរទង់ជាតិ "ទាំងអស់" នឹងបណ្តាលឱ្យ "ព័ត៌មាន" រាយការណ៍អំពីអត្តសញ្ញាណរបស់ពង។
លទ្ធផលនៃទង់ - ព័ត៌មានអាចត្រូវបានប្រើឡើងវិញជាអាគុយម៉ង់ដែលរំពឹងទុកមុន។
expect_tty [expect_args]
គឺដូចជា រំពឹងទុក ប៉ុន្តែវាអានតួអក្សរពី / dev / tty (ឧ។ សង្កត់គ្រាប់ចុចពីអ្នកប្រើ) ។ តាមលំនាំដើមការអានត្រូវបានអនុវត្តនៅក្នុងរបៀបឆ្អិន។ ដូច្នេះបន្ទាត់ត្រូវបញ្ចប់ដោយការត្រលប់មកវិញដើម្បី រំពឹង មើលវា។ នេះអាចត្រូវបានផ្លាស់ប្តូរតាមរយៈ stty (សូមមើលពាក្យបញ្ជា stty ខាងក្រោម) ។
expect_user [expect_args]
គឺដូចជា រំពឹងទុក ប៉ុន្តែវាអានតួអក្សរពី stdin (ឧ។ សង្កត់គ្រាប់ចុចពីអ្នកប្រើ) ។ តាមលំនាំដើមការអានត្រូវបានអនុវត្តនៅក្នុងរបៀបឆ្អិន។ ដូច្នេះបន្ទាត់ត្រូវបញ្ចប់ដោយការត្រលប់មកវិញដើម្បី រំពឹង មើលវា។ នេះអាចត្រូវបានផ្លាស់ប្តូរតាមរយៈ stty (សូមមើលពាក្យបញ្ជា stty ខាងក្រោម) ។
សម
បង្កើត ដំណើរការ ថ្មី មួយ ។ ដំណើរការ ថ្មីគឺជាច្បាប់ចម្លងជាក់លាក់នៃ ដំណើរការ រំពឹងទុក បច្ចុប្បន្ន។ នៅពេលទទួលបានជោគជ័យ សំពត់ ត្រលប់ទៅដំណើរការថ្មី (កូនក្មេង) ហើយត្រឡប់លេខ ដំណើរការ នៃ ដំណើរការ កូនទៅ ដំណើរការ មេវិញ។ លើការបរាជ័យ (ជានិច្ចកាលដោយសារតែការខ្វះធនធានដូចជាឧទាហរណ៍ចន្លោះផ្លាស់ប្តូរ, ការចងចាំ), សម - ត្រឡប់ទៅ ដំណើរការ មេនិងគ្មាន ដំណើរការ កូនទេ។
ដំណើរការ Forked ចេញតាមរយៈពាក្យបញ្ជា ចេញ ដូចដែល ដំណើរការ ដើម។ ដំណើរការ Forked ត្រូវបានអនុញ្ញាតឱ្យសរសេរទៅឯកសារកំណត់ហេតុ។ ប្រសិនបើអ្នកមិនបិទការបំបាត់កំហុសឬការកាប់ឈើក្នុងដំណើរការភាគច្រើនទេលទ្ធផលអាចធ្វើអោយពិបាកយល់។
ការអនុវត្ត pty មួយចំនួនអាចត្រូវបានច្រឡំដោយអ្នកអានច្រើននិងអ្នកនិពន្ធសូម្បីតែមួយភ្លែត។ ដូច្នះវាមានសុវត្ថិភាពបំផុតក្នុងការបនា្ទាប់ពីដំណើរការពងកូន។
អន្តរកម្ម [string1 body1] ... [stringn [bodyn]]
ផ្តល់ការត្រួតពិនិត្យ ដំណើរការ បច្ចុប្បន្នដល់អ្នកប្រើដូច្នេះគ្រាប់ចុចត្រូវបានផ្ញើទៅ ដំណើរការ បច្ចុប្បន្នហើយ stdout និង stderr នៃ ដំណើរការ បច្ចុប្បន្នត្រូវបានត្រឡប់។
គូរាងកាយខ្សែអក្សរអាចត្រូវបានបញ្ជាក់ជាអាគុយម៉ង់ក្នុងករណីដែលតួអង្គត្រូវបានប្រតិបត្តិនៅពេលដែលខ្សែអក្សរត្រូវគ្នាត្រូវបានបញ្ចូល។ (តាមលំនាំដើមខ្សែអក្សរមិនត្រូវបានផ្ញើទៅក្នុង ដំណើរការ បច្ចុប្បន្ន។ ) ពាក្យបញ្ជា អ្នកបកប្រែ ត្រូវបានសន្មត់ប្រសិនបើសាកសពចុងក្រោយត្រូវបានបាត់។
ប្រសិនបើអាគុយម៉ង់ទៅសេចក្តីថ្លែងការណ៍ អន្តរកម្ម ទាំងមូលទាមទារច្រើនជាងមួយបន្ទាត់អាគុយម៉ង់ទាំងអស់អាចត្រូវបាន "ភ្ជាប់" ទៅជាមួយដូច្នេះដើម្បីជៀសវាងការបញ្ចប់បន្ទាត់នីមួយៗដោយសញ្ញា \\ ។ ក្នុងករណីមួយនេះការផ្លាស់ប្តូរ Tcl ធម្មតានឹងកើតឡើងទោះបីជាដង្កៀបក៏ដោយ។
ឧទាហរណ៍ពាក្យបញ្ជាដូចខាងក្រោមរត់ទំនាក់ទំនងជាមួយគូដូចខាងក្រោមខ្សែអក្សររាងកាយ: ពេល ^ Z ត្រូវបានចុច រង់ចាំ ត្រូវបានផ្អាក។ (ទង់ -reet ស្តាររបៀបស្ថានីយ។ ) ពេល ^ A ត្រូវបានចុចអ្នកប្រើនឹងឃើញ "អ្នកបានវាយ control-A" ហើយ ដំណើរការ ត្រូវបានផ្ញើទៅ ^ A ។ នៅពេលដែលត្រូវបានចុច, អ្នកប្រើមើលឃើញកាលបរិច្ឆេទ។ ពេល ^ C ត្រូវបានចុច រំពឹងថានឹង ចេញ។ ប្រសិនបើ "foo" ត្រូវបានបញ្ចូលអ្នកប្រើនឹងឃើញ "របារ" ។ នៅពេលចុចលើ ~ ~ កម្មវិធីបកប្រែ រំពឹងទុក ដំណើរការដោយអន្តរសកម្ម។
កំណត់ CTRLZ \ 032 ធ្វើអន្តរកម្ម {-reet $ CTRLZ {ប្រតិបត្តិ exec-STOP [pid]} \ 001 {send_user "អ្នកបានវាយបញ្ចូលវត្ថុបញ្ជា-A \ n"; ផ្ញើ "001"} $ {send_user "កាលបរិច្ឆេទគឺ [ទម្រង់នាឡិកា [ម៉ោងនាឡិកា]] ។ "} \ 003 ច្រកចេញ foo {send_user "bar"} ~~}នៅក្នុងគូតួអក្សរខ្សែ, ខ្សែអក្សរត្រូវបានផ្គូផ្គងតាមលំដាប់ដែលពួកគេត្រូវបានរាយជាអាគុយម៉ង់។ ខ្សែអក្សរដែលផ្គូផ្គងដោយផ្នែកមិនត្រូវបានផ្ញើទៅ ដំណើរការ បច្ចុប្បន្នក្នុងការស្មានទុកជាមុននូវអ្វីដែលនៅសេសសល់នឹងមកដល់។ ប្រសិនបើតួអក្សរត្រូវបានបញ្ចូលនៅពេលនោះវាមិនអាចជាការប្រកួតទេមានតែផ្នែកនៃខ្សែអក្សរដែលនឹងត្រូវបានផ្ញើទៅ ដំណើរការ ដែលមិនអាចចាប់ផ្ដើមការផ្គូផ្គងផ្សេងទៀត។ ដូច្នេះខ្សែអក្សរដែលជាខ្សែអក្សរនៃការផ្គូផ្គងផ្នែកណាមួយអាចផ្គូផ្គងនៅពេលក្រោយប្រសិនបើខ្សែអក្សរដើមដែលកំពុងព្យាយាមផ្គូផ្គងចុងក្រោយបរាជ័យ។
តាមលំនាំដើមការផ្គូផ្គងខ្សែអក្សរគឺពិតប្រាកដដោយគ្មានសញ្ញា ព្រួញ ។ (ផ្ទុយទៅវិញពាក្យបញ្ជាដែល រំពឹងទុក ប្រើលំនាំរចនាប័ទ្មតាមលំនាំដើម។ ) ទង់ -ex អាចត្រូវបានប្រើដើម្បីការពារលំនាំដែលមិនដូច្នោះអាចផ្គូផ្គងទង់ដែលអាចធ្វើប្រតិបត្តិការបាន។ លំនាំណាមួយដែលចាប់ផ្ដើមដោយ "-" ត្រូវបានការពារដោយវិធីនេះ។ (ខ្សែអក្សរទាំងអស់ដែលចាប់ផ្ដើមដោយ "-" ត្រូវបានបម្រុងសម្រាប់ជម្រើសនាពេលអនាគត។ )
ទង់ជាតិនេះបង្ខំខ្សែអក្សរដែលត្រូវបានបកប្រែជាលំនាំរចនាប័ទ្ម regexp ។ ក្នុងករណីនេះខ្សែអក្សរផ្គូផ្គងត្រូវបានរក្សាទុកក្នុងអថេរ interact_out ស្រដៀងគ្នាទៅនឹងវិធី រំពឹង ទុកនូវលទ្ធផលរបស់វាក្នុងអថេរ expect_out ។ ទង់ជាតិត្រូវបានគាំទ្រដូចគ្នា។
លំនាំ eof បង្ហាញសកម្មភាពដែលត្រូវបានប្រតិបត្តិនៅចុងនៃឯកសារ។ លំនាំ eof ដាច់ដោយឡែកក៏អាចធ្វើតាមទង់ --output ក្នុងករណីដែលវាត្រូវបានផ្គូផ្គងប្រសិនបើ eof ត្រូវបានរកឃើញខណៈពេលសរសេរលទ្ធផល។ សកម្មភាព eof លំនាំដើមគឺ "ត្រឡប់" ដូច្នេះ អន្តរកម្ម គ្រាន់តែត្រឡប់ទៅលើ EOF ណាមួយ។
អស់ពេលវេលា លំនាំបង្ហាញអស់ពេល (គិតជាវិនាទី) និងសកម្មភាពដែលត្រូវបានប្រតិបត្តិបន្ទាប់ពីគ្មានតួអក្សរត្រូវបានអានសម្រាប់ពេលវេលាដែលបានផ្តល់ឱ្យ។ លំនាំ ពេល ផុតកំណត់អនុវត្តទៅ ដំណើរការ ដែលបានបញ្ជាក់ថ្មីៗបំផុត។ មិនមានពេលវេលាលំនាំដើមទេ។ អញ្ញាត្តិពិសេស "អស់ពេល" (ត្រូវបានប្រើដោយពាក្យបញ្ជាដែល រំពឹងទុក ) មិនមានឥទ្ធិពលលើពេលនេះទេ។
ឧទាហរណ៍សេចក្តីថ្លែងការណ៍ដូចខាងក្រោមអាចត្រូវបានប្រើដើម្បី autologout អ្នកប្រើដែលមិនបានវាយអ្វីមួយម៉ោងប៉ុន្តែអ្នកនៅតែទទួលបានសារប្រព័ន្ធញឹកញាប់:
អន្តរកម្ម - បញ្ចូល $ user_spawn_id អស់ពេល 3600 ត្រឡប់ - បញ្ចូល \ $ spawn_idប្រសិនបើលំនាំដើមគឺពាក្យគន្លឹះ null ហើយនិង nulls ត្រូវបានអនុញ្ញាត (តាមរយៈពាក្យ remove_nulls ) តួអក្សរ ឆ្លើយតបត្រូវបានប្រតិបត្តិប្រសិនបើ ASCII 0 តែមួយត្រូវបានផ្គូផ្គង។ វាមិនអាចផ្គូផ្គង 0 បៃតាមរយៈគំរូ glob ឬ regexp ទេ។
ការយកលំនាំតាមគំរូដែលមានទង់ជាតិ - សរសេរសរសេរ អោយអថេរ interact_out (spawn_id) ត្រូវបានកំណត់ទៅ spawn_id ដែលត្រូវនឹងលំនាំ (ឬ eof) ។
សកម្មភាពដូចជា ការបំផ្លាញ និង បន្ត បណ្តាលឱ្យរចនាសម្ព័ន្ធគ្រប់គ្រង (ឧ។ សម្រាប់ proc ) ដើម្បីធ្វើតាមឥរិយាបទធម្មតា។ ទោះជាយ៉ាងណាក៏ដោយមូលហេតុ បង្វែរត្រឡប់មកវិញ អាចធ្វើអន្តរកម្មដើម្បីត្រលប់ទៅអ្នកហៅរបស់ខ្លួនវិញខណៈពេលដែល inter_return បណ្តាលឱ្យ មានអន្តរអំពើ ដើម្បីឱ្យអ្នកត្រលប់មកវិញ។ ឧទាហរណ៍ប្រសិនបើ "proc foo" ត្រូវបានគេហៅថា អន្តរកម្ម ដែលបន្ទាប់មកប្រតិបត្តិ inter_return , proc foo នឹងត្រលប់មកវិញ។ (នេះមានន័យថាបើសិនជា ការ ហៅ អន្តរកម្ម ហៅ អ្នកបកប្រែ អន្តរកម្មវាយ ត្រឡប់ នឹងធ្វើឱ្យអន្តរកម្មបន្តហើយ inter_return នឹងធ្វើឱ្យអន្តរកម្មត្រលប់ទៅអ្នកហៅរបស់វាវិញ។ )
ក្នុងកំឡុងពេល អន្តរសកម្ម របៀបឆៅត្រូវបានប្រើដើម្បីអោយតួអក្សរទាំងអស់អាចត្រូវបានបញ្ជូនទៅ ដំណើរការ បច្ចុប្បន្ន។ ប្រសិនបើ ដំណើរការ បច្ចុប្បន្នមិនមានសញ្ញាត្រួតពិនិត្យការងារវានឹងបញ្ឈប់ប្រសិនបើបានផ្ញើសញ្ញាបញ្ឈប់ (តាមលំនាំដើម ^ Z) ។ ដើម្បីចាប់ផ្តើមវាឡើងវិញផ្ញើសញ្ញាបន្ត (ដូចជា "kill -ONT") ។ ប្រសិនបើអ្នកពិតជាចង់ផ្ញើ SIGSTOP ទៅ ដំណើរការ បែបនេះ (ដោយ ^ Z) សូមគិតអំពីការបង្កើតពងអេសស៊ីដំបូងហើយបន្ទាប់មករត់កម្មវិធីរបស់អ្នក។ ម្យ៉ាងវិញទៀតប្រសិនបើអ្នកចង់ផ្ញើ SIGSTOP ទៅ រំពឹងទុក ខ្លួនឯងសូមហៅអ្នកបកប្រែដំបូង (ប្រហែលជាដោយប្រើតួអក្សរគេចចេញ) ហើយបន្ទាប់មកចុច ^ Z ។
គូតួអក្សរទ្រនាប់អាចត្រូវបានប្រើជាខ្ទង់ខ្លីសម្រាប់ជៀសវាងការបញ្ចូលអ្នកបកប្រែនិងប្រតិបត្តិពាក្យសកម្មអន្តរកម្ម។ របៀបស្ថានីយមុនត្រូវបានប្រើខណៈពេលដែលតួនៃតួអក្សរខ្សែអក្សរត្រូវបានប្រតិបត្តិ។
សម្រាប់ល្បឿនសកម្មភាពដែលប្រតិបត្តិក្នុងវត្ថុដើមតាមលំនាំដើម។ ទង់ - ស្តារកំណត់ស្ថានីយឡើងវិញទៅរបៀបដែលវាមានមុនពេល អន្តរកម្ម ត្រូវបានប្រតិបត្តិ (ជារបៀបចម្អិន) ។ សូមចំណាំថាតួអក្សរដែលបានបញ្ចូលនៅពេលដែលរបៀបកំពុងត្រូវបានប្តូរអាចបាត់បង់ (លក្ខណៈពិសេសមិនល្អនៃកម្មវិធីបញ្ជាស្ថានីយនៅលើប្រព័ន្ធមួយចំនួន) ។ ហេតុផលតែមួយគត់ក្នុងការប្រើ -reet គឺប្រសិនបើសកម្មភាពរបស់អ្នកពឹងផ្អែកទៅលើការរត់នៅក្នុងរបៀបឆ្អិន។
ទង់ -echo ផ្ញើតួអក្សរដែលផ្គូផ្គងលំនាំដូចខាងក្រោមត្រឡប់ទៅ ដំណើរការ ដែលបានបង្កើតពួកវាជាតួអក្សរនីមួយៗត្រូវបានអាន។ វាអាចមានប្រយោជន៍នៅពេលអ្នកប្រើត្រូវការមើលការឆ្លើយតបពីលំនាំដែលបានវាយបញ្ចូល។
ប្រសិនបើលំនាំកំពុងត្រូវបានបន្លឺឡើងប៉ុន្តែនៅទីបំផុតមិនបានផ្គូរផ្គងតួអង្គត្រូវបានបញ្ជូនទៅ ដំណើរការ បង្កើត។ ប្រសិនបើ ដំណើរការ បង្កើតរួចបញ្ចោញពួកវាអ្នកប្រើនឹងឃើញតួអង្គពីរដង។ -echo គឺប្រហែលជាសមរម្យនៅក្នុងស្ថានភាពដែលអ្នកប្រើប្រាស់ទំនងមិនបំពេញគំរូ។ ឧទាហរណ៍ការដកស្រង់ខាងក្រោមគឺមកពី rftp ស្គ្រីប recursive-ftp ដែលអ្នកប្រើត្រូវបានសួរឱ្យបញ្ចូល ~ g, ~ p ឬ ~ l ដើម្បីទទួលយកដាក់ឬរាយបញ្ជីថតបច្ចុប្បន្នឡើងវិញ។ ទាំងនេះគឺនៅឆ្ងាយពីពាក្យបញ្ជា ftp ធម្មតាដែលអ្នកប្រើទំនងជាមិនវាយបញ្ចូលដោយមានអ្វីផ្សេងទៀតក្រៅពីកំហុសឆ្គងក្នុងករណីនោះពួកគេប្រហែលជាមិនអើពើលទ្ធផលទេ។
អន្តរកម្ម {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}ទង់ ទទេ ផ្ញើតួអក្សរដែលផ្គូផ្គងលំនាំដូចខាងក្រោមទៅ ដំណើរការចេញ ជាតួអក្សរដែលត្រូវបានអាន។
វាមានប្រយោជន៍នៅពេលដែលអ្នកចង់ឱ្យកម្មវិធី ឆ្លើយតបទៅនឹង លំនាំ។ ឧទាហរណ៍ដូចខាងក្រោមអាចត្រូវបានប្រើដើម្បីត្រួតពិនិត្យកន្លែងដែលមនុស្សម្នាក់កំពុងហៅ (ម៉ូឌឹមម៉ូដែល Hayes) ។ រាល់ពេលដែល "atd" ត្រូវបានគេឃើញស្គ្រីបកំណត់ត្រានៅសល់នៃបន្ទាត់។
proc logber {} {អន្តរកម្ម - មិនមាន --re "(។ *) \ r" ត្រឡប់ដាក់ $ log "[ទម្រង់នាឡិកា [វិនាទីវិនាទី]]: បានហៅ $ interactive (1, ខ្សែអក្សរ)"} អន្តរកម្ម - មិនអនុលោម "លេខសម្គាល់" លេខរៀងក្នុងកំឡុងពេល ធ្វើអន្តរកម្មការ ប្រើពីមុននៃ log_user ត្រូវបានមិនអើពើ។ ជាពិសេស អន្តរកម្ម នឹងបង្ខំឱ្យលទ្ធផលរបស់វាត្រូវបានចូល (បញ្ជូនទៅលទ្ធផលស្តង់ដារ) ព្រោះវាត្រូវបានសន្មត់ថាអ្នកប្រើមិនចង់ធ្វើអន្តរកម្មដោយងងឹតងងុលទេ។
ទង់ -o បណ្តាលឱ្យគូគន្លឹះសំខាន់ណាមួយដូចខាងក្រោមត្រូវបានអនុវត្តចំពោះលទ្ធផលនៃ ដំណើរការ បច្ចុប្បន្ន។ វាអាចមានប្រយោជន៍ឧទាហរណ៍ពេលដោះស្រាយជាមួយ ម៉ាស៊ីន ដែលផ្ញើតួអក្សរដែលមិនចង់បានក្នុងសម័យ telnet ។
តាមលំនាំដើម អន្តរកម្ម រំពឹងថាអ្នកប្រើកំពុងសរសេរ stdin និងអាន stdout នៃ ដំណើរការ រំពឹងទុក ដោយខ្លួនឯង។ ទង់ -u (សម្រាប់ "អ្នកប្រើ") ធ្វើឱ្យ អន្តរ មុខរកមើលអ្នកប្រើជា ដំណើរការដែល មានឈ្មោះដោយអាគុយម៉ង់របស់វា (ដែលត្រូវតែជាលេខសំញែងបង្កើត) ។
នេះអនុញ្ញាតឱ្យដំណើរការមិនទាក់ទងគ្នាពីរត្រូវបានបញ្ចូលគ្នាដោយមិនប្រើរង្វិលជុំច្បាស់លាស់។ ដើម្បីជួយក្នុងការបំបាត់កំហុស, ការវិនិច្ឆ័យការរំពឹងទុកតែងតែទៅ stderr (ឬ stdout សម្រាប់ព័ត៌មានអំពីការចុះកំណត់ហេតុជាក់លាក់និងបំបាត់កំហុស) ។ ចំពោះហេតុផលដូចគ្នាពាក្យបញ្ជា អ្នកបកប្រែ នឹងអានអន្តរកម្មពី stdin ។
ឧទាហរណ៍បំណែកខាងក្រោមបង្កើត ដំណើរការ ចូល។ បន្ទាប់មកវាត្រលប់អ្នកប្រើ (មិនបង្ហាញ) ហើយទីបំផុតភ្ជាប់អ្នកទាំងពីរ។ ជាការពិត ដំណើរការ ណាមួយអាចត្រូវជំនួសដោយការចូល។ ឧទាហរណ៍សែលនឹងអនុញ្ញាតឱ្យអ្នកប្រើធ្វើការដោយគ្មានការផ្តល់គណនីនិងពាក្យសម្ងាត់។
ការកំណត់ចូលពងកូនភ្លីចុះឈ្មោះ $ spawn_id ម៉ូដឹមជំនួយពងបែក # ត្រលប់មកវិញអ្នកប្រើ # ភ្ជាប់អ្នកប្រើដើម្បីចូលអន្តរអំពើ -u $ loginដើម្បីផ្ញើទិន្នផលទៅដំណើរការច្រើនរាយតារាងលេខសម្គាល់ ពងត្រីនីមួយៗដែលមាន ទង់ជាតិ -output ។ ការបញ្ចូលសម្រាប់ ក្រុមបង្ហាញ លេខសម្គាល់ស្បូនអាចត្រូវបានកំនត់ដោយបញ្ជីលេខសំគាល់ពងកូនដោយប្រើទង់ - បញ្ចូល។ (ទាំងការ បញ្ចូល និង - ការ ចាក់ អាចយកបញ្ជីក្នុងទំរង់ដូចគ្នានឹងទង់ -i នៅក្នុងបញ្ជា រំពឹងទុក ដែរលើកលែងតែថា _spawn_id មិនមានន័យក្នុងការ ធ្វើអន្តរកម្ម ។ ) ទង់និង ខ្សែអក្សរ (ឬលំនាំ) ខាងក្រោមទាំងអស់អនុវត្តចំពោះធាតុបញ្ចូលនេះរហូតដល់មួយផ្សេងទៀត - ទង់បញ្ចូលចូលនឹងលេចឡើង។ ប្រសិនបើគ្មានការ បញ្ចូល លេចឡើង, -output implies "- បញ្ចូល $ user_spawn_id -output" ។ (ដូចគ្នានេះដែរដោយមានលំនាំដែលមិនមាន - បញ្ចូល ។ ) ប្រសិនបើបញ្ចូលមួយត្រូវបានបញ្ជាក់វាបដិសេធ $ user_spawn_id ។ ប្រសិនបើការបញ្ចូលទីពីរត្រូវបានបញ្ជាក់វាបដិសេធ $ spawn_id ។ ទង់ បញ្ចូល បន្ថែមអាចត្រូវបានបញ្ជាក់។
ដំណើរការបញ្ចូលពីរ implied default ទៅមានលទ្ធផលរបស់វាដូចដែល $ spawn_id និង $ user_spawn_id (in reverse) ។ ប្រសិនបើទង់ - បញ្ចូលលេចឡើងដោយទង់គ្មានការ បញ្ចេញ ទេតួអង្គពី ដំណើរការនោះ ត្រូវបានបោះបង់ចោល។
ទង់ -i បាន បង្ហាញការជំនួសសម្រាប់ spawn_id បច្ចុប្បន្ននៅពេលដែលមិនមានទង់ - បញ្ចូលឬ - សន្លឹកចេញដែល ត្រូវបានប្រើ។ ទង់អ៊ីស៊ីមានន័យថាទង់អូ។
វាអាចផ្លាស់ប្តូរដំណើរការដែលកំពុងត្រូវបានប្រាស្រ័យជាមួយដោយការប្រើលេខកូដប្រាណដោយប្រយោល។ (លេខសម្គាល់ស្បូនដោយប្រយោលត្រូវបានពិពណ៌នានៅក្នុងផ្នែកនៅលើពាក្យបញ្ជាដែលរំពឹងទុក។ ) លេខសម្គាល់ពងមាន់ប្រយោលអាចត្រូវបានបញ្ជាក់ដោយទង់ -i, -u, -input ឬ -output ។
កម្មវិធីបកប្រែ [args]
បណ្តាលឱ្យអ្នកប្រើត្រូវបានគេសួររកអន្តរកម្មសម្រាប់ពាក្យបញ្ជា Expect និង Tcl ។ លទ្ធផលនៃពាក្យបញ្ជានីមួយៗត្រូវបានបោះពុម្ព។
សកម្មភាពដូចជា ការបំផ្លាញ និង បន្ត បណ្តាលឱ្យរចនាសម្ព័ន្ធគ្រប់គ្រង (ឧ។ សម្រាប់ proc ) ដើម្បីធ្វើតាមឥរិយាបទធម្មតា។ ទោះជាយ៉ាងណាក៏ដោយការ បញ្ជូនត្រលប់មកវិញ បណ្តាលឱ្យអ្នកបកប្រែអាចត្រលប់ទៅអ្នកហៅរបស់ខ្លួនវិញខណៈពេល អន្តរកម្ម បណ្តាលឱ្យ អ្នកបកប្រែបកប្រែ ត្រឡប់មកវិញនៅក្នុងអ្នកហៅចូល។ ឧទាហរណ៍ប្រសិនបើ "proc foo" ត្រូវបានគេហៅថា អ្នកបកប្រែ ដែលបន្ទាប់មកប្រតិបត្តិ inter_return សកម្មភាព proc foo នឹងត្រឡប់មកវិញ។ ពាក្យបញ្ជាណាមួយផ្សេងទៀតបណ្តាលឱ្យ អ្នកបកប្រែ បន្តជំរុញឱ្យមានពាក្យបញ្ជាថ្មី។
តាមលំនាំដើមប្រអប់បញ្ចូលមានចំនួនគត់ពីរ។ ចំនួនគត់ដំបូងពិពណ៌នាជម្រៅនៃការវាយតំលៃជង់ (មានន័យថាតើ Tcl_Eval ត្រូវបានគេហៅថាប៉ុន្មានដង) ។ ចំនួនគត់ទីពីរគឺជាលេខសំគាល់ប្រវត្តិសាស្ត្រ Tcl ។ ប្រអប់បញ្ចូលអាចត្រូវបានកំណត់ដោយកំណត់បែបបទហៅថា "prompt1" ដែលតម្លៃត្រឡប់របស់វាក្លាយជាប្រអប់បញ្ចូលបន្ទាប់។ ប្រសិនបើសេចក្តីថ្លែងការណ៍មានសញ្ញាសម្រង់អថេរសញ្ញាវង់ក្រចកវង់ដង្កៀបឬតង្កៀបសេចក្តីណែនាំទីពីរ (តាមលំនាំដើម "+" ") ត្រូវបានចេញនៅលើបន្ទាត់ថ្មី។ សញ្ញាណែនាំទីពីរអាចត្រូវបានកំណត់ដោយការកំណត់បែបបទហៅថា "ប្រអប់ទី 2" ។
ក្នុងកំឡុងពេល អ្នកបកប្រែ របៀបឆ្អិនត្រូវបានប្រើទោះបីជាអ្នកហៅទូរស័ព្ទរបស់ខ្លួនកំពុងប្រើរបៀបឆៅក៏ដោយ។
ប្រសិនបើ stdin ត្រូវបានបិទ អ្នកបកប្រែ នឹងត្រលប់មកវិញលើកលែងតែទង់ជាតិត្រូវបានប្រើក្នុងករណីដែលអាគុយម៉ង់បន្តបន្ទាប់ត្រូវបានគេប្រើ។
log_file [args] [[-a] file]
ប្រសិនបើឈ្មោះឯកសារត្រូវបានផ្តល់នោះឯកសារកំណត់ហេតុនឹងកត់ត្រាប្រតិចារិកនៃសម័យ (ចាប់ផ្តើមពីចំណុចនោះ) នៅក្នុងឯកសារ។ ឯកសារកំណត់ហេតុ នឹងបញ្ឈប់ការថតប្រសិនបើគ្មានអាគុយម៉ង់។ ឯកសារកំណត់ហេតុពីមុនត្រូវបានបិទ។
ជំនួសឱ្យឈ្មោះឯកសារអ្នកកំណត់អត្តសញ្ញាណឯកសារ Tcl អាចត្រូវបានផ្ដល់ដោយប្រើទង់ - បើកចំហរ ឬ ដោះសោ ។ នេះគឺស្រដៀងទៅនឹងពាក្យបញ្ជា ស្បូន ។ (សូមមើល ទារក សម្រាប់ព័ត៌មានបន្ថែម។ )
ទិន្នផលកម្លាំងទង់ជាតិ -a ត្រូវបានចុះហត្ថលេខាដែលត្រូវបានបង្ក្រាបដោយពាក្យបញ្ជា log_user ។
តាមលំនាំដើមពាក្យបញ្ជា log_file បន្ថែម ទៅឯកសារចាស់ៗជាជាងកាត់ឱ្យខ្លីពួកគេដើម្បីភាពងាយស្រួលក្នុងការបើកការចុះកំណត់ហេតុនិងច្រើនដងក្នុងមួយសម័យ។ ដើម្បីកាត់បន្ថយឯកសារ, ប្រើទង់ -noappend ។
ទង់ -info ធ្វើឱ្យ log_file ត្រឡប់ការពិពណ៌នានៃអាគុយម៉ង់មិនមែនព័ត៌មានថ្មីបំផុតដែលបានផ្ដល់។
log_user -info | 0 | 1
តាមលំនាំដើមប្រអប់ផ្ញើ / រំពឹងត្រូវបានចូលទៅកាន់ stdout (ហើយឯកសារកំណត់ហេតុប្រសិនបើបើក) ។ ការចូលទៅ stdout ត្រូវបានបិទដោយពាក្យបញ្ជា "log_user 0" និងបានបើកដំណើរការឡើងវិញដោយ "log_user 1" ។ ការចូលទៅឯកសារកំណត់ហេតុមិនត្រូវបានផ្លាស់ប្តូរទេ។
ទង់ -info ធ្វើឱ្យ log_user ត្រលប់ការពិពណ៌នាអំពីអាគុយម៉ង់មិនមែនព័ត៌មានថ្មីបំផុតដែលបានផ្តល់។
match_max [-d] [-i spawn_id] [size]
កំណត់ទំហំសតិបណ្ដោះអាសន្ន (គិតជាបៃ) ដែលបានប្រើខាងក្នុងដោយ រំពឹងទុក ។ ដោយគ្មានអាគុយម៉ង់ទំហំទំហំបច្ចុប្បន្នត្រូវបានត្រឡប់។
ជាមួយទង់ -d , ទំហំលំនាំដើមត្រូវបានកំណត់។ (លំនាំដើមគឺ 2000 ។ ) ដោយទង់ -i , ទំហំត្រូវបានកំណត់សម្រាប់លេខសម្គាល់ spawn បើមិនដូច្នេះទេវាត្រូវបានកំណត់សម្រាប់ ដំណើរការ បច្ចុប្បន្ន។
overlay [- # spawn_id] [- # spawn_id] [... ] កម្មវិធី [args]
ប្រតិបត្តិ "កម្មវិធី អាគុយម៉ង់" ជំនួសឱ្យកម្មវិធី រំពឹងទុក បច្ចុប្បន្នដែលបញ្ចប់។ អាគុយម៉ង់កន្លាតទទេបង្ខំសហសញ្ញាមួយនៅពីមុខឈ្មោះពាក្យបញ្ជាថាវាជាសែលចូល។ ទាំងអស់ spawn_ids ត្រូវបានបិទលើកលែងតែសម្រាប់ឈ្មោះដែលមានឈ្មោះថាជាអាគុយម៉ង់។ ទាំងនេះត្រូវបានបង្ហាញលើអត្តសញ្ញាណឯកសារដែលមានឈ្មោះ។
Spawn_ids ត្រូវបានរៀបចំផែនទីដើម្បីកំណត់អត្តសញ្ញាណសម្គាល់សម្រាប់កម្មវិធីថ្មីដើម្បីទទួលមរតក។ ឧទាហរណ៍បន្ទាត់ដូចខាងក្រោមរត់អុកនិងអនុញ្ញាតឱ្យវាត្រូវបានគ្រប់គ្រងដោយ ដំណើរការ បច្ចុប្បន្ន - និយាយថាមេមេអុក។
overlay -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id chessនេះមានប្រសិទ្ធភាពជាង "អន្តរកម្ម -u" ទោះយ៉ាងណាវាលះបង់លទ្ធភាពធ្វើអន្តរកម្មកម្មវិធីពីព្រោះ ដំណើរការ រំពឹងទុក លែងស្ថិតក្នុងការគ្រប់គ្រងទៀតហើយ។
ចំណាំថាគ្មានស្ថានីយត្រួតពិនិត្យត្រូវបានផ្តល់ឱ្យទេ។ ដូច្នេះប្រសិនបើអ្នកផ្ដាច់ឬប្ដូរបទបញ្ចូលស្តង់ដារកម្មវិធីដែលធ្វើការត្រួតពិនិត្យការងារ (សែលការចូល។ ល។ ) នឹងមិនដំណើរការបានត្រឹមត្រូវ។
សមាមាត្រ [-d] [-i spawn_id] [តម្លៃ]
កំណត់ថាតើ parity គួរត្រូវបានរក្សាទុកឬដកចេញពីលទ្ធផលនៃដំណើរការបង្កើត។ ប្រសិនបើ តម្លៃ គឺសូន្យភាពស្មើត្រូវបានដកចេញបើមិនដូច្នេះទេវានឹងមិនត្រូវបានយកចេញទេ។ ដោយគ្មានអាគុយម៉ង់តម្លៃតម្លៃបច្ចុប្បន្នត្រូវបានត្រឡប់។
ជាមួយទង់ -d , តម្លៃ parity លំនាំដើមត្រូវបានកំណត់។ (លំនាំដើមដំបូងគឺ 1 ដែលមានន័យថា parity មិនត្រូវបានយកចេញ) ។ ជាមួយនឹងទង់ -i តម្លៃស្មើគ្នាត្រូវបានកំណត់សម្រាប់លេខសម្គាល់ spawn បើមិនដូច្នេះទេវាត្រូវបានកំណត់សម្រាប់ ដំណើរការ បច្ចុប្បន្ន។
remove_nulls [-d] [-i spawn_id] [តម្លៃ]
កំណត់ថាតើ nulls ត្រូវបានរក្សាទុកឬដកចេញពីលទ្ធផលនៃដំណើរការបង្កើតមុននឹងផ្គូផ្គងលំនាំឬរក្សាទុកក្នុងអថេរ expect_out ឬ interaction_out ។ ប្រសិនបើ តម្លៃ គឺ 1 nulls ត្រូវបានយកចេញ។ ប្រសិនបើ តម្លៃ គឺ 0 នោះទេ nulls មិនត្រូវបានយកចេញទេ។ ដោយគ្មានអាគុយម៉ង់តម្លៃតម្លៃបច្ចុប្បន្នត្រូវបានត្រឡប់។
ជាមួយទង់ -d , តម្លៃលំនាំដើមត្រូវបានកំណត់។ (លំនាំដើមដំបូងគឺ 1 មានន័យថា nulls ត្រូវបានយកចេញ។ ) ដោយមានទង់ -i តម្លៃត្រូវបានកំណត់សម្រាប់លេខសម្គាល់ spawn បើមិនដូច្នេះទេវាត្រូវបានកំណត់សម្រាប់ ដំណើរការ បច្ចុប្បន្ន។
ថាតើត្រូវលុបចោលឬក៏អត់ទេ, រំពឹងថា នឹងកត់ត្រាបៃទទេទៅកំណត់ហេតុនិង stdout ។
ផ្ញើខ្សែអក្សរ [-flags]
ផ្ញើ ខ្សែ ទៅ ដំណើរការ បច្ចុប្បន្ន។ ឧទាហរណ៍ពាក្យបញ្ជា
ផ្ញើតួអក្សរ, helloworld ទៅនឹង ដំណើរការ បច្ចុប្បន្ន។ (Tcl រួមបញ្ចូលនូវពាក្យបញ្ជា printf - like (ដែលហៅថា format ) ដែលអាចកសាងខ្សែអក្សរស្មុគ្រស្មាញ arbitrally ។ )
តួអក្សរត្រូវបានផ្ញើភ្លាមៗទោះបីជាកម្មវិធីដែលមានបញ្ចូលបន្ទាត់ដោយស្វ័យប្រវត្តិនឹងមិនអានតួអក្សររហូតដល់តួអក្សរត្រឡប់ត្រូវបានផ្ញើក៏ដោយ។ តួអក្សរត្រឡប់ត្រូវបានដាក់ឈ្មោះ "\ r" ។
ទង់ - បង្ខំឱ្យអាគុយម៉ង់បន្ទាប់ត្រូវបានបកប្រែជាខ្សែអក្សរជាជាងទង់។ ខ្សែអក្សរណាមួយអាចត្រូវបានបន្តដោយថាតើវាពិតជា "" ទង់។ នេះផ្តល់នូវយន្តការដែលអាចជឿទុកចិត្តបានដើម្បីបញ្ជាក់ខ្សែអក្សរអថេរដោយមិនត្រូវបានបម្លែងដោយអ្នកដែលមើលទៅដូចជាទង់ជាតិ។ (ខ្សែអក្សរទាំងអស់ដែលចាប់ផ្ដើមដោយ "-" ត្រូវបានបម្រុងសម្រាប់ជម្រើសនាពេលអនាគត។ )
ទង់ -i ប្រកាសថាខ្សែអក្សរត្រូវបានបញ្ជូនទៅឈ្មោះថា spawn_id ។ ប្រសិនបើ spawn_id គឺ user_spawn_id ហើយស្ថានីយស្ថិតក្នុងរបៀបឆៅថ្មីបន្ទាត់ក្នុងខ្សែអក្សរត្រូវបានបកប្រែទៅលំដាប់ត្រឡប់បន្ទាត់ថ្មីដូច្នេះវាលេចឡើងដូចជាស្ថានីយនៅក្នុងរបៀបឆ្អិន។ ទង់ -wague បិទការបកប្រែនេះ។
ទង់ទទឹងផ្ញើតួអក្សរទទេ (0 បៃ) ។ តាមលំនាំដើមមួយត្រូវបានផ្ញើ។ ចំនួនគត់អាចធ្វើតាម លេខ - ចង្អុលបង្ហាញថាតើចំនួនប៉ុន្មានដែលត្រូវផ្ញើ។
ទង់ជាតិ - បាក់ធ្វើឱ្យមានលក្ខខណ្ឌបំបែក។ នេះធ្វើឱ្យយល់បានលុះត្រាតែលេខសម្គាល់ពងក្រពើសំដៅទៅលើឧបករណ៍តិត្យូមួយដែលបានបើកតាមរយៈ "ស្បូន" ។ ប្រសិនបើអ្នកបានបង្កើត ដំណើរការ ដូចជាព័ត៌មានជំនួយអ្នកគួរតែប្រើអនុសញ្ញាព័ត៌មានសម្រាប់បង្កើតការសម្រាក។
ទិន្នផលកម្លាំងទង់ជាតិ -s ត្រូវបានបញ្ជូន "យឺត ៗ " ដូច្នេះជៀសវាងស្ថានភាពធម្មតាដែលកុំព្យូទ័រមួយ outpipe សតិបណ្តោះអាសន្នបញ្ចូលដែលត្រូវបានរចនាឡើងសម្រាប់មនុស្សដែលមិនដែលលើសពី សតិបណ្ដោះអាសន្ន ដូចគ្នា។ លទ្ធផលនេះត្រូវបានគ្រប់គ្រងដោយតម្លៃនៃអថេរ "send_slow" ដែលត្រូវការបញ្ជីធាតុពីរ។ ធាតុទីមួយគឺចំនួនគត់ដែលពណ៌នាចំនួនបៃដែលត្រូវផ្ញើអាតូម។ ធាតុទីពីរគឺជាលេខពិតដែលពិពណ៌នាអំពីចំនួនវិនាទីដែលអ៊ីម៉ែលត្រូវបញ្ជូន។ ឧទាហរណ៍ "set send_slow {10 .001}" នឹងបង្ខំ "send -s" ផ្ញើខ្សែដែលមាន 1 មិល្លីវិនាទីនៅចន្លោះតួអក្សរ 10 ដែលបានផ្ញើ។
លទ្ធផលនៃកម្លាំងទង់ជាតិ -h ដែលត្រូវបានផ្ញើ (ខ្លះ) ដូចមនុស្សពិតប្រាកដវាយ។ ភាពយឺតយ៉ាវដូចជាមនុស្សលេចឡើងរវាងតួអង្គ។ (ក្បួនដោះស្រាយគឺផ្អែកលើការចែកចាយ Weibull ដោយមានការកែប្រែដើម្បីបំពេញតាមកម្មវិធីជាក់លាក់នេះ។ ) លទ្ធផលនេះត្រូវបានគ្រប់គ្រងដោយតម្លៃនៃអថេរ "send_human" ដែលត្រូវការបញ្ជីធាតុប្រាំ។ ធាតុពីរដំបូងគឺពេលវេលាអន្តរការីនៃតួអក្សរជាវិនាទី។ ដំបូងត្រូវបានប្រើតាមលំនាំដើម។ ទីពីរត្រូវបានគេប្រើនៅចុងបញ្ចប់ពាក្យដើម្បីក្លែងបន្លំល្បិចដែលកើតឡើងម្តងម្កាលនៅការផ្លាស់ប្តូរបែប។ ប៉ារ៉ាម៉ែត្រទីបីគឺជារង្វាស់នៃអថេរដែល .1 គឺអថេរណាស់ 1 គឺអថេរសមរម្យនិង 10 គឺមិនប្រែប្រួល។ យ៉ាងខ្លាំងគឺ 0 ទៅអណ្តែត។ ប៉ារ៉ាម៉ែត្រពីរចុងក្រោយគឺអប្បបរមានិងអប្បបរមា interarrival ពេលវេលា។ អប្បបរមានិងអតិបរមាត្រូវបានប្រើចុងក្រោយនិង "ខ្ទាស់" ពេលចុងក្រោយ។ មធ្យមចុងក្រោយអាចខុសគ្នាពីមធ្យមដែលបានផ្តល់បើឈុតវីដេអូអប្បបរមានិងអតិបរមាគ្រប់គ្រាន់។
ជាឧទាហរណ៏ពាក្យបញ្ជាដូចខាងក្រោមធ្វើត្រាប់តាមអ្នកវាយអត្ថបទដែលមានល្បឿនលឿននិងស្របតាម:
កំណត់ send_human {.1 .3 1 .05 2} send -h "ខ្ញុំឃ្លានយើងធ្វើអាហារថ្ងៃត្រង់" ។ខណៈពេលដែលដូចខាងក្រោមអាចនឹងត្រូវបានសមរម្យបន្ថែមទៀតបន្ទាប់ពីការខកខានមួយ:
កំណត់ send_human {.4 .4 .2 .5} 100} ផ្ញើរ -h "យប់ជប់លៀងគណបក្សល្អ!"ចំណាំថាកំហុសមិនត្រូវបានក្លែងក្លាយទេទោះបីអ្នកអាចបង្កើតស្ថានភាពកែកំហុសដោយខ្លួនឯងដោយបង្កប់កំហុសនិងការកែតម្រូវក្នុងអាគុយម៉ង់ផ្ញើ។
ទង់ជាតិសម្រាប់ការផ្ញើតួអក្សរទទេសម្រាប់ការផ្ញើការបំបែកសម្រាប់បង្ខំឱ្យទិន្នផលយឺតនិងសម្រាប់លទ្ធផលបែបផែនមនុស្សត្រូវបានផ្តាច់ទៅវិញទៅមក។ មានតែលេខដែលបានបញ្ជាក់ចុងក្រោយប៉ុណ្ណោះនឹងត្រូវបានប្រើ។ លើសពីនេះទៀតអាគុយម៉ង់ ខ្សែអក្សរ មិនអាចត្រូវបានបញ្ជាក់ជាមួយទង់សម្រាប់ផ្ញើតួអក្សរចោលឬបំបែក។
វាជាគំនិតដ៏ល្អដែលត្រូវដើរមុនការ ផ្ញើ ដំបូងទៅ ដំណើរការ ដោយ រំពឹងទុក ។ រំពឹងថា នឹងរង់ចាំ ដំណើរការ ចាប់ផ្តើមប៉ុន្តែមិនអាច បញ្ជូន ។ ជាពិសេសប្រសិនបើការ ផ្ញើ ដំបូងបញ្ចប់មុនពេល ដំណើរការ ដំណើរការអ្នកនឹងរត់ហានិភ័យនៃការមិនឱ្យទិន្នន័យរបស់អ្នកអើពើ។ ក្នុងករណីដែលកម្មវិធីអន្តរកម្មមិនផ្តល់ជូនប្រអប់បញ្ចូលដំបូងអ្នកអាច បញ្ជូន មុនដោយការពន្យាពេលដូចខាងក្រោម:
# ដើម្បីចៀសវាងការផ្តល់ជំនួយដល់ពួក Hacker លើរបៀបបំបែក, # ប្រព័ន្ធនេះមិនបានសួររកពាក្យសម្ងាត់ខាងក្រៅទេ។ # រង់ចាំ 5 វិនាទីដើម្បីប្រតិបត្តិការសំរាលកូន telnet net very.secure.gov ផ្ញើពាក្យសម្ងាត់ \ rexp_send គឺជាឈ្មោះក្លែងក្លាយសម្រាប់ ផ្ញើ។ ប្រសិនបើអ្នកកំពុងប្រើ Expectk ឬវ៉ារ្យ៉ង់ផ្សេងទៀតនៃការរំពឹងទុកនៅក្នុងបរិស្ថាន Tk ផ្ញើ ត្រូវបានកំណត់ដោយ TK សម្រាប់គោលបំណងខុសគ្នាទាំងស្រុង។ exp_send ត្រូវបានផ្តល់ជូនសម្រាប់ភាពឆបគ្នារវាងបរិស្ថាន។ ឈ្មោះក្លែងក្លាយស្រដៀងគ្នាត្រូវបានផ្តល់សម្រាប់ពាក្យបញ្ជាផ្ញើផ្សេងទៀតរបស់រំពឹងផ្សេងទៀត។
ផ្ញើរ_error [-flags]
គឺដូចជាការ ផ្ញើ លើកលែងតែលទ្ធផលត្រូវបានផ្ញើទៅ stderr ជាជាង ដំណើរការ បច្ចុប្បន្ន។
ផ្ញើរ [-] ខ្សែអក្សរ
គឺដូចជាការ ផ្ញើ លើកលែងតែខ្សែអក្សរត្រូវបានផ្ញើទៅឯកសារកំណត់ហេតុ (មើលឯកសារកំណត់ហេតុប៉ុណ្ណោះ) ។ អាគុយម៉ង់ត្រូវបានអើពើប្រសិនបើគ្មានឯកសារកំណត់ហេតុទេ។
send_tty [-flags] ខ្សែអក្សរ
គឺដូចជាការ ផ្ញើ លើកលែងតែលទ្ធផលត្រូវបានផ្ញើទៅ / dev / tty ជាជាង ដំណើរការ បច្ចុប្បន្ន។
send_user [-flags] string
គឺដូចជាការ ផ្ញើ លើកលែងតែលទ្ធផលត្រូវបានផ្ញើទៅ stdout ជាជាង ដំណើរការ បច្ចុប្បន្ន។
ដេករយៈពេលខ្លី
បណ្តាលឱ្យស្គ្រីប ដេក សម្រាប់ចំនួនដែលបានផ្តល់ឱ្យ។ វិនាទីអាចជាលេខគោលដប់។ ការផ្អាក (និងព្រឹត្តិការណ៍ Tk ប្រសិនបើអ្នកកំពុងប្រើ Expectk) ត្រូវបានដំណើរការខណៈពេលដែលរំពឹងថានឹងគេង។
ពងកូន [args] កម្មវិធី [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 មិនមាន (ដូចជា cron, at ឬ batch script) នោះ tty_spawn_id មិនត្រូវបានកំណត់។ នេះអាចត្រូវបានសាកល្បងជា:
ប្រសិនបើ {{info} {# / dev / tty exists} ផ្សេងទៀត {# / dev / tty មិនមាន # ប្រហែលជានៅក្នុង cron, បាច់ឬនៅស្គ្រីប}spawn ត្រឡប់ id ដំណើរការ UNIX ។ ប្រសិនបើគ្មាន ដំណើរការ ទេទើប 0 ត្រូវបានបញ្ជូនមកវិញ។ អថេរ spawn_out (slave ឈ្មោះ) ត្រូវបានកំណត់ទៅជាឈ្មោះនៃឧបករណ៍ slave pty ។
តាមលំនាំដើម spawn echoes ឈ្មោះពាក្យបញ្ជានិងអាគុយម៉ង់។ ទង់ជាតិ -Noecho ឈប់ បង្កាត់ពូជ ពីការធ្វើបែបនេះ។
សញ្ញាទង់ - ផ្ងា ធ្វើឱ្យលទ្ធផលកុងសូលត្រូវបានប្ដូរទិសទៅ ដំណើរការ បង្កើត។ វាមិនត្រូវបានគាំទ្រលើប្រព័ន្ធទាំងអស់ទេ។
នៅខាងក្នុង, ពងកូន ប្រើ pty មួយ, បានចាប់ផ្តើមវិធីដូចគ្នានឹង tty របស់អ្នកប្រើ។ នេះត្រូវបានចាប់ផ្ដើមជាបន្តបន្ទាប់ដូច្នេះការកំណត់ទាំងអស់គឺ "ត្រឹមត្រូវ" (នេះបើយោងតាម stty (1)) ។ ប្រសិនបើអថេរ stty_init ត្រូវបានកំណត់នោះវាត្រូវបានបកប្រែនៅក្នុងរចនាប័ទ្មអាគុយម៉ង់ដែលជាការតំឡើងបន្ថែមទៀត។ ឧទាហរណ៍ "set stty_init raw" នឹងបណ្តាលឱ្យស្ថានីយពងកូនកាត់បន្ថែមទៀតចាប់ផ្តើមជារបៀបឆៅ។ - nottycopy រំលងការចាប់ផ្ដើមដែលមានមូលដ្ឋានលើ tty របស់អ្នកប្រើ។ -nottyinit រំលងការចាប់ផ្ដើម "គំនិត" ។
ជាទូទៅ ពងមាន់ ត្រូវការពេលតិចតួចដើម្បីប្រតិបត្តិ។ ប្រសិនបើអ្នកសម្គាល់ឃើញពងមាន់ដែលចំណាយពេលវេលាច្រើនគួរសមវាអាចនឹងជួបប្រទះ ptys ដែលត្រូវបានភ្ជាប់គ្នា។ ចំនួននៃការធ្វើតេស្តត្រូវបានដំណើរការនៅលើ ptys ដើម្បីជៀសវាងការពាក់ព័ន្ធជាមួយនឹងដំណើរការ errant ។ (ទាំងនេះយក 10 វិនាទីក្នុងមួយ pty wedged ។ ) ការរត់រំពឹងទុកជាមួយនឹងជម្រើស -d នឹងបង្ហាញប្រសិនបើ រំពឹងថា ត្រូវបានជួប ptys ជាច្រើននៅក្នុងរដ្ឋសេស។ ប្រសិនបើអ្នកមិនអាចបញ្ឈប់ដំណើរការដែល ptys ទាំងនេះត្រូវបានភ្ជាប់នោះពឹងផ្អែកតែមួយគត់របស់អ្នកអាចចាប់ផ្តើមឡើងវិញ។
ប្រសិនបើ កម្មវិធី មិនអាចបង្កើតដោយជោគជ័យបានទេពីព្រោះកម្មវិធី (2) បរាជ័យ (ឧទាហរណ៍នៅពេលមិនមាន កម្មវិធី ) សារកំហុសមួយនឹងត្រូវបានត្រឡប់ដោយ អន្តរកម្ម ឬ រំពឹងថានឹងមាន ពាក្យបញ្ជាដូចដែល កម្មវិធី បានដំណើរការនិងបង្កើតសារកំហុសជាលទ្ធផល។ ឥរិយាបថនេះគឺជាផលវិបាកធម្មជាតិនៃការអនុវត្ត ពងបែក ។ នៅខាងក្នុងពែង spawn ដែលបន្ទាប់មក ដំណើរការដែល មានពងគ្មានវិធីដើម្បីទំនាក់ទំនងជាមួយ ដំណើរការ រំពឹងទុក ដើមលើកលែងតែតាមរយៈការទំនាក់ទំនងតាមរយៈ spawn_id ។
ទង់ -open បណ្តាលឱ្យអាគុយម៉ង់បន្ទាប់ត្រូវបានបកប្រែជាលេខសម្គាល់ឯកសារ Tcl (មានន័យថាបានត្រឡប់ដោយ បើក ។ ) បន្ទាប់មកលេខសំគាល់ពងអាចត្រូវបានប្រើដូចជាប្រសិនបើវាត្រូវបានបង្កើត។ (អ្នកកំណត់អត្តសញ្ញាណឯកសារមិនត្រូវបានប្រើទៀតទេ។ ) នេះអនុញ្ញាតឱ្យអ្នកចាត់ទុកឧបករណ៍ឆៅឯកសារនិងបំពង់បំពង់ឆៅជាដំណើរការដែលបង្កើតដោយមិនប្រើ pty ។ 0 ត្រូវបានត្រលប់ដើម្បីចង្អុលបង្ហាញថាមិនមាន ដំណើរការ ពាក់ព័ន្ធ។ នៅពេលការភ្ជាប់ទៅ ដំណើរការ ពងកូនគឺបិទដូច្នេះអ្នកកំណត់អត្តសញ្ញាណឯកសារ Tcl ។ ទង់ជាតិ -theaveopen គឺស្រដៀងគ្នាទៅនឹង -open លើកលែងតែ -theaveopen បណ្តាលឱ្យអ្នកកំណត់អត្តសញ្ញាណឯកសារត្រូវបានបើកចំហទោះបីជាលេខសំគាល់របស់ពងកូនកណ្តុរត្រូវបានបិទក៏ដោយ។
ទង់ ទទេ បណ្តាលអោយមានការបើក pty ប៉ុន្តែមិនមាន ដំណើរការ ទេ។ 0 ត្រូវបានត្រលប់ដើម្បីចង្អុលបង្ហាញថាមិនមាន ដំណើរការ ពាក់ព័ន្ធ។ Spawn_id ត្រូវបានកំណត់ជាធម្មតា។
អថេរ spawn_out (slave, fd) ត្រូវបានកំណត់ទៅជាអត្តសញ្ញាណសម្គាល់ឯកសារដែលត្រូវគ្នាទៅនឹង pty slave ។ វាអាចបិទដោយប្រើ "បិទជិត" ។
ទង់ជាតិ - នាមឈ្មោះ សញ្ញាត្រូវបានមិនអើពើនៅក្នុង ដំណើរការ បង្កើត។ បើមិនដូច្នោះទេសញ្ញាទទួលឥរិយាបថលំនាំដើម។ សញ្ញាត្រូវបានដាក់ឈ្មោះ តាម ពាក្យបញ្ជា អន្ទាក់ លើកលែងតែសញ្ញានីមួយៗទាមទារទង់ដាច់ដោយឡែក។
strace level
បណ្តាលឱ្យសេចក្តីថ្លែងការណ៍ដូចខាងក្រោមត្រូវបានបោះពុម្ពមុនពេលប្រតិបត្តិ។ (ពាក្យបញ្ជាតាមដានរបស់ Tcl តាមដានអថេរ។ ) កម្រិត បង្ហាញពីរបៀបដែលនៅឆ្ងាយក្នុងការហៅជង់ដើម្បីដាន។ ឧទាហរណ៍ពាក្យបញ្ជាដូចខាងក្រោមនេះដំណើរការ រំពឹងទុក ខណៈពេលដែលតាមដាននូវកម្រិតនៃការហៅទូរស័ព្ទ 4 កម្រិតដំបូងប៉ុន្តែគ្មាននៅក្រោមនោះទេ។
ទង់ - ព័ត៌មានខាងក្រោម បណ្តាលឱ្យមានភាពតឹងតែងដើម្បីផ្តល់ការពិពណ៌នាអំពីអាគុយម៉ង់មិនមែនព័ត៌មានថ្មីបំផុតដែលបានផ្តល់ឱ្យ។
stty args
ផ្លាស់ប្តូររបៀបស្ថានីយស្រដៀងទៅនឹងពាក្យបញ្ជា stty ខាងក្រៅ។
តាមលំនាំដើមស្ថានីយត្រួតពិនិត្យត្រូវបានចូលដំណើរការ។ ស្ថានីយផ្សេងទៀតអាចត្រូវបានចូលដំណើរការដោយការបន្ថែម "សំណើសម្រាប់ការត្រឡប់មកវិញស្ថានភាពវាជាលទ្ធផលនៃពាក្យបញ្ជា។ ប្រសិនបើគ្មានស្ថានភាពត្រូវបានស្នើរហើយស្ថានីយត្រួតពិនិត្យត្រូវបានចូលដំណើរការស្ថានភាពមុននៃគុណលក្ខណៈដើមនិងអេកូត្រូវបានត្រឡប់មកវិញនៅក្នុងសំណុំបែបបទដែលអាចជាពេលក្រោយ។ ប្រើដោយពាក្យបញ្ជា។
ឧទាហរណ៍អាគុយម៉ង់ វត្ថុដើម ឬ -cooked ដាក់ស្ថានីយទៅជារបៀបឆៅ។ អាគុយម៉ង់ - ចម្អិន ឬ ចម្អិន ដាក់ស្ថានីយទៅក្នុងរបៀបឆ្អិន។ អាគុយម៉ង់ អេកូ និង -echo ដាក់ស្ថានីយទៅជាអេកូនិងរបៀប noecho រៀងគ្នា។
ឧទាហរណ៍ដូចខាងក្រោមបង្ហាញពីរបៀបបិទការបន្ទរជាបណ្តោះអាសន្ន។ វាអាចត្រូវបានប្រើក្នុងស្គ្រីបបើមិនដូច្នេះទេស្វ័យប្រវត្តិដើម្បីជៀសវាងការបង្កប់ពាក្យសម្ងាត់ក្នុងពួកវា។ (សូមមើលការពិភាក្សាបន្ថែមទៀតនៅលើនេះនៅក្រោម EXPECT HINTS ខាងក្រោម។ )
stty -echo send_user "ពាក្យសម្ងាត់:" expect_user -re "(។ *) \ n" កំណត់ពាក្យសម្ងាត់ $ expect_out (1, string) stty echo ប្រព័ន្ធអាគុយម៉ង់
ផ្ដល់ អាគុយ ទៅ sh (1) ជាធាតុបញ្ចូលដូចជាប្រសិនបើវាត្រូវបានវាយបញ្ចូលជាពាក្យបញ្ជាពីស្ថានីយមួយ។ រំពឹង រង់ចាំរហូតដល់សែលបញ្ចប់។ ស្ថានភាពត្រឡប់មកវិញពី sh ត្រូវបានដោះស្រាយតាមវិធីដូចគ្នាដែល ប្រតិបត្តិប្រតិបត្តិ ស្ថានភាពត្រឡប់របស់វា។
ផ្ទុយទៅនឹង exec ដែលបញ្ជូនបន្ត stdin និង stdout ទៅស្គ្រីប ប្រព័ន្ធនឹង មិនធ្វើការប្ដូរទិសទេ (ក្រៅពីអ្វីដែលបានបង្ហាញដោយខ្សែអក្សរខ្លួនវាផ្ទាល់) ។ ដូច្នេះវាអាចប្រើកម្មវិធីដែលត្រូវនិយាយដោយផ្ទាល់ទៅ / dev / tty ។ ចំពោះហេតុផលដូចគ្នាលទ្ធផលនៃ ប្រព័ន្ធ មិនត្រូវបានកត់ត្រានៅក្នុងកំណត់ហេតុទេ។
ត្រាពេលវេលា [args]
ត្រឡប់ត្រាពេលវេលាមួយ។ ដោយគ្មានអាគុយម៉ង់ចំនួននៃវិនាទីចាប់តាំងពីសម័យត្រូវបានត្រឡប់។
ទំរង់ --format បង្ហាញខ្សែអក្សរដែលត្រូវបានត្រឡប់ប៉ុន្តែជាមួយការជំនួសដែលបានធ្វើឡើងយោងទៅតាមគោលការណ៍ POSIX សម្រាប់ដំណាក់កាលដំបូង។ ឧទាហរណ៍% a ត្រូវបានជំនួសដោយឈ្មោះថ្ងៃធ្វើការកាត់ឈ្មោះ (ឧទាហរណ៍ថ្ងៃសៅរ៍) ។ ផ្សេងៗទៀតគឺ:
% a ឈ្មោះថ្ងៃអក្សរកាត់នាម% A ឈ្មោះថ្ងៃពេញមួយ% b ឈ្មោះខែខ្លី% B ឈ្មោះពេញខែ% កាលបរិច្ឆេទកាលបរិច្ឆេទគិតត្រឹមថ្ងៃពុធទី 6 ខែតុលាឆ្នាំ 11 ម៉ោង 45 នាទី 1993% d ថ្ងៃនៃខែ (01-31% H ម៉ោង (00-23)% I ម៉ោង (01-12)% j ថ្ងៃ (001 - 366)% m ខែ (01-12)% នាទីនាទី (00-59)% ប៉ាឬ pm% S វិនាទី (00-61) % u ថ្ងៃ (1-7 ថ្ងៃច័ន្ទជាថ្ងៃដំបូងនៃសប្ដាហ៍)% U សប្ដាហ៍ (00-53 ថ្ងៃអាទិត្យដំបូងគឺជាថ្ងៃដំបូងនៃសប្ដាហ៍) សប្ដាហ៍% V (01-53 រចនាប័ទ្ម ISO 8601)% w day (0- 6)% W សប្ដាហ៍ (00-53, ថ្ងៃច័ន្ទដំបូងគឺថ្ងៃដំបូងនៃសប្ដាហ៍ 1)% x កាលបរិច្ឆេតគិតត្រឹមថ្ងៃពុធទី 6 ខែតុលាឆ្នាំ 1993% X ពេលវេលាដូចក្នុង: 23:59:59% y ឆ្នាំ (00-99) % Y ក្នុងឆ្នាំ: 1993 z Zonezone (ឬគ្មានអ្វីប្រសិនបើមិនអាចកំណត់បាន)%% សញ្ញាភាគរយភាពជាក់លាក់% ផ្សេងទៀតមិនត្រូវបានកំណត់។ តួអង្គផ្សេងៗទៀតនឹងត្រូវបានឆ្លងកាត់ដោយមិនប៉ះពាល់។ មានតែមូលដ្ឋាន C ប៉ុណ្ណោះដែលត្រូវបានគាំទ្រ។
ទង់ - ពីរលើកណែនាំពីចំនួនវិនាទីចាប់តាំងពីអាយុកាលត្រូវបានប្រើជាប្រភពដែលត្រូវធ្វើទ្រង់ទ្រាយ។ បើមិនដូច្នោះទេពេលវេលាបច្ចុប្បន្នត្រូវបានប្រើ។
គំនូសតាង -gmt បង្ខំលទ្ធផល timestamp ដើម្បីប្រើតំបន់ពេលវេលារបស់ស្ថានីយ GMT ។ ដោយមិនមានទង់ជាតិតំបន់ម៉ោងក្នុងតំបន់ត្រូវបានប្រើ។
អន្ទាក់ [សញ្ញាពាក្យបញ្ជា]
បណ្តាលឱ្យ ពាក្យបញ្ជាដែលបាន ផ្តល់ឱ្យត្រូវបានប្រតិបត្តិនៅពេលទទួលបានសញ្ញាណាមួយដែលបានផ្តល់នាពេលអនាគត។ ពាក្យបញ្ជាត្រូវបានប្រតិបត្តិក្នុងវិសាលភាពសកល។ ប្រសិនបើ ពាក្យបញ្ជា អវត្តមានសកម្មភាពសញ្ញាត្រូវបានត្រឡប់។ ប្រសិនបើ ពាក្យបញ្ជា ជាខ្សែអក្សរ SIG_IGN សញ្ញាត្រូវបានមិនអើពើ។ ប្រសិនបើ ពាក្យបញ្ជា ជាខ្សែអក្សរ SIG_DFL សញ្ញាគឺជាលទ្ធផលទៅលំនាំដើមរបស់ប្រព័ន្ធ។ សញ្ញា គឺជា សញ្ញា តែមួយឬបញ្ជីសញ្ញា។ សញ្ញាអាចបញ្ជាក់លេខឬនិមិត្តសញ្ញាតាមសញ្ញា (3) ។ បុព្វបទ "SIG" អាចត្រូវបានលុបចោល។
ដោយគ្មានអាគុយម៉ង់ (អាគុយម៉ង់ - ចំនួន) អន្ទាក់ ត្រឡប់លេខសញ្ញារបស់ពាក្យបញ្ជាអន្ទាក់បច្ចុប្បន្នកំពុងត្រូវបានប្រតិបត្តិ។
ទង់ -code ប្រើលេខកូដត្រឡប់នៃពាក្យបញ្ជាជំនួសកូដអ្វីដែល Tcl នឹងវិលត្រឡប់មកវិញនៅពេលពាក្យបញ្ជាចាប់ផ្តើមដំណើរការ។
ទង់ជាតិ -inter បណ្តាលឱ្យពាក្យបញ្ជាត្រូវបានវាយតំលៃដោយប្រើអ្នកបកប្រែសកម្មនៅពេលដែលពាក្យបញ្ជាបានចាប់ផ្តើមដំណើរការជាជាងនៅពេលដែលអន្ទាក់ត្រូវបានប្រកាស។
ទង់នាម - ឈ្មោះ បង្កឱ្យពាក្យបញ្ជា អន្ទាក់ ដើម្បីត្រឡប់ឈ្មោះសញ្ញារបស់ពាក្យបញ្ជាអន្ទាក់បច្ចុប្បន្នកំពុងត្រូវបានប្រតិបត្តិ។
ទង់ ម៉ាក់ បណ្តាលឱ្យពាក្យបញ្ជា អន្ទាក់ ត្រឡប់លេខសញ្ញាធំបំផុតដែលអាចត្រូវបានកំណត់។
ឧទាហរណ៍ពាក្យបញ្ជា "trap {send_user" Ouch!}} SIGINT "នឹងបោះពុម្ព" អ៊ុច! " រាល់ពេលដែលអ្នកប្រើចុច C ។
តាមលំនាំដើម SIGINT (ដែលជាធម្មតាអាចបង្កើតដោយចុច C ^) និង SIGTERM cause រំពឹងថានឹងចាកចេញ។ នេះដោយសារតែអន្ទាក់ដូចខាងក្រោមដែលត្រូវបានបង្កើតតាមលំនាំដើមនៅពេលរំពឹងថានឹងចាប់ផ្តើម។
ច្រឡាក់ចេញ {SIGINT SIGTERM}ប្រសិនបើអ្នកប្រើទង់ -D ដើម្បីចាប់ផ្ដើមកម្មវិធីបំបាត់កំហុស SIGINT ត្រូវបានកំណត់ឡើងវិញដើម្បីចាប់ផ្តើមកម្មវិធីបំបាត់កំហុសអន្តរកម្ម។ នេះគឺដោយសារតែអន្ទាក់ដូចខាងក្រោម:
អន្ទាក់ {exp_debug 1} SIGINTអន្ទាក់បំបាត់កំហុសអាចត្រូវបានផ្លាស់ប្ដូរដោយកំណត់អថេរបរិស្ថាន EXPECT_DEBUG_INIT ទៅពាក្យបញ្ជាអន្ទាក់ថ្មីមួយ។
អ្នកអាចបដិសេធទាំងពីរនេះដោយគ្រាន់តែបន្ថែមពាក្យបញ្ជាអន្ទាក់ទៅកាន់ស្គ្រីបរបស់អ្នក។ ជាពិសេសប្រសិនបើអ្នកមាន "អន្ទាក់ SIGINT" ផ្ទាល់របស់អ្នកវានឹងបដិសេធអន្ទាក់បំបាត់កំហុស។ វាមានប្រយោជន៍ប្រសិនបើអ្នកចង់បង្ការអ្នកប្រើមិនឱ្យទៅអ្នកបំបាត់កំហុស។
ប្រសិនបើអ្នកចង់កំណត់អន្ទាក់ផ្ទាល់ខ្លួនរបស់អ្នកនៅលើ SIGINT ប៉ុន្តែនៅតែជាប់អន្ទាក់លើកម្មវិធីបំបាត់កំហុសនៅពេលវាកំពុងដំណើរការសូមប្រើ:
ប្រសិនបើ {! [exp_debug]} {trap mystuff SIGINT}ជាជម្រើសអ្នកអាចអន្ទាក់ទៅកម្មវិធីបំបាត់កំហុសដោយប្រើសញ្ញាផ្សេង។
អន្ទាក់ នឹងមិនអនុញ្ញាតឱ្យអ្នកបដិសេធសកម្មភាពសម្រាប់ SIGALRM ទេព្រោះវាត្រូវបានប្រើក្នុងការ រំពឹងទុក ។ ពាក្យបញ្ជាផ្តាច់កំណត់ SIGALRM ទៅ SIG_IGN (មិនអើពើ) ។ អ្នកអាចបើកវាឡើងវិញបានដរាបណាអ្នកបិទវាកំឡុងពេលពាក្យបញ្ជាពងកូនបន្តបន្ទាប់។
មើលសញ្ញា (3) សម្រាប់ព័ត៌មានបន្ថែម។
រង់ចាំ [អាដ្រាត]
ពន្យាពេលរហូតដល់ ដំណើរ ពងកូន (ឬ ដំណើរការ បច្ចុប្បន្នប្រសិនបើគ្មាននរណាម្នាក់ត្រូវបានគេដាក់ឈ្មោះ) បញ្ចប់។
រង់ចាំ តែងតែត្រឡប់បញ្ជីនៃចំនួនគត់បួន។ ចំនួនគត់ដំបូងគឺជា ជំហាន នៃ ដំណើរការ ដែលត្រូវបានរង់ចាំ។ ចំនួនគត់ទីពីរគឺជាលេខសម្គាល់ពងកូនដែលត្រូវគ្នា។ ចំនួនគត់ទីបីគឺ -1 ប្រសិនបើមានកំហុសឆ្គងប្រព័ន្ធប្រតិបត្តិការឬ 0 បើមិនដូច្នេះទេ។ ប្រសិនបើចំនួនគត់ទីបីគឺ 0 នោះចំនួនគត់ទីបួនគឺជាស្ថានភាពដែលបានត្រឡប់ដោយ ដំណើរការ ពង។ ប្រសិនបើចំនួនគត់ទីបីគឺ -1, ចំនួនគត់ទីបួនគឺជាតំលៃនៃ errno ដែលបានកំណត់ដោយប្រព័ន្ធប្រតិបត្តិការ។ លេខកំហុសកំហុសអថេរសកលត្រូវបានកំណត់ផងដែរ។
ធាតុបន្ថែមអាចលេចឡើងនៅចុងបញ្ចប់នៃតម្លៃត្រឡប់ពីការ រង់ចាំ ។ ធាតុទី 5 ស្រេចចិត្តកំណត់ប្រភេទព័ត៌មាន។ បច្ចុប្បន្នតម្លៃតែមួយគត់សម្រាប់ធាតុនេះគឺ CHILDKILLED ក្នុងករណីដែលតម្លៃពីរបន្ទាប់គឺជាឈ្មោះសញ្ញាឈ្មោះរចនាប័ទ្មគ្លីកនិងសេចក្ដីពិពណ៌នាអត្ថបទខ្លី។
ទង់ -i ប្រកាសអំពី ដំណើរការដែល ត្រូវរង់ចាំដែលត្រូវគ្នានឹងឈ្មោះ spawn_id (NOT id process ) ។ នៅខាងក្នុងឧបករណ៍ដោះស្រាយ SIGCHLD វាអាចធ្វើបានដើម្បីរង់ចាំ ដំណើរការ ពងកូនដោយប្រើលេខសម្គាល់ពងក្រពើ -1 ។
ទង់អាមេរិចបណ្តាលឱ្យរង់ចាំដើម្បីវិលត្រឡប់មកវិញភ្លាមជាមួយនឹងសញ្ញានៃការរង់ចាំដោយជោគជ័យ។ នៅពេល ដំណើរការ ចេញ (ក្រោយ) វានឹងបាត់ដោយស្វ័យប្រវត្តិដោយពុំចាំបាច់រង់ចាំអោយច្បាស់។
ពាក្យបញ្ជា រង់ចាំ ក៏អាចត្រូវបានប្រើរង់ចាំសម្រាប់ ដំណើរការ forked ដោយប្រើអាគុយម៉ង់ "-i -1" ។ មិនដូចការប្រើប្រាស់របស់វាជាមួយនឹងដំណើរពងកូនពាក្យបញ្ជានេះអាចត្រូវបានប្រតិបត្តិគ្រប់ពេល។ មិនមានការគ្រប់គ្រងលើ ដំណើរការ ណាមួយដែលត្រូវបានប្រមូល។ ទោះយ៉ាងណាក៏ដោយ, តម្លៃត្រឡប់អាចត្រូវបានពិនិត្យសម្រាប់លេខសម្គាល់ ដំណើរការ ។
បណ្ណាល័យ
រំពឹងថានឹងដឹងដោយស្វ័យប្រវត្តិអំពីបណ្ណាល័យដែលមានស្រាប់ចំនួនពីរសម្រាប់រំពឹងស្គ្រីប។ ទាំងនេះត្រូវបានកំណត់ដោយថតដែលមានឈ្មោះនៅក្នុងអថេរ exp_library និង exp_exec_library ។ ទាំងពីរនេះមានផ្ទុកនូវឯកសារប្រើប្រាស់ដែលអាចប្រើដោយស្គ្រីបផ្សេងទៀត។
exp_library មានឯកសារឯករាជ្យនៃស្ថាបត្យកម្ម។ exp_exec_library មានឯកសារដែលអាស្រ័យលើស្ថាបត្យកម្ម។ អាស្រ័យលើប្រព័ន្ធរបស់អ្នកទាំងពីរថតអាចទទេបានទាំងស្រុង។ អត្ថិភាពនៃឯកសារ $ exp_exec_library / cat-buffers ពណ៌នាថាតើថេរ / bin / cat របស់អ្នកតាមលំនាំដើម។
PRINT PRINTING
និយមន័យ Vgrind មួយអាចរកបានសម្រាប់ការបោះពុម្ពស្អាតគួរ រំពឹង ស្គ្រីប។ ការសន្មតថានិយមន័យ Vgrind ដែលបានផ្គត់ផ្គង់ដោយការ រំពឹងថា ការចែកចាយត្រូវបានតម្លើងត្រឹមត្រូវអ្នកអាចប្រើវាជា:
vgrind -lexpect fileឧទាហរណ៍
មានមនុស្សជាច្រើនមិនដឹងច្បាស់អំពីរបៀបដាក់អ្វីទាំងអស់ជាមួយគ្នាដែលទំព័រ បុរស ពិពណ៌នា។ ខ្ញុំសូមលើកទឹកចិត្តឱ្យអ្នកអាននិងសាកល្បងឧទាហរណ៍នៅក្នុងថតគំរូនៃការ រំពឹងទុក ការចែកចាយ។ កម្មវិធីមួយចំនួនជាកម្មវិធីពិត។ អ្នកផ្សេងទៀតគ្រាន់តែជាគំរូនៃបច្ចេកទេសជាក់លាក់, ហើយជាការពិតណាស់, ប្តីប្រពន្ធមួយគ្រាន់តែជាការ Hack រហ័ស។ ឯកសារ INSTALL មានទិដ្ឋភាពរហ័សនៃកម្មវិធីទាំងនេះ។
ឯកសារ រំពឹងទុក (សូមមើល SEE ALSO) ក៏មានប្រយោជន៍ផងដែរ។ ខណៈពេលដែលឯកសារខ្លះប្រើវាក្យសម្ព័ន្ធដែលត្រូវគ្នាទៅនឹងកំណែមុននៃរំពឹងទុក, មូលហេតុដែលអមនឹងនៅតែមានសុពលភាពនិងត្រូវបានលម្អិតច្រើនជាងទំព័រ man នេះ។
CAVEATS
ផ្នែកបន្ថែមអាចប៉ះទង្គិចជាមួយឈ្មោះពាក្យបញ្ជារបស់ Expect ។ ឧទាហរណ៍ ផ្ញើ ត្រូវបានកំណត់ដោយ Tk សម្រាប់គោលបំណងខុសគ្នាទាំងស្រុង។ ចំពោះហេតុផលនេះភាគច្រើននៃពាក្យបញ្ជា រំពឹង អាចប្រើបានផងដែរជា "exp_XXXX" ។ ពាក្យបញ្ជានិងអថេរចាប់ផ្ដើមដោយ "exp" "inter" "spawn" និង "timeout" មិនមានឈ្មោះក្លែងក្លាយទេ។ ប្រើឈ្មោះពាក្យបញ្ជាដែលបានពង្រីកបើអ្នកត្រូវការភាពឆបគ្នារវាងបរិស្ថាន។
រំពឹងថានឹង មានទិដ្ឋភាពសេរីនៃវិសាលភាព។ ជាពិសេសអថេរអានដោយពាក្យបញ្ជាជាក់លាក់ទៅ នឹង កម្មវិធី រំពឹងទុក នឹងត្រូវបានស្វែងរកដំបូងពីវិសាលភាពមូលដ្ឋានហើយប្រសិនបើរកមិនឃើញទេក្នុងវិសាលភាពសកល។ ឧទាហរណ៍វាជៀសវាងតម្រូវឱ្យដាក់ "ពេលវេលាសកល" ក្នុងគ្រប់នីតិវិធីដែលអ្នកសរសេរដែលប្រើ រំពឹងទុក ។ ម៉្យាងទៀតអថេរដែលបានសរសេរគឺតែងតែនៅក្នុងវិសាលភាពមូលដ្ឋាន (លុះត្រាតែពាក្យបញ្ជា "សកល" ត្រូវបានចេញ) ។ បញ្ហាទូទៅបំផុតដែលបណ្តាលមកពីមូលហេតុគឺនៅពេលដែលការបង្កកំណើតត្រូវបានអនុវត្តនៅក្នុងនីតិវិធី។ នៅខាងក្រៅនីតិវិធី, spawn_id លែងមានទៀតហើយដូច្នេះ ដំណើរការ ពងមាន់ មិនអាចចូលបានទៀតទេដោយសារតែវិសាលភាព។ បន្ថែម "spawn_id សកល" ទៅបែបបទបែបនេះ។
ប្រសិនបើអ្នកមិនអាចបើកដំណើរការ multispawning បានទេ (មានន័យថាប្រព័ន្ធរបស់អ្នកមិនគាំទ្រការជ្រើសរើស (BSD * ។ *) ការស្ទង់មតិ (SVR> 2) ឬក៏អ្វីដែលមានតម្លៃស្មើគ្នានោះ រំពឹងថា នឹងអាចគ្រប់គ្រងតែម្តងប៉ុណ្ណោះ។ ក្នុងករណីនេះកុំព្យាយាមកំណត់ spawn_id ហើយអ្នកក៏មិនគួរប្រតិបត្តិដំណើរការតាមរយៈ exec ដែរខណៈដែល ដំណើរ ពងកូន កំពុងដំណើរការ។ លើសពីនេះទៀតអ្នកនឹងមិនអាច រំពឹង ពីដំណើរការច្រើន (រួមបញ្ចូលទាំងអ្នកប្រើម្នាក់ៗ) ក្នុងពេលតែមួយ។
ប៉ារ៉ាម៉ែត្រស្ថានីយអាចមានប្រសិទ្ធិភាពធំនៅលើស្គ្រីប។ ឧទាហរណ៍ប្រសិនបើស្គ្រីបត្រូវបានសរសេរដើម្បីរកមើលការស្រែកវានឹងមិនដំណើរការប្រសិនបើការបន្លឺអេកូត្រូវបានបិទ។ សម្រាប់ហេតុផលនេះប៉ារ៉ាម៉ែត្ររំពឹងទុកប៉ារ៉ាម៉ែត្រប៉ារ៉ាម៉ែត្រច្រាសតាមលំនាំដើម។ ជាអកុសលវាអាចធ្វើឱ្យរឿងមិនល្អចំពោះកម្មវិធីផ្សេងទៀត។ ជាឧទាហរណ៍សែល emacs ចង់ផ្លាស់ប្តូរការផ្គូផ្គង "ធម្មតា": បន្ទាត់ថ្មីត្រូវបានផ្គូផ្គងទៅបន្ទាត់ថ្មីជំនួសឱ្យបន្ទាត់ថ្មីនិងការត្រាប់តាមត្រូវបានបិទ។ នេះអនុញ្ញាតឱ្យអ្នកប្រើ emacs ដើម្បីកែសម្រួលបន្ទាត់បញ្ចូល។ ជាអកុសលរំពឹងថានឹងមិនអាចទាយបានទេ។
អ្នកអាចស្នើសុំសង្ឃឹមថាមិនបដិសេធការកំណត់ប៉ារ៉ាម៉ែត្រលំនាំដើមរបស់វាទេប៉ុន្តែអ្នកត្រូវប្រយ័ត្នពេលសរសេរស្គ្រីបសម្រាប់បរិស្ថានបែបនេះ។ ក្នុងករណី emacs ជៀសវាងការពឹងផ្អែកលើវត្ថុដូចជាការផ្គុំនិងការផ្គូផ្គងចុងបន្ទាត់។
ពាក្យបញ្ជាដែលបានទទួលយកអាគុយម៉ង់បញ្ចូលក្នុងបញ្ជីតែមួយ (វ៉ារ្យ៉ង់ រំពឹងទុក និង អន្តរកម្ម ) ប្រើ heuristic ដើម្បីសម្រេចថាតើបញ្ជីពិតជាអាគុយម៉ង់មួយឬច្រើន។ heuristic អាចបរាជ័យតែក្នុងករណីដែលបញ្ជីពិតជាតំណាងឱ្យអាគុយម៉ង់តែមួយដែលមានបង្កប់ \ n ច្រើនជាមួយតួអក្សរមិនមែនចន្លោះរវាងពួកវា។ នេះមើលទៅហាក់ដូចជាមិនគួរឱ្យជឿគ្រប់គ្រាន់ទេទោះជាយ៉ាងណាក៏ដោយអាគុយម៉ង់ "ការអនុគ្រោះ" អាចត្រូវបានប្រើដើម្បីបង្ខំអាគុយម៉ង់ទោលមួយត្រូវបានដោះស្រាយជាអាគុយម៉ង់តែមួយ។ នេះអាចត្រូវបានគេប្រើជាមួយលេខកូដដែលបង្កើតដោយម៉ាស៊ីន។ ស្រដៀងគ្នានេះដែរកម្លាំងរណបតែមួយអាគុយម៉ង់តែមួយនឹងត្រូវបានដោះស្រាយជាលំនាំ / សកម្មភាពច្រើន។
BUGS
វាពិតជាល្បួងឈ្មោះកម្មវិធី "ការរួមភេទ" (សម្រាប់ "Smart Exec" ឬ "Send-Expect") ប៉ុន្តែគំនិតល្អ (ឬប្រហែលជា Puritanism) បានយកឈ្នះ។
នៅលើប្រព័ន្ធមួយចំនួននៅពេលដែលសែលមួយត្រូវបានបង្កើតវាត្អូញត្អែរអំពីការមិនអាចចូលដំណើរការ tty ប៉ុន្តែរត់យ៉ាងណាក៏ដោយ។ នេះមានន័យថាប្រព័ន្ធរបស់អ្នកមានយន្តការដើម្បីទទួលបានការគ្រប់គ្រងដែលមិន រំពឹង ។ សូមស្វែងយល់ថាតើវាជាអ្វីហើយផ្ញើព័ត៌មាននេះមកខ្ញុំ។
Ultrix 4.1 (យ៉ាងហោចណាស់កំណែចុងក្រោយបំផុតនៅទីនេះ) ចាត់ទុកថាអស់ពេលនៃការខាងលើ 1000000 ត្រូវស្មើនឹង 0 ។
ឌីជីថល UNIX 4.0A (និងប្រហែលជាកំណែផ្សេងទៀត) បដិសេធក្នុងការបម្រុងទុក ptys ប្រសិនបើអ្នកកំណត់កម្មវិធីដោះស្រាយ SIGCHLD ។ សូមមើលទំព័រផ្តល់ជូនសម្រាប់ព័ត៌មានបន្ថែម។
IRIX 6.0 មិនគ្រប់គ្រងសិទ្ធ Pty អោយបានត្រឹមត្រូវទេបើគិតថាការប៉ុនប៉ងប្រើប្រហាក់ប្រហែលដែលត្រូវបានប្រើពីមុនដោយនរណាម្នាក់ផ្សេងទៀតវាបរាជ័យ។ ធ្វើបច្ចុប្បន្នភាពទៅ IRIX 6.1 ។
Telnet (ផ្ទៀងផ្ទាត់នៅក្រោមសូវីស 4.1.2) ព្យួរប្រសិនបើ TERM មិនត្រូវបានកំណត់។ នេះជាបញ្ហានៅក្រោម cron, និងនៅក្នុងស្គ្រីប cgi, ដែលមិនកំណត់ TERM ។ ដូច្នេះអ្នកត្រូវតែកំណត់វាយ៉ាងជាក់លាក់ - ទៅជាប្រភេទអ្វីដែលជាធម្មតាមិនពាក់ព័ន្ធ។ វាគ្រាន់តែត្រូវបានកំណត់ទៅជាអ្វីមួយ! ដូចខាងក្រោមនេះប្រហែលជាគ្រប់គ្រាន់សម្រាប់ករណីភាគច្រើន។
កំណត់ env (TERM) vt100ព័ត៌មានជំនួយ (ផ្ទៀងផ្ទាត់តែក្រោម BSDI BSD / OS 3.1 i386) ព្យួរប្រសិនបើ SHELL និង HOME មិនត្រូវបានកំណត់។ នេះជាបញ្ហានៅក្រោម cron , នៅនិងក្នុង cgi ស្គ្រីប, ដែលមិនកំណត់អថេរបរិស្ថានទាំងនេះ។ ដូច្នេះអ្នកត្រូវកំណត់ឱ្យពួកគេយ៉ាងច្បាស់ - ចំពោះអ្វីដែលជាធម្មតាមិនពាក់ព័ន្ធ។ វាគ្រាន់តែត្រូវបានកំណត់ទៅជាអ្វីមួយ! ដូចខាងក្រោមនេះប្រហែលជាគ្រប់គ្រាន់សម្រាប់ករណីភាគច្រើន។
កំណត់ env (SHELL) / bin / sh កំណត់ env (HOME) / usr / local / binការប្រតិបត្តិមួយចំនួននៃ ptys ត្រូវបានរចនាឡើងដូច្នេះខឺណែលបោះចោលលទ្ធផលដែលមិនទាន់អានបន្ទាប់ពី 10 ទៅ 15 វិនាទី (ចំនួនពិតប្រាកដគឺការអនុវត្ដការអនុលោម) បន្ទាប់ពី ដំណើរការ បានបិទកម្មវិធីពិពណ៌នាឯកសារ។ ដូច្នេះ រំពឹងថា កម្មវិធីដូចជា
ការគេងថ្ងៃកំណើត 20 រំពឹងថានឹងនឹងបរាជ័យ។ ដើម្បីជៀសវាងបញ្ហានេះសូមស្នើសុំកម្មវិធីដែលមិនមានអន្តរកម្មជាមួយប្រត្តិបត្តិជាជាង ពង ។ ខណៈពេលដែលស្ថានភាពបែបនេះមានសារធាតុចិញ្ចឹមក្នុងការអនុវត្តខ្ញុំមិនដែលបានជួបប្រទះស្ថានការណ៍ដែលលទ្ធផលចុងបញ្ចប់នៃកម្មវិធីអន្តរកម្មពិតប្រាកដមួយនឹងត្រូវបាត់បង់ដោយសារតែឥរិយាបថនេះ។
ម្យ៉ាងវិញទៀត Cray UNICOS ptys បោះចោលលទ្ធផលដែលមិនទាន់អានភ្លាមៗបន្ទាប់ពី ដំណើរការ បានបិទកម្មវិធីពិពណ៌នាឯកសារ។ ខ្ញុំបានរាយការណ៍រឿងនេះទៅ Cray ហើយពួកគេកំពុងធ្វើការជួសជុល។
ជួនកាលការពន្យាពេលត្រូវបានទាមទាររវាងប្រអប់បញ្ចូលនិងការឆ្លើយតបដូចជានៅពេលចំណុចប្រទាក់ tty កំពុងផ្លាស់ប្តូរការកំណត់ UART ឬការផ្គូផ្គង អត្រា baud ដោយការស្វែងរកប៊ីតចាប់ផ្តើម / បញ្ឈប់។ តាមធម្មតាអ្វីៗទាំងអស់នេះគឺតម្រូវឱ្យដេកក្នុងរយៈពេល 2 ឬ 2 នាទី។ បច្ចេកទេសដ៏រឹងមាំមួយគឺត្រូវព្យាយាមម្ដងទៀតរហូតដល់ផ្នែករឹងត្រៀមរួចរាល់ដើម្បីទទួលបានការបញ្ចូល។ ឧទាហរណ៍ខាងក្រោមប្រើយុទ្ធសាស្ត្រទាំងពីរនេះ:
ផ្ញើ "ល្បឿន 9600 \ r"; គេង 1 រំពឹងទុក {timeout {ផ្ញើ "\ r"; exp_continue} $ prompt}អន្ទាក់កូដនឹងមិនដំណើរការជាមួយពាក្យបញ្ជាណាដែលអង្គុយក្នុងរង្វង់ព្រឹត្តិការណ៍របស់ Tcl ទេដូចជាការគេង។ បញ្ហាគឺថានៅក្នុងរង្វង់ព្រឹត្តិការណ៍ Tcl បោះបង់កូដត្រឡប់ពីកម្មវិធីដោះស្រាយព្រឹត្តការណ៍ async ។ ការដោះស្រាយបញ្ហាគឺដើម្បីកំណត់ទង់ជាតិនៅក្នុងកូដអន្ទាក់។ បន្ទាប់មកពិនិត្យមើលទង់ជាតិភ្លាមៗបន្ទាប់ពីពាក្យបញ្ជា (មានន័យថាដេក) ។
ពាក្យបញ្ជា expect_background មិនអើពើនឹងអាគុយម៉ង់ពេលវេលានិងគ្មានគំនិតនៃការអស់ពេលជាទូទៅ។
& # 34; EXPECT HINTS & # 34;
មានរឿងពីរអំពីការ រំពឹង ថាអាចនឹងមិនមែនជាវិចារណញាណ។ ផ្នែកនេះព្យាយាមដោះស្រាយបញ្ហាទាំងនេះដោយការផ្តល់យោបល់មួយចំនួន។
បញ្ហាដែលរំពឹងទុកជាទូទៅគឺត្រូវស្គាល់ការណែនាំប្រអប់សែល។ ដោយហេតុថាទាំងនេះត្រូវបានប្ដូរតាមបំណងខុសៗគ្នាដោយមនុស្សផ្សេងគ្នានិងសែលខុសៗគ្នាដោយស្វ័យប្រវត្តិរ៉ាលីនអាចមានការពិបាកដោយមិនដឹងពីប្រអប់បញ្ចូល។ អនុសញ្ញាសមហេតុផលមួយគឺត្រូវឱ្យអ្នកប្រើប្រាស់រក្សាទុកកន្សោមធម្មតាដែលរៀបរាប់អំពីប្រអប់បញ្ចូល (ជាពិសេសចុងបញ្ចប់) នៅក្នុងអថេរបរិស្ថាន EXPECT_PROMPT ។ កូដដូចខាងក្រោមអាចត្រូវបានប្រើ។ ប្រសិនបើគ្មាន EXPECT_PROMPT ទេកូដនៅតែមានឱកាសល្អក្នុងការដំណើរការបានត្រឹមត្រូវ។
កំណត់ប្រអប់បញ្ចូល "(% | # | \\ $) $"; ប្រអប់ចាប់ផ្តើម # លំនាំដើម {កំណត់ប្រអប់បញ្ចូល $ env (EXPECT_PROMPT)} រំពឹងថា - និង $ promptខ្ញុំលើកទឹកចិត្តឱ្យអ្នកសរសេរលំនាំ រំពឹងទុក ដែលរួមបញ្ចូលទាំងការបញ្ចប់នូវអ្វីដែលអ្នករំពឹងចង់បាន។ វាជៀសវាងលទ្ធភាពនៃការឆ្លើយសំណួរមុនពេលមើលឃើញរឿងទាំងមូល។ លើសពីនេះទៀតខណៈពេលដែលអ្នកអាចឆ្លើយសំនួរមុននឹងឃើញវាទាំងស្រុងប្រសិនបើអ្នកឆ្លើយចាស់ចម្លើយរបស់អ្នកអាចលេចឡើងនៅក្នុងពាក់កណ្តាលសំណួរ។ និយាយម្យ៉ាងទៀតការសន្ទនាលទ្ធផលនឹងត្រឹមត្រូវប៉ុន្តែមើលទៅមិនច្បាស់។
ប្រអប់បញ្ចូលច្រើនបំផុតមានតួអករនៅចុងបញ្ចប់។ ឧទាហរណ៍ប្រអប់ពី ftp គឺ 'f', 't', 'p', '>' និង។ ដើម្បីផ្គូផ្គងប្រអប់បញ្ចូលនេះអ្នកត្រូវតែកត់ត្រាតួអក្សរទាំងនេះ។ វាជាកំហុសទូទៅមួយដែលមិនរាប់បញ្ចូលទាំងទទេ។ ដាក់ទទេយ៉ាងច្បាស់។
ប្រសិនបើអ្នកប្រើលំនាំនៃសំណុំបែបបទ X *, * នឹងផ្គូផ្គងលទ្ធផលទាំងអស់ដែលទទួលបានពីចុងបញ្ចប់នៃ X ទៅជារឿងចុងក្រោយដែលទទួលបាន។ នេះស្តាប់ទៅគួរអោយចាប់អារម្មណ៍ប៉ុន្តែអាចធ្វើឱ្យយល់ច្រឡំព្រោះឃ្លាថា "រឿងចុងក្រោយដែលទទួលបាន" អាចប្រែប្រួលអាស្រ័យលើល្បឿននៃកុំព្យូទ័រនិងដំណើរការនៃ I / O ទាំងខឺណែលនិងកម្មវិធីបញ្ជាឧបករណ៍។
ជាពិសេសមនុស្សមាននិន្នាការមើលលទ្ធផលនៃកម្មវិធីដែលមានទំហំធំ (អាតូម) នៅពេលដែលកម្មវិធីភាគច្រើនផលិតទិន្នផលមួយបន្ទាត់ក្នុងពេលតែមួយ។ សន្មតថានេះគឺជាករណី * ក្នុងលំនាំដើមនៃកថាខណ្ឌមុនអាចផ្គូផ្គងចុងបញ្ចប់នៃបន្ទាត់បច្ចុប្បន្នទោះបីជាវាហាក់បីដូចជាច្រើនជាងនេះព្រោះនៅពេលនៃការប្រកួតដែលជាលទ្ធផលទាំងអស់ដែលត្រូវបានទទួល។
រំពឹងថានឹង គ្មានវិធីនៃការដឹងថាទិន្នផលបន្ថែមទៀតនឹងមកដល់ទេលុះត្រាតែលំនាំរបស់អ្នកកំណត់យ៉ាងជាក់លាក់សម្រាប់វា។
សូម្បីតែអាស្រ័យលើសតិបណ្តោះអាសន្នតាមបន្ទាត់គឺមិនឆ្លាត។ មិនតែប៉ុណ្ណោះកម្មវិធីជាច្រើនកម្រនឹងធ្វើការសន្យាអំពីប្រភេទនៃការសន្សំដែលពួកគេធ្វើប៉ុន្តែការរំលាយអាហាររបស់ប្រព័ន្ធអាចបំបែកបន្ទាត់ចេញដែលធ្វើអោយបន្ទាត់មានលក្ខណៈចៃដន្យ។ ដូច្នេះប្រសិនបើអ្នកអាចបង្ហាញតួអក្សរតូចៗចុងក្រោយនៃប្រអប់បញ្ចូលនៅពេលសរសេរលំនាំវាជាការល្អដែលអ្នកធ្វើដូច្នេះ។
ប្រសិនបើអ្នកកំពុងរង់ចាំគំរូមួយនៅក្នុងលទ្ធផលចុងក្រោយនៃកម្មវិធីហើយកម្មវិធីនឹងបញ្ចេញអ្វីផ្សេងជំនួសវិញអ្នកនឹងមិនអាចរកឃើញវាជាមួយនឹងពាក្យគន្លឹះ អស់ពេល ទេ។ មូលហេតុគឺថា រំពឹងថា នឹងមិនអស់ពេល - ជំនួសវិញវានឹងទទួលបានការបង្ហាញមួយ។ ប្រើវាជំនួសវិញ។ ប្រសើរជាងប្រើទាំងពីរ។ វិធីនោះបើបន្ទាត់នោះផ្លាស់ប្តូរនៅជុំវិញអ្នកនឹងមិនចាំបាច់កែសម្រួលបន្ទាត់ដោយខ្លួនវាទេ។
បន្ទាត់ថ្មីត្រូវបានបម្លែងទៅជាការត្រឡប់មកវិញនៃការដឹកជញ្ជូនជួរខ្សែស្រឡាយបន្ទាត់នៅពេលទិន្នផលដោយកម្មវិធីបញ្ជាស្ថានីយ។ ដូច្នេះប្រសិនបើអ្នកចង់បានលំនាំដែលផ្គូផ្គងយ៉ាងជាក់លាក់ពីរបន្ទាត់ពីនិយាយ printf ("foo \ nbar") អ្នកគួរតែប្រើលំនាំ "foo \ r \ nbar" ។
ការបកប្រែស្រដៀងគ្នាកើតឡើងនៅពេលអានពីអ្នកប្រើតាមរយៈ expect_user ។ ក្នុងករណីនេះនៅពេលអ្នកចុចត្រឡប់វានឹងត្រូវបានបកប្រែទៅបន្ទាត់ថ្មីមួយ។ ប្រសិនបើរង់ចាំបន្ទាប់មកបញ្ជូនទៅកម្មវិធីដែលកំណត់ស្ថានីយ៍របស់វាទៅជារបៀបឆៅ (ដូចជា telnet) វានឹងមានបញ្ហានៅពេលដែលកម្មវិធីរំពឹងថាការត្រលប់មកវិញពិតប្រាកដ។ (កម្មវិធីខ្លះពិតជាអភ័យទោសក្នុងន័យថាពួកគេនឹងបកប្រែអត្ថបទថ្មីដោយស្វ័យប្រវត្តិដើម្បីត្រឡប់ទៅវិញប៉ុន្តែភាគច្រើនមិនបានធ្វើទេ។ ) ជាអកុសលគ្មានវិធីដើម្បីរកឱ្យឃើញថាកម្មវិធីមួយដាក់ស្ថានីយ៍របស់ខ្លួនទៅជារបៀបឆៅ។
ជំនួសឱ្យការជំនួសបន្ទាត់ថ្មីជាមួយការត្រឡប់មកវិញដំណោះស្រាយគឺប្រើពាក្យបញ្ជា "stty raw" ដែលនឹងបញ្ឈប់ការបកប្រែ។ ចំណាំទោះជាយ៉ាងណាក៏ដោយនេះមានន័យថាអ្នកនឹងលែងទទួលបានលក្ខណៈពិសេសនៃការកែសម្រួលបន្ទាត់។
ទាក់ទងគ្នា យ៉ាងជាក់ច្បាស់កំណត់ស្ថានីយរបស់អ្នកទៅជារបៀបឆៅដូច្នេះបញ្ហានេះនឹងមិនកើតឡើងនោះទេ។
ជាញឹកញាប់វាមានប្រយោជន៍ក្នុងការផ្ទុកពាក្យសម្ងាត់ (ឬព័ត៌មានឯកជនផ្សេងទៀត) នៅក្នុងការ រំពឹងទុក ស្គ្រីប។ វាមិនត្រូវបានគេណែនាំទេព្រោះអ្វីដែលត្រូវបានរក្សាទុកនៅលើកុំព្យូទ័រគឺអាចចូលដំណើរការបានដោយនរណាម្នាក់។ ដូច្ន្រះការបំផុសគំនិតដ្រយរំល្រចត្រមូវចំពោះពាក្យសម្ងាត់ពីស្គ្រីបគឺជាគំនិតឆ្លាតជាងការបង្កប់ពួកវា។ យ៉ាងណាក៏ដោយជួនកាលការបង្កប់បែបនេះគឺជាលទ្ធភាពតែមួយគត់។
ជាអកុសលប្រព័ន្ធឯកសារយូនីកមិនមានវិធីបង្កើតស្គ្រីបដែលអាចប្រតិបត្តិបានទេប៉ុន្តែមិនអាចអានបានទេ។ ប្រព័ន្ធដែលគាំទ្រស្គ្រីបសែល setgid អាចធ្វើដូចនេះដោយប្រយោល:
បង្កើតស្គ្រីប រំពឹងទុក (ដែលផ្ទុកទិន្នន័យសម្ងាត់) ជាធម្មតា។ ធ្វើឱ្យសិទ្ធិរបស់វាក្លាយជា 750 (-rwxr-x ---) និងជាកម្មសិទ្ធិរបស់ក្រុមដែលទុកចិត្តពោលគឺក្រុមដែលត្រូវបានអនុញ្ញាតឱ្យអានវា។ បើចាំបាច់បង្កើតក្រុមថ្មីសម្រាប់គោលបំណងនេះ។ បន្ទាប់មកបង្កើតស្គ្រីប / bin / sh ដោយមានសិទ្ធិអនុញ្ញាត 2751 (-rwxr-s-x) ដែលគ្រប់គ្រងដោយក្រុមដូចគ្នានឹងពីមុន។
លទ្ធផលគឺជាស្គ្រីបដែលអាចត្រូវបានប្រតិបត្តិ (និងអាន) ដោយនរណាម្នាក់។ នៅពេលត្រូវបានហៅវារត់ស្គ្រីប រំពឹងទុក ។
& # 34; មើល ALSO & # 34;
Tcl (3) libexpect (3)
"Exploring Expect: ប្រអប់ឧបករណ៍ដែលមានមូលដ្ឋានលើ Tcl សម្រាប់ស្វ័យប្រវត្តិកម្មកម្មវិធីអន្តរកម្ម" ដោយ Don Libes, ទំព័រ 602, ISBN 1-56592-090-2, O'Reilly និង Associates, ឆ្នាំ 1995 ។
"រំពឹងថា: ការព្យាបាលអ្នកដែលងាយនឹងទប់ទល់នឹងការធ្វើអន្តរកម្ម" ដោយ Don Le Libres សុន្ទរកថា នៃសន្និសីទ USENIX នៅរដូវក្តៅឆ្នាំ 1990 អាណាហៃរដ្ឋកាលីហ្វ័រញ៉ាពីថ្ងៃទី 11 ដល់ថ្ងៃទី 15 ខែមិថុនាឆ្នាំ 1990 ។
។ ខ្ញុំប្រើប្រាស់ការ រំពឹងទុក ក្នុងការគ្រប់គ្រងប្រព័ន្ធគ្រប់គ្រងដោយស្វ័យប្រវត្តិដោយ Don Le Libes អនុប្រធានសន្និសិទរដ្ឋបាលប្រព័ន្ធដំឡើង USENIX ឆ្នាំ 1990 នៅ Colorado Springs រដ្ឋ Colorado ពីថ្ងៃទី 17-19 ខែតុលាឆ្នាំ 1990 ។
។ ខ្ញុំ "រំពឹងថា: ស្គ្រីបសម្រាប់ការត្រួតពិនិត្យកម្មវិធីអន្តរកម្ម" ដោយ Don Le Libres, ប្រព័ន្ធគណនាកុំព្យូទ័រ។ , Vol ។ 4, ទី 2, ទិនានុប្បវត្តិកាសែតសាកលវិទ្យាល័យកាលីហ្វញ៉ា, ខែវិច្ឆិកាឆ្នាំ 1991 .. "ការធ្វើតេស្តតំរែតំរង់និងការធ្វើសមាហរណកម្មសាកល្បងកម្មវិធីអន្តរកម្ម" ដោយដុនលែសស៍នីតិវិធីនៃសន្និសីទ USENIX នៅរដូវក្តៅ 1992, ទំព័រ 135-144, សាន់អាន់តូនីញ៉ូ, ថ្ងៃទី 12-15 ខែមិថុនាឆ្នាំ 1992 .. ខ្ញុំ "Kibitz - ការភ្ជាប់កម្មវិធីអន្តរសកម្មជាច្រើនរួមគ្នា" ដោយដុនឡេលីសកម្មវិធី - ការអនុវត្តនិងបទពិសោធន៍ John Wiley & Sons West Sussex, England, Vol ។
23, លេខ 5, ឧសភាឆ្នាំ 1993 .. ខ្ញុំគឺជាអ្នកបំបាត់កំហុសសម្រាប់ការដាក់ពាក្យស្នើសុំ Tcl ដោយដេនលីបេសនីសនីតិវិធីនៃសិក្ខាសាលា Tcl / Tk ឆ្នាំ 1993 នៅ Berkeley, CA, ថ្ងៃទី 10-11 ខែមិថុនាឆ្នាំ 1993 ។
AUTHOR
ដុនឡេលីសវិទ្យាស្ថានជាតិស្តង់ដារនិងបច្ចេកវិទ្យា
ការទទួលស្គាល់
សូមអរគុណដល់លោក John Ousterhout សម្រាប់ Tcl, និងលោក Scott Paisley សម្រាប់ការបំផុសគំនិត។ សូមអរគុណដល់លេខកូដស្វ័យប្រវត្តិសម្រាប់ Rob Savoye សម្រាប់រំពឹងទុក។
ឯកសារឯកសារប្រវត្តិសាស្រ្តភាគច្រើននៃការវិវត្តន៍នៃការ រំពឹងទុក ។ វាធ្វើឱ្យការអានគួរឱ្យចាប់អារម្មណ៍និងអាចផ្តល់ឱ្យអ្នកនូវការយល់ដឹងបន្ថែមទៀតចំពោះកម្មវិធីនេះ។ សូមថ្លែងអំណរគុណដល់មនុស្សដែលបានលើកឡើងនៅក្នុងនោះដែលបានផ្ញើឱ្យខ្ញុំនូវការជួសជុលកំហុសហើយបានផ្ដល់ជំនួយផ្សេងទៀត។
ការរចនានិងការអនុវត្តការ រំពឹងទុក ត្រូវបានចំណាយដោយផ្នែកខ្លះដោយរដ្ឋាភិបាលសហរដ្ឋអាមេរិកហើយដូច្នេះនៅក្នុងដែនសាធារណៈ។ ទោះជាយ៉ាងណាក៏ដោយអ្នកនិពន្ធនិង NIST ចង់បានការផ្តល់ឥណទានប្រសិនបើកម្មវិធីនិងឯកសារទាំងនេះឬផ្នែកខ្លះរបស់ពួកគេត្រូវបានប្រើប្រាស់។