ਆਸ ਇਕ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਕਿਸੇ ਸਕਰਿਪਟ ਦੇ ਅਨੁਸਾਰ ਦੂਜੇ ਪ੍ਰਭਾਵੀ ਪ੍ਰੋਗਰਾਮ ਨਾਲ ਗੱਲਬਾਤ ਕਰਦੀ ਹੈ. ਸਕ੍ਰਿਪਟ ਦੀ ਪਾਲਣਾ ਕਰੋ, ਪਤਾ ਕਰੋ ਕਿ ਪ੍ਰੋਗਰਾਮ ਤੋਂ ਕੀ ਉਮੀਦ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਅਤੇ ਸਹੀ ਜਵਾਬ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਇੱਕ ਅਨੁਵਾਦ ਕੀਤੀ ਭਾਸ਼ਾ ਡਾਇਲਾਗ ਨੂੰ ਨਿਰਦੇਸ਼ ਦੇਣ ਲਈ ਸ਼ਾਖਾ ਅਤੇ ਉੱਚ ਪੱਧਰੀ ਕੰਟਰੋਲ ਢਾਂਚਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਯੂਜ਼ਰ ਲੋੜ ਪੈਣ ਤੇ ਸਿੱਧਾ ਕੰਟਰੋਲ ਅਤੇ ਸੰਚਾਰ ਕਰ ਸਕਦਾ ਹੈ, ਬਾਅਦ ਵਿੱਚ ਸਕਰਿਪਟ ਤੇ ਕੰਟਰੋਲ ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ.
ਐਕਸਪੈਕ ਇਕ ਅੰਦਾਜ਼ਾ ਹੈ ਅਤੇ ਟੀ. ਇਹ ਸਿਰਫ ਆਸ ਅਤੇ ਟੀਐੱਸ ਦੀ ਇੱਛਾ ਦੀ ਤਰ੍ਹਾਂ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈ. ਆਸ ਵੀ ਸਿੱਧੇ C ਜਾਂ C ++ ਵਿੱਚ Tcl ਬਿਨਾਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.
ਨਾਮ "ਆਸ" ਨਾਮ, ਯੂਸਪ, ਕਰਮਿਟ ਅਤੇ ਹੋਰ ਮਾਡਮ ਕੰਟਰੋਲ ਪ੍ਰੋਗਰਾਮਾਂ ਦੁਆਰਾ ਪ੍ਰਚਲਿਤ ਕਲਪਨਾਂ / ਆਸਾਂ ਦੇ ਵਿਚਾਰਾਂ ਤੋਂ ਆਉਂਦਾ ਹੈ. ਹਾਲਾਂਕਿ ਯੂਕਪ ਦੇ ਉਲਟ, ਆਸ ਆਮ ਤੌਰ ਤੇ ਬਣਾਈ ਜਾਂਦੀ ਹੈ ਤਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਕੰਮ ਨੂੰ ਧਿਆਨ ਵਿਚ ਰੱਖ ਕੇ ਉਪਭੋਗਤਾ-ਪੱਧਰ ਦੀ ਕਮਾਂਡ ਦੇ ਤੌਰ ਤੇ ਚਲਾਇਆ ਜਾ ਸਕੇ. ਆਸ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਇੱਕੋ ਸਮੇਂ ਕਈ ਪ੍ਰੋਗਰਾਮਾਂ ਨਾਲ ਗੱਲ ਕਰ ਸਕਦੇ ਹੋ.
ਕੀ ਉਮੀਦ ਕਰ ਸਕਦੇ ਹੋ
ਉਦਾਹਰਨ ਲਈ, ਇੱਥੇ ਕੁਝ ਗੱਲਾਂ ਹਨ ਜੋ ਉਮੀਦ ਦੀ ਕਮਾਂਡ ਕਰ ਸਕਦੀਆਂ ਹਨ:
- ਆਪਣੇ ਕੰਪਿਊਟਰ ਨੂੰ ਤੁਹਾਨੂੰ ਵਾਪਸ ਡਾਇਲ ਕਰਨ ਲਈ ਕਾਰਨ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਕਾਲ ਲਈ ਭੁਗਤਾਨ ਕੀਤੇ ਬਿਨਾਂ ਲਾਗਿੰਨ ਕਰ ਸਕੋ.
- ਇੱਕ ਖੇਡ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਜੇ ਅਨੁਕੂਲ ਸੰਰਚਨਾ ਦਿਖਾਈ ਨਹੀਂ ਦਿੰਦੀ, ਇਸਨੂੰ ਦੁਬਾਰਾ ਅਤੇ ਦੁਬਾਰਾ ਚਾਲੂ ਕਰੋ) ਜਦੋਂ ਤੱਕ ਇਹ ਨਹੀਂ ਹੁੰਦਾ, ਅਤੇ ਫਿਰ ਤੁਹਾਡੇ ਲਈ ਨਿਯੰਤਰਣ ਨੂੰ ਸੌਂਪਦਾ ਹੈ.
- ਚਲਾਓ fsck , ਅਤੇ ਆਪਣੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਹੁੰਗਾਰੇ ਪੂਰਵ-ਨਿਰਧਾਰਤ ਮਾਪਦੰਡਾਂ ਦੇ ਆਧਾਰ ਤੇ, "ਹਾਂ" ਜਾਂ "ਨਹੀਂ" ਦਾ ਜਵਾਬ ਦਿਓ ਜਾਂ ਤੁਹਾਨੂੰ ਵਾਪਸ ਮੋੜੋ.
- ਕਿਸੇ ਹੋਰ ਨੈਟਵਰਕ ਨਾਲ ਕਨੈਕਟ ਕਰੋ ਅਤੇ ਆਪਣੇ ਮੇਲ ਨੂੰ ਆਟੋਮੈਟਿਕਲੀ ਪ੍ਰਾਪਤ ਕਰੋ ਤਾਂ ਕਿ ਇਹ ਲਗਦਾ ਹੈ ਜਿਵੇਂ ਇਹ ਤੁਹਾਡੇ ਸਥਾਨਕ ਸਿਸਟਮ ਨੂੰ ਭੇਜਿਆ ਗਿਆ ਹੋਵੇ.
- ਵਾਤਾਵਰਨ ਵੇਰੀਬਲ, ਵਰਤਮਾਨ ਡਾਇਰੈਕਟਰੀ, ਜਾਂ ਹਰ ਤਰ੍ਹਾਂ ਦੀ ਜਾਣਕਾਰੀ, ਜੋ ਕਿ ਰੋਲੌਗਿਨ, ਟੇਲਨੈਟ, ਟਿਪ, ਸੂ , ਜਾਂ ਸੀਐਲਆਰਪੀ
ਕਈ ਕਾਰਨਾਂ ਹੁੰਦੀਆਂ ਹਨ ਕਿ ਕਿਉਂ ਸ਼ੈੱਲ ਇਨ੍ਹਾਂ ਕੰਮਾਂ ਨੂੰ ਪੂਰਾ ਨਹੀਂ ਕਰ ਸਕਦਾ. ਆਸ ਨਾਲ ਸਾਰੇ ਸੰਭਵ ਹਨ
ਆਮ ਤੌਰ ਤੇ, ਕਿਸੇ ਵੀ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਚਾਲੂ ਕਰਨ ਲਈ ਆਸ ਕਰਨੀ ਲਾਭਦਾਇਕ ਹੈ ਜਿਸਦਾ ਪ੍ਰੋਗ੍ਰਾਮ ਅਤੇ ਉਪਭੋਗਤਾ ਵਿਚਕਾਰ ਸੰਚਾਰ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਸਭ ਕੁਝ ਜਰੂਰੀ ਹੈ ਇਹ ਹੈ ਕਿ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਪ੍ਰੋਗ੍ਰਾਮ ਰੂਪ ਵਿਚ ਦੱਸਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਉਮੀਦ ਹੈ ਕਿ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਕਾਬੂ ਨਾ ਕੀਤੇ ਬਗੈਰ ਉਪਭੋਗਤਾ ਨੂੰ ਕੰਟਰੋਲ ਵਾਪਸ ਵੀ ਦੇ ਸਕਦਾ ਹੈ. ਇਸੇ ਤਰ੍ਹਾਂ, ਉਪਭੋਗਤਾ ਕਿਸੇ ਵੀ ਸਮੇਂ ਸਕ੍ਰਿਪਟ ਤੇ ਨਿਯੰਤਰਣ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹਨ.
ਵਰਤੋਂ
Exec ਦੀ ਕਮਾਂਡ ਚਲਾਉਣ ਲਈ cmdfile ਦੀ ਲੋੜ ਹੈ. ਆਸ ਹੈ ਕਿ ਉਹਨਾਂ ਸਿਸਟਮਾਂ ਤੇ ਜੋ ਕਿ # ਦਾ ਸਮਰਥਨ ਕਰਦੇ ਹਨ, ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ! ਸਕਰਿਪਟ ਵਿੱਚ ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚੱਲਣਯੋਗ ਅਤੇ ਸਕਰਿਪਟ ਦੇ ਤੌਰ ਤੇ ਸਕ੍ਰਿਪਟ ਬਣਾ ਕੇ ਸੰਕੇਤ:
#! / usr / local / bin / expect -fਬੇਸ਼ਕ, ਮਾਰਗ ਨੂੰ ਇਹ ਬਿਲਕੁਲ ਸਹੀ ਬਿਆਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿੱਥੇ ਜੀਣਾ ਚਾਹੀਦਾ ਹੈ? / usr / local / bin ਇੱਕ ਉਦਾਹਰਨ ਹੈ.
-c ਝੰਡਾ ਸਕਰਿਪਟ ਵਿੱਚ ਕਿਸੇ ਵੀ ਸਮੇਂ ਤੋਂ ਪਹਿਲਾਂ ਚਲਾਉਣ ਲਈ ਕਮਾਂਡ ਦਿੰਦਾ ਹੈ. ਸ਼ੈੱਲ ਦੁਆਰਾ ਟੁੱਟਣ ਤੋਂ ਬਚਾਉਣ ਲਈ ਕਮਾਂਡ ਨੂੰ ਹਵਾਲਾ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਹ ਚੋਣ ਕਈ ਵਾਰ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਬਹੁਤੇ ਕਮਾਂਡਾਂ ਨੂੰ ਇਕ -ਸੀ-ਸੀ ਨਾਲ ਅਰਧਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਉਹਨਾਂ ਨੂੰ ਸੈਮੀਕੋਲਨ ਨਾਲ ਵੰਡਦਾ ਹੈ. ਕਮਾਂਡਾਂ ਉਹਨਾਂ ਕ੍ਰਮ ਵਿੱਚ ਚਲਦੀਆਂ ਹਨ ਜੋ ਉਹ ਪ੍ਰਗਟ ਕਰਦੇ ਹਨ Expectk ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਚੋਣ ਨੂੰ- ਕਮਾਂਡ ਤੌਰ ਤੇ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ.
-d ਫਲੈਗ ਕੁਝ ਡਾਇਗਨੌਸਟਿਕ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ, ਜੋ ਮੁੱਖ ਤੌਰ ਤੇ ਆਦੇਸ਼ਾਂ ਦੀ ਅੰਦਰੂਨੀ ਗਤੀਵਿਧੀਆਂ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਉਮੀਦ ਅਤੇ ਸੰਚਾਰ ਕਰਦੇ ਹਨ. ਇਹ ਫਲੈਗ ਨੂੰ ਇੱਕ Expect script ਦੀ ਸ਼ੁਰੂਆਤ ਤੇ "exp_internal 1" ਦੇ ਤੌਰ ਤੇ ਉਹੀ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ, ਨਾਲ ਹੀ ਆਸ ਦਾ ਵਰਜਨ ਵੀ ਛਾਪਿਆ ਜਾਂਦਾ ਹੈ.
-D ਫਲੈਗ ਇੱਕ ਇੰਟਰੈਕਟਿਵ ਡੀਬਗਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ ਇੱਕ ਪੂਰਨ ਅੰਕ ਮੁੱਲ ਦਾ ਪਾਲਣ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਡੀਬੱਗਰ ਅਗਲੀ Tcl ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਪਹਿਲਾਂ ਨਿਯੰਤਰਣ ਲਵੇਗਾ ਜੇਕਰ ਵੈਲਯੂ ਗੈਰ-ਜ਼ੀਰੋ ਹੈ ਜਾਂ ਜੇ ਇੱਕ ^ C ਦਬਾਇਆ ਗਿਆ ਹੈ ਜਾਂ ਬ੍ਰੇਕਪੁਆਇੰਟ ਹਿੱਟ ਹੈ ਜਾਂ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੋਈ ਹੋਰ ਉਚਿਤ ਡੀਬਗਰ ਕਮਾਂਡ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ. Expectk ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਚੋਣ ਨੂੰ ਡੀਬੱਗ ਦੇ ਤੌਰ ਤੇ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ.
-f ਫਲੈਗ ਇੱਕ ਫਾਇਲ ਨੂੰ ਪਹਿਲ ਦਿੰਦਾ ਹੈ ਜਿਸ ਤੋਂ ਕਮਾਂਡਜ਼ ਨੂੰ ਪੜਨਾ ਹੈ. ਫਲੈਗ ਖੁਦ ਹੀ ਚੋਣਵਾਂ ਹੈ ਕਿਉਂਕਿ ਇਹ # ਦੀ ਵਰਤੋਂ ਸਮੇਂ ਸਿਰਫ ਉਪਯੋਗੀ ਹੈ! ਸੰਕੇਤ, ਤਾਂ ਕਿ ਹੋਰ ਆਰਗੂਮਿੰਟ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੇ ਸਪਲਾਈ ਕੀਤਾ ਜਾ ਸਕੇ. Expectk ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਚੋਣ ਨੂੰ-file ਦੇ ਤੌਰ ਤੇ ਦਰਸਾਇਆ ਗਿਆ ਹੈ.
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਕਮਾਂਡ ਫਾਇਲ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਪੂਰੀ ਤਰਾਂ ਚਲਾਉਣ ਲਈ ਕਦੇ-ਕਦਾਈਂ ਇਕ ਵਾਰ ਫਾਈਲ ਪੜ੍ਹਨ ਲਈ ਇਹ ਕਦੇ ਵੀ ਫਾਇਦੇਮੰਦ ਹੁੰਦਾ ਹੈ. ਮਨਜੂਰੀ ਫਾਈਲਾਂ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣ ਲਈ ਮਜ਼ਬੂਰ ਕਰਨ ਲਈ, -b ਫਲੈਗ ਵਰਤੋ. Expectk ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਚੋਣ ਨੂੰ -ਬਰਫਰ ਦੇ ਤੌਰ ਤੇ ਦਰਸਾਇਆ ਗਿਆ ਹੈ
ਜੇ ਸਤਰ ਫਾਇਲ ਨਾਂ ਦੇ ਤੌਰ ਤੇ ਦਿੱਤੀ ਗਈ ਹੈ, ਤਾਂ "-" ਇਸ ਦੀ ਬਜਾਏ ਮਿਆਰੀ ਇੰਪੁੱਟ ਪੜ੍ਹੀ ਜਾਂਦੀ ਹੈ. ਅਸਲ ਵਿੱਚ "-" ਨਾਂ ਵਾਲੀ ਫਾਇਲ ਤੋਂ ਪੜ੍ਹਨ ਲਈ "./-" ਵਰਤੋਂ.
-i ਫਲੈਗ ਕਾਰਨ ਇੱਕ ਫਾਇਲ ਤੋਂ ਪੜ੍ਹਨ ਦੀ ਬਜਾਏ ਕਮਾਂਡਾਂ ਲਈ ਇੰਟਰੈਕਟਿਵ ਪ੍ਰਾਉਟ ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਪੁੱਛਗਿੱਛ ਨੂੰ ਐਗਜ਼ਿਟ ਕਮਾਂਡ ਦੁਆਰਾ ਜਾਂ EOF ਦੁਆਰਾ ਖਤਮ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. -i ਫਲੈਗ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜੇ ਨਾ ਤਾਂ ਕਮਾਂਡ ਫਾਇਲ ਅਤੇ ਨਾ ਹੀ -c ਵਰਤੀ ਜਾਂਦੀ ਹੈ. Expectk ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਚੋਣ ਨੂੰ-ਇੰਟਰਰੇਟਿਵ ਦੇ ਤੌਰ ਤੇ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
- ਵਿਕਲਪ ਦੇ ਅਖੀਰ ਨੂੰ ਸੀਮਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਇਹ ਫਾਇਦੇਮੰਦ ਹੈ ਜੇ ਤੁਸੀਂ ਆਪਣੀ ਸਕਰਿਪਟ ਦੇ ਨਾਲ ਇੱਕ ਚੋਣ-ਵਰਗੇ ਆਰਗੂਮਿੰਟ ਪਾਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਬਿਨਾਂ ਇਸ ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ. ਇਹ ਉਪਯੋਗੀ ਨੂੰ # ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ! ਉਮੀਦ ਦੁਆਰਾ ਕਿਸੇ ਵੀ ਝੰਡੇ ਵਰਗਾ ਵਿਆਖਿਆ ਨੂੰ ਰੋਕਣ ਲਈ ਲਾਈਨ. ਉਦਾਹਰਣ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤੇ ਆਰਗੂਏਜ਼ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਨਾਮ ਸਮੇਤ ਮੂਲ ਆਰਗੂਮੈਂਟ ਛੱਡ ਦਿੱਤੇ ਜਾਣਗੇ.
#! / usr / local / bin / expect -ਨੋਟ ਕਰੋ ਕਿ ਆਮ getopt (3) ਅਤੇ execve (2) ਸੰਮੇਲਨਾਂ ਨੂੰ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ ਜਦੋਂ # ਨੂੰ ਦਲੀਲਾਂ ਨੂੰ ਸ਼ਾਮਿਲ ਕੀਤਾ ਜਾਵੇ! ਲਾਈਨ
$ Exp_library / expect.rc ਫਾਇਲ ਨੂੰ ਆਟੋਮੈਟਿਕ ਹੀ ਉਪਲੱਬਧ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਜਦੋਂ ਤੱਕ- N ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ. (ਐਕਸਪੈਕੈਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਚੋਣ ਨੂੰ- NORC ਦੇ ਤੌਰ ਤੇ ਦਰਸਾਇਆ ਗਿਆ ਹੈ.) ਇਸ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ, ਫਾਇਲ ~ / .expect.rc ਆਟੋਮੈਟਿਕਲੀ ਲਏ ਜਾਂਦੇ ਹੈ, ਜਦ ਤੱਕ -n ਫਲੈਗ ਵਰਤਿਆ ਨਹੀਂ ਜਾਂਦਾ. ਜੇ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲ DOTDIR ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਨੂੰ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ .expect.rc ਉੱਥੇ ਤੋਂ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ. Expectk ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਚੋਣ -norc ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ ਹੈ ਇਹ ਸਰੋਤ ਕਿਸੇ ਵੀ -C ਫਲੈਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਤੋਂ ਬਾਅਦ ਹੀ ਵਾਪਰਦਾ ਹੈ.
-v ਕਾਰਨ ਇਸ ਦੇ ਵਰਜਨ ਨੰਬਰ ਨੂੰ ਛਾਪਣ ਅਤੇ ਬੰਦ ਕਰਨ ਦੀ ਉਮੀਦ ਹੈ. ਐਕਸਪੈਕਟ ਦਾ ਅਨੁਸਾਰੀ ਫਲੈਗ, ਜੋ ਲੰਬੇ ਫਲੈਗ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਹੈ-ਵਿਵਰਜਨ.
ਅਖ਼ਤਿਆਰੀ ਆਰਗੂਜ਼ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਬਣਾਏ ਗਏ ਹਨ ਅਤੇ ਆਰਗੂਵੀ ਨਾਂ ਦੇ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਹੋਏ ਹਨ ਅਤੇ argc ਆਰਗੂਵਰ ਦੀ ਲੰਬਾਈ ਦੇ ਅਰੰਭ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
ਜੇਕਰ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ Argv0 ਨੂੰ ਸਕ੍ਰਿਪਟ ਜਾਂ ਬਾਈਨਰੀ ਦਾ ਨਾਮ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਉਦਾਹਰਣ ਵਜੋਂ, ਹੇਠਾਂ ਲਿਖੇ ਸਕ੍ਰਿਪਟ ਦੇ ਨਾਂ ਅਤੇ ਪਹਿਲੇ ਤਿੰਨ ਆਰਗੂਮਿੰਟ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ:
send_user "$ argv0 [ਲਿਜੈਂਜ $ ਆਰਗੂਵ 2 2] \ n"ਕਮਾਂਡਾਂ
ਟੂਲ ਕਮੈਂਡਰ ਲੈਂਗੂਏਜ ਦੀ ਵਰਤੋਂ ਦੀ ਉਮੀਦ ਕਰੋ. Tcl ਕੰਟ੍ਰੋਲ ਪ੍ਰਵਾਹ (ਜੇ, ਬ੍ਰੇਕ ਲਈ), ਸਮੀਕਰਨ ਮੁਲਾਂਕਣ ਅਤੇ ਕਈ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਿਵੇਂ ਰੀਕੋਰਿਯਨ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਪਰਿਭਾਸ਼ਾ ਦਿੰਦਾ ਹੈ. ਇੱਥੇ ਵਰਤੀਆਂ ਕਮਾਂਡਾਂ ਪਰ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹਨ (ਸੈਟ, ਜੇ, ਐੱਕ) Tcl ਕਮਾਂਡ ਹਨ. ਵਾਧੂ ਕਮਾਡਾਂ ਦਾ ਸਮਰਥਨ ਕਰਨ ਦੀ ਆਸ ਜਦੋਂ ਤੱਕ ਹੋਰ ਨਾ ਦਿੱਤਾ ਹੋਵੇ, ਕਮਾਂਡ ਖਾਲੀ ਸਤਰ ਵਾਪਸ ਆਉਂਦੇ ਹਨ.
ਆਦੇਸ਼ਾਂ ਦੀ ਸੂਚੀ ਕ੍ਰਮਵਾਰ ਵਰਣਮਾਲਾਬੱਧ ਕੀਤੀ ਗਈ ਹੈ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਛੇਤੀ ਨਾਲ ਲੱਭਿਆ ਜਾ ਸਕੇ. ਹਾਲਾਂਕਿ, ਨਵੇਂ ਉਪਕਰਨਾਂ ਨੂੰ ਇਸ ਹੁਕਮ ਵਿੱਚ ਸਪੌਨ ਦੇ ਵਰਣਨ, ਭੇਜਣ, ਆਸ ਅਤੇ ਇੰਟਰੈਕਟ ਕਰਨ ਤੋਂ ਸ਼ੁਰੂ ਕਰਨਾ ਆਸਾਨ ਹੋ ਸਕਦਾ ਹੈ.
[-ਸਲੇਵ] ਬੰਦ ਕਰੋ [-onexec 0 | 1] [-i ਸਪੌਨ_id]ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਕਰਦਾ ਹੈ . ਜ਼ਿਆਦਾਤਰ ਪਰਸਪਰ ਪ੍ਰੋਗ੍ਰਾਮ ਆਪਣੇ ਸਟੈਂਨ ਤੇ ਐੱਫੌਫ ਨੂੰ ਲੱਭਦੇ ਹਨ ਅਤੇ ਬੰਦ ਹੋ ਜਾਂਦੇ ਹਨ; ਇਸ ਤਰ੍ਹਾਂ ਆਮ ਤੌਰ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ ਆਮ ਤੌਰ' ਤੇ ਕਾਫੀ ਹੁੰਦਾ ਹੈ. -i ਫਲੈਗ ਨਾਮ ਦੀ spawn_id ਨਾਲ ਸੰਬੰਧਿਤ ਬੰਦ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਐਲਾਨ ਕਰਦਾ ਹੈ
ਦੋਵਾਂ ਦੀ ਆਸ ਅਤੇ ਇੰਟਰੈਕਟ ਪਤਾ ਲੱਗਣਗੀਆਂ ਕਿ ਜਦੋਂ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਖ਼ਤਮ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬੰਦ ਕਰਦੀ ਹੈ, ਪਰ ਜੇ ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖਤਮ ਕਰਦੇ ਹੋ, ਤਾਂ "exec exec $ pid" ਨੂੰ ਮਾਰੋ, ਤੁਹਾਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ ਨੇੜੇ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ .
-onexec ਝੰਡੇ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ spawn id ਕਿਸੇ ਵੀ ਨਵੀਂ ਅਰਜਤ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਬੰਦ ਹੈ ਜਾਂ ਜੇ ਕਾਰਜ ਓਵਰਲੇਅਡ ਹੈ. ਇੱਕ ਸਪੌਨ id ਨੂੰ ਖੁੱਲ੍ਹਾ ਛੱਡਣ ਲਈ, ਮੁੱਲ 0 ਵਰਤੋ. ਇੱਕ ਗ਼ੈਰ-ਜ਼ੀਰੋ ਪੂਰਨ ਅੰਕ ਮੁੱਲ ਕਿਸੇ ਵੀ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਵਿਚ ਸਪੌਨ ਨੂੰ ਬੰਦ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ.
-ਸਲਾਵ ਫਲੈਗ ਸਪੌਨ ਆਈਡੀ ਨਾਲ ਸੰਬੰਧਿਤ ਸਲੇਵ ਨੂੰ ਬੰਦ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਗੁਲਾਮ ਆਪੇ ਹੀ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ ਜੇ ਇਹ ਅਜੇ ਵੀ ਖੁੱਲ੍ਹਾ ਹੈ.
ਕੋਈ ਗੱਲ ਨਹੀਂ ਭਾਵੇਂ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਜਾਂ ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ ਬੰਦ ਹੋਵੇ, ਤੁਹਾਨੂੰ ਅਨੁਸਾਰੀ ਕਾਰਲ ਪ੍ਰਕਿਰਿਆ ਸਲਾਟ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਲਈ ਉਡੀਕ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ. ਬੰਦ ਕਮੀਸ਼ਨ ਦੀ ਉਡੀਕ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਕਿਉਂਕਿ ਇਹ ਗਾਰੰਟੀ ਨਹੀਂ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਕਰਨ ਨਾਲ ਇਹ ਬੰਦ ਹੋ ਜਾਵੇਗਾ.
ਡੀਬੱਗ [[-now] 0 | 1]ਇੱਕ Tcl ਡੀਬੱਗਰ ਨੂੰ ਨਿਯੰਤ੍ਰਿਤ ਕਰਦਾ ਹੈ ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਸਟੇਟਮੈਂਟਾਂ ਰਾਹੀਂ ਕਦਮ ਚੁੱਕ ਸਕਦੇ ਹੋ ਅਤੇ ਬ੍ਰੇਕਪੁਆਇੰਟ ਸੈਟ ਕਰ ਸਕਦੇ ਹੋ.
ਕੋਈ ਆਰਗੂਮਿੰਟ ਦੇ ਨਾਲ, ਇੱਕ 1 ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਜੇ ਡੀਬੱਗਰ ਚੱਲ ਨਹੀਂ ਰਿਹਾ ਹੋਵੇ, ਨਹੀਂ ਤਾਂ 0 ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ.
1 ਆਰਗੂਮੈਂਟ ਦੇ ਨਾਲ, ਡੀਬੱਗਰ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ. ਇੱਕ 0 ਦਲੀਲ ਦੇ ਨਾਲ, ਡੀਬੱਗਰ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ. ਜੇ 1 ਆਰਗੂਮੈਂਟ ਪਹਿਲਾਂ-ਪਹਿਲਾਂ ਫਲੈਗ ਨਾਲ ਅੱਗੇ ਹੈ, ਤਾਂ ਡੀਬੱਗਰ ਤੁਰੰਤ ਸ਼ੁਰੂ ਹੋ ਜਾਵੇਗਾ. ਨਹੀਂ ਤਾਂ ਡੀਬੱਗਰ ਅਗਲਾ Tcl ਸਟੇਟਮੈਂਟ ਨਾਲ ਸ਼ੁਰੂ ਹੋ ਜਾਵੇਗਾ.
ਡੀਬੱਗ ਕਮਾਂਡ ਕਿਸੇ ਫਾਹੀ ਨੂੰ ਨਹੀਂ ਬਦਲਦੀ. -D ਫਲੈਗ ਨਾਲ ਉਮੀਦ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇਸ ਦੀ ਤੁਲਨਾ ਕਰੋ.
ਡਿਸਕਨੈਕਟ ਕਮਾਂਡ ਟਰਮੀਨਲ ਤੋਂ ਕਿੱਕਡ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਡਿਸਕਨੈਕਟ ਕਰਦੀ ਹੈ . ਇਹ ਬੈਕਗ੍ਰਾਉਂਡ ਵਿੱਚ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ. ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਆਪਣਾ ਖੁਦ ਦਾ ਪ੍ਰੋਸੈਸ ਗਰੁੱਪ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਸਟੈਂਡਰਡ I / O ਨੂੰ / dev / null ਤੇ ਰੀਡਾਇਰੈਕਟ ਕੀਤਾ ਗਿਆ ਹੈ
ਬੈਕਗਰਾਊਂਡ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਨੂੰ ਜਾਰੀ ਰੱਖਣ ਲਈ ਅੱਗੇ ਦਿੱਤੇ ਭਾਗ ਨੂੰ ਡਿਸਕਨੈਕਟ ਵਰਤਦਾ ਹੈ
ਜੇ {[ਕਾਂਟਾ]! = 0} ਡਿਸਕਨੈਕਟ ਬੰਦ ਕਰੋ. . .ਹੇਠ ਦਿੱਤੀ ਸਕਰਿਪਟ ਇੱਕ ਪਾਸਵਰਡ ਨੂੰ ਪੜ੍ਹਦੀ ਹੈ ਅਤੇ ਫਿਰ ਹਰ ਘੰਟੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਚਲਾਉਂਦੀ ਹੈ ਜੋ ਹਰ ਵਾਰ ਚੱਲਣ ਸਮੇਂ ਪਾਸਵਰਡ ਦੀ ਮੰਗ ਕਰਦੀ ਹੈ. ਸਕਰਿਪਟ ਪਾਸਵਰਡ ਦਿੰਦੀ ਹੈ ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਸਿਰਫ ਇਕ ਵਾਰ ਲਿਖਣਾ ਪਵੇ.
ਭੇਜਣ ਲਈ "ਪਾਸਵਰਡ" 1, ਸਤਰ) \ r ". . . ਨਿਕਾਸ }ਸ਼ੈੱਲ ਅਸਿੰਕਰੋਨਸ ਪ੍ਰੋਸੈੱਸ ਫੀਚਰ (&) ਉੱਤੇ ਡਿਸਕਨੈਕਟ ਵਰਤਣ ਦਾ ਫਾਇਦਾ ਇਹ ਹੈ ਕਿ ਉਮੀਦ ਹੈ ਕਿ ਬੰਦ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਟਰਮੀਨਲ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਬਚਾ ਕੇ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇਹਨਾਂ ਨੂੰ ਨਵੇਂ ਪੀਟੀਸੀਜ਼ ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਨਾਲ &, ਉਮੀਦ ਹੈ ਕਿ ਟਰਮੀਨਲ ਦੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪੜ੍ਹਨ ਦਾ ਕੋਈ ਮੌਕਾ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਟਰਮੀਨਲ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਸਮੇਂ ਨਾਲ ਡਿਸਕਨੈਕਟ ਹੋ ਗਿਆ ਹੈ.
exit [-opts] [ਸਥਿਤੀ]ਕਾਰਨ ਬੰਦ ਕਰਨ ਦੀ ਉਮੀਦ ਜ ਹੋਰ ਅਜਿਹਾ ਕਰਨ ਲਈ ਤਿਆਰ.
-ਐਲ-ਐਂਜੀਟ ਫਲੈਗ ਇਕ ਐਕਸੈੱਸ ਹੈਂਡਲਰ ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਅਗਲਾ ਦਲੀਲ ਬਣਦਾ ਹੈ. ਕੋਈ ਬਹਿਸ ਦੇ ਬਿਨਾਂ, ਮੌਜੂਦਾ ਨਿਕਾਸ ਹੈਂਡਲਰ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ.
-ਨੋexit ਫਲੈਗ ਕਾਰਨ ਬਾਹਰ ਜਾਣ ਲਈ ਤਿਆਰ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ ਹੈ ਪਰ ਅਸਲ ਵਿੱਚ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਨਿਯੰਤਰਣ ਵਾਪਸ ਕਰਨ ਤੋਂ ਛੋਟ. ਯੂਜ਼ਰ ਪਰਿਭਾਸ਼ਿਤ ਨਿਪਟਾਰਾ ਹੈਂਡਲਰ ਦੇ ਨਾਲ ਨਾਲ ਉਮੀਦ ਹੈ ਕਿ ਖੁਦ ਦੇ ਅੰਦਰੂਨੀ ਹੈਂਡਲਰ ਚਲਾਉਂਦੇ ਹਨ. ਕੋਈ ਹੋਰ ਅੱਗੇ Expect ਕਮਾਂਡਾਂ ਚਲਾਉਣੀਆਂ ਨਹੀਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ. ਇਹ ਲਾਭਦਾਇਕ ਹੈ ਜੇ ਤੁਸੀਂ ਹੋਰ Tcl ਐਕਸਟੈਂਸ਼ਨਾਂ ਦੀ ਆਸ ਨਾਲ ਚੱਲ ਰਹੇ ਹੋ. ਮੌਜੂਦਾ ਦੁਭਾਸ਼ੀਆ (ਅਤੇ ਮੁੱਖ ਵਿੱਤ ਜੇਕਰ ਇਕ ਪ੍ਰਤੀ ਵਾਤਾਵਰਣ ਵਿਚ ਹੋਵੇ) ਤਾਂ ਜੋ ਬਾਕੀ Tcl ਐਕਸਟੈਂਸ਼ਨਾਂ ਨੂੰ ਸਾਫ ਕੀਤਾ ਜਾ ਸਕੇ. ਜੇ ਉਮੀਦ ਹੈ ਕਿ ਇਸ ਦੇ ਨਿਕਾਸ ਨੂੰ ਦੁਬਾਰਾ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ (ਹਾਲਾਂਕਿ ਇਹ ਹੋ ਸਕਦਾ ਹੈ), ਹੈਡਲਰ ਮੁੜ ਤੋਂ ਮੁੜਨ ਨਹੀਂ ਹੁੰਦੇ.
ਬਾਹਰ ਆਉਣ ਤੇ, ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਸਾਰੇ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਹੁੰਦੇ ਹਨ. ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੁਆਰਾ ਬੰਦ ਕਰਨ ਦਾ ਇੱਕ EOF ਵਜੋਂ ਖੋਜਿਆ ਜਾਵੇਗਾ. ਬਾਹਰ ਨਿਕਲਣ ਨਾਲ ਹੋਰ ਕੋਈ ਕਾਰਵਾਈ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਜੋ ਕਿ ਆਮ _ ਐਕਸਿਸ (2) ਵਿਧੀ ਕੀ ਕਰਦਾ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ, ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜੋ ਈਓਐਫ ਲਈ ਜਾਂਚ ਨਹੀਂ ਕਰਦੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ (ਕਈ ਸਥਿਤੀਆਂ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੀਆਂ ਹਨ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਸਪੱਸ਼ਟ ਪ੍ਰਕਿਰਿਆ ਜੋ ਸੰਕੇਤ ਕਰਦੀ ਹੈ ਭੇਜੀ ਜਾਵੇਗੀ, ਪਰ ਇਹ ਸਿਸਟਮ-ਨਿਰਭਰ ਹਨ, ਆਮ ਤੌਰ ਤੇ ਨਿਕਾਸ (3) ਦੇ ਅਧੀਨ ਦਸਤਾਵੇਜ਼.) ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜੋ ਚੱਲਣ ਲਈ ਜਾਰੀ ਹਨ ਨੂੰ init ਦੁਆਰਾ ਵਿਰਾਸਤ ਕੀਤਾ ਜਾਵੇਗਾ.
ਸਥਿਤੀ (ਜਾਂ 0 ਜੇ ਨਿਸ਼ਚਿਤ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ) ਨੂੰ ਉਮੀਦ ਦੀ ਬੰਦਗੀ ਦੀ ਸਥਿਤੀ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਜੇ ਸਕ੍ਰਿਪਟ ਦਾ ਅੰਤ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ ਤਾਂ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ.
exp_continue [-continue_timer]
Exp_continue ਕਮਾਂਡ ਨੂੰ ਆਪਣੇ ਆਪ ਹੀ ਵਾਪਸ ਆਉਣ ਦੀ ਬਜਾਏ ਇਸਨੂੰ ਆਮ ਵਾਂਗ ਜਾਰੀ ਰੱਖਣ ਦੀ ਉਮੀਦ ਦਿੰਦੀ ਹੈ . ਮੂਲ ਰੂਪ ਵਿੱਚ exp_continue ਸਮਾਂ ਸਮਾਪਤੀ ਟਾਈਮਰ ਨੂੰ ਰੀਸੈਟ ਕਰਦਾ ਹੈ -continue_timer ਫਲੈਗ ਮੁੜ ਚਾਲੂ ਕਰਨ ਤੋਂ ਟਾਈਮਰ ਰੋਕਦਾ ਹੈ. (ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ ਉਮੀਦ ਦੇਖੋ.)
exp_internal [-f ਫਾਇਲ] ਮੁੱਲ
ਹੋਰ ਕਮਾਂਡਾਂ ਦਾ ਕਾਰਨ ਡਾਇਗਨੌਸਟਿਕ ਇਨਫਰਮੇਸ਼ਨ ਅੰਦਰ ਭੇਜਣ ਲਈ stderr ਤੋਂ ਉਮੀਦ ਹੈ ਜੇ ਵੈਲਯੂ ਨਾ-ਜ਼ੀਰੋ ਹੈ. ਇਹ ਆਉਟਪੁਟ ਅਯੋਗ ਹੈ ਜੇ ਵੈਲਯੂ 0. ਹੈ, ਡਾਇਗਨੌਸਟਿਕ ਜਾਣਕਾਰੀ ਵਿੱਚ ਹਰ ਇੱਕ ਅੱਖਰ ਮਿਲੇ ਹਨ, ਅਤੇ ਪੈਟਰਨਾਂ ਦੇ ਖਿਲਾਫ ਮੌਜੂਦਾ ਆਉਟਪੁੱਟ ਨਾਲ ਮੇਲਣ ਲਈ ਹਰ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਗਈ ਹੈ.
ਜੇਕਰ ਵਿਕਲਪਿਕ ਫਾਇਲ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਾਰੇ ਸਧਾਰਣ ਅਤੇ ਡੀਬੱਗਿੰਗ ਆਊਟਪੁਟ ਉਸ ਫਾਈਲ ਵਿੱਚ ਲਿਖੇ ਜਾਂਦੇ ਹਨ (ਮੁੱਲ ਦੇ ਮੁੱਲ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ). ਕੋਈ ਵੀ ਪਿਛਲੀ ਡਾਇਗਨੌਸਟਿਕ ਆਉਟਪੁੱਟ ਫਾਈਲ ਬੰਦ ਹੈ.
-ਇੰਟਾ ਫਲੈਗ ਵਲੋਂ ਦਿੱਤੇ ਗਏ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਗੈਰ-ਜਾਣਕਾਰੀ ਆਰਗੂਮੈਂਟਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ exp_internal ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ.
exp_open [args] [-i spawn_id]
ਇੱਕ Tcl ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਦਿੰਦਾ ਹੈ ਜੋ ਅਸਲੀ ਸਪੌਨ id ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ. ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਨੂੰ ਫਿਰ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇਹ Tcl ਦੀ ਓਪਨ ਕਮਾਂਡ ਦੁਆਰਾ ਖੋਲ੍ਹਿਆ ਗਿਆ ਸੀ. (ਸਪਾਨ id ਨੂੰ ਹੁਣ ਵਰਤਿਆ ਨਹੀਂ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ.
-ਲਾਵਓਪੈਨ ਫਲੈਗ ਐਕਸੈਪਟ ਕਮਾਂਡਜ਼ ਦੁਆਰਾ ਐਕਸੈਸ ਕਰਨ ਲਈ ਸਪੌਨ id ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ. ਸਪੌਨ ਆਈਡੀ ਤੇ ਇੱਕ ਇੰਤਜਾਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ
exp_pid [-i spawn_id]
ਮੌਜੂਦਾ ਪ੍ਰੋਡ ਪ੍ਰੋਸੈੱਸ ਨਾਲ ਸੰਬੰਧਿਤ ਪ੍ਰਕਿਰਿਆ ਆਈਡੀ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇ -i ਫਲੈਗ ਵਰਤਿਆ ਗਿਆ ਹੈ, ਤਾਂ pid ਦਿੱਤੇ ਸਪੌਨ id ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ.
exp_send
ਭੇਜਣ ਲਈ ਉਪਨਾਮ ਹੈ
exp_send_error
send_error ਲਈ ਉਪਨਾਮ ਹੈ
exp_send_log
send_log ਲਈ ਉਪਨਾਮ ਹੈ
exp_send_tty
send_tty ਲਈ ਉਪਨਾਮ ਹੈ
exp_send_user
send_user ਲਈ ਉਪਨਾਮ ਹੈ .
exp_version [[-exit] ਵਰਜਨ]
ਇਹ ਤਸਦੀਕ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੈ ਕਿ ਸਕ੍ਰਿਪਟ ਉਮੀਦ ਦੀ ਵਰਤਮਾਨ ਵਿਵਸਥਾ ਦੇ ਅਨੁਕੂਲ ਹੈ.
ਕੋਈ ਆਰਗੂਮਿੰਟ ਦੇ ਨਾਲ, ਉਮੀਦ ਦੀ ਮੌਜੂਦਾ ਵਰਜਨ ਵਾਪਸ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ ਇਸ ਸੰਸਕਰਣ ਨੂੰ ਤੁਹਾਡੇ ਸਕਰਿਪਟ ਵਿੱਚ ਏਨਕੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਜਾਣਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਹਾਲ ਦੇ ਵਰਜਨਾਂ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪੁਰਾਣੇ ਵਰਜਨ ਨੂੰ ਦਰਸਾ ਸਕਦੇ ਹੋ.
ਵਰਜਨ ਵਿੱਚ ਤਿੰਨ ਬਿੰਦੂ ਬਿੰਦੀਆਂ ਨਾਲ ਵੱਖ ਹੁੰਦੇ ਹਨ. ਪਹਿਲਾ ਮੁੱਖ ਨੰਬਰ ਹੈ ਇੱਕ ਵੱਖਰੀ ਵੱਡੀ ਗਿਣਤੀ ਦੇ ਨਾਲ ਆਸ ਕਰਨ ਦੇ ਵਰਜਨਾਂ ਲਈ ਲਿਖੀਆਂ ਸਕਰਤੀਆਂ ਲਗਭਗ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦੀਆਂ. exp_version ਗਲਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇ ਮੁੱਖ ਨੰਬਰ ਮੇਲ ਨਹੀਂ ਖਾਂਦੇ.
ਦੂਜਾ ਮਾਮੂਲੀ ਨੰਬਰ ਹੈ. ਮੌਜੂਦਾ ਵਰਜਨ ਦੀ ਤੁਲਨਾ ਵਿਚ ਇਕ ਹੋਰ ਛੋਟੀ ਜਿਹੀ ਗਿਣਤੀ ਨਾਲ ਲਿਖੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਕੁਝ ਨਵੇਂ ਫੀਚਰ ਤੇ ਨਿਰਭਰ ਰਹਿ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਹੋ ਸਕਦੀਆਂ ਹਨ ਨਹੀਂ. exp_version ਗਲਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇ ਮੁੱਖ ਨੰਬਰ ਮੇਲ ਖਾਂਦੇ ਹਨ, ਲੇਕਿਨ ਸਕ੍ਰਿਪਟ ਨਾਬਾਲਗ ਨੰਬਰ ਚੱਲ ਰਹੇ ਆਸ ਨਾਲੋਂ ਵੱਧ ਹੈ.
ਤੀਜਾ ਇਕ ਅਜਿਹਾ ਨੰਬਰ ਹੁੰਦਾ ਹੈ ਜੋ ਸੰਸਕਰਣ ਦੀ ਤੁਲਨਾ ਵਿਚ ਕੋਈ ਹਿੱਸਾ ਨਹੀਂ ਖੇਡਦਾ. ਹਾਲਾਂਕਿ, ਇਸ ਨੂੰ ਵਧਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ Expect ਸਾਫਟਵੇਅਰ ਵਿਤਰਣ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਵਾਧੂ ਦਸਤਾਵੇਜ਼ ਜਾਂ ਅਨੁਕੂਲਤਾ. ਹਰੇਕ ਨਵੇਂ ਛੋਟੇ ਵਰਜਨ ਤੇ ਇਹ 0 ਤੇ ਰੀਸੈਟ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ.
-ਐਕਸਿਟ ਫਲੈਗ ਨਾਲ, ਇੱਕ ਤਰੁੱਟੀ ਛਾਪੋ ਅਤੇ ਬਾਹਰ ਨਿਕਲ ਜਾਣ ਦੀ ਉਮੀਦ ਕਰੋ ਜੇਕਰ ਵਰਜਨ ਪੁਰਾਣਾ ਹੈ
[[-opts] pat1 body1] ... [-opts] patn [bodyn] ਦੀ ਉਮੀਦ ਕਰੋ
ਉਡੀਕ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਕਿ ਇੱਕ ਪੈਮਾਨੇ ਨੂੰ ਸਪੌਂਦ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਆਊਟਪੁੱਟ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮ ਅਵਧੀ ਪਾਸ ਹੋ ਜਾਂਦੀ ਹੈ, ਜਾਂ ਫਾਈਨ-ਆਫ-ਫਾਈਲ ਦੇਖੀ ਜਾਂਦੀ ਹੈ. ਜੇ ਅੰਤਿਮ ਸਰੀਰ ਖਾਲੀ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ.
ਕਿਸੇ ਵੀ ਹੋਰ ਪੈਟਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਦੀ ਆਸ ਦੀ ਪੂਰਵ-ਅਨੁਮਾਨ ਤੋਂ ਪਹਿਲਾਂ ਪੈਟਰਨ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਕਿਸੇ ਵੀ ਹੋਰ ਪੈਟਰਨ ਦੇ ਬਾਅਦ ਸਭ ਤੋਂ ਹਾਲੀਆ ਉਮੀਦ / ਪਰੀ ਕਮਾਂਡ ਤੋਂ ਪੈਟਰਨ ਵਰਤੇ ਜਾਂਦੇ ਹਨ.
ਜੇ ਪੂਰੇ ਉਮੀਦ ਬਿਆਨ ਲਈ ਆਰਗੂਮਿੰਟ ਇੱਕ ਤੋਂ ਵੱਧ ਲਾਈਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਸਾਰੇ ਆਰਗੂਮਿੰਟ ਇੱਕ "ਬਰਾਂਡ" ਹੋ ਸਕਦੀਆਂ ਹਨ ਤਾਂ ਕਿ ਇੱਕ ਲਾਈਨ ਬੈਕਸਲਾਸ਼ ਦੇ ਨਾਲ ਹਰੇਕ ਲਾਈਨ ਨੂੰ ਖਤਮ ਕਰ ਸਕੇ. ਇਸ ਇੱਕ ਕੇਸ ਵਿੱਚ, ਬ੍ਰੇਸਿਜ਼ ਦੇ ਬਾਵਜੂਦ ਆਮ Tcl ਦੇ ਪ੍ਰਤੀਭੂਤੀਆਂ ਵਾਪਰਨਗੀਆਂ.
ਜੇਕਰ ਪੈਟਰਨ ਕੀਵਰਡ eof ਹੈ , ਤਾਂ ਸੰਬੰਧਿਤ ਸੰਸਥਾ ਨੂੰ ਅੰਤ ਵਿੱਚ-ਫਾਇਲ ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਜੇਕਰ ਪੈਟਰਨ ਕੀਵਰਡ ਸਮਾਂ ਸਮਾਪਤ ਹੁੰਦਾ ਹੈ , ਤਾਂ ਅਨੁਸਾਰੀ ਸੰਸਥਾ ਨੂੰ ਮਿਆਦ ਪੁੱਗਣ ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਜੇਕਰ ਕੋਈ ਟਾਈਮਆਊਟ ਕੀਵਰਡ ਨਹੀਂ ਵਰਤਿਆ ਗਿਆ ਹੈ, ਤਾਂ ਇੱਕ ਨਿਸ਼ਕਿਰਿਆ ਕਾਰਵਾਈ ਨੂੰ ਸਮਾਂ ਸਮਾਪਤ ਤੇ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ. ਡਿਫਾਲਟ ਟਾਈਮਆਊਟ ਸਮਾਂ 10 ਸੈਕਿੰਡ ਹੈ, ਪਰ "ਸੈੱਟ ਟਾਈਮਆਉਟ 30" ਕਮਾਂਡ ਰਾਹੀਂ, ਜਿਵੇਂ ਕਿ 30 ਤੱਕ, ਸੈੱਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਇੱਕ ਬੇਅੰਤ ਟਾਈਮਆਉਟ ਨੂੰ ਮੁੱਲ -1 ਦੇ ਰੂਪ ਵਿੱਚ ਮਨੋਨੀਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੇਕਰ ਪੈਟਰਨ ਕੀਵਰਡ ਡਿਫਾਲਟ ਹੁੰਦਾ ਹੈ , ਤਾਂ ਅਨੁਸਾਰੀ ਸੰਸਥਾ ਨੂੰ ਕਿਸੇ ਵੀ ਸਮੇਂ ਤੇ ਜਾਂ ਅੰਤ ਵਿੱਚ-ਫਾਇਲ ਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ.
ਜੇ ਇੱਕ ਪੈਟਰਨ ਮਿਲਦਾ ਹੈ, ਤਾਂ ਸੰਬੰਧਿਤ ਸੰਸਥਾ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ. ਉਮੀਦ ਕਰਦਾ ਹੈ ਕਿ ਸਰੀਰ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ (ਜਾਂ ਜੇ ਖਾਲੀ ਪੈਟਰਨ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ). ਉਸ ਘਟਨਾ ਵਿੱਚ ਜੋ ਬਹੁ-ਪੈਮਾਨੇ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ, ਪਹਿਲੀ ਵਾਰ ਦਿਖਾਈ ਦੇਣ ਵਾਲਾ ਇੱਕ ਸਰੀਰ ਨੂੰ ਚੁਣਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ.
ਹਰ ਵਾਰੀ ਜਦੋਂ ਨਵੇਂ ਆਊਟਪੁੱਟ ਆਉਂਦੇ ਹਨ, ਤਾਂ ਉਹਨਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਹਰ ਪੈਟਰਨ ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇਸ ਲਈ, ਤੁਸੀਂ ਆਖਰੀ ਪੈਟਰਨ ਨੂੰ ਦਿਖਾਉਣ ਦੀ ਗਾਰੰਟੀ ਬਣਾ ਕੇ ਮੈਚ ਦੀ ਗ਼ੈਰ-ਮੌਜੂਦਗੀ ਦੀ ਪ੍ਰੀਖਿਆ ਦੇ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਪ੍ਰੋਂਪਟ ਅਜਿਹੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਜਿੱਥੇ ਕਿ ਕੋਈ ਪ੍ਰੌਮਪਟ ਨਹੀਂ ਹੈ, ਤੁਹਾਨੂੰ ਟਾਈਮਆਉਟ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ (ਜਿਵੇਂ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਜੇਕਰ ਤੁਸੀਂ ਖੁਦ ਆਪਸ ਵਿੱਚ ਸੰਚਾਰ ਕਰ ਰਹੇ ਹੋ).
ਪੈਟਰਨ ਤਿੰਨ ਤਰੀਕਿਆਂ ਵਿੱਚ ਨਿਰਦਿਸ਼ਟ ਹਨ ਮੂਲ ਰੂਪ ਵਿੱਚ, ਪੈਟਰਨ Tcl ਦੀ ਸਤਰ ਮੈਚ ਕਮਾਂਡ ਦੇ ਨਾਲ ਨਿਰਦਿਸ਼ਟ ਹੁੰਦੇ ਹਨ. (ਅਜਿਹੇ ਨਮੂਨੇ ਸੀ-ਸ਼ੈੱਲ ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਵਰਗੇ ਹਨ ਜੋ ਆਮ ਤੌਰ ਤੇ "ਗੋਲ" ਪੈਟਰਨਾਂ ਵਜੋਂ ਜਾਣੇ ਜਾਂਦੇ ਹਨ) -gl ਫਲੈਗ ਪੈਟਰਨ ਨੂੰ ਬਚਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਫਲੈਗ ਨੂੰ ਅਜਿਹਾ ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੋਵੇ. ਇਸ ਨਾਲ ਸੁਰੱਖਿਅਤ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ("-" ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਸਾਰੇ ਸਤਰ ਭਵਿੱਖ ਦੇ ਵਿਕਲਪਾਂ ਲਈ ਰਾਖਵੇਂ ਹਨ.)
ਉਦਾਹਰਣ ਲਈ, ਹੇਠਲਾ ਭਾਗ ਸਫਲਤਾਪੂਰਵਕ ਲੌਗਿਨ ਲਈ ਦਿਖਦਾ ਹੈ. (ਨੋਟ ਕਰੋ ਕਿ abort ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਿਤੇ ਵੀ ਪ੍ਰਭਾਸ਼ਿਤ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆ ਵਜੋਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ.)
ਇੰਝ {ਰੁਝਿਆ ਹੋਇਆ ਹੈ. exp_continue} ਅਸਫਲ "ਅਯੋਗ ਪਾਸਵਰਡ" ਅਧੂਰਾ ਛੱਡਣ ਦਾ ਸਮਾਂ ਸਮਾਪਤ ਹੋਇਆ ਅਧੂਰਾ ਛੱਡਿਆ}ਚੌਥਾ ਪੈਟਰਨ ਤੇ ਹਵਾਲੇ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਇੱਕ ਸਪੇਸ ਹੈ, ਜੋ ਕਿ ਕਾਰਜ ਤੋਂ ਪੈਟਰਨ ਵੱਖ ਕਰੇਗੀ. ਇਕੋ ਕਿਰਿਆ (ਜਿਵੇਂ ਕਿ ਤੀਜੀ ਅਤੇ ਚੌਥੀ) ਵਾਲੇ ਪੈਟਰਨ ਨੂੰ ਦੁਬਾਰਾ ਕਿਰਿਆਵਾਂ ਦੀ ਸੂਚੀ ਦੇਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਇਹ regexp- ਸ਼ੈਲੀ ਦੇ ਪੈਟਰਨ (ਹੇਠਾਂ ਦੇਖੋ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਗਲੋਬ-ਸ਼ੈਲੀ ਦੇ ਪੈਟਰਨ ਬਣਾਉਣ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਨੂੰ Tcl ਮੈਨੁਅਲ ਵਿਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ.
Regexp- ਸ਼ੈਲੀ ਦੇ ਪੈਟਰਨ Tcl ਦੀ regexp ("ਰੈਗੂਲਰ ਐਕਸਪ੍ਰੈਸ" ਲਈ ਛੋਟਾ) ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀ ਸਿੰਟੈਕਸ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹਨ. regexp ਪੈਟਰਨ ਫਲੈਗ -ਰੇ ਨਾਲ ਪੇਸ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਪਿਛਲੀ ਉਦਾਹਰਨ ਨੂੰ regexp ਵਰਤ ਕੇ ਮੁੜ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:
ਇੰਝ {ਰੁਝਿਆ ਹੋਇਆ ਹੈ. exp_continue} -re "ਅਸਫਲ | ਅਯੋਗ ਪਾਸਵਰਡ" ਅਧੂਰਾ ਛੱਡਣ ਦਾ ਸਮਾਂ ਸਮਾਪਤ ਹੋ ਗਿਆ ਹੈ}ਦੋਨੋ ਕਿਸਮ ਦੇ ਪੈਟਰਨ "ਅਨਾਂਚਾਂਚੂਰ" ਹਨ. ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪੈਟਰਨਾਂ ਨੂੰ ਪੂਰੀ ਸਤਰ ਨਾਲ ਮੇਲ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਪਰ ਸਤਰ ਵਿਚ ਕਿਤੇ ਵੀ ਮੈਚ ਸ਼ੁਰੂ ਅਤੇ ਖ਼ਤਮ ਕਰ ਸਕਦਾ ਹੈ (ਜਿੰਨੀ ਦੇਰ ਤਕ ਬਾਕੀ ਸਭ ਕੁਝ ਮਿਲਦਾ ਹੈ). ਸਤਰ ਦੀ ਸ਼ੁਰੂਆਤ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ^ ਦਾ ਪ੍ਰਯੋਗ ਕਰੋ, ਅਤੇ $ ਅੰਤ ਨੂੰ ਮੇਲਣ ਲਈ. ਨੋਟ ਕਰੋ ਕਿ ਜੇ ਤੁਸੀਂ ਸਤਰ ਦੇ ਅੰਤ ਦੀ ਉਡੀਕ ਨਹੀਂ ਕਰਦੇ, ਤਾਂ ਤੁਹਾਡੇ ਜਵਾਬ ਆਸਾਨੀ ਨਾਲ ਸਤਰ ਦੇ ਮੱਧ ਵਿੱਚ ਖਤਮ ਹੋ ਸਕਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਗੂੰਜਦੇ ਹਨ. ਅਜੇ ਵੀ ਸਹੀ ਨਤੀਜੇ ਦੇਣ ਦੇ ਦੌਰਾਨ, ਆਉਟਪੁੱਟ ਕੁਦਰਤੀ ਨਜ਼ਰ ਆ ਸਕਦੀ ਹੈ ਇਸ ਲਈ, $ ਦੀ ਵਰਤੋਂ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜੇ ਤੁਸੀਂ ਇੱਕ ਸਤਰ ਦੇ ਅਖੀਰ ਤੇ ਅੱਖਰਾਂ ਦਾ ਬਿਲਕੁਲ ਵਰਣਨ ਕਰ ਸਕਦੇ ਹੋ.
ਨੋਟ ਕਰੋ ਕਿ ਬਹੁਤ ਸਾਰੇ ਸੰਪਾਦਕਾਂ ਵਿੱਚ, ਕ੍ਰਮਵਾਰ ਕ੍ਰਮਵਾਰ ਲਾਈਨਾਂ ਦੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਨਾਲ ਮਿਲਦੇ ^ ^ ਅਤੇ $. ਹਾਲਾਂਕਿ, ਕਿਉਂਕਿ ਇਹ ਉਮੀਦ ਲਾਈਨ ਆਧਾਰਿਤ ਨਹੀਂ ਹੈ, ਇਹ ਅੱਖਰ ਇਸ ਮਿਤੀ ਵਾਲੇ ਬਫਰ ਦੀ ਆਧੁਨਿਕਤਾ ਨਾਲ ਡੇਟਾ ਦੇ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ. (ਇਸਦੇ ਨਾਲ ਹੀ, "ਸਿਸਟਮ ਬਦਹਜ਼ਮੀ" ਉੱਤੇ ਨੋਟ ਵੇਖੋ.)
-x ਫਲੈਗ ਪੈਟਰਨ ਨੂੰ ਇੱਕ "ਸਹੀ" ਸਤਰ ਦੇ ਤੌਰ ਤੇ ਮਿਲਾਉਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ. *, ^, ਆਦਿ ਦੀ ਕੋਈ ਵਿਆਖਿਆ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ (ਹਾਲਾਂਕਿ ਆਮ Tcl ਸੰਮੇਲਨਾਂ ਨੂੰ ਅਜੇ ਵੀ ਦੇਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ). ਸਹੀ ਨਮੂਨਿਆਂ ਦਾ ਹਮੇਸ਼ਾ ਅਨਾਂਚਾਂਕ ਹੁੰਦਾ ਹੈ.
-ਨੌਕੇਜ਼ ਝੰਡੇ ਆਊਟਪੁਟ ਦੇ ਵੱਡੇ ਅੱਖਰ ਨੂੰ ਤੁਲਨਾ ਕਰਨ ਦੇਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਉਹ ਲੋਅਰਕੇਸ ਅੱਖਰ ਸਨ ਪੈਟਰਨ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਹੁੰਦਾ.
ਆਉਟਪੁਟ ਨੂੰ ਪੜਦੇ ਹੋਏ, 2000 ਤੋਂ ਜਿਆਦਾ ਬਾਈਟ ਪੁਰਾਣੇ ਬਾਈਟਾਂ ਨੂੰ "ਭੁੱਲ" ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰ ਸਕਦੇ ਹਨ. ਇਹ ਫੰਕਸ਼ਨ match_max ਦੇ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਨੋਟ ਕਰੋ ਕਿ ਜ਼ਿਆਦਾ ਵੱਡੇ ਮੁੱਲ ਪੈਟਰਨ ਮੈਟਰ ਨੂੰ ਹੌਲੀ ਕਰ ਸਕਦੇ ਹਨ.) ਜੇਕਰ ਪੇਟਲਿਸਟ ਫੁਲ-ਬਫਰ ਹੈ, ਤਾਂ ਸੰਬੰਧਿਤ ਇਕਾਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ match_max ਬਾਈਟ ਮਿਲੇ ਹਨ ਅਤੇ ਕੋਈ ਹੋਰ ਪੈਟਰਨ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ ਭਾਵੇਂ full_buffer ਸ਼ਬਦ ਵਰਤਿਆ ਗਿਆ ਹੋਵੇ ਜਾਂ ਨਹੀਂ, ਭੁੱਲੇ ਅੱਖਰ ਨੂੰ expect_out (ਬਫਰ) ਤੇ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ.
ਜੇ ਪੇਟਲਿਸਟ ਵਿੱਚ ਸ਼ਬਦ ਨਾਵਲ ਹੈ , ਅਤੇ nulls ਦੀ ਆਗਿਆ ਹੈ ( remove_nulls ਕਮਾਂਡ ਰਾਹੀਂ), ਅਨੁਸਾਰੀ ਇਕਾਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇ ਇੱਕ ਸਿੰਗਲ ASCII 0 ਮਿਲਾਇਆ ਜਾਂਦਾ ਹੈ. Glob ਜਾਂ regexp ਪੈਟਰਨ ਰਾਹੀਂ 0 ਬਾਈਟ ਨਾਲ ਮੇਲ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਹੈ.
ਇੱਕ ਪੈਟਰਨ (ਜਾਂ eof ਜਾਂ full_buffer) ਦੇ ਮਿਲਣ ਤੇ, ਕਿਸੇ ਵੀ ਮੇਲਿੰਗ ਅਤੇ ਪਹਿਲੇ ਬੇਮੇਲ ਆਉਟਪੁਟ ਵੇਰੀਏਬਲ expect_out (ਬਫਰ) ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਹੁੰਦਾ ਹੈ. Up to 9 regexp ਸਬਸਟਿੰਗ ਮੈਚ expect_out (9, ਸਤਰ) ਦੁਆਰਾ expect_out ( 1, ਸਤਰ) ਦੇ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ. ਜੇ -ਡਿੰਡੋਜ਼ ਫਲੈਗ ਪੈਟਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ 10 ਸਟ੍ਰਿੰਗਜ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਵਾਲੇ ਸੂਚਕਾਂਕ ( ਲਾਰਜ ਲਈ ਢੁਕਵੇਂ ਫਾਰਮ ਵਿਚ) ਨੂੰ ਵੇਰੀਏਬਲਜ਼ ਆਊਟ-ਆਊਟ (ਐਕਸ, ਸਟਾਰਟ) ਅਤੇ ਉਡੀਕ_ਅਟ (ਐਕਸ, ਐਂਡ) ਵਿਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿੱਥੇ ਐਕਸ ਇਕ ਹੈ ਡਿਜ਼ਿਟ, ਬਫਰ ਵਿੱਚ ਸਬਰਥਿੰਗ ਪੋਜੀਸ਼ਨ ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ. 0 ਸਤਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਪੂਰੇ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਅਤੇ ਗਲੋਬਲ ਪੈਟਰਨਾਂ ਦੇ ਨਾਲ ਨਾਲ ਰੀਜੈਕਸਪ ਪੈਟਰਨਾਂ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਜੇ ਕੋਈ ਪ੍ਰਕਿਰਿਆ "abcdefgh \ n" ਦੀ ਆਉਟਪੁੱਟ ਤਿਆਰ ਕਰਦੀ ਹੈ, ਤਾਂ ਇਸ ਦਾ ਨਤੀਜਾ:
"ਸੀ ਡੀ" ਦੀ ਉਮੀਦ ਕਰੋਜਿਵੇਂ ਕਿ ਹੇਠ ਲਿਖੀਆਂ ਗੱਲਾਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ:
set_out (0, ਸਤਰ) ਸੀਡੀ ਸੈੱਟ expect_out (ਬਫਰ) ਏਬੀਸੀਡੀਅਤੇ "ਐਫਗ \ n" ਆਊਟਪੁੱਟ ਬਫਰ ਵਿੱਚ ਬਾਕੀ ਹੈ. ਜੇ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੇ ਆਉਟਪੁੱਟ "abbbcabkkkka \ n" ਤਿਆਰ ਕੀਤੀ, ਤਾਂ ਇਸ ਦਾ ਨਤੀਜਾ:
ਉਮੀਦ ਕਰੋ- indices -re "b (b *). * (k +)"ਜਿਵੇਂ ਕਿ ਹੇਠ ਲਿਖੀਆਂ ਗੱਲਾਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ:
ਸੈੱਟ expect_out (0, ਸ਼ੁਰੂ) 1 ਸੈਟ expect_out (0, ਅੰਤ) 10 ਸੈਟ expect_out (0, ਸਤਰ) bbbcabkkkk set expect_out (1, ਸ਼ੁਰੂ) 2 set expect_out (1, ਅੰਤ) 3 ਸੈਟ expect_out (1, string) bb set expect_out (2, ਸ਼ੁਰੂ) 10 ਸੈੱਟ expect_out (2, ਅੰਤ) 10 ਸੈੱਟ expect_out (2, ਸਤਰ) k set expect_out (ਬਫਰ) abbbcabkkkkਅਤੇ "ਇੱਕ \ n" ਆਊਟਪੁੱਟ ਬਫਰ ਵਿੱਚ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਪੈਟਰਨ "*" (ਅਤੇ -re ". *") ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਕੋਈ ਹੋਰ ਆਉਟਪੁੱਟ ਪੜ੍ਹੇ ਬਗੈਰ ਆਉਟਪੁੱਟ ਬਫਰ ਨੂੰ ਫਲੱਸ ਕਰੇਗਾ.
ਆਮ ਤੌਰ 'ਤੇ, ਆਉਟਪੁਟ ਦੇ ਅੰਦਰੂਨੀ ਬਫਰਾਂ ਤੋਂ ਮੇਲ ਖਾਂਦਾ ਆਉਟਪੁੱਟ ਰੱਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇਸ ਨੂੰ- ਨੋਟਰਸੈਂਸਰ ਫਲੈਗ ਨਾਲ ਪੈਟਰਨ ਪ੍ਰੀਫਿਕਸ ਕਰਕੇ ਰੋਕੀ ਜਾ ਸਕਦੀ ਹੈ. ਇਹ ਫਲੈਗ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਪ੍ਰਯੋਗ ਕਰਨ ਵਿੱਚ ਉਪਯੋਗੀ ਹੈ (ਅਤੇ ਇਸਦਾ ਇਸਤੇਮਾਲ ਕਰਨ ਵੇਲੇ ਸਹੂਲਤ ਲਈ "ਨਾ" ਲਈ ਸੰਖੇਪ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ).
ਮੇਲ ਖਾਂਦੇ ਆਊਟਪੁਟ (ਜਾਂ ਈਓਫ ਜਾਂ ਫੁਲ-ਬਫਰ) ਨਾਲ ਜੁੜੇ ਸਪੈਨ ਆਈਡੀ ਨੂੰ expect_out (spawn_id) ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
ਟਾਈਮ-ਆਉਟ ਝੰਡਾ ਮੌਜੂਦਾ ਉਮੀਦ ਹੈ ਕਿ ਕਮਾਂਡ ਨੂੰ ਟਾਈਮਆਊਟ ਦੇ ਤੌਰ ਤੇ ਹੇਠਲੇ ਮੁੱਲ ਨੂੰ ਟਾਈਮ-ਆਉਟ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਬਜਾਏ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ.
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਪੈਟਰਨ ਨੂੰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਆਉਟਪੁੱਟ ਨਾਲ ਮਿਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਹਾਲਾਂਕਿ -i ਫਲੈਗ ਨਾਮਕ spawn_id ਦੀ ਸੂਚੀ ਤੋਂ ਆਉਟਪੁੱਟ ਘੋਸ਼ਿਤ ਕਰਦਾ ਹੈ ਕਿਸੇ ਵੀ ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਟਰਨਾਂ (ਅਗਲੇ -i ਤੱਕ ) ਦੇ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ. Spawn_id ਸੂਚੀ ਵਿੱਚ spawn_ids ਦੀ ਖਾਲੀ ਸਪੇਸ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਜਾਂ spawn_id ਦੀ ਅਜਿਹੀ ਸੂਚੀ ਦਾ ਹਵਾਲਾ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ.
ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੀ ਉਦਾਹਰਨ $ proc2 ਦੁਆਰਾ ਨਾਮ ਕੀਤੇ spawn_id ਤੋਂ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ, ਜਾਂ "ਰੁਝੇਵੇਂ", "ਅਸਫਲ" ਜਾਂ "ਅਯੋਗ ਪਾਸਵਰਡ" ਤੋਂ "ਕਨੈਕਟ ਕੀਤੇ" ਲਈ ਉਡੀਕ ਕਰਦੀ ਹੈ.
ਦੀ ਉਮੀਦ {-i $ proc2 busy {busy busy \ n; exp_continue} -re "ਅਸਫਲ | ਅਯੋਗ ਪਾਸਵਰਡ" ਅਧੂਰਾ ਛੱਡਣ ਦਾ ਸਮਾਂ ਸਮਾਪਤ ਹੋ ਗਿਆ ਹੈ}ਗਲੋਬਲ ਵੈਰੀਏਬਲ ਦਾ ਮੁੱਲ ਕਿਸੇ ਵੀ spawn_ids ਦੇ ਪੈਟਰਨ ਨੂੰ ਮੇਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਮੌਜੂਦਾ ਉਮੀਦ ਕਮਾਂਡ ਵਿਚ ਦੂਜੇ ਸਾਰੇ -i ਫਲੈਗਾਂ ਦੇ ਨਾਂ ਹਨ. No-spawn_id ਨਾਲ ਸਬੰਧਿਤ ਇੱਕੋ ਹੀ ਉਮੀਦ ਕਮਾਨ ਵਿਚ ਕਿਸੇ ਹੋਰ ਪੈਟਰਨ ਲਈ ਕਿਸੇ ਵੀ ਸੰਬੰਧਿਤ ਪੈਟਰਨ (ਭਾਵ, ਕਿਸੇ ਹੋਰ - i ਦੁਆਰਾ ਤੁਰੰਤ ਲਾਗੂ ਕੀਤੇ ਗਏ) ਨਾਲ -i ਫਲੈਗ ਤੋਂ spawn_id.
-i ਫਲੈਗ ਇੱਕ ਗਲੋਬਲ ਵੈਰੀਐਬਲ ਵੀ ਕਰ ਸਕਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਉਹ ਪ੍ਰੋਵਿਨ ਆਈਡੀਜ਼ ਦੀ ਸੂਚੀ ਲਈ ਵੇਰੀਏਬਲ ਪੜਿਆ ਜਾਂਦਾ ਹੈ. ਵੇਰੀਏਬਲ ਰੀ-ਰੀ - ਰੀਦ ਕਰਨਾ ਹੈ ਜਦੋਂ ਵੀ ਉਹ ਬਦਲਦਾ ਹੈ. ਇਹ I / O ਸਰੋਤ ਨੂੰ ਬਦਲਣ ਦਾ ਇਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਕਮਾਂਡ ਚੱਲਣ ਤੇ ਹੈ. ਸਪੌਨ IDs ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਦਿੱਤਾ ਗਿਆ ਹੈ ਜਿਸਨੂੰ "ਅਸਿੱਧੇ" ਸਪੌਨ ਆਈਡੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ.
ਕਿਰਿਆਵਾਂ ਜਿਵੇਂ ਕਿ ਬ੍ਰੇਕ ਅਤੇ ਜਾਰੀ ਰਹਿਣ ਵਾਲਾ ਨਿਯੰਤਰਣ ਬਣਤਰ (ਅਰਥਾਤ, ਪ੍ਰਕ ) ਆਮ ਤਰੀਕੇ ਨਾਲ ਵਿਵਹਾਰ ਕਰਨ ਲਈ. Exp_continue ਕਮਾਂਡ ਨੂੰ ਆਪਣੇ ਆਪ ਹੀ ਵਾਪਸ ਆਉਣ ਦੀ ਬਜਾਏ ਇਸਨੂੰ ਆਮ ਵਾਂਗ ਜਾਰੀ ਰੱਖਣ ਦੀ ਉਮੀਦ ਦਿੰਦੀ ਹੈ .
ਇਹ ਸਪੱਸ਼ਟ ਰੂਪ ਵਿਚ ਛੂਛੀਆਂ ਜਾਂ ਦੁਹਰਾਏ ਉਮੀਦ ਬਿੰਦੂਆਂ ਤੋਂ ਬਚਣ ਲਈ ਉਪਯੋਗੀ ਹੁੰਦਾ ਹੈ. ਹੇਠ ਦਿੱਤੀ ਉਦਾਹਰਨ rlogin ਆਟੋਮੈਟਿਕ ਕਰਨ ਲਈ ਇੱਕ ਭਾਗ ਦਾ ਹਿੱਸਾ ਹੈ Exp_continue ਦੂਜੀ ਉਮੀਦ ਿਬਆਨ (ਪਰੌਂਪਟ ਨੂੰ ਮੁੜ ਵੇਖਣ ਲਈ) ਲਿਖਣ ਤੋਂ ਰੋਕਦਾ ਹੈ ਜੇ rlogin ਇੱਕ ਪਾਸਵਰਡ ਲਈ ਪੁੱਛਦਾ ਹੈ.
$ HO $ $ ਤੇ "ਪਾਸਵਰਡ: {stty -echo send_user" ਪਾਸਵਰਡ ($ ਯੂਜ਼ਰ ਲਈ) ਪਾਸਵਰਡ ਦੀ ਉਮੀਦ ਹੈ: "expect_user -re" (. *) \ n "ਭੇਜਣ ਵਾਲੇ" "\ n" ਭੇਜੋ "$ expect_out (1, ਸਤਰ) \ r" stty ਈਕੋ ਐਕਸ_continue} ਗਲਤ {send_user "ਗਲਤ ਪਾਸਵਰਡ ਜਾਂ ਖਾਤਾ \ n" exit} ਟਾਈਮਆਊਟ {send_user "} $ ਹੋਸਟ ਤੇ ਕੁਨੈਕਸ਼ਨ ਸਮਾਪਤ ਹੋ ਗਿਆ ਹੈ ਹੋਸਟ ਲਈ {exit_user \" ਕੁਨੈਕਸ਼ਨ} ਅਸਫਲ: $ expect_out (ਬਫਰ) "ਬੰਦ} - re $ ਪ੍ਰੋਂਪਟ}ਉਦਾਹਰਨ ਲਈ, ਹੇਠਲਾ ਖੰਡ ਇੱਕ ਉਪਭੋਗਤਾ ਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਵੈਚਾਲਿਤ ਹੋਣ ਵਾਲੀ ਇੰਟਰੈਕਸ਼ਨ ਦੀ ਸਹਾਇਤਾ ਕਰ ਸਕਦਾ ਹੈ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਟਰਮੀਨਲ ਨੂੰ ਕੱਚਾ ਮੋਡ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ ਹੈ. ਜੇ ਯੂਜ਼ਰ "+" ਦਬਾਉਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ ਵੇਰੀਏਬਲ ਵਧਾਇਆ ਜਾਂਦਾ ਹੈ. ਜੇ "ਪੀ" ਤੇ ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਬਹੁਤ ਸਾਰੇ ਰਿਟਰਨ ਪ੍ਰਕਿਰਿਆ ਲਈ ਭੇਜੇ ਜਾਂਦੇ ਹਨ, ਸ਼ਾਇਦ ਕਿਸੇ ਤਰੀਕੇ ਨਾਲ ਇਸ ਨੂੰ ਦਬਾਉਣ ਲਈ, ਅਤੇ "i" ਯੂਜ਼ਰ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦਿੰਦਾ ਹੈ, ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸਕ੍ਰਿਪਟ ਤੇ ਨਿਯੰਤਰਣ ਦੂਰ ਕਰ ਸਕਦਾ ਹੈ. ਹਰੇਕ ਮਾਮਲੇ ਵਿੱਚ, exp_continue ਮੌਜੂਦਾ ਕਾਰਵਾਈ ਨੂੰ ਚਲਾਉਣ ਦੇ ਬਾਅਦ ਮੌਜੂਦਾ ਪੈਟਰਨ ਪੈੱਨ ਨੂੰ ਜਾਰੀ ਰੱਖਣ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ.
stty raw -echo expect_after {-i $ user_ spawn_id "p" {ਭੇਜੋ "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "ਬੰਦ" ਬੰਦ ਕਰੋ}ਮੂਲ ਰੂਪ ਵਿੱਚ, exp_continue ਟਾਈਮਆਉਟ ਟਾਈਮਰ ਨੂੰ ਰੀਸੈਟ ਕਰਦਾ ਹੈ ਟਾਈਮਰ ਨੂੰ ਮੁੜ ਚਾਲੂ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ, ਜੇ exp_continue ਨੂੰ -continue_timer ਫਲੈਗ ਨਾਲ ਸੱਦਿਆ ਜਾਂਦਾ ਹੈ
expect_after [expect_args]
ਇਸ ਤੋਂ ਇਲਾਵਾ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਜੇ ਦੋਵਾਂ ਤੋਂ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਇਸ ਤੋਂ ਬਾਅਦ ਉਮੀਦ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ expect_be ਕਮਾਂਡ ਤੋਂ ਪਹਿਲਾਂ ਦੇਖੋ.
expect_background [expect_args]
ਇਹ ਉਹੀ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ , ਹਾਲਾਂਕਿ ਇਹ ਤੁਰੰਤ ਰਿਟਰਨ ਦਿੰਦਾ ਹੈ. ਨਵੇਂ ਇੰਪੁੱਟ ਆਉਣ ਤੇ ਪੈਟਰਨ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਪੈਟਰਨ ਸਮਾਂ-ਅੰਤਰਾਲ ਅਤੇ ਡਿਫੌਲਟ ਨੂੰ expect_background ਲਈ ਬੇਅਸਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਚੁੱਪਚਾਪ ਰੱਦ ਕੀਤੇ ਜਾਂਦੇ ਹਨ. ਨਹੀਂ ਤਾਂ, expect_background ਕਮਾਂਡ ਪਹਿਲਾਂ ਤੋਂ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ- ਉਮੀਦ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ- ਜਿਵੇਂ ਕਿ ਉਮੀਦ ਹੈ ਜਿਵੇਂ
ਜਦੋਂ expect_background ਕਾਰਵਾਈਆਂ ਦਾ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਇੱਕੋ ਸਪੌਨ id ਲਈ ਪਿਛੋਕੜ ਪ੍ਰਕਿਰਿਆ ਬਲੌਕ ਕੀਤੀ ਹੋਈ ਹੈ. ਕਾਰਵਾਈ ਮੁਕੰਮਲ ਹੋਣ 'ਤੇ ਪਿਛੋਕੜ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅਨਬਲੌਕ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਜਦੋਂ ਬੈਕਗਰਾਊਂਡ ਪ੍ਰੋਸੈਸਿੰਗ ਬਲੌਕ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਸੰਭਵ ਹੈ ਕਿ (ਫੋਰਗਰਾਉਡ) ਇੱਕ ਹੀ ਸਪਾਨ id ਤੇ ਆਸ ਕੀਤੀ ਜਾਵੇ.
ਉਮੀਦ ਦੀ ਪੂਰਤੀ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਹੈ ਜਦੋਂ ਇੱਕ expect_background ਅਣ- ਬਲੌਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਇੱਕ ਖ਼ਾਸ spawn id ਲਈ expect_background ਨੂੰ ਉਸੇ ਸਪੌਨ id ਨਾਲ ਇੱਕ ਨਵਾਂ expect_background ਘੋਸ਼ਿਤ ਕਰਕੇ ਮਿਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਕੋਈ ਪੈਟਰਨ ਨਾ ਹੋਣ ਦੀ ਉਮੀਦ ਬੱਝੇ ਹੋਣ ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ ਪਿਛੋਕੜ ਵਿੱਚ ਪੈਟਰਨਾਂ ਨੂੰ ਮੇਲ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਤੋਂ ਸਪੌਨ id ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ.
[expect_args] ਤੋਂ ਪਹਿਲਾਂ
ਇਹ ਉਹੀ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ , ਹਾਲਾਂਕਿ ਇਹ ਤੁਰੰਤ ਰਿਟਰਨ ਦਿੰਦਾ ਹੈ. ਸਭ ਤੋਂ ਹਾਲ ਹੀ ਦੀ ਉਮੀਦ ਤੋਂ ਪੈਟਰਨ-ਐਕਸ਼ਨ ਜੋੜਿਆਂ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਇੱਕੋ ਸਪੌਨ ਆਈਡੀ ਦੇ ਨਾਲ ਆਦੇਸ਼ਾਂ ਦੀਆਂ ਆਸਾਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ. ਜੇਕਰ ਪੈਟਰਨ ਮਿਲਦਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਇਹ ਉਮੀਦ ਕਮਾਂਡ ਵਿੱਚ ਦਰਸਾਈ ਗਈ ਹੋਵੇ, ਅਤੇ ਸੰਬੰਧਿਤ ਸੰਸਥਾ ਦੀ ਉਮੀਦ ਕਮਾਨ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਲਾਗੂ ਹੁੰਦੀ ਹੈ. ਜੇਕਰ ਪਹਿਲਾਂ ਤੋਂ ਉਮੀਦ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ ਅਤੇ ਉਮੀਦ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਦੋਵਾਂ ਦੇ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਤਾਂ expectation- ਪਹਿਲਾਂ ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ.
ਜੇ ਕੋਈ ਪੈਟਰਨ ਸਪਸ਼ਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਸਪਾਨ id ਕਿਸੇ ਵੀ ਪੈਟਰਨ ਲਈ ਨਹੀਂ ਚੁਣਿਆ ਗਿਆ ਹੈ.
ਜਦ ਤੱਕ ਕਿ ਇੱਕ -i ਫਲੈਗ ਦੁਆਰਾ ਅਣਡਿੱਠਾ ਨਾ ਕੀਤਾ ਜਾਵੇ, ਤਾਂ expect_be ਕਮਾਂਡ ਦੀ ਪਾਲਣਾ (ਉਸ ਦੇ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਨਹੀਂ) ਤੇ ਉਸ ਸਮੇਂ ਪਰਿਭਾਸ਼ਿਤ ਸਪੌਨ ਆਈ ਡੀ ਦੇ ਮੁਕਾਬਲੇ ਪੈਟਰਨ ਮੈਚ ਦੀ ਉਮੀਦ ਹੈ.
-ਇੰਮਾ ਫਲੈਗ ਕਾਰਨ ਉਮੀਦ ਹੈ ਕਿ ਮੌਜੂਦਾ ਮਾਪਦੰਡ ਇਸ ਦੇ ਕਿਸ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ. ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ ਮੌਜੂਦਾ ਸਪੌਨ id ਤੇ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ ਉਸ ਸਪਵਨ ਆਈਡੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਈ ਇੱਕ ਵਿਕਲਪਿਕ ਸਪੌਨ id ਸਪੈਸੀਫਿਕੇਸ਼ਨ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਉਦਾਹਰਣ ਲਈ
expect_before -info -i $ procਵੱਧ ਤੋਂ ਵੱਧ ਇੱਕ ਸਪੌਨ id ਨਿਰਧਾਰਨ ਦਿੱਤੀ ਜਾ ਸਕਦੀ ਹੈ. ਫਲੈਗ-ਸਿੱਧੇ ਸਿੱਧੇ ਸਪੌਨ ਆਈਡੀਜ਼ ਨੂੰ ਦਬਾਉਂਦਾ ਹੈ ਜੋ ਕੇਵਲ ਅਸਾਧਾਰਣ ਵਿਵਰਣਾਂ ਤੋਂ ਆਉਂਦੇ ਹਨ.
ਸਪੌਨ ਆਈ ਡੀ ਸਪੈਸੀਫਿਕੇਸ਼ਨ ਦੀ ਬਜਾਏ, ਫਲੈਗ "-ਲੱਭ" ਕਾਰਨ "-ਇੰਫੋ" ਨੂੰ ਸਾਰੇ ਸਪੌਨ ids ਤੇ ਰਿਪੋਰਟ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ.
-finfo ਫਲੈਗ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਦੁਬਾਰਾ expect_ before expectation arguments ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ
expect_tty [expect_args]
ਇਹ ਉਮੀਦ ਦੀ ਤਰ੍ਹਾਂ ਹੈ ਪਰ ਇਹ / dev / tty ਤੋਂ ਅੱਖਰ ਪੜ੍ਹਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਉਪਭੋਗਤਾ ਤੋਂ ਸਵਿੱਚਾਂ). ਮੂਲ ਰੂਪ ਵਿੱਚ, ਪਕਾਏ ਹੋਏ ਢੰਗ ਵਿੱਚ ਪੜ੍ਹਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹੁੰਦੀ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ, ਉਹਨਾਂ ਨੂੰ ਦੇਖਣ ਦੀ ਉਮੀਦ ਕਰਨ ਲਈ ਲਾਈਨਾਂ ਨੂੰ ਵਾਪਸੀ ਦੇ ਨਾਲ ਖ਼ਤਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਇਹ stty ਦੁਆਰਾ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਹੇਠ stty ਕਮਾਂਡ ਨੂੰ ਵੇਖੋ).
expect_user [expect_args]
ਇਹ ਉਮੀਦ ਦੀ ਤਰ੍ਹਾਂ ਹੈ ਪਰ ਇਹ ਸਟੈਂਨ ਤੋਂ ਅੱਖਰਾਂ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਯੂਜ਼ਰ ਤੋਂ ਕੀਸਟ੍ਰੋਕਸ). ਮੂਲ ਰੂਪ ਵਿੱਚ, ਪਕਾਏ ਹੋਏ ਢੰਗ ਵਿੱਚ ਪੜ੍ਹਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹੁੰਦੀ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ, ਉਹਨਾਂ ਨੂੰ ਦੇਖਣ ਦੀ ਉਮੀਦ ਕਰਨ ਲਈ ਲਾਈਨਾਂ ਨੂੰ ਵਾਪਸੀ ਦੇ ਨਾਲ ਖ਼ਤਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਇਹ stty ਦੁਆਰਾ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਹੇਠ stty ਕਮਾਂਡ ਨੂੰ ਵੇਖੋ).
ਫੋਰਕ
ਇੱਕ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਂਦਾ ਹੈ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਮੌਜੂਦਾ ਅਨੁਮਾਨ ਪ੍ਰਕਿਰਿਆ ਦੀ ਅਸਲ ਕਾਪੀ ਹੈ . ਸਫਲਤਾ ਤੇ, ਫੋਰਕ ਨਵੀਂ (ਬੱਚੇ) ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ਮੂਲ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ID ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ . ਫੇਲ੍ਹ ਹੋਣ ਸਮੇਂ (ਅਣਗਿਣਤ ਸਰੋਤਾਂ ਦੀ ਘਾਟ ਕਾਰਨ, ਜਿਵੇਂ ਕਿ ਸਵੈਪ ਸਪੇਸ, ਮੈਮੋਰੀ), ਫੋਰਕ ਰਿਟਰਨ -1 ਨੂੰ ਮਾਤਾ-ਪਿਤਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਤੱਕ , ਅਤੇ ਕੋਈ ਵੀ ਬਾਲ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਬਣਾਈ ਜਾਂਦੀ.
ਫੋਰਕਡ ਕਾਰਜਾਂ ਨੂੰ ਬੰਦ ਕਮਾਂਡ ਰਾਹੀਂ ਬੰਦ ਕਰੋ , ਜਿਵੇਂ ਕਿ ਅਸਲ ਪ੍ਰਕਿਰਿਆ . ਫੋਰਕਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਲਾਗ ਫਾਇਲਾਂ ਨੂੰ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ. ਜੇ ਤੁਸੀਂ ਜਿਆਦਾਤਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਡੀਬਗਿੰਗ ਜਾਂ ਲਾੱਗਿੰਗ ਨੂੰ ਅਯੋਗ ਨਹੀਂ ਕਰਦੇ, ਤਾਂ ਨਤੀਜਾ ਉਲਝਣ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ.
ਕੁਝ PTY ਸਥਾਪਨ ਕਈ ਪਾਠਕਾਂ ਅਤੇ ਲੇਖਕਾਂ ਦੁਆਰਾ ਵੀ ਉਲਝਣ ਵਿੱਚ ਹੋ ਸਕਦਾ ਹੈ, ਕੁਝ ਪਲ ਲਈ ਵੀ. ਇਸ ਤਰ੍ਹਾਂ, ਪ੍ਰਕਿਰਿਆ ਪ੍ਰਣਾਲੀ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਕਾਂਟੇ ਤੋਂ ਸੁਰੱਖਿਅਤ ਹੈ.
[string1 body1] ਸੰਚਾਰ ਕਰੋ ... [stringn [bodyn]]
ਉਪਭੋਗਤਾ ਨੂੰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਦਾ ਨਿਯੰਤਰਣ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਜੋ ਕੀਸਟ੍ਰੋਕਸ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਭੇਜੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਦੇ stdout ਅਤੇ stderr ਵਾਪਸ ਕਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ.
ਸਤਰ-ਸਤਰ ਜੋੜੇ ਨੂੰ ਆਰਗੂਮਿੰਟ ਦੇ ਤੌਰ ਤੇ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਉਸ ਦੀ ਅਨੁਸਾਰੀ ਸਟਰਿੰਗ ਕਦੋਂ ਦਰਜ ਕੀਤੀ ਗਈ ਹੈ. (ਮੂਲ ਰੂਪ ਵਿੱਚ, ਸਤਰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਨਹੀਂ ਭੇਜੀ ਜਾਂਦੀ.) ਇੰਟਰਪਰੇਟਰ ਕਮਾਂਡ ਮੰਨ ਲਈ ਜਾਂਦੀ ਹੈ, ਜੇ ਅੰਤਿਮ ਸਰੀਰ ਗੁੰਮ ਹੈ.
ਜੇ ਪੂਰੇ ਸੰਵਾਦ ਬਿਆਨ ਲਈ ਆਰਗੂਮਿੰਟ ਇੱਕ ਤੋਂ ਵੱਧ ਲਾਈਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਸਾਰੇ ਆਰਗੂਮਿੰਟ ਇੱਕ "ਬੋਰਸੇਡ" ਹੋ ਸਕਦੀਆਂ ਹਨ ਤਾਂ ਕਿ ਹਰ ਲਾਈਨ ਨੂੰ ਬੈਕਸਲਾਸ਼ ਨਾਲ ਬੰਦ ਕੀਤਾ ਜਾ ਸਕੇ. ਇਸ ਇੱਕ ਕੇਸ ਵਿੱਚ, ਬ੍ਰੇਸਿਜ਼ ਦੇ ਬਾਵਜੂਦ ਆਮ Tcl ਦੇ ਪ੍ਰਤੀਭੂਤੀਆਂ ਵਾਪਰਨਗੀਆਂ.
ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਹੇਠ ਦਿੱਤੇ ਸਤਰ-ਸਰੀਰ ਜੋੜੇ ਦੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ: ਜਦੋਂ ^ Z ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ, ਉਮੀਦ ਹੈ ਕਿ ਮੁਅੱਤਲ ਕੀਤਾ ਗਿਆ ਹੈ. ( -ਟਰੈਸਟ ਫਲੈਗ ਟਰਮੀਨਲ ਮੋਡ ਨੂੰ ਮੁੜ ਸਥਾਪਿਤ ਕਰਦਾ ਹੈ.) ਜਦੋਂ ^ ਏ ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ "ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਨਿਯੰਤਰਣ-ਏ" ਟਾਈਪ ਕਰਦੇ ਹਨ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ^ ਏ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ. ਜਦੋਂ $ ਨੂੰ ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ ਤਾਰੀਖ਼ ਨੂੰ ਵੇਖਦਾ ਹੈ ਜਦੋਂ ^ ਸੀ ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ, ਨਿਕਾਸ ਦੀ ਉਮੀਦ ਕਰੋ . ਜੇ "foo" ਦਾਖਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ "ਬਾਰ" ਦੇਖਦਾ ਹੈ. ਜਦੋਂ ~ ~ ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੰਟਰਪਰੇਟ ਇੰਟਰਪਰੀਟਰ ਆਪਸ ਵਿੱਚ ਚਲਦਾ ਹੈ.
ਸੈਟ ਕਰੋ CTRLZ \ 032 ਇੰਟਰੈਕਟ ਕਰੋ {-Reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "ਤੁਸੀਂ ਇੱਕ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਹੈ- A \ n"; "$ 001" ਭੇਜੋ $ {send_user} "ਤਾਰੀਖ ਹੈ [ਘੜੀ ਦੀ ਵਿਵਸਥਾ [ਕਲਕ ਸਕਿੰਟਾਂ]]."} \ 003 ਨਿਕਾਸ foo {send_user "bar"} ~ ~}ਸਤਰ-ਸਰੀਰ ਦੇ ਜੋੜੇ ਵਿੱਚ, ਸਤਰ ਉਹਨਾਂ ਆਰਗਰਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਸੂਚੀਬੱਧ ਹਨ. ਜਿਹੜੇ ਸਤਰ ਜੋ ਅਧੂਰੇ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਬਾਕੀ ਰਹਿੰਦੇ ਆ ਰਹੇ ਲੋਕਾਂ ਦੀ ਆਸ ਵਿੱਚ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਨਹੀਂ ਭੇਜੇ ਜਾਂਦੇ ਹਨ ਜੇ ਅੱਖਰ ਉਸ ਵਿੱਚ ਦਰਜ ਕੀਤੇ ਗਏ ਹਨ ਤਾਂ ਕਿ ਹੁਣ ਸੰਭਵ ਤੌਰ 'ਤੇ ਮੈਚ ਨਹੀਂ ਹੋ ਸਕਦਾ, ਕੇਵਲ ਸਤਰ ਦੀ ਇਕੋ ਇਕ ਪ੍ਰਕਿਰਿਆ ਹੀ ਭੇਜੀ ਜਾਵੇਗੀ, ਜੋ ਕਿਸੇ ਹੋਰ ਮੈਚ ਨੂੰ ਸ਼ੁਰੂ ਨਹੀਂ ਕਰ ਸਕਦੀ. ਇਸ ਤਰ੍ਹਾਂ, ਉਹ ਸਤਰਾਂ ਜੋ ਅੰਸ਼ਕ ਮੇਲ ਦੀਆਂ ਸਬਸਟ੍ਰਿੰਗਸ ਹੁੰਦੀਆਂ ਹਨ, ਬਾਅਦ ਵਿੱਚ ਮੇਲ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜੇ ਮੂਲ ਸਤਰ ਜੋ ਮੇਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਸਨ ਤਾਂ ਅੰਤ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ.
ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ, ਸਤਰ ਮਿਲਾਨ ਸਹੀ ਨਹੀਂ ਹੈ, ਬਿਨਾਂ ਕੋਈ ਵਾਈਲਡ ਕਾਰਡ . (ਇਸਦੇ ਉਲਟ, ਉਮੀਦ ਦੀ ਕਾਪੀ ਗਲੋਬਲ -ਸਟਾਈਲ ਪੈਟਰਨ ਨੂੰ ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ ਵਰਤਦੀ ਹੈ.) ਪੈਮਾਨਿਆਂ ਦੀ ਰੱਖਿਆ ਲਈ ਐਕਸ-ਫਲ ਝੰਡਾ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਅਜਿਹਾ ਕਰਨ ਤੋਂ ਪਰਸਪਰ ਫਲੈਗ ਮਿਲ ਸਕੇ. ਇਸ ਨਾਲ ਸੁਰੱਖਿਅਤ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ("-" ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਸਾਰੇ ਸਤਰ ਭਵਿੱਖ ਦੇ ਵਿਕਲਪਾਂ ਲਈ ਰਾਖਵੇਂ ਹਨ.)
-ਅਤੇ ਫਲੈਗ ਸਤਰ ਨੂੰ ਇੱਕ ਰੇਗੇਜਪ-ਸ਼ੈਲੀ ਦੇ ਪੈਟਰਨ ਦੇ ਤੌਰ ਤੇ ਵਿਆਖਿਆ ਕਰਨ ਲਈ ਜ਼ੋਰ ਪਾਉਂਦਾ ਹੈ. ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਮੇਲ ਖਾਂਦੀਆਂ ਸਬਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਵੇਰੀਏਬਲ ਇੰਟਰੈਕਟ_ ਅਟੇ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਵੇਰੀਏਬਲ ਦੀ ਉਮੀਦਵਾਰਾਂ ਵਿੱਚ ਸਟੋਰਾਂ ਦੀ ਆਊਟਪੁੱਟ ਆਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ . -ਡਿੰਡੋਜ਼ ਫਲੈਗ ਇਸੇ ਤਰ੍ਹਾਂ ਸਮਰਥਨ ਪ੍ਰਾਪਤ ਹੈ.
ਪੈਟਰਨ eof ਇੱਕ ਐਕਸ਼ਨ ਪੇਸ਼ ਕਰਦਾ ਹੈ ਜੋ ਅੰਤ ਵਿੱਚ-ਫਾਇਲ ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ. ਇੱਕ ਵੱਖਰਾ eof ਪੈਟਰਨ ਆਉਟਪੁੱਟ ਫਲੈਗ ਦੀ ਵੀ ਪਾਲਣਾ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਇਹ ਮੇਲ ਖਾਂਦਾ ਹੈ ਜੇਕਰ ਆਊਟਪੁੱਟ ਲਿਖਣ ਵੇਲੇ ਇੱਕ eof ਖੋਜਿਆ ਜਾਂਦਾ ਹੈ. ਡਿਫਾਲਟ eof ਐਕਸ਼ਨ "ਰਿਟਰਨ" ਹੈ, ਤਾਂ ਜੋ ਇੰਟਰੈਕਟ ਕੇਵਲ ਕਿਸੇ ਵੀ EOF ਤੇ ਵਾਪਸ ਆਉਂਦਾ ਹੈ.
ਪੈਟਰਨ ਸਮਾਂ-ਅੰਤਰਾਲ ਇੱਕ ਟਾਈਮਆਊਟ (ਸਕਿੰਟਾਂ ਵਿੱਚ) ਅਤੇ ਕਿਰਿਆ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਕਿਸੇ ਨਿਸ਼ਚਤ ਸਮੇਂ ਲਈ ਕੋਈ ਅੱਖਰ ਨਹੀਂ ਪੜ੍ਹਿਆ ਗਿਆ ਹੈ. ਟਾਈਮਆਉਟ ਪੈਟਰਨ ਹਾਲ ਹੀ ਵਿੱਚ ਨਿਰਧਾਰਿਤ ਪ੍ਰਕਿਰਿਆ ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ . ਕੋਈ ਡਿਫਾਲਟ ਟਾਈਮਆਉਟ ਨਹੀਂ ਹੈ ਖਾਸ ਵੇਰੀਏਬਲ "ਟਾਈਮਆਉਟ" ( ਉਮੀਦ ਕਮਾਂਡ ਦੁਆਰਾ ਵਰਤੀ ਗਈ ਹੈ) ਇਸ ਟਾਈਮਆਊਟ ਤੇ ਕੋਈ ਪ੍ਰਭਾਵ ਨਹੀਂ ਪੈਂਦਾ ਹੈ.
ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਲਿਖੀ ਸਟੇਟਮੈਂਟ ਨੂੰ ਆਟੋਲੋਗ ਕਰਨ ਵਾਲੇ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਨੇ ਇੱਕ ਘੰਟੇ ਲਈ ਕੁਝ ਟਾਈਪ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਪਰ ਜਿਹੜੇ ਹਾਲੇ ਵੀ ਲਗਾਤਾਰ ਸਿਸਟਮ ਸੰਦੇਸ਼ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ:
ਇੰਟਰੈਕਟ ਇਨਇਨਪੁੱਟ $ user_spawn_id ਟਾਈਮਆਊਟ 3600 ਰਿਟਰਨ -output \ $ spawn_idਜੇਕਰ ਪੈਟਰਨ ਕੀਵਰਡ ਨਾਵਲ ਹੈ , ਅਤੇ nulls ਦੀ ਇਜਾਜ਼ਤ ਹੈ ( remove_nulls ਕਮਾਂਡ ਰਾਹੀਂ), ਅਨੁਸਾਰੀ ਸਰੀਰ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਸਿੰਗਲ ASCII 0 ਮਿਲਾਇਆ ਜਾਂਦਾ ਹੈ. Glob ਜਾਂ regexp ਪੈਟਰਨ ਰਾਹੀਂ 0 ਬਾਈਟ ਨਾਲ ਮੇਲ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਹੈ.
ਫਲੈਗ ਦੇ ਨਾਲ ਇੱਕ ਪੈਟਰਨ ਪਹਿਲਣ ਨਾਲ ਪਰਿਵਰਤਨਸ਼ੀਲ interact_out (spawn_id) ਨੂੰ spawn_id ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਪੈਟਰਨ (ਜਾਂ eof) ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ.
ਕਿਰਿਆਵਾਂ ਜਿਵੇਂ ਕਿ ਬ੍ਰੇਕ ਅਤੇ ਜਾਰੀ ਰਹਿਣ ਵਾਲਾ ਨਿਯੰਤਰਣ ਬਣਤਰ (ਅਰਥਾਤ, ਪ੍ਰਕ ) ਆਮ ਤਰੀਕੇ ਨਾਲ ਵਿਵਹਾਰ ਕਰਨ ਲਈ. ਪਰ ਵਾਪਸੀ ਦੇ ਕਾਰਨ ਉਸਦੇ ਕਾਲਰ ਨੂੰ ਵਾਪਸ ਜਾਣ ਦਾ ਸੰਚਾਰ ਕਰਦਾ ਹੈ, ਜਦਕਿ ਅੰਤਰ-ਰੇਟ ਕਾਰਨ ਉਸਦੇ ਕਾਲਰ ਵਿਚ ਵਾਪਸੀ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ . ਉਦਾਹਰਨ ਲਈ, ਜੇ "proc foo" ਨੂੰ ਇੰਟਰੈਕਟ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਇੰਟਰ ਸਟਰੀਟ ਐਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ , proc foo ਵਾਪਸ ਆ ਜਾਵੇਗਾ. (ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਜੇਕਰ ਇੰਟਰਪ੍ਰੈਸ ਕਾਲ ਕਰਦਾ ਹੈ ਤਾਂ ਇੰਟਰਪ੍ਰੈਪਿੰਗ ਨਾਲ ਇੰਟਰਪ੍ਰਾਈਸਿੰਗ ਟਾਈਪ ਕਰਨ ਨਾਲ ਇੰਟਰੈਕਟ ਜਾਰੀ ਰਹੇਗਾ, ਜਦੋਂ ਕਿ ਇੰਟਰ-ਰੇਟ ਆਪਣੇ ਕਾਲਰ ਤੇ ਵਾਪਸ ਆਉਣ ਲਈ ਇੰਟਰੈਕਟਸ ਦਾ ਕਾਰਨ ਬਣੇਗਾ.)
ਇੰਟਰੈਕਟ ਦੌਰਾਨ, ਕੱਚੀ ਮੋਡ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕਿ ਸਾਰੇ ਅੱਖਰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਪਾਸ ਕੀਤੇ ਜਾ ਸਕਣ. ਜੇ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੌਕਰੀ ਨਿਯੰਤਰਣ ਸੰਕੇਤਾਂ ਨੂੰ ਨਹੀਂ ਫੜਦੀ, ਤਾਂ ਇਸ ਨੂੰ ਰੋਕ ਦਿੱਤਾ ਜਾਏਗਾ ਜੇ ਇੱਕ ਸਟੌਪ ਸਿਗਨਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ (ਡਿਫੌਲਟ ^ Z) ਇਸ ਨੂੰ ਮੁੜ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਇੱਕ ਜਾਰੀ ਸੰਕੇਤ ਭੇਜੋ (ਜਿਵੇਂ ਕਿ "kill -CONT"). ਜੇ ਤੁਸੀਂ ਸੱਚਮੁੱਚ ਅਜਿਹੀ ਪ੍ਰਕਿਰਿਆ (^ Z) ਦੇ ਕੇ ਇੱਕ SIGSTOP ਭੇਜਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੀਐਸ਼ ਨੂੰ ਫੇਰ ਸ਼ੁਰੂਆਤ ਕਰੋ ਅਤੇ ਫਿਰ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਓ. ਦੂਜੇ ਪਾਸੇ, ਜੇ ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ ਲੋਚਣ ਲਈ ਇੱਕ SIGSTOP ਭੇਜਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਪਹਿਲਾਂ ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਕਾਲ ਕਰੋ (ਸ਼ਾਇਦ ਇੱਕ ਬਚੇ ਅੱਖਰ ਵਰਤ ਕੇ), ਅਤੇ ਫਿਰ ^ Z ਦਬਾਓ.
ਸਟਰਿੰਗ-ਬਾਡੀ ਜੋੜੇ ਨੂੰ ਇੰਟਰਪ੍ਰੈਟਰ ਵਿਚ ਦਾਖਲ ਕਰਨ ਅਤੇ ਕਮਾਂਡਾਂ ਨੂੰ ਅੰਜਾਮ ਦੇਣ ਤੋਂ ਬਚਣ ਲਈ ਲਘੂ ਸ਼ਬਦ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਪਿਛਲੇ ਟਰਮੀਨਲ ਮੋਡ ਨੂੰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਸਤਰ-ਸਰੀਰ ਜੋੜਾ ਦੇ ਸਰੀਰ ਨੂੰ ਚਲਾਇਆ ਜਾ ਰਿਹਾ ਹੈ.
ਸਪੀਡ ਲਈ, ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ ਕੱਚਾ ਮੋਡ ਵਿੱਚ ਐਕਸ਼ਨ ਲਾਗੂ ਹੁੰਦੇ ਹਨ. -ਟਰੈਗ ਫਲੈਗ ਟਰਮਿਨਲ ਨੂੰ ਮੋਡ ਵਿੱਚ ਰੀਸੈੱਟ ਕਰਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਪਹਿਲਾਂ ਇੰਟਰੈਕਟ ਕੀਤਾ ਗਿਆ ਸੀ (ਨਿਰੰਤਰ, ਪਕਾਇਆ ਹੋਇਆ ਮੋਡ). ਯਾਦ ਰੱਖੋ ਕਿ ਜਦੋਂ ਪਾਵਰ ਬਦਲਿਆ ਜਾ ਰਿਹਾ ਹੈ ਤਾਂ ਅੱਖਰ ਦਰਜ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ (ਕੁਝ ਸਿਸਟਮਾਂ ਉੱਤੇ ਟਰਮੀਨਲ ਡਰਾਈਵਰ ਦੀ ਇੱਕ ਮੰਦਭਾਗੀ ਵਿਸ਼ੇਸ਼ਤਾ). ਇਸਦਾ ਇਸਤੇਮਾਲ ਕਰਨ ਦਾ ਇਕੋ ਇਕ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਤੁਹਾਡੀ ਕਾਰਵਾਈ ਪਕਾਏ ਹੋਏ ਢੰਗ ਨਾਲ ਚਲਾਉਣ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ.
-ਈਓ ਫਲੈਗ ਉਹ ਅੱਖਰ ਭੇਜਦਾ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪਿੱਛੇ ਜਿਹੇ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਨੂੰ ਤਿਆਰ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਹਰ ਇੱਕ ਅੱਖਰ ਨੂੰ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ. ਇਹ ਉਦੋਂ ਉਪਯੋਗੀ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਉਪਯੋਗਕਰਤਾ ਨੂੰ ਅੰਸ਼ਕ ਤੌਰ ਤੇ ਟਾਈਪ ਕੀਤੇ ਪੈਟਰਨਾਂ ਤੋਂ ਫੀਡਬੈਕ ਦੇਖਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ.
ਜੇ ਇੱਕ ਪੈਟਰਨ ਗੂੰਜ ਰਿਹਾ ਹੈ ਪਰ ਆਖਰਕਾਰ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ, ਤਾਂ ਅੱਖਰ ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਭੇਜੇ ਜਾਂਦੇ ਹਨ. ਜੇ ਪੈਦਾ ਹੋਈ ਪ੍ਰਕ੍ਰੀਆ ਉਨ੍ਹਾਂ ਨੂੰ ਗੰਢਦੀ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ ਅੱਖਰ ਦੋ ਵਾਰ ਦੇਖਣਗੇ. -ਏਚੋ ਸੰਭਵ ਤੌਰ 'ਤੇ ਸਿਰਫ ਉਹਨਾਂ ਹਾਲਤਾਂ ਵਿਚ ਉੱਚਿਤ ਹੈ ਜਿੱਥੇ ਉਪਭੋਗਤਾ ਪੈਟਰਨ ਨੂੰ ਪੂਰਾ ਨਾ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੇ ਐਕਸਪਰਿਟ ਨੂੰ rftp, recursive-ftp ਸਕਰਿਪਟ, ਤੋਂ ਹੈ, ਜਿੱਥੇ ਉਪਭੋਗਤਾ ਨੂੰ ~ g, ~ p, ਜਾਂ ~ l ਵਿੱਚ ਪ੍ਰਵੇਸ਼ ਕਰਨ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਲਗਾਤਾਰ ਮਿਲਦੀ ਹੈ ਇਹ ਆਮ FTP ਕਮਾਂਡਾਂ ਤੋਂ ਬਹੁਤ ਦੂਰ ਹਨ, ਇਸ ਲਈ ਕਿ ਉਪਭੋਗਤਾ ਨੂੰ ਟਾਈਪ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ, ਇਸਦੇ ਬਾਅਦ ਕੁਝ ਹੋਰ, ਗਲਤੀ ਨਾਲ ਛੱਡ ਕੇ, ਇਸ ਕੇਸ ਵਿੱਚ, ਉਹ ਸੰਭਵ ਤੌਰ ਤੇ ਨਤੀਜੇ ਦੇ ਨਤੀਜੇ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰ ਦੇਣਗੇ.
ਇੰਟਰੈਕਟ ਕਰੋ {--echo ~ g {getcurdirectory 1} -ਤੇੋਂ ~ l {getcurdirectory 0} -ਤੇ ~ ਪੀ {putcurdirectory}}-ਨੌਬਫ਼ਰ ਫਲੈਗ ਉਹਨਾਂ ਅੱਖਰਾਂ ਨੂੰ ਭੇਜਦਾ ਹੈ ਜੋ ਆਊਟਪੁੱਟ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦਿੱਤੇ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਅੱਖਰ ਪੜ੍ਹੇ ਜਾਂਦੇ ਹਨ
ਇਹ ਉਦੋਂ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਪੈਟਰਨ ਵਾਪਸ ਇਕੋ ਕਰਨਾ ਚਾਹੋਗੇ. ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਲਿਖਿਆਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਇਕ ਵਿਅਕਤੀ ਕਿੱਥੇ ਡਾਇਲ ਕਰ ਰਿਹਾ ਹੈ (ਹੇੇਸ-ਸ਼ੈਲੀ ਮਾਡਮ). ਹਰ ਵਾਰ "ਏ ਡੀ ਡੀ" ਦਿਖਾਇਆ ਗਿਆ ਹੈ ਕਿ ਸਕ੍ਰਿਪਟ ਬਾਕੀ ਲਾਈਨ ਨੂੰ ਲੌਗ ਕਰਦੀ ਹੈ.
proc lognumber {} {interact -nobuffer -re "(. *) \ r" ਰਿਟਰਨ ਪਾਉਂਦਾ ਹੈ $ ਲਾਗ "[ਘੜੀ ਦੀ ਵਿਵਸਥਾ [ਕਲਕ ਸਕਿੰਟਾਂ]]: ਡਾਇਲ ਕੀਤੇ $ interact_out (1, ਸਤਰ)"} ਇੰਟਰੈਕਟ -ਨੌਬਫ਼ਰ "ਐਡ" ਲੌਗਨੰਬਰਇੰਟਰੈਕਟ ਦੌਰਾਨ, ਲੌਗ_ਯੂਜ਼ਰ ਦੀ ਪਿਛਲੀ ਵਰਤੋਂ ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਗਿਆ ਹੈ. ਖਾਸ ਕਰਕੇ, ਇੰਟਰੈਕਟ ਕਰਕੇ ਇਸ ਦੀ ਆਉਟਪੁੱਟ ਨੂੰ ਲੌਗ ਕਰਨ (ਸਟੈਂਡਰਡ ਆਉਟਪੁਟ ਨੂੰ ਭੇਜੇ) ਤੋਂ ਪ੍ਰੇਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਯੂਜ਼ਰ ਅੰਨ੍ਹੇਵਾਹ ਇੰਟਰੈਕਟ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦਾ.
-o ਫਲੈਗ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਦੇ ਆਊਟਪੁੱਟ ਤੇ ਲਾਗੂ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਕਿਸੇ ਕੁੰਜੀ-ਜੋੜ ਦੇ ਜੋੜੇ ਨੂੰ ਕਾਰਨ ਦਿੰਦਾ ਹੈ . ਇਹ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ, ਉਦਾਹਰਣ ਲਈ, ਹੋਸਟ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਜਦੋਂ ਇੱਕ ਟੈੱਲਨੈਟ ਸੈਸ਼ਨ ਦੇ ਦੌਰਾਨ ਅਣਚਾਹੇ ਅੱਖਰ ਭੇਜੇ ਜਾਂਦੇ ਹਨ.
ਡਿਫਾਲਟ ਤੌਰ ਤੇ, ਇੰਟਰੈਕਟ ਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਨੂੰ stdin ਲਿਖਣਾ ਅਤੇ Expect ਪ੍ਰਕਿਰਿਆ ਦੀ ਆਪਣੀ ਸਟੈਡਟ ਪੜ੍ਹਨ ਦੀ ਲੋੜ ਹੈ. -ਯੂ ਫਲੈਗ ("ਯੂਜ਼ਰ" ਲਈ) ਉਪਭੋਗਤਾ ਨੂੰ ਇਸਦੇ ਆਰਗੂਮੈਂਟ ਦੁਆਰਾ ਨਾਮਿਤ ਪ੍ਰਕਿਰਿਆ ਵਜੋਂ ਗੱਲਬਾਤ ਕਰਦਾ ਹੈ (ਜੋ ਇਕ ਸਪਾਡ ਆਈਡੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ).
ਇਸ ਨਾਲ ਸਪੱਸ਼ਟ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਦੋ ਪਰਸਪਰੈੱਸ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਇਕੱਠਿਆਂ ਜੋੜਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ. ਡੀਬੱਗਿੰਗ ਵਿੱਚ ਸਹਾਇਤਾ ਲਈ, ਨਿਦਾਨਕ ਦੀ ਹਮੇਸ਼ਾਂ stderr (ਜਾਂ ਕੁਝ ਨਿਸ਼ਚਿਤ ਲੌਗਿੰਗ ਅਤੇ ਡੀਬੱਗਿੰਗ ਜਾਣਕਾਰੀ ਲਈ stdout) ਤੇ ਜਾਉ. ਇਸੇ ਕਾਰਨ ਕਰਕੇ, ਇੰਟਰਪਰੀਟਰ ਕਮਾਂਡ ਸਟੈਂਨ ਤੋਂ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨਾਲ ਪੜ੍ਹੇਗਾ.
ਉਦਾਹਰਨ ਲਈ, ਹੇਠਲਾ ਭਾਗ ਇੱਕ ਲੌਗਿਨ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਂਦਾ ਹੈ . ਤਦ ਇਹ ਉਪਭੋਗਤਾ ਨੂੰ ਡਾਇਲ ਕਰਦਾ ਹੈ (ਦਿਖਾਇਆ ਨਹੀਂ ਗਿਆ), ਅਤੇ ਅੰਤ ਵਿੱਚ ਦੋਵਾਂ ਨੂੰ ਇੱਕਠੇ ਜੋੜਦਾ ਹੈ. ਬੇਸ਼ੱਕ, ਲੌਗਿਨ ਲਈ ਕੋਈ ਪ੍ਰਕਿਰਿਆ ਬਦਲ ਦਿੱਤੀ ਜਾ ਸਕਦੀ ਹੈ. ਇੱਕ ਸ਼ੈੱਲ, ਉਦਾਹਰਣ ਵਜੋਂ, ਉਪਭੋਗਤਾ ਨੂੰ ਖਾਤਾ ਅਤੇ ਪਾਸਵਰਡ ਸਪਲਾਈ ਕੀਤੇ ਬਗੈਰ ਕੰਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ.
spawn login set login $ spawn_id spawn tip modem # ਉਪਭੋਗੀ ਨੂੰ ਵਾਪਸ ਡਾਇਲ ਕਰੋ # ਲਾਗਇਨ ਨਾਲ ਜੁੜਨ ਲਈ ਯੂਜ਼ਰ ਨਾਲ ਜੁੜੋ- $$ ਲਾਗਇਨਬਹੁ-ਕਾਰਜਾਂ ਲਈ ਆਉਟਪੁੱਟ ਭੇਜਣ ਲਈ, ਇੱਕ- ਆਉਟਪੁਟ ਫਲੈਗ ਦੁਆਰਾ ਪ੍ਰਭਾਸ਼ਿਤ ਹਰ ਇੱਕ spawn id ਸੂਚੀ ਦੀ ਸੂਚੀ ਬਣਾਓ. ਆਉਟਪੁਟ ਸਪੌਨ ਆਈਡੀਜ਼ ਦੇ ਸਮੂਹ ਲਈ ਇੰਪੁੱਟ ਨੂੰ ਇੱਕ ਇਨਪੁਟ ਫਲੈਗ ਦੁਆਰਾ ਪ੍ਰਭਾਸ਼ਿਤ ਇੱਕ ਸਪੌਨ ਆਈਡੀ ਸੂਚੀ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. (- ਇੰਪੁੱਟ ਅਤੇ -ਆਉਟਪੁੱਟ ਦੋਵੇਂ ਉਸੇ ਫਾਰਮ ਵਿਚ ਸੂਚੀਆਂ ਲੈ ਸਕਦੇ ਹਨ ਜਿਵੇਂ -i ਫਲੈਗ ਦੀ ਉਮੀਦ ਕਮਾਨ ਵਿਚ, ਇਸ ਤੋਂ ਇਲਾਵਾ ਕੋਈ ਵੀ_ ਸਪੌਨ_ਆਈਡ ਇੰਟਰੈਕਟ ਵਿਚ ਅਰਥਪੂਰਨ ਨਹੀਂ ਹੈ.) ਹੇਠਾਂ ਦਿੱਤੇ ਸਾਰੇ ਫਲੈਗ ਅਤੇ ਸਤਰ (ਜਾਂ ਪੈਟਰਨ) ਇਸ ਇੰਪੁੱਟ 'ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਦੂਜਾ - ਇਨਪੁਟ ਫਲੈਗ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ ਜੇ ਕੋਈ- ਇੰਪੁੱਟ ਨਹੀਂ ਦਿਸਦਾ, ਤਾਂ -ਆਉਟਪੁੱਟ ਦਾ ਮਤਲਬ ਹੈ "-ਇੰਪੁੱਟ $ user_spawn_id -output" (ਇਸੇ ਤਰ੍ਹਾਂ, ਅਜਿਹੇ ਨਮੂਨੇ ਦੇ ਨਾਲ ਜਿਹਨਾਂ ਕੋਲ ਇੰਪੁੱਟ ਨਹੀਂ ਹੈ.) ਜੇਕਰ ਇੱਕ- ਇੰਪੁੱਟ ਨਿਰਦਿਸ਼ਟ ਹੈ, ਤਾਂ ਇਹ $ user_spawn_id ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦਾ ਹੈ. ਜੇਕਰ ਦੂਜੀ ਇਨਪੁੱਟ ਸਪਸ਼ਟ ਕੀਤੀ ਗਈ ਹੈ, ਤਾਂ ਇਹ $ spawn_id ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦਾ ਹੈ ਵਾਧੂ- ਇੰਪੁੱਟ ਫਲੈਗ ਦਿੱਤੇ ਜਾ ਸਕਦੇ ਹਨ.
ਦੋ ਅਪ੍ਰਤੱਖ ਇੰਪੁੱਟ ਡਿਫਾਲਟ ਵਜੋਂ ਆਪਣੇ ਆਊਟਪੁੱਟ ਨੂੰ $ spawn_id ਅਤੇ $ user_spawn_id (ਰਿਵਰਸ ਵਿੱਚ) ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਉਂਦਾ ਹੈ. ਜੇਕਰ ਇੱਕ- ਇਨਪੁਟ ਫਲੌਗ ਨੋ- ਆਉਟਪੁਟ ਫਲੈਗ ਨਾਲ ਵਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਉਸ ਪ੍ਰਕ੍ਰਿਆ ਦੇ ਅੱਖਰ ਬਰਖਾਸਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ.
-i ਫਲੈਗ ਮੌਜੂਦਾ spawn_id ਲਈ ਇੱਕ ਤਬਦੀਲੀ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕੋਈ ਹੋਰ - ਇੰਪੁੱਟ ਜਾਂ -outਪੁੱਟ ਫਲੈਗ ਵਰਤਿਆ ਨਹੀਂ ਜਾਂਦਾ ਏ-ਆਈ ਫਲੈਗ ਇਕ-ਓ ਫਲੈਗ ਦਾ ਮਤਲਬ ਹੈ
ਪ੍ਰਕ੍ਰਿਆਵਾਂ ਨੂੰ ਬਦਲਣਾ ਸੰਭਵ ਹੈ ਜੋ ਪਰਸਪਰ ਸਪੌਨ ਆਈਡੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਪਾ ਰਹੇ ਹਨ. (ਅਸਿੱਧੇ ਸਪੌਨ IDs ਨੂੰ ਉਮੀਦ ਦੀ ਕਮਾਨ ਦੇ ਭਾਗ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ.) ਅਸਿੱਧੇ ਸਪਾਨ ਆਈਡੀਆਂ -i, -u, -input, ਜਾਂ -output flags ਨਾਲ ਨਿਸ਼ਚਿਤ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ.
ਦੁਭਾਸ਼ੀਏ [ਆਰਗਜ਼]
ਯੂਜ਼ਰ ਨੂੰ ਆਸ ਅਤੇ Tcl ਕਮਾਂਡਾਂ ਲਈ ਇੰਟਰਐਕਵਟੀ ਪੁੱਛੇ ਜਾਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ. ਹਰੇਕ ਹੁਕਮ ਦਾ ਨਤੀਜਾ ਛਾਪਿਆ ਜਾਂਦਾ ਹੈ.
ਕਿਰਿਆਵਾਂ ਜਿਵੇਂ ਕਿ ਬ੍ਰੇਕ ਅਤੇ ਜਾਰੀ ਰਹਿਣ ਵਾਲਾ ਨਿਯੰਤਰਣ ਬਣਤਰ (ਅਰਥਾਤ, ਪ੍ਰਕ ) ਆਮ ਤਰੀਕੇ ਨਾਲ ਵਿਵਹਾਰ ਕਰਨ ਲਈ. ਹਾਲਾਂਕਿ ਵਾਪਸੀ ਕਾਰਨ ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਆਪਣੇ ਕਾਲਰ 'ਤੇ ਵਾਪਸ ਆਉਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਅੰਤਰ-ਰੇਟ ਕਾਰਨ ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਆਪਣੇ ਕਾਲਰ ਵਿੱਚ ਵਾਪਸ ਆਉਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ . ਉਦਾਹਰਨ ਲਈ, ਜੇ "proc foo" ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਕਹਿੰਦੇ ਹਨ ਜਿਸ ਨੇ ਫਿਰ ਕਾਰਵਾਈ inter_return ਨੂੰ ਚਲਾਇਆ, proc foo ਵਾਪਸ ਆ ਜਾਵੇਗਾ. ਕੋਈ ਹੋਰ ਕਮਾਂਡ ਨਵੇਂ ਤਰਕਾਂ ਲਈ ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਜਾਰੀ ਰੱਖਣ ਦਾ ਕਾਰਨ ਬਣਦੀ ਹੈ .
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਪਰੌਂਪਟ ਵਿੱਚ ਦੋ ਪੂਰਨ ਅੰਕ ਹੁੰਦੇ ਹਨ. ਪਹਿਲੇ ਪੂਰਨ ਅੰਕ ਵਿਚ ਮੁਲਾਂਕਣ ਸਟੈਕ ਦੀ ਡੂੰਘਾਈ (ਜਿਵੇਂ ਕਿ ਟੀਐਚਐਲ-ਈਵਵਲ ਕਿੰਨੀ ਵਾਰ ਕਿਹਾ ਗਿਆ ਹੈ) ਬਾਰੇ ਦੱਸਦਾ ਹੈ. ਦੂਜਾ ਪੂਰਨ ਅੰਕ Tcl ਇਤਿਹਾਸ ਪਛਾਣਕਰਤਾ ਹੈ. ਪ੍ਰਾਉਟ ਨੂੰ "prompt1" ਨਾਂ ਦੀ ਇਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸਦਾ ਵਾਪਸ ਮੁੱਲ ਅਗਲਾ ਪਰੌਂਪਟ ਬਣਦਾ ਹੈ. ਜੇ ਕਿਸੇ ਬਿਆਨ ਵਿਚ ਖੁੱਲ੍ਹੇ ਕੋਟਸ, ਪੈਰਾ, ਬ੍ਰੇਸ ਜਾਂ ਬ੍ਰੈਕਟਾਂ ਹਨ, ਤਾਂ ਇੱਕ ਸੈਕੰਡਰੀ ਪ੍ਰੌਮਪਟ (ਮੂਲ ਰੂਪ ਵਿੱਚ "+>") ਨਵੀਂ ਲਾਈਨ ਤੇ ਜਾਰੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. "ਪ੍ਰਾਉਟ 2" ਨਾਮ ਦੀ ਇੱਕ ਵਿਧੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸੈਕੰਡਰੀ ਪਰੌਂਪਟ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ
ਦੁਭਾਸ਼ੀਏ ਦੇ ਦੌਰਾਨ, ਪਿਕਸਡ ਮੋਡ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਉਸਦਾ ਕਾਲਰ ਕੱਚਾ ਮੋਡ ਵਰਤ ਰਿਹਾ ਹੋਵੇ.
ਜੇ ਸਟਡੀਿਨ ਬੰਦ ਹੈ, ਤਾਂ ਇੰਟਰਪ੍ਰੈਟਰ ਵਾਪਸ ਆਵੇਗਾ ਜਦੋਂ ਤੱਕ ਐਫ ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ ਜਾਏਗੀ , ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਅਗਲੀ ਬਹਿਸ ਜਾਰੀ ਹੋਵੇਗੀ.
log_file [ਆਰਗਜ਼] [[-a] ਫਾਈਲ]
ਜੇ ਇੱਕ ਫਾਈਲ ਦਾ ਨਾਮ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਤਾਂ log_file ਫਾਈਲ ਵਿੱਚ ਸੈਸ਼ਨ ਦਾ ਟ੍ਰਾਂਸਲੇਸ਼ਨ (ਉਸ ਸਮੇਂ ਦੀ ਸ਼ੁਰੂਆਤ) ਰਿਕਾਰਡ ਕਰੇਗਾ. log_file ਰਿਕਾਰਡਿੰਗ ਨੂੰ ਰੋਕ ਦੇਵੇਗੀ ਜੇਕਰ ਕੋਈ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਕੋਈ ਵੀ ਪਿਛਲੀ ਲਾਗ ਫਾਇਲ ਬੰਦ ਹੈ.
ਇੱਕ ਫਾਇਲ ਨਾਂ ਦੀ ਬਜਾਏ, ਇੱਕ Tcl ਫਾਇਲ ਪਛਾਣਕਰਤਾ -Open ਜਾਂ -leaveopen ਫਲੈਗ ਵਰਤ ਕੇ ਮੁਹੱਈਆ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਇਹ ਸਪੌਨ ਕਮਾਂਡ ਵਰਗੀ ਹੈ. (ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ ਸਪੌਨ ਵੇਖੋ.)
-ਐਲ ਨੂੰ ਫਲੈਗ ਕਰਨ ਲਈ ਆਉਟਪੁੱਟ ਆਉਟਪੁੱਟ, ਜੋ ਕਿ log_user ਕਮਾਂਡ ਦੁਆਰਾ ਦਬਾਇਆ ਗਿਆ ਸੀ.
ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ, log_file ਕਮਾਂਡ ਪੁਰਾਣੇ ਫਾਇਲਾਂ ਨੂੰ ਜੋੜਦੀ ਹੈ ਨਾ ਕਿ ਉਹਨਾਂ ਨੂੰ ਛੱਡੇ ਜਾਣ ਦੀ, ਇੱਕ ਸੈਸ਼ਨ ਵਿੱਚ ਲੌਗਿੰਗ ਚਾਲੂ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਅਤੇ ਕਈ ਵਾਰ. ਫਾਇਲਾਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ, -noappend ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰੋ.
-ਇੰਟਾ ਫਲੈਗ ਨੇ log_file ਨੂੰ ਦਿੱਤੇ ਸਭ ਤੋਂ ਨਵੇਂ ਅਣ-ਜਾਣਕਾਰੀ ਆਰਗੂਮੈਂਟ ਦਾ ਵੇਰਵਾ ਦੇਣ ਲਈ ਕਾਰਨ ਦਿੱਤੇ ਹਨ.
log_user-info | 0 | 1
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਭੇਜਣ / ਉਮੀਦ ਵਾਰਤਾਲਾਪ stdout ਤੇ ਲਾਗ (ਅਤੇ ਇੱਕ ਲਾਗਫਾਇਲ ਜੇ ਖੁੱਲ੍ਹਾ ਹੈ). Stdout ਤੇ ਲਾਗਿੰਗ ਨੂੰ "log_user 0" ਕਮਾਂਡ ਦੁਆਰਾ ਅਯੋਗ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ "log_user 1" ਦੁਆਰਾ reenabled ਕੀਤਾ ਗਿਆ ਹੈ. ਲਾਗਫਾਇਲ ਉੱਤੇ ਲਾਗਇਨ ਕਰਨਾ ਤਬਦੀਲ ਨਹੀਂ ਹੈ.
-ਇੰਟਾ ਫਲੈਗ ਨੇ ਲੌਗ_ ਯੂਜਰ ਨੂੰ ਦਿੱਤੇ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਗੈਰ-ਜਾਣਕਾਰੀ ਦਲੀਲਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਦਾ ਕਾਰਨ ਦਿੱਤਾ ਹੈ.
match_max [-d] [-i spawn_id] [ਆਕਾਰ]
ਬਫ਼ਰ ਦਾ ਆਕਾਰ (ਬਾਇਟ ਵਿੱਚ) ਨੂੰ ਅੰਦਰੂਨੀ ਰੂਪ ਵਿੱਚ ਆਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ . ਕੋਈ ਆਕਾਰ ਦੀ ਦਲੀਲ ਦੇ ਨਾਲ, ਮੌਜੂਦਾ ਆਕਾਰ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ.
-d ਫਲੈਗ ਦੇ ਨਾਲ, ਡਿਫੌਲਟ ਆਕਾਰ ਸੈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. (ਸ਼ੁਰੂਆਤੀ ਮੂਲ 2000 ਹੈ.) -i ਫਲੈਗ ਨਾਲ, ਅਕਾਰ ਨਾਮ ਦੇ spawn id ਲਈ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਨਹੀਂ ਤਾਂ ਇਹ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ .
ਓਵਰਲੇ [- # ਸਪੌਨ_ਆਈਡੀ] [- # ਸਪੌਨ_ਆਈਡ] [...] ਪ੍ਰੋਗਰਾਮ [ਆਰਗਜ਼]
ਮੌਜੂਦਾ ਅਨੁਮਾਨ ਪ੍ਰੋਗ੍ਰਾਮ ਦੇ ਸਥਾਨ ਤੇ "ਪ੍ਰੋਗਰਾਮ ਆਰਗੂਏਜ਼" ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਜੋ ਸਮਾਪਤ ਹੁੰਦਾ ਹੈ. ਇੱਕ ਬੇਅਰ ਹਾਈਫਨ ਆਰਗੂਮੈਂਟ ਕਮਾਂਡ ਨਾਂ ਦੇ ਸਾਹਮਣੇ ਇੱਕ ਹਾਈਫਨ ਭੇਜਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇਹ ਇੱਕ ਲਾਗਿੰਨ ਸ਼ੈੱਲ ਸੀ. ਸਾਰੇ spawn_ids ਨੂੰ ਆਰਗੂਮਿੰਟ ਦੇ ਨਾਂ ਨਾਲ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ. ਇਹਨਾਂ ਨੂੰ ਨਾਮਿਤ ਫਾਈਲ ਆਈਡੈਂਟੀਫਾਇਰਸ ਤੇ ਮੈਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
Spawn_ids ਨੂੰ ਆਪਣੇ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਨਵੇਂ ਪ੍ਰੋਗਰਾਮ ਲਈ ਪਛਾਣਕਰਤਾ ਫਾਈਲ ਕਰਨ ਲਈ ਮੈਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੀ ਲਾਈਨ ਸ਼ਤਰੰਜ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ - ਮੰਨੋ, ਇੱਕ ਸ਼ਤਰੰਜ ਮਾਸਟਰ.
ਓਵਰਲੇ -0 $ ਸਪੌਨ_id -1 $ spawn_id -2 $ spawn_id ਸ਼ਤਰੰਜਇਹ "ਇੰਟਰੈਕਟ-ਓ" ਨਾਲੋਂ ਵਧੇਰੇ ਪ੍ਰਭਾਵੀ ਹੈ, ਹਾਲਾਂਕਿ, ਇਹ ਪ੍ਰੋਗ੍ਰਾਮ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਕੁਰਬਾਨ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਉਮੀਦ ਪ੍ਰਕਿਰਿਆ ਹੁਣ ਕੰਟਰੋਲ ਵਿੱਚ ਨਹੀਂ ਹੈ.
ਯਾਦ ਰੱਖੋ ਕਿ ਕੋਈ ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ ਨਹੀਂ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਇਸ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਸਟੈਂਡਰਡ ਇੰਨਪੁੱਟ ਕੱਟਣ ਜਾਂ ਰੀਮੈਪ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਜੋ ਕੰਮ ਨਿਯੰਤਰਣ (ਸ਼ੈੱਲ, ਲੌਗਿਨ, ਆਦਿ) ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦੀਆਂ
ਪੈਰਾਟੀ [-ਡ] [-i ਸਪੌਨ_ਆਈਡ] [ਮੁੱਲ]
ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸਮਾਨਤਾ ਸਪੱਸ਼ਟ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਉਤਪਾਦਨ ਤੋਂ ਰੱਖੀ ਜਾ ਚੁੱਕੀ ਜਾਂ ਛੱਡੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ. ਜੇ ਮੁੱਲ ਸਿਫਰ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸਮਾਨਤਾ ਲਾਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ, ਨਹੀਂ ਤਾਂ ਇਸਨੂੰ ਤੰਗ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ. ਬਿਨਾਂ ਮੁੱਲ ਦਲੀਲ ਦੇ ਨਾਲ, ਮੌਜੂਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ.
-d ਫਲੈਗ ਨਾਲ, ਡਿਫਾਲਟ ਪੈਰੀਟੀ ਵੈਲਯੂ ਸੈਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. (ਸ਼ੁਰੂਆਤੀ ਮੂਲ 1 ਹੈ, ਭਾਵ, ਪੈਰਿਟੀ ਨਹੀਂ ਛਾਪੀ ਜਾਂਦੀ.) -i ਫਲੈਗ ਦੇ ਨਾਲ, ਪੈਰਾਟੀ ਵੈਲਯੂ ਨਾਂ ਵਾਲੇ ਸਪੌਨ ਆਈਡੀ ਲਈ ਸੈਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਨਹੀਂ ਤਾਂ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ ਸੈਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ .
remove_nulls [-d] [-i spawn_id] [ਮੁੱਲ]
ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਬੇਤਰਤੀਬ expect_out ਜਾਂ interact_out ਵਿੱਚ ਪੈਟਰਨ ਮੇਲਿੰਗ ਜਾਂ ਸਟੋਰਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਸਪੰਜ ਕੀਤੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਆਉਟਪੁਟ ਤੋਂ ਖਰਾਬੀਆਂ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਿਆ ਜਾਂ ਹਟਾਇਆ ਗਿਆ ਹੈ . ਜੇ ਵੈਲਯੂ 1 ਹੈ, ਤਾਂ ਰੱਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਜੇ ਮੁੱਲ 0 ਹੈ, ਤਾਂ ਰੱਦ ਕੀਤਾ ਨਹੀਂ ਜਾਵੇਗਾ. ਬਿਨਾਂ ਮੁੱਲ ਦਲੀਲ ਦੇ ਨਾਲ, ਮੌਜੂਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ.
-d ਫਲੈਗ ਨਾਲ, ਡਿਫਾਲਟ ਮੁੱਲ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. (ਸ਼ੁਰੂਆਤੀ ਡਿਫਾਲਟ 1 ਹੈ, ਅਰਥਾਤ, ਸਟਾਕਾਂ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ.) -i ਫਲੈਗ ਨਾਲ, ਵੈਲਯੂ ਨਾਂ ਵਾਲੇ ਸਪੌਨ ਆਈਡੀ ਲਈ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਨਹੀਂ ਤਾਂ ਇਹ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ .
Nulls ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ ਜਾਂ ਨਹੀਂ, ਦੀ ਉਮੀਦ ਲੌਕ ਅਤੇ stdout ਵਿਚ ਬੇਅਰ ਬਾਈਟਾਂ ਨੂੰ ਰਿਕਾਰਡ ਕਰੇਗੀ.
[-flags] ਸਤਰ ਭੇਜੋ
ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਤਰ ਭੇਜਦਾ ਹੈ . ਉਦਾਹਰਣ ਲਈ, ਕਮਾਂਡ
ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅੱਖਰ, helloworld ਭੇਜਦਾ ਹੈ (Tcl ਵਿੱਚ printf- ਵਰਗੇ ਕਮਾਂਡ ( ਫਾਰਮੇਟ ਕਹਿੰਦੇ ਹਨ) ਸ਼ਾਮਲ ਹੈ ਜੋ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਗੁੰਝਲਦਾਰ ਸਤਰ ਬਣਾ ਸਕਦੇ ਹਨ.)
ਅੱਖਰਾਂ ਨੂੰ ਤੁਰੰਤ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ ਭਾਵੇਂ ਕਿ ਲਾਈਨ-ਬਫਰ ਕੀਤੇ ਇੰਪੁੱਟ ਦੇ ਨਾਲ ਪਰਿਵਰਤਨਾਂ ਅੱਖਰ ਨਹੀਂ ਪੜ੍ਹਦਾ ਜਦੋਂ ਤੱਕ ਰਿਟਰਨ ਅੱਖਰ ਨਹੀਂ ਭੇਜਿਆ ਜਾਂਦਾ. ਇੱਕ ਰਿਟਰਨ ਅੱਖਰ "\ r" ਨੂੰ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ.
- ਫਲੈਗ ਫਲੈਗ ਦੀ ਬਜਾਏ ਸਤਰ ਦੇ ਤੌਰ ਤੇ ਅਗਲੀ ਬਹਿਸ ਨੂੰ ਮਜਬੂਰ ਕਰਦਾ ਹੈ. ਕੋਈ ਵੀ ਸਤਰ "-" ਅੱਗੇ ਜਾ ਸਕਦਾ ਹੈ ਭਾਵੇਂ ਇਹ ਫਲੈਗ ਵਰਗਾ ਹੋਵੇ. ਇਹ ਉਨ੍ਹਾਂ ਭਰੋਸੇਯੋਗ ਵਿਧੀ ਦਿੰਦਾ ਹੈ ਜੋ ਉਨ੍ਹਾਂ ਦੁਆਰਾ ਫੇਲ੍ਹ ਕੀਤੇ ਬਿਨਾਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਸਤਰਾਂ ਨੂੰ ਨਿਸ਼ਚਤ ਕਰਦਾ ਹੈ ਜੋ ਅਚਾਨਕ ਝੰਡੇ ਦੇਖਦੇ ਹਨ. ("-" ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਸਾਰੇ ਸਤਰ ਭਵਿੱਖ ਦੇ ਵਿਕਲਪਾਂ ਲਈ ਰਾਖਵੇਂ ਹਨ.)
-i ਫਲੈਗ ਘੋਸ਼ਣਾ ਕਰਦਾ ਹੈ ਕਿ ਸਤਰ ਨਾਂ ਵਾਲੇ spawn_id ਤੇ ਭੇਜੀ ਜਾਵੇਗੀ ਜੇ spawn_id user_spawn_id ਹੈ, ਅਤੇ ਟਰਮੀਨਲ ਕੱਚਾ ਮੋਡ ਵਿੱਚ ਹੈ, ਸਤਰ ਵਿੱਚ ਨਵੀਂ ਲਾਈਨਜ਼ ਨੂੰ ਨਵੇਂ-ਨਵੇਂ ਸਿਲੈਕਸ਼ਨਾਂ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕਿ ਉਹ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ ਜਿਵੇਂ ਟਰਮੀਨਲ ਪਕਾਇਆ ਹੋਇਆ ਢੰਗ ਸੀ. -ਅਰਾ ਫਲੈਗ ਇਸ ਅਨੁਵਾਦ ਨੂੰ ਅਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ
-ਨਲ ਫਲੈਗ ਬੇਕਾਰ ਅੱਖਰਾਂ ਨੂੰ ਭੇਜਦਾ ਹੈ (0 ਬਾਈਟਾਂ). ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ, ਇੱਕ ਨੱਲ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ. ਇੱਕ ਸੰਖਿਆ ਨੂੰ ਇਹ ਦਰਸਾਉਣ ਲਈ ਕਿ ਕਿੰਨੇ nulls ਭੇਜਣੇ ਹਨ, ਦੀ ਪਾਲਣਾ ਕਰ ਸਕਦੇ ਹਨ.
-break ਝੰਡਾ ਇੱਕ ਬ੍ਰੇਕ ਸੰਕੇਤ ਬਣਾਉਂਦਾ ਹੈ. ਇਹ ਕੇਵਲ ਤਾਂ ਹੀ ਸਮਝਦਾ ਹੈ ਜੇ ਸਪੌਨ id "ਸਪੌਨ -ਪੈਨ" ਦੁਆਰਾ ਖੋਲ੍ਹਿਆ ਗਿਆ ਇੱਕ tty ਜੰਤਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆ ਜਿਵੇਂ ਕਿ ਟਿਪ ਪੈਦਾ ਕੀਤੀ ਹੋਈ ਹੈ , ਤਾਂ ਤੁਹਾਨੂੰ ਟਿਪ ਦੇ ਸੰਮੇਲਨ ਦੀ ਵਰਤੋਂ ਬ੍ਰੇਕ ਬਣਾਉਣ ਲਈ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ.
-ਐਲਡ ਫਲੈਗ ਬਲਾਂ ਨੂੰ "ਹੌਲੀ ਹੌਲੀ" ਭੇਜਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਇਸ ਲਈ ਆਮ ਸਥਿਤੀ ਤੋਂ ਬਚੋ ਜਿੱਥੇ ਇੱਕ ਕੰਪਿਊਟਰ ਇਨਪੁਟ ਬਫਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਮਨੁੱਖ ਲਈ ਬਣਾਇਆ ਗਿਆ ਸੀ ਜੋ ਕਦੇ ਵੀ ਉਸੇ ਬਫਰ ਦਾ ਆਕਾਰ ਨਹੀਂ ਕਹੇਗਾ. ਇਹ ਆਉਟਪੁਟ ਵੇਰੀਏਬਲ "send_slow" ਦੇ ਮੁੱਲ ਦੁਆਰਾ ਕੰਟਰੋਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਦੋ ਤੱਤ ਸੂਚੀ ਹੁੰਦੀ ਹੈ. ਪਹਿਲਾ ਤੱਤ ਇੱਕ ਪੂਰਨ ਅੰਕ ਹੈ ਜੋ ਪ੍ਰਮਾਣਿਤ ਤੌਰ ਤੇ ਭੇਜਣ ਲਈ ਬਾਈਟਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ. ਦੂਜਾ ਤੱਤ ਇੱਕ ਅਸਲ ਸੰਖਿਆ ਹੈ ਜੋ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਵਰਣਨ ਕਰਦੀ ਹੈ ਜਿਸ ਦੁਆਰਾ ਪ੍ਰਮਾਣਿਤ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, "send send_slow {10 .001}" ਨੂੰ "ਭੇਜਣ ਲਈ" ਸਬਰ ਨੂੰ ਭੇਜਣ ਲਈ 1 ਮਿਲੀਸਕਿੰਟ ਨਾਲ ਸਤਰਾਂ ਭੇਜਣ ਲਈ ਮਜਬੂਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਭੇਜਿਆ ਗਿਆ ਹਰੇਕ 10 ਅੱਖਰ ਦੇ ਵਿੱਚ ਹੋਵੇਗਾ.
-h ਫਲੈਗ ਫਲੈਟ ਨੂੰ ਭੇਜਣ ਲਈ ਆਊਟਪੁਟ (ਕੁਝ ਹੱਦ ਤਕ) ਜਿਵੇਂ ਕਿਸੇ ਮਨੁੱਖੀ ਅਸਲ ਵਿੱਚ ਟਾਈਪ ਕਰਨਾ. ਮਨੁੱਖਾਂ ਦੀ ਤਰ੍ਹਾਂ ਦੇ ਕਿਰਨਾਂ ਅੱਖਰ ਦੇ ਵਿਚਕਾਰ ਪ੍ਰਗਟ ਹੁੰਦੀਆਂ ਹਨ (ਐਲਗੋਰਿਦਮ ਇੱਕ ਵਾਈਬੂਲ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਤੇ ਆਧਾਰਿਤ ਹੈ, ਇਸ ਖ਼ਾਸ ਅਰਜ਼ੀ ਮੁਤਾਬਕ ਸੋਧਾਂ ਸਮੇਤ.) ਇਹ ਆਉਟਪੁਟ "send_human" ਵੈਰੀਐਬਲ ਦੇ ਮੁੱਲ ਦੁਆਰਾ ਕੰਟਰੋਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸਦੇ ਅਨੁਸਾਰ ਪੰਜ ਤੱਤ ਸੂਚੀ ਹੁੰਦੀ ਹੈ. ਪਹਿਲੇ ਦੋ ਤੱਤ ਸਕਿੰਟਾਂ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਔਸਤ ਅੰਤਰਰਾਸ਼ਟਰੀ ਸਮਾਂ ਹੁੰਦੇ ਹਨ. ਪਹਿਲਾਂ ਡਿਫੌਲਟ ਦੁਆਰਾ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਦੂਸਰੀ ਦਾ ਇਸਤੇਮਾਲ ਸ਼ਬਦਾਂ ਦੇ ਅੰਤ ਵਿਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਸੁਚੱਜੀ ਵਿਰਾਮਾਂ ਦਾ ਅਨੁਰੋਧ ਕਰਨਾ, ਜੋ ਕਦੇ-ਕਦੇ ਅਜਿਹੇ ਸੰਵਾਦਾਂ ਵਿਚ ਵਾਪਰਦੇ ਹਨ. ਤੀਸਰਾ ਪੈਰਾਮੀਟਰ ਉਹ ਪਰਿਵਰਤਨ ਦੀ ਹੱਦ ਹੈ ਜਿੱਥੇ .1 ਬਹੁਤ ਬਦਲ ਹੈ, 1 ਬਹੁਤ ਹੱਦ ਤੱਕ ਵੇਰੀਏਬਲ ਹੈ ਅਤੇ 10 ਕਾਫ਼ੀ ਅਨਿਯਮਤ ਹੈ. ਅਤਿਅੰਤ 0 ਹਨ ਅਨੰਤਤਾ ਲਈ. ਆਖਰੀ ਦੋ ਮਾਪਦੰਡ ਹਨ, ਕ੍ਰਮਵਾਰ, ਇੱਕ ਘੱਟੋ ਘੱਟ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਇੰਟਰਰਰਗ ਟਾਈਮ. ਘੱਟੋ ਘੱਟ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਵਰਤੋਂ ਆਖਰੀ ਵਾਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਆਖਰੀ ਵਾਰ "ਕਲਿੱਪ" ਹੁੰਦੀ ਹੈ. ਅੰਤਮ ਔਸਤ ਦਿੱਤੀ ਗਈ ਔਸਤ ਨਾਲੋਂ ਕਾਫ਼ੀ ਵੱਖਰੀ ਹੋ ਸਕਦੀ ਹੈ ਜੇ ਘੱਟੋ ਘੱਟ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਕਲਿਪ ਕਾਫੀ ਮੁੱਲਾਂ.
ਇੱਕ ਉਦਾਹਰਣ ਦੇ ਤੌਰ ਤੇ, ਹੇਠ ਲਿਖੀ ਕਮਾਂਡ ਇੱਕ ਤੇਜ਼ ਅਤੇ ਇਕਸਾਰ ਟਾਈਪਿਸਟ ਨੂੰ ਇਮੂਲੇਟ ਕਰਦੀ ਹੈ:
send_human ਸੈਟ ਕਰੋ {1.33 .05 2} ਭੇਜੋ -h "ਮੈਂ ਭੁੱਖਾ ਹਾਂ, ਆਓ ਦੁਪਹਿਰ ਦਾ ਖਾਣਾ ਕਰੀਏ."ਜਦੋਂ ਕਿ ਹੈਂਗਓਵਰ ਤੋਂ ਬਾਅਦ ਹੇਠ ਲਿਖੇ ਜਿਆਦਾ ਅਨੁਕੂਲ ਹੋ ਸਕਦੇ ਹਨ:
send_human ਸੈਟ ਕਰੋ .4 .4 .2 .5 100} ਭੇਜੋ- "ਗੁੱਡਡ ਪਾਰਟੀ ਲਾਸ਼ ਰਾਤ!"ਨੋਟ ਕਰੋ ਕਿ ਗਲਤੀਆਂ ਸਿਮੂਲੇਟ ਨਹੀਂ ਕੀਤੀਆਂ ਗਈਆਂ, ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਇੱਕ ਗਲਤੀ ਦਲੀਲ ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਜੋੜ ਕੇ ਅਤੇ ਸੰਸ਼ੋਧਨਾਂ ਕਰਕੇ ਗਲਤੀ ਸੁਧਾਰ ਦੀਆਂ ਸਥਿਤੀਆਂ ਬਣਾ ਸਕਦੇ ਹੋ.
ਨਕਾਰਾਤਮਕ ਕਿਰਦਾਰਾਂ ਨੂੰ ਭੇਜਣ ਲਈ, ਬਰੇਕ ਭੇਜਣ ਲਈ, ਹੌਲੀ ਆਉਟਪੁੱਟ ਨੂੰ ਰੋਕਣ ਲਈ ਅਤੇ ਮਨੁੱਖੀ-ਸ਼ੈਲੀ ਦੇ ਉਤਪਾਦਨ ਲਈ ਝੰਡੇ ਇਕ ਦੂਜੇ 'ਤੇ ਵੱਖਰੇ ਹਨ. ਆਖਰੀ ਨਿਰਧਾਰਿਤ ਕੇਵਲ ਇਕ ਹੀ ਵਰਤਿਆ ਜਾਵੇਗਾ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਨਿਰਦਿਸ਼ਟ ਅੱਖਰਾਂ ਜਾਂ ਅੰਤਰਾਲ ਭੇਜਣ ਲਈ ਫਲੈਗ ਨਾਲ ਕੋਈ ਸਟਰਿੰਗ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ
ਇੱਕ ਉਮੀਦ ਦੁਆਰਾ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਪਹਿਲੀ ਵਾਰ ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਹੁੰਦਾ ਹੈ . ਉਮੀਦ ਹੈ ਕਿ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੇਗਾ, ਜਦੋਂ ਕਿ ਭੇਜਣਾ ਸੰਭਵ ਨਹੀਂ ਹੋਵੇਗਾ. ਖਾਸ ਤੌਰ 'ਤੇ, ਜੇਕਰ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਪਹਿਲੇ ਭੇਜੇ ਨੂੰ ਪੂਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਡੇਟਾ ਨੂੰ ਅਣਡਿੱਠ ਕਰਨ ਦੇ ਜੋਖਮ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ. ਅਜਿਹੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਜਿੱਥੇ ਪ੍ਰਭਾਵੀ ਪ੍ਰੋਗਰਾਮ ਕੋਈ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰੋਂਪਟ ਪੇਸ਼ ਨਹੀਂ ਕਰਦੇ, ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਦੇਰੀ ਦੇ ਰੂਪ ਵਿੱਚ ਦੇਰੀ ਦੇ ਅੱਗੇ ਭੇਜ ਸਕਦੇ ਹੋ:
# ਹੈਕਰ ਨੂੰ ਇਹ ਦੱਸਣ ਤੋਂ ਬਚਣ ਲਈ ਕਿ ਕਿਵੇਂ ਤੋੜਣਾ ਹੈ, # ਇਹ ਸਿਸਟਮ ਇੱਕ ਬਾਹਰੀ ਪਾਸਵਰਡ ਲਈ ਨਹੀਂ ਪੁੱਛਦਾ. # ਫਿਨ ਟੇਲਨੈਟ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ 5 ਸਕਿੰਟਾਂ ਦੀ ਉਡੀਕ ਕਰੋ .secure.gov ਸਲੀਪ 5 ਪਾਸਵਰਡ ਭੇਜੋ \ rexp_send ਭੇਜਣ ਲਈ ਉਪਨਾਮ ਹੈ . ਜੇ ਤੁਸੀਂ ਪ੍ਰਤੀ ਵਾਤਾਵਰਣ ਵਿਚ ਐਕਸਪੈਕਕ ਜਾਂ ਹੋਰ ਕਿਸਮ ਦੇ ਉਮੀਦਵਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਭੇਜੋ ਇੱਕ ਵੱਖਰੇ ਉਦੇਸ਼ ਲਈ ਰੁਪਏ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. exp_send ਵਾਤਾਵਰਣਾਂ ਵਿਚਕਾਰ ਅਨੁਕੂਲਤਾ ਲਈ ਦਿੱਤਾ ਗਿਆ ਹੈ ਦੂਜੀਆਂ ਆਸਾਂ ਦੇ ਹੋਰ ਭੇਜਣ ਕਮਾਂਡਾਂ ਲਈ ਮਿਲਦੀਆਂ-ਜੁਲਦੀਆਂ ਉਪਨਾਮ ਹਨ
send_error [-flags] ਸਤਰ
ਭੇਜਣ ਵਾਂਗ ਹੈ, ਇਸਦੇ ਸਿਵਾਏ ਕਿ ਆਉਟਪੁੱਟ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਦੀ ਬਜਾਏ stderr ਨੂੰ ਭੇਜੀ ਜਾਂਦੀ ਹੈ .
send_log [-] ਸਤਰ
ਭੇਜਣ ਵਾਂਗ ਹੈ, ਸਿਵਾਏ ਕਿ ਸਤਰ ਸਿਰਫ ਲਾਗ ਫਾਇਲ ਨੂੰ ਭੇਜੀ ਜਾਂਦੀ ਹੈ (ਵੇਖੋ log_file .) ਆਰਗੂਮਿੰਟ ਨੂੰ ਅਣਡਿੱਠਾ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ ਜੇ ਕੋਈ ਲਾਗ ਫਾਇਲ ਨਹੀਂ ਹੈ.
send_tty [-flags] ਸਤਰ
ਭੇਜਣ ਵਾਂਗ ਹੈ, ਇਸਦੇ ਸਿਵਾਏ ਕਿ ਆਉਟਪੁੱਟ ਨੂੰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਦੀ ਬਜਾਏ / dev / tty ਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ .
send_user [-flags] ਸਤਰ
ਭੇਜਣ ਵਾਂਗ ਹੈ, ਇਸਦੇ ਸਿਵਾਏ ਕਿ ਆਉਟਪੁੱਟ ਨੂੰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਦੀ ਬਜਾਏ stdout ਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ .
ਸਲੀਪ ਸਕਿੰਟ
ਸਕਿੰਟਾਂ ਨੂੰ ਦਿੱਤੇ ਸਕਿੰਟਾਂ ਲਈ ਸੌਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ. ਸਕਿੰਟ ਇਕ ਦਸ਼ਮਲਵ ਅੰਕ ਹੋ ਸਕਦੀਆਂ ਹਨ. ਰੁਕਾਵਟਾਂ (ਅਤੇ Tk ਦੀਆਂ ਘਟਨਾਵਾਂ ਜੇ ਤੁਸੀਂ ਐਕਸਪੈਕੈਕ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ) ਤੇ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਸਲੀਪਾਂ ਦੀ ਆਸ ਹੁੰਦੀ ਹੈ.
ਸਪੌਨ [ਆਰਗਜ਼] ਪ੍ਰੋਗਰਾਮ [ਆਰਗਜ਼]
"ਪ੍ਰੋਗ੍ਰਾਮ ਆਰਗੂਜ਼" ਨੂੰ ਚਲਾਉਣ ਵਾਲੀ ਇੱਕ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਤਿਆਰ ਕਰਦੀ ਹੈ. ਇਸ ਦੇ stdin, stdout ਅਤੇ stderr ਆਸ ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ, ਤਾਂ ਕਿ ਉਹ ਦੂਜੀਆਂ ਆਸਾਂ ਕਮਾਂਡਰਾਂ ਦੁਆਰਾ ਪੜ੍ਹ ਅਤੇ ਲਿਖ ਸਕਦੀਆਂ ਹਨ. ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਹੋ ਗਿਆ ਹੈ ਜਾਂ ਜੇ ਪ੍ਰਕਿਰਿਆ ਆਪਣੇ ਆਪ ਹੀ ਕਿਸੇ ਵੀ ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਨੂੰ ਬੰਦ ਕਰਦੀ ਹੈ
ਸਪੌਨ ਦੁਆਰਾ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਹੋਣ 'ਤੇ, ਵੇਅਰਿਏਬਲ spawn_id ਉਸ ਪ੍ਰਕਿਰਿਆ ਦਾ ਹਵਾਲਾ ਦੇਂਦੇ ਹੋਏ ਇੱਕ ਵਰਣਨ ਕਰਨ ਲਈ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ . Spawn_id ਦੁਆਰਾ ਦਰਸਾਈ ਪ੍ਰਕਿਰਿਆ ਨੂੰ "ਵਰਤਮਾਨ ਪ੍ਰਕਿਰਿਆ " ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ. spawn_id ਨੂੰ ਪੜ੍ਹਿਆ ਜਾਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਸਰਦਾਰ ਤਰੀਕੇ ਨਾਲ ਜੌਬ ਨਿਯੰਤਰਣ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ.
user_spawn_id ਇੱਕ ਵਿਆਪਕ ਵੈਰੀਐਬਲ ਹੈ ਜੋ ਕਿ ਇੱਕ ਡਿਸਕ੍ਰਿਪਟਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਯੂਜ਼ਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ spawn_id ਨੂੰ ਇਸ ਮੁੱਲ ਤੇ ਸੈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਉਮੀਦ ਹੈ ਕਿ ਉਮੀਦ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ
. Error_spawn_id ਇੱਕ ਵਿਆਪਕ ਵੈਰੀਐਬਲ ਹੈ ਜੋ ਕਿ ਇਕ ਡਿਸਕ੍ਰਿਪਟਰ ਰੱਖਦਾ ਹੈ ਜੋ ਸਟੈਂਡਰਡ ਗਲਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ spawn_id ਇਸ ਮੁੱਲ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਹੁੰਦਾ ਹੈ, send_error ਦੀ ਤਰਾਂ ਕੰਮ ਕਰੋ ਭੇਜੋ
tty_spawn_id ਇੱਕ ਵਿਆਪਕ ਵੇਰੀਏਬਲ ਹੈ ਜੋ ਇੱਕ ਵਰਣਨ ਵਾਲਾ ਹੈ, ਜੋ ਕਿ / dev / tty ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਜੇ / dev / tty ਮੌਜੂਦ ਨਹੀਂ ਹੈ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਕਰੋਨ, ਤੇ, ਜਾਂ ਬੈਚ ਲਿਪੀ ਵਿੱਚ), ਫਿਰ tty_spawn_id ਨਹੀਂ ਦਿੱਤੀ ਗਈ ਹੈ. ਇਹ ਇਸ ਤਰਾਂ ਪਰਖੇ ਜਾ ਸਕਦਾ ਹੈ:
ਜੇ {{info vars tty_spawn_id}} {# / dev / tty ਮੌਜੂਦ ਹੈ} ਹੋਰ {# / dev / tty ਮੌਜੂਦ ਨਹੀਂ ਹੈ / ਹੋ ਸਕਦਾ ਹੈ ਕਿ # ਕਰੋਨ, ਬੈਚ, ਜਾਂ ਸਕਰਿਪਟ ਵਿੱਚ)ਸਪੈਨ ਯੂਐਨਐਕਸ ਪ੍ਰਕਿਰਿਆ id ਦਿੰਦਾ ਹੈ ਜੇ ਕੋਈ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਚਲਾਈ ਜਾਂਦੀ, ਤਾਂ 0 ਵਾਪਸ ਆਉਂਦੀ ਹੈ. ਵੇਰੀਏਬਲ spawn_out (ਗੁਲਾਮ, ਨਾਮ) ਨੂੰ pty ਸਲੇਵ ਡਿਵਾਈਸ ਦੇ ਨਾਮ ਤੇ ਸੈਟ ਕੀਤਾ ਗਿਆ ਹੈ.
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਸਪੈਨ ਕਮਾਨ ਦਾ ਨਾਮ ਅਤੇ ਆਰਗੂਮਿੰਟ ਲੈਂਦੀ ਹੈ. -ਨੋoecho ਫਲੈਗ ਨੂੰ ਅਜਿਹਾ ਕਰਨ ਤੋਂ ਸਪੌਨ ਰੋਕਦਾ ਹੈ .
-ਕੋਸੋਲ ਫਲੈਗ ਨੂੰ ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਮੁੜ ਨਿਰਦੇਸ਼ਤ ਕਰਨ ਲਈ ਕੰਨਸੋਲ ਆਉਟਪੁੱਟ ਕਾਰਨ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ . ਇਹ ਸਭ ਸਿਸਟਮਾਂ ਤੇ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ.
ਅੰਦਰੂਨੀ ਰੂਪ ਵਿੱਚ, ਸਪੌਨ ਇੱਕ PTY ਵਰਤਦਾ ਹੈ, ਜਿਸਦਾ ਉਪਯੋਗਕਰਤਾ ਦੇ tty ਦੇ ਤੌਰ ਤੇ ਉਸੇ ਤਰ੍ਹਾਂ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ. ਇਹ ਅੱਗੇ ਅਰੰਭ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਸਾਰੀਆਂ ਸੈਟਿੰਗਾਂ "ਸਿਆਣਪ" ਹੋਣ (ਸਟਟੀ (1) ਅਨੁਸਾਰ). ਜੇ ਵੇਰੀਏਬਲ stty_init ਨੂੰ ਪਰਿਭਾਸ਼ਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਸਟਾਈਲ ਆਰਗੂਮੈਂਟ ਦੀ ਸ਼ੈਲੀ ਵਿੱਚ ਹੋਰ ਸੰਰਚਨਾ ਦੇ ਤੌਰ ਤੇ ਸਮਝਾਇਆ ਗਿਆ ਹੈ. ਉਦਾਹਰਨ ਲਈ, "stty_init raw ਸੈੱਟ ਕਰੋ" ਨਾਲ ਅੱਗੇ ਪੈਦਾ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਟਰਮੀਨਲ ਨੂੰ ਕੱਚਾ ਮੋਡ ਵਿੱਚ ਚਾਲੂ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣੇਗਾ. -ਨੌਟਾਈਕੌਪੀ ਉਪਭੋਗਤਾ ਦੇ tty ਤੇ ਆਧਾਰਿਤ ਅਰੰਭਿਕਤਾ ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ. -ਨੋਟਿੀਨੀਟ " ਸਾਏ " ਸ਼ੁਰੂਆਤ ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ.
ਆਮ ਤੌਰ 'ਤੇ, ਚਲਾਉਣ ਲਈ ਥੋੜ੍ਹਾ ਸਮਾਂ ਹੁੰਦਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਸਪੌਨ ਨੂੰ ਮਹੱਤਵਪੂਰਣ ਮਾਤਰਾ ਵਿਚ ਲੈਣ ਦਾ ਨੋਟਿਸ ਲਗਾਉਂਦੇ ਹੋ, ਤਾਂ ਇਹ ਸੰਭਵ ਤੌਰ 'ਤੇ ਪੀਟੀਐਸ ਦੀ ਸਾਹਮਣਾ ਕਰ ਰਿਹਾ ਹੈ ਜੋ ਵਢੇ ਹੋਏ ਹਨ. ਗਲਤ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨਾਲ ਉਲਝਣ ਤੋਂ ਬਚਣ ਲਈ ਬਹੁਤ ਸਾਰੇ ਟੈਸਟ ਪੀਟੀਆਈਸੀ ਤੇ ਚੱਲਦੇ ਹਨ. (ਇਹ 10 ਸਿਕਿਡਾਂ ਪ੍ਰਤੀ ਬੀਟਾ ਪੀਟੀ ਲਗਦਾ ਹੈ.) -d ਚੋਣ ਨਾਲ ਚੱਲਣ ਦੀ ਸੰਭਾਵਨਾ ਦਿਖਾਈ ਦੇਵੇਗੀ ਜੇ ਉਮੀਦ ਹੈ ਕਿ ਅਜੀਬ ਰਾਜਾਂ ਵਿੱਚ ਕਈ ਪੀਟੀਐਸਜ਼ ਆ ਰਹੇ ਹਨ. ਜੇ ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਨਹੀਂ ਮਾਰ ਸੱਕਦੇ ਜਿਹਨਾਂ ਨਾਲ ਇਹ ਪੀਟੀਐਸ ਜੁੜੇ ਹੋਏ ਹਨ, ਤਾਂ ਤੁਹਾਡੀ ਸਿਰਫ ਰਿਟਰਨ ਦੁਬਾਰਾ ਚਾਲੂ ਹੋ ਸਕਦੀ ਹੈ.
ਜੇ ਪ੍ਰੋਗਰਾਮ ਸਫਲਤਾਪੂਰਕ ਨਹੀਂ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ exec (2) ਫੇਲ੍ਹ ਹੋ ਜਾਂਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਜਦੋਂ ਪ੍ਰੋਗਰਾਮ ਮੌਜੂਦ ਨਹੀਂ ਹੈ), ਤਾਂ ਅਗਲਾ ਇੰਟਰੈਕਟ ਦੁਆਰਾ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਵਾਪਸ ਕੀਤਾ ਜਾਵੇਗਾ ਜਾਂ ਕਮਾਂਡ ਦੀ ਉਮੀਦ ਹੈ ਜਿਵੇਂ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ ਗਲਤੀ ਸੁਨੇਹਾ ਆਉਟਪੁੱਟ ਇਹ ਵਿਹਾਰ ਸਪੌਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਇੱਕ ਕੁਦਰਤੀ ਨਤੀਜਾ ਹੈ. ਅੰਦਰੂਨੀ ਤੌਰ ਤੇ, ਸਪੌਨ ਫਾਰਕਜ਼, ਜਿਸ ਤੋਂ ਬਾਅਦ ਸਪੌਨ_ਆਈਡੀ ਦੁਆਰਾ ਸੰਚਾਰ ਦੁਆਰਾ ਸਿਵਾਏ ਅਸਲੀ ਉਮੀਦ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੁੰਦਾ ਹੈ.
-ਪੈਨ ਝੰਡੇ ਅਗਲੇ ਦਲੀਲ ਨੂੰ ਇੱਕ Tcl ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਦੇ ਤੌਰ ਤੇ ਅਰਥ ਕੱਢੇ ਜਾਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ (ਅਰਥਾਤ, ਖੁੱਲ ਕੇ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ .) ਸਪੌਨ id ਨੂੰ ਫਿਰ ਇਸ ਤਰ੍ਹਾਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਇਹ ਸਪੱਸ਼ਟ ਪ੍ਰਕਿਰਿਆ ਸੀ . (ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਨੂੰ ਹੁਣ ਵਰਤੀ ਨਹੀਂ ਜਾਣੀ ਚਾਹੀਦੀ.) ਇਸ ਨਾਲ ਤੁਹਾਨੂੰ ਕੱਚੇ ਜੰਤਰ, ਫਾਇਲਾਂ ਅਤੇ ਪਾਈਪਲਾਈਨਾਂ ਦਾ ਇਸਤੇਮਾਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਜੋ ਕਿ pty ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਗੈਰ ਪੈਦਾ ਹੋਈ ਕਾਰਜ ਹਨ. 0 ਨੂੰ ਵਾਪਸ ਭੇਜਣ ਲਈ ਦਰਸਾਇਆ ਗਿਆ ਹੈ ਕਿ ਕੋਈ ਵੀ ਸੰਬੰਧਿਤ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਹੈ ਜਦੋਂ ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਵੀ Tcl ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਹੈ. -ਲਾਵਓਪੈਨ ਫਲੈਗ, ਇਸ ਤੋਂ ਇਲਾਵਾ ਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਇਸ ਤੋਂ ਇਲਾਵਾ- ਲੇਵੀਓਪਨ ਕਾਰਨ ਬਣਦਾ ਹੈ ਕਿ ਫੌਨ ਆਈਡੀ ਬੰਦ ਹੋਣ ਤੋਂ ਬਾਅਦ ਵੀ ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ.
ਖਾਲੀ ਫਲੈਗ ਨੂੰ ਇੱਕ pty ਖੋਲ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ ਪਰ ਕੋਈ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਉਤਪੰਨ ਹੋਈ. 0 ਨੂੰ ਵਾਪਸ ਭੇਜਣ ਲਈ ਦਰਸਾਇਆ ਗਿਆ ਹੈ ਕਿ ਕੋਈ ਵੀ ਸੰਬੰਧਿਤ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਹੈ Spawn_id ਨੂੰ ਆਮ ਵਾਂਗ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ
ਵੇਰੀਏਬਲ spawn_out (ਗੁਲਾਬੀ, ਐਫ ਡੀ) pty slave ਨਾਲ ਸੰਬੰਧਿਤ ਫਾਇਲ ਪਛਾਣਕਰਤਾ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ. ਇਸਨੂੰ "ਨੇੜੇ-ਸਲੇਵ" ਵਰਤ ਕੇ ਬੰਦ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ
ਗਾਇਕ ਪ੍ਰੌਕਸੀ ਵਿੱਚ ਅਣਗਹਿਲੀ ਕੀਤੇ ਜਾਣ ਲਈ ਇੱਕ ਸੰਕੇਤ ਦਾ ਨਾਮ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ . ਨਹੀਂ ਤਾਂ, ਸਿਗਨਲਾਂ ਨੂੰ ਡਿਫੌਲਟ ਵਿਵਹਾਰ ਪ੍ਰਾਪਤ ਹੋਵੇਗਾ ਸਿਗਨਲਾਂ ਨੂੰ ਟਰੈਪ ਕਮਾਂਡ ਵਿੱਚ ਨਾਮ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਸਿਵਾਏ ਕਿ ਹਰੇਕ ਸੰਕੇਤ ਲਈ ਇੱਕ ਅਲੱਗ ਝੰਡੇ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ.
ਸਟਰੇਸ ਲੈਵਲ
ਹੇਠ ਲਿਖੇ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਛਾਪਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ. (Tcl ਦਾ ਟ੍ਰੇਸ ਕਮਾਂਡਰ ਵੇਰੀਏਬਲ ਟਰੇਸ ਕਰਦਾ ਹੈ.) ਪੱਧਰ ਦੱਸਦਾ ਹੈ ਕਿ ਕਾਲ ਸਟੈਕ ਵਿਚ ਟਰੇਸ ਕਿੰਨੀ ਦੂਰ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡ ਕਾਲਾਂ ਦੇ ਪਹਿਲੇ 4 ਸਤਰਾਂ ਦੀ ਟਰੇਸਿੰਗ ਕਰਦੇ ਸਮੇਂ ਆਸ ਕਰਦਾ ਹੈ, ਪਰ ਇਸ ਤੋਂ ਥੱਲੇ ਕੋਈ ਨਹੀਂ.
-ਇੰਫੋ ਫਲੈਗ ਸਟਰੈਸ ਨੂੰ ਦਿੱਤੇ ਗਏ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਗੈਰ-ਜਾਣਕਾਰੀ ਦਲੀਲਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਕਾਰਨ ਦਿੰਦਾ ਹੈ.
ਸਟਟੀ ਆਰਗਜ਼
ਬਾਹਰੀ ਸਟਿੱਟ ਕਮਾਂਡ ਦੇ ਨਾਲ ਹੀ ਟਰਮੀਨਲ ਢੰਗ ਬਦਲਦਾ ਹੈ.
ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ, ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ ਤੇ ਪਹੁੰਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਹੋਰ ਟਰਮੀਨਲਜ਼ ਨੂੰ "ਕਮਾਂਡ ਲਈ ਪਰਿਵਰਤਨ ਲਈ ਦਰਖਾਸਤ ਦੇ ਕੇ ਬੇਨਤੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ: ਜੇਕਰ ਕੋਈ ਸਥਿਤੀ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਅਤੇ ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ ਨੂੰ ਐਕਸੈਸ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਕੱਚਾ ਅਤੇ ਈਕੋ ਗੁਣਾਂ ਦੀ ਪਿਛਲੀ ਸਥਿਤੀ ਨੂੰ ਉਸੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਬਾਅਦ ਵਿੱਚ ਹੋ ਸਕਦਾ ਹੈ ਹੁਕਮ ਦੁਆਰਾ ਵਰਤਿਆ
ਉਦਾਹਰਨ ਲਈ, ਆਰਗੂਮੈਂਟ ਆਰਜ਼ੀ ਜਾਂ ਟੋਕਰੀ ਨੂੰ ਟਰਮੀਨਲ ਨੂੰ ਕੱਚਾ ਮੋਡ ਵਿੱਚ ਪਾਓ. ਆਰਗੂਮਿੰਟ - ਪਕਾਏ ਹੋਏ ਪਕਾਏ ਹੋਏ ਵਿਧੀ ਨੂੰ ਟਰਮੀਨਲ ਵਿੱਚ ਪਾਓ. ਆਰਗੂਮੈਂਟ ਗੂੰਜ ਅਤੇ -echo ਟਰਮੀਨਲ ਨੂੰ ਕ੍ਰਮਵਾਰ echo ਅਤੇ noecho ਮੋਡ ਵਿੱਚ ਪਾਓ
ਨਿਮਨਲਿਖਤ ਉਦਾਹਰਨ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ਪ੍ਰਤੀਬਿੰਬ ਨੂੰ ਅਸਥਾਈ ਰੂਪ ਵਿੱਚ ਅਯੋਗ ਕਰਨਾ ਹੈ ਇਨ੍ਹਾਂ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਏਮਬੈਡਿੰਗ ਪਾਸਵਰਡ ਤੋਂ ਬਚਾਉਣ ਲਈ ਇਸ ਨੂੰ ਹੋਰ-ਆਟੋਮੈਟਿਕ ਸਕਰਿਪਟਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. (ਹੇਠ ਛਪਾਈ ਦੀਆਂ ਆਸਾਂ ਹੇਠ ਇਸ ਬਾਰੇ ਵਧੇਰੇ ਚਰਚਾ ਦੇਖੋ.)
stty -echo send_user "ਪਾਸਵਰਡ:" expect_user -re "(. *) \ n" ਪਾਸਵਰਡ ਸੈੱਟ ਕਰੋ $ expect_out (1, ਸਤਰ) stty echo ਸਿਸਟਮ ਆਰਗੂਮਜ਼
ਆਰਗੂਜੇਸ਼ਨ ਨੂੰ sh (1) ਇੰਪੁੱਟ ਦੇ ਤੌਰ ਤੇ ਦਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਹ ਟਰਮੀਨਲ ਤੋਂ ਇੱਕ ਕਮਾਂਡ ਦੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਹੈ. ਜਦੋਂ ਤੱਕ ਸ਼ੈੱਲ ਬੰਦ ਨਹੀਂ ਹੁੰਦਾ, ਉਦੋਂ ਤੱਕ ਉਡੀਕ ਨਹੀਂ ਕਰਦਾ Sh ਤੋਂ ਵਾਪਸੀ ਦੀ ਸਿਥਤੀ ਉਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜੋ exec ਆਪਣੀ ਰਿਟਰਨ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ.
Exec ਦੇ ਉਲਟ, ਜੋ stdin ਅਤੇ stdout ਨੂੰ ਸਕਰਿਪਟ ਵਿੱਚ ਰੀਡਾਇਰੈਕਟ ਕਰਦਾ ਹੈ, ਸਿਸਟਮ ਕੋਈ ਰੀਡਾਇਰੈਕਸ਼ਨ (ਸਟਰਿੰਗ ਦੁਆਰਾ ਦਰਸਾਏ ਗਏ ਦੂਜੇ ਤੋਂ ਇਲਾਵਾ) ਨਹੀਂ ਕਰਦਾ ਹੈ. ਇਸ ਲਈ, ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਵਰਤਣਾ ਸੰਭਵ ਹੈ ਜੋ ਸਿੱਧੇ ਤੌਰ ਤੇ / dev / tty ਤੇ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ. ਇਸੇ ਕਾਰਨ ਕਰਕੇ, ਸਿਸਟਮ ਦੇ ਨਤੀਜੇ ਲਾਗ ਵਿਚ ਨਹੀਂ ਰਿਕਾਰਡ ਕੀਤੇ ਜਾਂਦੇ ਹਨ.
ਟਾਈਮਸਟੈਂਪ [ਆਰਗਜ਼]
ਇੱਕ ਟਾਈਮਸਟੈਂਪ ਵਾਪਸ ਕਰਦਾ ਹੈ ਕੋਈ ਆਰਗੂਮਿੰਟ ਨਹੀਂ, ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਆਉਂਦੀ ਹੈ.
-ਫਾਰਮੈਟ ਫਲੈਗ ਇੱਕ ਸਤਰ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਦਾ ਹੈ ਜੋ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਪਰ ਪੋਰਟਫੋਸਟ ਦੇ ਨਿਯਮਾਂ ਅਨੁਸਾਰ ਅੰਤਰਰਾਸ਼ਟਰੀਕਰਨ ਅਨੁਸਾਰ ਅੰਤਰਰਾਸ਼ਟਰੀਕਰਨ . ਉਦਾਹਰਨ ਲਈ,% a ਨੂੰ ਇੱਕ ਸੰਖੇਪ ਦਿਨ ਦਾ ਨਾਮ (ਅਰਥਾਤ, ਸਤਿ) ਨਾਲ ਤਬਦੀਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਹੋਰ ਹਨ:
% ਇੱਕ ਛੋਟਾ ਕਾਰਜ ਦਿਵਸ ਦਾ ਨਾਮ% ਇੱਕ ਪੂਰਾ ਹਫਤੇ ਦਾ ਦਿਨ ਦਾ ਨਾਮ% b ਸੰਖੇਪ ਮਹੀਨੇ ਦਾ ਨਾਮ% ਬੀ ਪੂਰਾ ਮਹੀਨਾ ਦਾ ਨਾਮ% c ਤਾਰੀਖ ਸਮਾਂ ਜਿਵੇਂ ਕਿ: ਬੁੱਧਵਾਰ 6 ਅਕਤੂਬਰ 11:45:56 1993% ਦਿਨ ਦੇ ਡੀ ਦਿਨ (01-31% ਘੰਟਾ (00-23)% I ਘੰਟਾ (01-12)% ਜੀ ਦਿਨ (001-366)% ਮਹੀਨਾ ਮਹੀਨਾ (01-12)% ਮਿੰਟ (00-59)% ਪ ਸਵੇਰਾਂ ਜਾਂ ਪਾਮ% ਸਕਿੰਟ ਦੂਜਾ (00-61) % u ਦਿਨ (1-7, ਸੋਮਵਾਰ ਹਫ਼ਤੇ ਦਾ ਪਹਿਲਾ ਦਿਨ ਹੈ)% ਯੂ ਹਫ਼ਤੇ (00-53, ਪਹਿਲਾ ਐਤਵਾਰ ਹਫ਼ਤੇ ਦਾ ਪਹਿਲਾ ਦਿਨ)% V ਹਫਤਾ (01-53, ISO 8601 ਸ਼ੈਲੀ)% w ਦਿਨ (0- 6)% W ਹਫਤਾ (00-53, ਪਹਿਲੇ ਸੋਮਵਾਰ ਇੱਕ ਹਫ਼ਤੇ ਦਾ ਪਹਿਲਾ ਦਿਨ ਹੈ)% x ਤਾਰੀਖ ਸਮਾਂ ਜਿਵੇਂ ਕਿ: ਬੁੱਧਵਾਰ ਅਕਤੂਬਰ 6 1993%: 23: 59: 59% ਸਾਲ ਦੇ ਰੂਪ ਵਿੱਚ ਸਾਲ (00-99) % Y ਸਾਲ ਦੇ ਰੂਪ ਵਿੱਚ: 1993% Z ਸਮਾਂ ਜ਼ੋਨ (ਜਾਂ ਜੇ ਨਿਰਧਾਰਨਯੋਗ ਨਹੀਂ ਹੈ) %% ਬੇਅਰ ਪ੍ਰਤੀਸ਼ਤ ਚਿੰਨ੍ਹਹੋਰ% ਨਿਰਧਾਰਨ ਅਣਪਛਾਰੇ ਹਨ. ਹੋਰ ਅੱਖਰ ਨੂੰ ਛੇੜਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਸਿਰਫ਼ ਸੀ ਲੋਕਲੇ ਸਮਰਥਿਤ ਹੈ.
-ਸੈਕੰਡਜ਼ ਝੰਡੇ ਕਈ ਸਕਿੰਟਾਂ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਯੁਗ ਨੂੰ ਸਰੋਤ ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਜਾ ਰਿਹਾ ਹੈ ਜਿਸ ਤੋਂ ਫਾਰਮੈਟ ਕਰਨਾ ਹੈ. ਨਹੀਂ ਤਾਂ ਮੌਜੂਦਾ ਸਮਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ.
-Gmt ਝੰਡਾ GMT ਟਾਈਮਜ਼ੋਨ ਨੂੰ ਵਰਤਣ ਲਈ ਟਾਈਮਸਟੈਪ ਆਉਟਪੁੱਟ ਨੂੰ ਬਲ ਦਿੰਦਾ ਹੈ. ਕੋਈ ਝੰਡੇ ਦੇ ਨਾਲ, ਸਥਾਨਕ ਟਾਈਮਜ਼ੋਨ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ
ਫੰਕਸ਼ਨ [[ਕਮਾਂਡ] ਸਿਗਨਲਾਂ]
ਕਿਸੇ ਦਿੱਤੇ ਸਿਗਨਲਾਂ ਦੀ ਭਵਿੱਖ ਦੀ ਰਸੀਦ ਉੱਤੇ ਦਿੱਤੀ ਗਈ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣ ਦਾ ਕਾਰਨ ਬਣਦੀ ਹੈ ਇਹ ਹੁਕਮ ਸੰਸਾਰਕ ਖੇਤਰ ਵਿੱਚ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ. ਜੇ ਕਮਾਂਡ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਤਾਂ ਸਿਗਨਲ ਕਾਰਵਾਈ ਵਾਪਸ ਕੀਤੀ ਗਈ ਹੈ. ਜੇ ਕਮਾਂਡ ਸਤਰ SIG_IGN ਹੈ, ਤਾਂ ਸਿਗਨਲਾਂ ਨੂੰ ਅਣਡਿੱਠਾ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਜੇ ਕਮਾਂਡ SIG_DFL ਸਤਰ ਹੈ, ਤਾਂ ਸਿਗਨਲ ਸਿਸਟਮ ਮੂਲ ਰੂਪ ਵਿੱਚ ਹੁੰਦਾ ਹੈ. ਸੰਕੇਤ ਜਾਂ ਤਾਂ ਇੱਕ ਸਿੰਗਲ ਸਿਗਨਲ ਜਾਂ ਸਿਗਨਲਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ. ਸੰਕੇਤ ਸੰਕੇਤ ਦੇ ਅਨੁਸਾਰ ਸੰਕੇਤਕ ਤੌਰ 'ਤੇ ਸੰਕੇਤਕ ਜਾਂ ਸੰਕੇਤਕ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ (3). "SIG" ਪ੍ਰੀਫਿਕਸ ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ.
ਕੋਈ ਆਰਗੂਮੈਂਟ (ਜਾਂ ਆਰਗੂਮੈਂਟ-ਨੰਬਰ) ਦੇ ਨਾਲ, ਫਰੇਮ ਫੜੇ ਜਾਣ ਵਾਲੇ ਸਪੈਮ ਕਮਾਂਡ ਦੀ ਸਿਗਨਲ ਨੰਬਰ ਦਿੰਦਾ ਹੈ.
-ਕੋਡ ਫਲੈਗ ਕਮਾਂਡ ਦੀ ਰਿਟਰਨ ਕੋਡ ਵਰਤਦਾ ਹੈ ਜੋ ਕਿ ਕਮਾਂਡ ਦੇ ਸ਼ੁਰੂ ਵਿਚ ਚੱਲਣ ਦੇ ਸਮੇਂ ਸੀ.ਐੱਮ.ਏ.
-nterp ਫਲੈਗ ਜਦੋਂ ਘੋਸ਼ਣਾ ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੀ ਗਈ ਸੀ, ਉਦੋਂ ਤੋਂ ਕਮਾਂਡ ਦੀ ਸ਼ੁਰੂਆਤ ਸਮੇਂ ਉਸ ਸਮੇਂ ਕਿਰਿਆਸ਼ੀਲ ਇੰਟਰਪ੍ਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਹੁਕਮ ਦੀ ਘੋਖ ਕਰਦੇ ਹਨ.
-name ਫਲੈਗ ਫਾਸਟ ਕਮਾਂਡ ਨੂੰ ਫੜੇ ਜਾਣ ਵਾਲੇ ਗੁਪਤ ਹੁਕਮ ਦੇ ਸਿਗਨਲ ਨਾਮ ਨੂੰ ਵਾਪਸ ਕਰਨ ਦੇ ਕਾਰਨ ਬਣਦੀ ਹੈ.
-ਮੈਕਸ ਫਲੈਗ ਸਭ ਤੋਂ ਵੱਡੇ ਸੰਕੇਤ ਨੰਬਰ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ trap ਕਮਾਂਡ ਨੂੰ ਕਾਰਨ ਦਿੰਦਾ ਹੈ ਜੋ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.
ਉਦਾਹਰਨ ਲਈ, "ਫਾੱਪ {send_user" Ouch! "} SIGINT" "Ouch!" ਛਾਪੇਗਾ ਹਰ ਵਾਰ ਜਦੋਂ ਯੂਜ਼ਰ ਦਬਾਉਂਦਾ ਹੈ ^ ਸੀ.
ਮੂਲ ਰੂਪ ਵਿੱਚ, SIGINT (ਜੋ ਆਮ ਤੌਰ 'ਤੇ ^ C ਦਬਾ ਕੇ ਤਿਆਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ) ਅਤੇ SIGTERM ਕਾਰਨ ਬਾਹਰ ਜਾਣ ਦੀ ਸੰਭਾਵਨਾ. ਇਹ ਹੇਠ ਦਿੱਤੇ ਜਾਲ ਦੇ ਕਾਰਨ ਹੈ, ਜਦੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਤਾਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ.
ਫਾਸਟ ਨਿਕਾਸ {SIGINT SIGTERM}ਜੇ ਤੁਸੀਂ ਡੀ-ਝੰਡਾ ਨੂੰ ਡੀਬਗਰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਵਰਤਦੇ ਹੋ, ਤਾਂ SIGINT ਪਰਿਭਾਸ਼ਿਤ ਡੀਬੱਗਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਪ੍ਰਭਾਸ਼ਿਤ ਹੁੰਦਾ ਹੈ. ਇਹ ਹੇਠ ਦਰਜ ਜਾਲਾਂ ਕਾਰਨ ਹੁੰਦਾ ਹੈ:
trap {exp_debug 1} SIGINTਡੀਬੱਗਰ ਫਾਸਰ ਨੂੰ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲ EXPECT_DEBUG_INIT ਨੂੰ ਇੱਕ ਨਵੇਂ ਜਾਲ ਕਮਾਂਡ ਵਿੱਚ ਸੈਟ ਕਰਕੇ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ.
ਬੇਸ਼ਕ, ਤੁਸੀਂ ਆਪਣੀ ਸਕਰਿਪਟ ਵਿੱਚ ਫਾਸਫ ਕਮਾਂਡਾਂ ਜੋੜ ਕੇ ਇਹ ਦੋਨਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦੇ ਹੋ. ਖਾਸ ਤੌਰ ਤੇ, ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਆਪਣਾ "ਫਲਾਇਟ ਐਗਜ਼ੁਟ SIGINT" ਹੈ, ਤਾਂ ਇਹ ਡਿਬਬਗਰ ਫੜ ਨੂੰ ਅਣਡਿੱਠਾ ਕਰ ਦੇਵੇਗਾ. ਇਹ ਫਾਇਦੇਮੰਦ ਹੈ ਜੇ ਤੁਸੀਂ ਉਪਭੋਗੀਆਂ ਨੂੰ ਡੀਬੱਗਰ ਤੋਂ ਬਿਲਕੁਲ ਨਹੀਂ ਬਚਣਾ ਚਾਹੁੰਦੇ.
ਜੇ ਤੁਸੀਂ SIGINT ਤੇ ਆਪਣਾ ਫਾਲਣਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਪਰ ਫਿਰ ਵੀ ਚੱਲ ਰਹੇ ਸਮੇਂ ਡੀਬਗਰ ਨੂੰ ਫੜ ਸਕਦੇ ਹੋ, ਤਾਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ:
ਜੇ {! [exp_debug]} {ਫਸਟ ਮਾਇਸਟਫੁੱਫ SIGINT}ਇਸ ਤੋਂ ਉਲਟ, ਤੁਸੀਂ ਕੁਝ ਹੋਰ ਸਿਗਨਲ ਵਰਤ ਕੇ ਡੀਬੱਗਰ ਨੂੰ ਫੜ ਸਕਦੇ ਹੋ.
ਫੈਂਪ ਤੁਹਾਨੂੰ SIGALRM ਲਈ ਕਿਰਿਆ ਨੂੰ ਓਵਰਰਾਈਡ ਨਹੀਂ ਕਰਨ ਦੇਵੇਗਾ ਕਿਉਂਕਿ ਇਹ ਆਸ ਲਈ ਅੰਦਰੂਨੀ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. ਡਿਸਕਨੈਕਟ ਕਮਾਂਡ SIGALRM ਨੂੰ SIG_IGN (ਅਣਡਿੱਠਾ) ਤੇ ਸੈੱਟ ਕਰਦੀ ਹੈ. ਤੁਸੀਂ ਉਦੋਂ ਤੱਕ ਇਸ ਨੂੰ ਮੁੜ ਸਮਰੱਥ ਬਣਾ ਸਕਦੇ ਹੋ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਅਗਲੀ ਸਪੌਨ ਕਮਾਂਡਾਂ ਦੇ ਦੌਰਾਨ ਇਸਨੂੰ ਅਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹੋ.
ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ ਸਿਗਨਲ ਵੇਖੋ (3)
ਉਡੀਕ ਕਰੋ [ਆਰਗਜ਼]
ਇੱਕ ਅਰਜਿਤ ਪ੍ਰਕਿਰਿਆ (ਜਾਂ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ, ਜੇ ਕੋਈ ਵੀ ਨਾ ਹੋਵੇ) ਦੇਰੀ ਹੋਣ ਤੱਕ ਦੇਰੀ ਸਮਾਪਤ ਹੋ ਜਾਂਦੀ ਹੈ
ਆਮ ਤੌਰ 'ਤੇ ਚਾਰ ਪੂਰਨ ਅੰਕ ਸੂਚੀ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ. ਪਹਿਲੀ ਪੂਰਨ ਅੰਕ ਪ੍ਰਕਿਰਿਆ ਦਾ ਪੇਜ ਹੈ ਜਿਸਦੀ ਉਡੀਕ ਕੀਤੀ ਗਈ ਸੀ ਦੂਜਾ ਪੂਰਨ ਅੰਕ ਅਨੁਸਾਰੀ ਸਪਾਨ ਆਈਡੀ ਹੈ ਤੀਜੀ ਪੂਰਨ ਅੰਕ -1 ਹੈ ਜੇਕਰ ਇੱਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਗਲਤੀ ਆਈ ਹੈ, ਜਾਂ 0 ਹੋਰ ਹੈ. ਜੇ ਤੀਜੀ ਪੂਰਨ ਅੰਕ 0 ਹੈ, ਤਾਂ ਚੌਥੀ ਪੂਰਨ ਅੰਕ ਸਪਾਉਟ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਵਾਪਸ ਪ੍ਰਾਪਤ ਕੀਤੀ ਸਥਿਤੀ ਹੈ . ਜੇ ਤੀਜਾ ਪੂਰਨ ਅੰਕ -1 ਸੀ, ਤਾਂ ਚੌਥੀ ਪੂਰਨ ਅੰਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੁਆਰਾ ਨਿਰਧਾਰਤ errno ਦੇ ਮੁੱਲ ਦਾ ਹੁੰਦਾ ਹੈ. ਗਲੋਬਲ ਵੇਰੀਏਬਲ ਗਲਤੀਕੋਡ ਵੀ ਸੈਟ ਹੈ.
ਉਡੀਕ ਤੋਂ ਆਉਣ ਵਾਲੇ ਮੁੱਲ ਦੇ ਅੰਤ 'ਤੇ ਅਤਿਰਿਕਤ ਤੱਤ ਪ੍ਰਗਟ ਹੋ ਸਕਦੇ ਹਨ. ਇੱਕ ਵਿਕਲਪਕ ਪੰਜਵੀਂ ਤੱਤ ਜਾਣਕਾਰੀ ਦੇ ਇੱਕ ਵਰਗ ਦੀ ਪਛਾਣ ਕਰਦਾ ਹੈ. ਵਰਤਮਾਨ ਵਿੱਚ, ਇਸ ਤੱਤ ਦੇ ਲਈ ਇਕੋ-ਇਕ ਸੰਭਵ ਮੁੱਲ ਚਿਲਡਕੇਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਸਥਿਤੀ ਵਿਚ ਅਗਲੇ ਦੋ ਮੁੱਲ ਸੀ-ਸਟਾਈਲ ਸਿਗਨਲ ਨਾਮ ਅਤੇ ਇੱਕ ਛੋਟੇ ਪਾਠ ਦਾ ਵਰਣਨ ਹੈ.
-i ਫਲੈਗ ਨਾਮ ਦੀ spawn_id (ਨਾ ਕਿ ਪ੍ਰਕਿਰਿਆ id) ਦੀ ਅਨੁਸਾਰੀ ਉਡੀਕ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਘੋਸ਼ਣਾ ਕਰਦਾ ਹੈ. ਇੱਕ SIGCHLD ਹੈਂਡਲਰ ਦੇ ਅੰਦਰ, spawn id-1 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਵੀ ਸਪੰਜ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਉਡੀਕ ਕਰਨਾ ਸੰਭਵ ਹੈ.
-ਸੋਚ ਝੰਡਾ ਇੱਕ ਸਫਲ ਉਡੀਕ ਦੇ ਸੰਕੇਤ ਦੇ ਨਾਲ ਤੁਰੰਤ ਵਾਪਸ ਆਉਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ ਜਦੋਂ ਪ੍ਰਕਿਰਿਆ ਖ਼ਤਮ ਹੋ ਜਾਂਦੀ ਹੈ (ਬਾਅਦ ਵਿੱਚ), ਤਾਂ ਇਹ ਇੱਕ ਸਪਸ਼ਟ ਉਡੀਕ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਆਪਣੇ-ਆਪ ਖ਼ਤਮ ਹੋ ਜਾਵੇਗਾ.
ਉਡੀਕ ਕਮਾਂਡ ਨੂੰ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ "-i -1" ਆਰਗੂਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫੋਰਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਉਡੀਕ ਕਰੋ. ਸਪਾਂਡ ਪ੍ਰਕਿਰਿਆ ਦੇ ਨਾਲ ਇਸਦੀ ਵਰਤੋਂ ਤੋਂ ਉਲਟ, ਇਹ ਕਮਾਂਡ ਕਿਸੇ ਵੀ ਸਮੇਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ. ਇਸ ਪ੍ਰਕਿਰਿਆ ਦਾ ਫ਼ਸਲ ਵੱਢਣ 'ਤੇ ਕੋਈ ਨਿਯੰਤਰਣ ਨਹੀਂ ਹੈ. ਹਾਲਾਂਕਿ, ਵਾਪਸੀ ਮੁੱਲ ਦੀ ਪ੍ਰਕਿਰਿਆ ID ਲਈ ਜਾਂਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ.
ਲਿਬਰੀਆਂ
ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਉਮੀਦ ਲਈ ਦੋ ਬਿਲਟ-ਇਨ ਲਾਇਬ੍ਰੇਰੀਆਂ ਬਾਰੇ ਆਟੋਮੈਟਿਕ ਹੀ ਜਾਣਦਾ ਹੈ. ਇਹਨਾਂ ਨੂੰ ਪਰਿਵਰਤਨਾਂ exp_library ਅਤੇ exp_exec_library ਵਿੱਚ ਨਾਮਜ਼ਦ ਡਾਇਰੈਕਟਰੀਆਂ ਦੁਆਰਾ ਪ੍ਰਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ. ਦੋਵੇਂ ਹੀ ਉਪਯੋਗਤਾ ਫਾਇਲਾਂ ਰੱਖਣੀਆਂ ਹਨ ਜਿਹੜੀਆਂ ਹੋਰ ਸਕਰਿਪਟਾਂ ਦੁਆਰਾ ਵਰਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ.
exp_library ਵਿੱਚ ਆਰਕੀਟੈਕਚਰ-ਸੁਤੰਤਰ ਫਾਇਲ ਸ਼ਾਮਿਲ ਹਨ exp_exec_ ਲਾਇਬਰੇਰੀ ਵਿੱਚ ਢਾਂਚਾ-ਨਿਰਭਰ ਫਾਇਲਾਂ ਸ਼ਾਮਿਲ ਹਨ ਤੁਹਾਡੇ ਸਿਸਟਮ ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਦੋਵੇਂ ਡਾਇਰੈਕਟਰੀਆਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਖਾਲੀ ਹੋ ਸਕਦੀਆਂ ਹਨ. $ Exp_exec_library / cat-buffers ਫਾਇਲ ਦੀ ਮੌਜੂਦਗੀ ਦੱਸਦੀ ਹੈ ਕਿ ਕੀ ਤੁਹਾਡਾ / bin / cat ਮੂਲ ਰੂਪ ਵਿੱਚ ਬਫਰ ਹੈ.
PRETY-PRINTING
ਇੱਕ vgrind ਪਰਿਭਾਸ਼ਾ ਪਰੈਟੀ-ਪ੍ਰਿੰਟਿੰਗ ਅਕਾਊਂਟ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਉਪਲਬਧ ਹੈ. ਅੰਦਾਜ਼ਾ ਵੰਡ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ vgrind ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਥਾਪਿਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤੁਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰਾਂ ਵਰਤ ਸਕਦੇ ਹੋ:
vgrind -lexpect ਫਾਇਲEXAMPLES
ਇਹ ਬਹੁਤ ਸਾਰੇ ਨਹੀਂ ਦੱਸਦੇ ਕਿ ਸਭ ਕੁਝ ਇਕਸੁਰਤਾ ਨਾਲ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ ਜਿਸ ਬਾਰੇ ਮੈਨ ਪੰਨੇ ਨੇ ਬਿਆਨ ਕੀਤਾ ਹੈ. ਮੈਂ ਤੁਹਾਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਉਤਸ਼ਾਹਤ ਕਰਦਾ ਹਾਂ ਅਤੇ ਉਮੀਦ ਹੈ ਕਿ ਅੰਦਾਜ਼ਾ ਵੰਡ ਦੀ ਉਦਾਹਰਨ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਉਦਾਹਰਨਾਂ ਨੂੰ ਅਜ਼ਮਾਓ. ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕੁਝ ਅਸਲ ਪ੍ਰੋਗਰਾਮ ਹਨ. ਦੂਜੀਆਂ ਕੁੱਝ ਤਕਨੀਕਾਂ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਹਨ, ਅਤੇ ਬੇਸ਼ਕ, ਇੱਕ ਜੋੜਾ ਹੁਣ ਕੇਵਲ ਹੈੱਟਾਂ ਹਨ. INSTALL ਫਾਈਲ ਵਿੱਚ ਇਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਹੈ.
ਅਜ਼ਮੇ ਕਾਗਜ਼ਾਂ (ਵੇਖੋ ਵੀ ਦੇਖੋ) ਵੀ ਲਾਭਦਾਇਕ ਹਨ. ਜਦੋਂ ਕਿ ਕੁਝ ਕਾਗਜ਼ਾਂ ਨੂੰ ਪੂਰਵ ਆਸ ਦੇ ਪਿਛਲੇ ਵਰਜਨ ਨਾਲ ਸੰਬੰਧਿਤ ਸਿੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ, ਪਰੰਤੂ ਨਾਲ ਜੁੜੇ ਰਣਨੀਤੀਆਂ ਅਜੇ ਵੀ ਯੋਗ ਹਨ ਅਤੇ ਇਸ ਮੈਨ ਪੇਜ ਤੋਂ ਵਧੇਰੇ ਵੇਰਵੇ ਵਿੱਚ ਜਾਣਗੀਆਂ.
ਕਵੇਟਾਂ
ਐਕਸਟੈਂਸ਼ਨਾਂ ਦੀ ਆਸ ਅੰਦਾਜ਼ੀ ਦੇ ਨਾਮਾਂ ਦੇ ਨਾਲ ਹੋ ਸਕਦੀ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਭੇਜੋ ਇੱਕ ਵੱਖਰੇ ਉਦੇਸ਼ ਲਈ Tk ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ. ਇਸ ਕਾਰਨ ਕਰਕੇ, ਬਹੁਤੇ Expect ਕਮਾਂਡਜ਼ ਵੀ "exp_XXXX" ਦੇ ਤੌਰ ਤੇ ਉਪਲਬਧ ਹਨ. "ਐਕਸਪ੍ਰੈਸ", "ਇੰਟਰ", "ਸਪੌਨ" ਅਤੇ "ਟਾਈਮਆਉਟ" ਤੋਂ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲ਼ੇ ਅਤੇ ਪਰਿਵਰਤਨ ਦੇ ਉਪਨਾਮ ਉਪਨਾਮ ਨਹੀਂ ਹਨ. ਜੇਕਰ ਤੁਹਾਨੂੰ ਵਾਤਾਵਰਣਾਂ ਵਿਚਕਾਰ ਇਸ ਅਨੁਕੂਲਤਾ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਵਿਸਥਾਰਿਤ ਕਮਾਂਡਾਂ ਦਾ ਉਪਯੋਗ ਕਰੋ.
ਉਮੀਦ ਹੈ ਕਿ ਸਕੌਪਿੰਗ ਦੇ ਇੱਕ ਬਜਾਏ ਖੁੱਲ੍ਹੇ ਦ੍ਰਿਸ਼ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ, ਸੰਭਾਵਿਤ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਆਦੇਸ਼ਾਂ ਦੁਆਰਾ ਪੜਿਆ ਗਏ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਸਥਾਨਕ ਸਕੋਪ ਤੋਂ ਪਹਿਲੀ ਮੰਗ ਕੀਤੀ ਜਾਵੇਗੀ, ਅਤੇ ਜੇ ਇਹ ਨਹੀਂ ਮਿਲੇ ਤਾਂ, ਵਿਸ਼ਵਵਿਆਪੀ ਖੇਤਰ ਵਿੱਚ. ਉਦਾਹਰਨ ਲਈ, ਇਹ ਤੁਹਾਨੂੰ ਲਿਖਣ ਵਾਲੀ ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ "ਗਲੋਬਲ ਟਾਈਮਆਉਟ" ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਜੋ ਉਮੀਦ ਕਰਦਾ ਹੈ ਕਿ ਉਪਯੋਗਾਂ ਦੀ ਵਰਤੋਂ ਹੁੰਦੀ ਹੈ ਦੂਜੇ ਪਾਸੇ, ਲਿਖੇ ਗਏ ਵੇਰੀਏਬਲ ਹਮੇਸ਼ਾ ਸਥਾਨਕ ਖੇਤਰ (ਹਮੇਸ਼ਾ "ਗਲੋਬਲ" ਕਮਾਂਡ ਜਾਰੀ ਕੀਤੇ ਗਏ ਹਨ) ਵਿਚ ਹੁੰਦੇ ਹਨ. ਇਹ ਸਭ ਤੋਂ ਆਮ ਸਮੱਸਿਆ ਇਹ ਹੈ ਜਦੋਂ ਸਪੌਨ ਨੂੰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿਚ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਪ੍ਰਕਿਰਿਆ ਦੇ ਬਾਹਰ, spawn_id ਹੁਣ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆ ਕੇਵਲ ਸਕੋਪਿੰਗ ਦੇ ਕਾਰਨ ਐਕਸੈਸ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ. ਅਜਿਹੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ "ਗਲੋਬਲ ਸਪੌਨ_id" ਜੋੜੋ.
ਜੇ ਤੁਸੀਂ ਮਲਟੀਸਪੇਵਿੰਗ ਸਮਰੱਥਾ (ਅਰਥਾਤ, ਤੁਹਾਡਾ ਸਿਸਟਮ ਨਾ ਚੁਣੋ (ਬੀ ਐਸ ਡੀ *. *), ਪੋਲ (ਐਸਵੀਆਰ> 2), ਅਤੇ ਕੁਝ ਬਰਾਬਰ ਨਹੀਂ) ਨੂੰ ਸਮਰੱਥ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਤਾਂ ਆਸ ਸਿਰਫ ਇਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਇਕ ਸਮੇਂ ਤੇ ਕੰਟਰੋਲ ਕਰਨ ਦੇ ਯੋਗ ਹੋ ਸਕਦੀ ਹੈ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, spawn_id ਨੂੰ ਸੈਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਾ ਕਰੋ, ਅਤੇ ਨਾ ਹੀ ਤੁਹਾਨੂੰ ਸਪੌਂਡ ਪ੍ਰਕਿਰਿਆ ਚੱਲਣ ਵੇਲੇ exec ਦੁਆਰਾ ਕਾਰਜਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਇੱਕ ਹੀ ਸਮੇਂ ਤੇ ਕਈ ਪ੍ਰਕਿਰਿਆਵਾਂ (ਇੱਕ ਹੀ ਉਪਭੋਗਤਾ ਸਮੇਤ) ਤੋਂ ਆਸ ਨਹੀਂ ਕਰ ਸਕੋਗੇ.
ਟਰਮੀਨਲ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਸਕ੍ਰਿਪਟਾਂ ਤੇ ਵੱਡਾ ਅਸਰ ਪੈ ਸਕਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਜੇ ਇੱਕ ਸਕਰਿਪਟ ਨੂੰ ਈਕੋ ਕਰਣ ਦੀ ਭਾਲ ਕਰਨ ਲਈ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਗਲਤ ਵਿਵਹਾਰ ਕਰੇਗਾ ਜੇ ਐਂਕੋਡਿੰਗ ਬੰਦ ਹੈ. ਇਸ ਕਾਰਨ ਕਰਕੇ, ਬਾਹਾਂ ਨੂੰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਟਰਮੀਨਲ ਪੈਮਾਨੇ ਤੇ ਵਿਚਾਰ ਕਰੋ. ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇਹ ਦੂਜੇ ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਕੁਝ ਅਪਣਾਉਣ ਵਾਲਾ ਬਣਾ ਸਕਦਾ ਹੈ. ਇੱਕ ਉਦਾਹਰਣ ਦੇ ਤੌਰ ਤੇ, emacs ਸ਼ੈੱਲ "ਆਮ" ਮੈਪਿੰਗ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦਾ ਹੈ: ਨਵੇਂ ਲਾਈਨਜ਼ ਨੂੰ ਕੈਰੇਜ਼-ਰਿਟਰਨ ਨਵੀਂ ਲਾਈਨਜ਼ ਦੀ ਬਜਾਏ ਨਵੇਂ ਲਾਈਨਾਂ ਲਈ ਮੈਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਐਕੋਿੰਗ ਅਯੋਗ ਹੈ. ਇਹ ਕਿਸੇ ਨੂੰ ਇਨਪੁਟ ਸਤਰ ਸੰਪਾਦਿਤ ਕਰਨ ਲਈ emacs ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇਸ ਦੀ ਅਨੁਮਾਨਤ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੋ ਸਕਦੀ.
ਤੁਸੀਂ ਬੇਨਤੀ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਟਰਮੀਨਲ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਆਪਣੀ ਡਿਫਾਲਟ ਸੈਟਿੰਗ ਨੂੰ ਅਣਡਿੱਠਾ ਨਾ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰੋ, ਪਰ ਅਜਿਹੇ ਮਾਹੌਲ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਲਿਖਣ ਸਮੇਂ ਤੁਹਾਨੂੰ ਬਹੁਤ ਧਿਆਨ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ. Emacs ਦੇ ਮਾਮਲੇ ਵਿਚ, ਐੱਕੋਿੰਗ ਅਤੇ ਅੰਤ ਵਿਚ-ਲਾਈਨ ਮੈਪਿੰਗ ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ 'ਤੇ ਨਿਰਭਰਤਾ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ.
ਆਦੇਸ਼ਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ ਨੂੰ ਇੱਕ ਸੂਚੀ ( ਆਸਰਾ ਰੂਪਾਂ ਅਤੇ ਪਰਸਪਰ ਕ੍ਰਿਆ ) ਵਿੱਚ ਤੈ ਕੀਤੇ ਜਾਣ ਲਈ ਇੱਕ ਅਨੁਮਾਨ ਦਾ ਇਸਤੇਮਾਲ ਕੀਤਾ ਗਿਆ ਹੈ ਕਿ ਇਹ ਸੂਚੀ ਅਸਲ ਵਿੱਚ ਇੱਕ ਆਰਗੂਮੈਂਟ ਹੈ ਜਾਂ ਕਈ ਖੋਜਕਰਤਾ ਕੇਵਲ ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਅਸਫਲ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਸੂਚੀ ਅਸਲ ਵਿੱਚ ਕਿਸੇ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੀ ਪ੍ਰਤੀਨਿਧਤਾ ਕਰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਐਂਬੈੱਡ ਕੀਤੇ ਗਏ ਹਨ \ n, ਉਨ੍ਹਾਂ ਦੇ ਵਿਚਕਾਰ ਗੋਰਨਸਪੇਸ ਅੱਖਰਾਂ ਦੇ ਨਾਲ. ਇਹ ਕਾਫੀ ਅਸੰਭਵ ਲੱਗਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਦਲੀਲ "-ਨੌਬ੍ਰੇਸ" ਨੂੰ ਇੱਕ ਆਰਗੂਮਿੰਟ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਆਰਗੂਲੇਸ਼ਨ ਦੇ ਤੌਰ ਤੇ ਵਰਤੇ ਜਾਣ ਲਈ ਮਜਬੂਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਇਹ ਮਸ਼ੀਨ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਉਮੀਦ ਕੋਡ ਦੇ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਇਸੇ ਤਰ੍ਹਾਂ, -ਬ੍ਰੈਸੇ ਇੱਕ ਸਿੰਗਲ ਆਰਗੂਮੈਂਟ ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਪੈਟਰਨ / ਐਕਸ਼ਨ ਵਜੋਂ ਹੈਂਡਲ ਕਰਨ ਲਈ ਮਜ਼ਬੂਰ ਕਰਦਾ ਹੈ.
ਬੱਗਸ
ਇਹ ਸੱਚਮੁੱਚ ਪ੍ਰੋਗਰਾਮ "ਸੈਕਸ" (ਜਾਂ ਤਾਂ "ਸਮਾਰਟ ਐਕਸਸੀ" ਜਾਂ "ਭੇਜੋ-ਸੁਪਨੇ") ਲਈ ਨਾਮਨਜ਼ੂਰ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ ਚੰਗੀ ਸਮਝ (ਜਾਂ ਸ਼ਾਇਦ ਕੇਵਲ ਪੁਰਾਤਨਵਾਦ) ਪ੍ਰਬਲ ਸੀ.
ਕੁਝ ਪ੍ਰਣਾਲੀਆਂ ਤੇ, ਜਦੋਂ ਇੱਕ ਸ਼ੈੱਲ ਪੈਦਾ ਹੁੰਦੀ ਹੈ, ਇਹ tty ਤੱਕ ਪਹੁੰਚ ਨਾ ਹੋਣ ਬਾਰੇ ਸ਼ਿਕਾਇਤ ਕਰਦਾ ਹੈ ਪਰ ਕਿਸੇ ਵੀ ਤਰਾਂ ਚਲਦਾ ਹੈ. ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡੇ ਸਿਸਟਮ ਵਿੱਚ ਕੰਟਰੋਲਿੰਗ ਟੀਟੀ ਟੀਚ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਣਾਲੀ ਹੈ ਜਿਸ ਬਾਰੇ ਉਮੀਦ ਨਹੀਂ ਹੈ. ਕਿਰਪਾ ਕਰਕੇ ਪਤਾ ਕਰੋ ਕਿ ਇਹ ਕੀ ਹੈ, ਅਤੇ ਇਹ ਜਾਣਕਾਰੀ ਮੈਨੂੰ ਵਾਪਸ ਭੇਜੋ
ਅਤ੍ਰਿਕਸ 4.1 (ਘੱਟੋ ਘੱਟ ਇੱਥੇ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਦੇ ਨਵੇਂ ਸੰਸਕਰਣ) 1000000 ਤੋਂ ਉਪਰ ਦੇ ਸਮਾਂ-ਸਮਾਨ ਨੂੰ 0 ਦੇ ਬਰਾਬਰ ਸਮਝਦਾ ਹੈ.
ਡਿਜੀਟਲ ਯੂਨਿਕਸ 4.0 ਏ (ਅਤੇ ਸੰਭਵ ਤੌਰ ਤੇ ਦੂਜੇ ਸੰਸਕਰਣਾਂ) ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ SIGCHLD ਹੈਂਡਲਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਤਾਂ ਪੀਟੀਐਸਸਾਂ ਨੂੰ ਵੰਡਣ ਤੋਂ ਇਨਕਾਰ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ ਗ੍ਰਹਿ ਵਿਭਾਗ ਦੇਖੋ.
IRIX 6.0 pty ਅਧਿਕਾਰਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਨਹੀਂ ਸੰਭਾਲਦਾ ਹੈ ਤਾਂ ਕਿ ਜੇ ਕਿਸੇ ਹੋਰ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਪਾਈਲੀਅਮ ਨੂੰ ਪਹਿਲਾਂ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਵੇ ਤਾਂ ਇਹ ਫੇਲ੍ਹ ਹੋ ਜਾਂਦਾ ਹੈ. IRIX 6.1 ਵੱਲ ਅੱਪਗਰੇਡ ਕਰੋ.
ਟੈਲਨੈੱਟ (SunOS 4.1.2 ਦੇ ਅਧੀਨ ਤਸਦੀਕ ਕੀਤਾ ਗਿਆ ਹੈ) ਜੇ TERM ਸੈਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਲਟਕ ਜਾਂਦਾ ਹੈ. ਇਹ cron, ਅਤੇ ਅਤੇ CGI ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਇੱਕ ਸਮੱਸਿਆ ਹੈ, ਜੋ TERM ਨੂੰ ਪ੍ਰਭਾਸ਼ਿਤ ਨਹੀਂ ਕਰਦੇ ਇਸ ਲਈ, ਤੁਹਾਨੂੰ ਸਪਸ਼ਟ ਤੌਰ ਤੇ ਇਸ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ - ਕਿਹੜਾ ਆਮ ਤੌਰ ਤੇ ਅਨੁਰੂਪ ਹੀ ਹੈ ਇਹ ਸਿਰਫ ਕਿਸੇ ਚੀਜ਼ 'ਤੇ ਸੈੱਟ ਹੋਣਾ ਹੈ! ਜ਼ਿਆਦਾਤਰ ਕੇਸਾਂ ਲਈ ਸੰਭਵ ਤੌਰ 'ਤੇ ਸੰਭਵ ਤੌਰ' ਤੇ ਸੰਭਵ ਤੌਰ 'ਤੇ ਕਾਫੀ ਹੈ.
ਸੈਟ ਇਨਵ (ਟੀ.ਆਰ.ਐਮ.) vt100ਟਿਪ (BSDI BSD / OS 3.1 i386 ਦੇ ਅਧੀਨ ਤਸਦੀਕ ਕੀਤਾ ਗਿਆ ਹੈ) ਜੇ SHELL ਅਤੇ HOME ਸੈਟ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ ਤਾਂ hangs. ਇਹ ਕਰੋਨ , ਅਤੇ ਅਤੇ CGI ਸਕਰਿਪਟਾਂ ਦੇ ਤਹਿਤ ਇੱਕ ਸਮੱਸਿਆ ਹੈ, ਜੋ ਇਹਨਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨੂੰ ਪ੍ਰਭਾਸ਼ਿਤ ਨਹੀਂ ਕਰਦੇ. ਇਸ ਲਈ, ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਰੂਪ ਨਾਲ ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ - ਕਿਹੜੀਆਂ ਚੀਜ਼ਾਂ ਆਮ ਤੌਰ ਤੇ ਅਨੁਰੂਪ ਹੀ ਹਨ. ਇਹ ਸਿਰਫ ਕਿਸੇ ਚੀਜ਼ 'ਤੇ ਸੈੱਟ ਹੋਣਾ ਹੈ! ਜ਼ਿਆਦਾਤਰ ਕੇਸਾਂ ਲਈ ਸੰਭਵ ਤੌਰ 'ਤੇ ਸੰਭਵ ਤੌਰ' ਤੇ ਸੰਭਵ ਤੌਰ 'ਤੇ ਕਾਫੀ ਹੈ.
ਸੈਟ ਇਨਵੇਯਰ (ਸ਼ੈਲ) / ਬੀਨ / ਸ਼ੈੱਟ ਸੈਟ env (HOME) / usr / local / binਪੀਟੀਐਸਸ ਦੇ ਕੁੱਝ ਸਥਾਪਨ ਇਸ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ ਕਿ ਪ੍ਰਕ੍ਰਿਆ ਨੇ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਨੂੰ ਬੰਦ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕਰਨਲ 10 ਤੋਂ 15 ਸੈਕਿੰਡ ਬਾਅਦ (ਅਸਲ ਨੰਬਰ ਲਾਗੂ ਕਰਨਾ-ਨਿਰਭਰ) ਦੇ ਬਾਅਦ ਕਿਸੇ ਵੀ ਅਨਪੜ੍ਹ ਆਉਟਪੁੱਟ ਨੂੰ ਸੁੱਟ ਦਿੰਦਾ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਆਸ ਰੱਖੋ ਜਿਵੇਂ ਕਿ
ਸਪੌਨ ਤਾਰੀਖ ਸਲੀਪ 20 ਆਸ ਕਰਦਾ ਹੈਫੇਲ ਹੋ ਜਾਵੇਗਾ. ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਗੈਰ-ਪਰਸਪਰ ਪ੍ਰਭਾਵਿਤ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਸਪੌਨ ਦੀ ਬਜਾਏ ਚਲਾਓ . ਹਾਲਾਂਕਿ ਅਜਿਹੇ ਹਾਲਾਤ ਸੋਚਣਯੋਗ ਹਨ, ਪ੍ਰੈਕਟਿਸ ਵਿੱਚ ਮੈਨੂੰ ਕਿਸੇ ਅਜਿਹੇ ਹਾਲਾਤ ਦਾ ਕਦੇ ਸਾਹਮਣਾ ਨਹੀਂ ਕਰਨਾ ਪਿਆ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸਲ ਵਿਵਹਾਰਕ ਪ੍ਰੋਗ੍ਰਾਮ ਦੇ ਆਖਰੀ ਨਤੀਜੇ ਇਸ ਵਿਹਾਰ ਕਾਰਨ ਖਤਮ ਹੋ ਜਾਣਗੇ.
ਦੂਜੇ ਪਾਸੇ, ਕਰੈ ਯੂਨੀਕੋਸ ਪੀਟੀਜ਼ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਨੂੰ ਬੰਦ ਕਰਨ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਕੋਈ ਵੀ ਅਨਪੜ੍ਹ ਆਉਟਪੁੱਟ ਸੁੱਟਦਾ ਹੈ. ਮੈਂ ਇਸ ਨੂੰ ਕ੍ਰੈ ਬਾਰੇ ਰਿਪੋਰਟ ਦਿੱਤੀ ਹੈ ਅਤੇ ਉਹ ਫਿਕਸ ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹਨ
ਕਈ ਵਾਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਵਿੱਚ ਇੱਕ ਦੇਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਜਦੋਂ ਇੱਕ tty ਇੰਟਰਫੇਸ UART ਸੈਟਿੰਗ ਬਦਲ ਰਿਹਾ ਹੈ ਜਾਂ ਬੌਡ ਦੀ ਦਰ ਸ਼ੁਰੂ / ਸਟਾਪ ਬਿੱਟਾਂ ਦੀ ਖੋਜ ਕਰ ਰਿਹਾ ਹੈ. ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਸਭ ਕੁਝ ਇਕ ਦੂਜੇ ਜਾਂ ਦੋ ਲਈ ਸੌਣ ਦੀ ਲੋੜ ਹੈ. ਇਕ ਹੋਰ ਮਜ਼ਬੂਤ ਤਕਨੀਕ ਨੂੰ ਉਦੋਂ ਤਕ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਹੈ ਜਦੋਂ ਤਕ ਇੰਪੁੱਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਹਾਰਡਵੇਅਰ ਤਿਆਰ ਨਹੀਂ ਹੁੰਦਾ. ਹੇਠ ਦਿੱਤੀ ਉਦਾਹਰਨ ਦੋਨੋ ਰਣਨੀਤੀ ਵਰਤਦਾ ਹੈ:
"ਸਪੀਡ 9600 \ r" ਭੇਜੋ; ਸਲੀਪ 1 ਦੀ ਉਮੀਦ ਹੈ {ਟਾਈਮਆਉਟ {ਭੇਜੋ "\ r"; exp_continue} $ ਪ੍ਰੋਂਪਟ}trap -code ਕਿਸੇ ਵੀ ਕਮਾਂਡ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ ਜੋ Tcl ਦੇ ਘਟਨਾ ਲੂਪ ਵਿੱਚ ਬੈਠਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਸਲੀਪ. ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਘਟਨਾ ਲੂਪ ਵਿੱਚ, Tcl ਐਸੀਂਕ ਘਟਨਾ ਹੈਂਡਲਰ ਤੋਂ ਰਿਟਰਨ ਕੋਡ ਰੱਦ ਕਰਦਾ ਹੈ ਫੰਕਸ਼ਨ ਕੋਡ ਵਿਚ ਇਕ ਫਲੈਗ ਲਗਾਉਣ ਦਾ ਇਕ ਹੱਲ ਹੈ. ਫਿਰ ਕਮਾਂਡ ਦੇ ਬਾਅਦ ਤੁਰੰਤ ਫਲੈਗ ਦੀ ਜਾਂਚ ਕਰੋ (ਜਿਵੇਂ, ਨੀਂਦ).
Expect_background ਕਮਾਂਡ ਅਣਡਿੱਠ ਕਰਦਾ ਹੈ- ਟਾਈਮਆਉਟ ਆਰਗੂਮੈਂਟ ਅਤੇ ਆਮ ਤੌਰ ਤੇ ਸਮਾਂ-ਸਮਾਪਤੀ ਦੀ ਕੋਈ ਧਾਰਨਾ ਨਹੀਂ ਹੁੰਦੀ ਹੈ.
& # 34; ਆਸ ਦੀਆਂ ਛਾਪੀਆਂ & # 34;
ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਗੈਰ-ਅਨੁਭਵੀ ਹੋ ਸਕਦਾ ਹੈ ਬਾਰੇ ਕੁਝ ਗੱਲਾਂ ਹਨ. ਇਹ ਭਾਗ ਕੁਝ ਸੁਝਾਵਾਂ ਦੇ ਨਾਲ ਇਹਨਾਂ ਕੁਝ ਚੀਜ਼ਾਂ ਨੂੰ ਸੰਬੋਧਨ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ.
ਇੱਕ ਆਮ ਉਮੀਦ ਸਮੱਸਿਆ ਹੈ ਕਿ ਸ਼ੈੱਲ ਪ੍ਰੋਂਪਟ ਦੀ ਪਛਾਣ ਕਿਵੇਂ ਕਰਨੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਲੋਕਾਂ ਅਤੇ ਵੱਖੋ-ਵੱਖਰੇ ਸ਼ੈਲਰਾਂ ਦੁਆਰਾ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਕਸਟਮਾਈਜ਼ ਕੀਤੇ ਗਏ ਹਨ, ਪੋਰਟੇਬਲ ਨੂੰ ਆਟੋਮੈਟਿਕ ਬਣਾਉਣ ਲਈ ਪ੍ਰੌਮਪਟ ਨੂੰ ਜਾਣੇ ਬਗੈਰ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ. ਇੱਕ ਵਾਜਬ ਸੰਮੇਲਨ ਇਹ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਆਪਣੇ ਪ੍ਰੌਮਪਟ (ਵਿਸ਼ੇਸ਼ ਤੌਰ ਤੇ, ਇਸ ਦੇ ਅੰਤ) ਦਾ ਵਰਣਨ ਕਰਨ ਵਾਲੇ ਇੱਕ ਰੈਗੂਲਰ ਐਕਸਪ੍ਰੈਸ ਨੂੰ ਵਾਤਾਵਰਣ ਵੇਰੀਬਲ EXPECT_PROMPT ਵਿੱਚ ਸਟੋਰ ਕਰਦੇ ਹਨ. ਹੇਠ ਲਿਖੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ. ਜੇ EXPECT_PROMPT ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਕੋਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਇੱਕ ਵਧੀਆ ਮੌਕਾ ਹੈ.
ਸੈੱਟ ਪ੍ਰੌਮ "(% | | | | | $ $ $ $) $ #; # ਡਿਫਾਲਟ ਪਰੌਂਪਟ ਕੈਪ ਕਰੋ {ਸੈੱਟ ਪ੍ਰਾਉਟ $ env (EXPECT_PROMPT)} ਦੀ ਉਮੀਦ ਕਰੋ -re $ ਪ੍ਰੋਂਪਟਮੈਂ ਤੁਹਾਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਨ ਲਈ ਹੱਲਾਸ਼ੇਰੀ ਦੇ ਰਿਹਾ ਹਾਂ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਜੋ ਵੀ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਉਸ ਦਾ ਅੰਤ ਸ਼ਾਮਲ ਕਰੋ. ਇਹ ਸਾਰਾ ਕੁਝ ਦੇਖਣ ਤੋਂ ਪਹਿਲਾਂ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਣ ਦੀ ਸੰਭਾਵਨਾ ਤੋਂ ਬਚਦਾ ਹੈ. ਇਸਦੇ ਇਲਾਵਾ, ਜਦੋਂ ਤੁਸੀਂ ਪੂਰੀ ਤਰਾਂ ਵੇਖਣ ਤੋਂ ਪਹਿਲਾਂ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦੇ ਸਕਦੇ ਹੋ, ਜੇ ਤੁਸੀਂ ਜਲਦੀ ਜਵਾਬ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡਾ ਜਵਾਬ ਪ੍ਰਸ਼ਨ ਦੇ ਮੱਧ ਵਿੱਚ ਗੂੰਜਦਾ ਪ੍ਰਗਟ ਹੋ ਸਕਦਾ ਹੈ. ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਨਤੀਜੇ ਵਜੋਂ ਸੰਵਾਦ ਠੀਕ ਹੋ ਜਾਵੇਗਾ ਪਰ ਤਿਰਛੇ ਵੱਲ ਵੇਖੋ.
ਜ਼ਿਆਦਾਤਰ ਪ੍ਰੋਂਪਟਾਂ ਵਿੱਚ ਅੰਤ ਵਿੱਚ ਇੱਕ ਸਪੇਸ ਅੱਖਰ ਸ਼ਾਮਿਲ ਹੁੰਦਾ ਹੈ ਉਦਾਹਰਨ ਲਈ, ਐਫ ਟੀ ਪੀ ਤੋਂ ਪਰੌਂਪਟ 'f', 't', 'p', '>' ਅਤੇ. ਇਸ ਪ੍ਰੌਮਪਟ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਅੱਖਰ ਲਈ ਖਾਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਇਹ ਇਕ ਆਮ ਗ਼ਲਤੀ ਹੈ ਨਾ ਕਿ ਖਾਲੀ ਜਗ੍ਹਾ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ. ਖਾਲੀ ਵਿੱਚ ਸਪੱਸ਼ਟ ਰੂਪ ਵਿੱਚ ਪਾ ਦਿਓ.
ਜੇ ਤੁਸੀਂ ਫਾਰਮ X * ਦੇ ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ * ਐਕਸ ਦੇ ਅਖੀਰ ਤੋਂ ਪ੍ਰਾਪਤ ਹੋਏ ਸਾਰੇ ਆਊਟਪੁਟ ਨਾਲ ਮਿਲੀਆਂ ਆਖਰੀ ਚੀਜਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ. ਇਹ ਅਨੁਭੱਭਾ ਜਾਪਦਾ ਹੈ ਪਰ ਕੁਝ ਗੜਬੜ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ "ਆਖਰੀ ਵਾਰ ਪ੍ਰਾਪਤ ਹੋਈ" ਸ਼ਬਦ, ਕੰਪਿਊਟਰ ਦੀ ਗਤੀ ਅਤੇ I / O ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਅਨੁਸਾਰ ਕਰਨਲ ਅਤੇ ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਦੁਆਰਾ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦੇ ਹਨ.
ਖਾਸ ਤੌਰ 'ਤੇ, ਮਨੁੱਖੀ ਪ੍ਰੋਗ੍ਰਾਮ ਦੇ ਆਊਟਪੁੱਟ ਨੂੰ ਵੱਡੇ ਹਿੱਸੇਵਾਂ (ਪ੍ਰਮਾਣੂ ਤੌਰ' ਤੇ) ਵਿਚ ਆਉਂਦੇ ਦੇਖਦੇ ਹਨ ਜਦੋਂ ਅਸਲ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮਾਂ ਇੱਕ ਸਮੇਂ ਆਉਟਪੁਟ ਇੱਕ ਲਾਈਨ ਬਣਾਉਂਦੇ ਹਨ. ਇਹ ਮੰਨ ਲੈਣਾ ਕਿ ਇਹ ਕੇਸ ਹੈ, * ਪਿਛਲੇ ਪੈਰੇ ਦੇ ਪੈਟਰਨ ਵਿਚ * ਮੌਜੂਦਾ ਲਾਈਨ ਦੇ ਅੰਤ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਇਸ ਤੋਂ ਜ਼ਿਆਦਾ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਕਿਉਂਕਿ ਮੇਲ ਸਮੇਂ ਉਸ ਸਮੇਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਗਈ ਸਾਰੀ ਆਉਟਪੁੱਟ ਸੀ.
ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਜਾਣਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ ਕਿ ਹੋਰ ਆਉਟਪੁੱਟ ਆ ਰਹੀ ਹੈ ਜਦੋਂ ਤੱਕ ਤੁਹਾਡਾ ਪੈਟਰਨ ਖਾਸ ਤੌਰ ਤੇ ਇਸ ਲਈ ਨਹੀਂ ਹੁੰਦਾ.
ਲਾਈਨ-ਮੁਖੀ ਬਫਰਿੰਗ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ ਵੀ ਮੂਰਖਤਾ ਨਹੀਂ ਹੈ. ਪ੍ਰੋਗ੍ਰਾਮਾਂ ਵਿਚ ਨਾ ਸਿਰਫ ਬਫਰਿੰਗ ਦੇ ਕਿਸਮ ਬਾਰੇ ਵਾਅਦੇ ਹੁੰਦੇ ਹਨ, ਪਰ ਸਿਸਟਮ ਵਿਚ ਬਦਹਜ਼ਮੀ ਆਊਟਪੁਟ ਲਾਈਨ ਨੂੰ ਤੋੜ ਸਕਦੇ ਹਨ ਤਾਂ ਕਿ ਲਾਈਨਾਂ ਨੂੰ ਰਲਵੇਂ ਸਥਾਨਾਂ ਵਿਚ ਟੁੱਟ ਜਾਵੇ. ਇਸ ਲਈ, ਜੇ ਤੁਸੀਂ ਪੈਟਰਨ ਲਿਖਦੇ ਸਮੇਂ ਪ੍ਰੌੜ ਦੇ ਆਖਰੀ ਕੁਝ ਅੱਖਰ ਦਰਸਾ ਸਕਦੇ ਹੋ, ਤਾਂ ਅਜਿਹਾ ਕਰਨਾ ਅਕਲਮੰਦੀ ਦੀ ਗੱਲ ਹੈ.
ਜੇ ਤੁਸੀਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਆਖਰੀ ਆਊਟਪੁਟ ਵਿੱਚ ਇੱਕ ਪੈਟਰਨ ਦੀ ਉਡੀਕ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਬਜਾਏ ਕੁਝ ਹੋਰ ਨਿਕਲਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਸ ਨੂੰ ਟਾਈਮਆਉਟ ਦੇ ਕੀਵਰਡ ਨਾਲ ਨਹੀਂ ਲੱਭ ਸਕੋਗੇ. ਇਸ ਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਉਮੀਦ ਸਮੇਂ ਦੀ ਮਿਆਦ ਨਹੀਂ ਹੋਵੇਗੀ - ਇਸ ਦੀ ਬਜਾਏ ਇਸ ਨੂੰ ਈਓਪ ਸੰਕੇਤ ਮਿਲੇਗਾ. ਇਸ ਦੀ ਬਜਾਏ ਇਸਦੀ ਵਰਤੋਂ ਕਰੋ. ਬਿਹਤਰ ਵੀ, ਦੋਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ. ਇਸ ਤਰੀਕੇ ਨਾਲ ਜੇਕਰ ਇਹ ਲਾਈਨ ਹਮੇਸ਼ਾਂ ਆਲੇ ਦੁਆਲੇ ਚਲੇ ਗਈ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਲਾਈਨ ਨੂੰ ਖੁਦ ਸੰਪਾਦਿਤ ਨਹੀਂ ਕਰਨਾ ਪਵੇਗਾ.
ਨਿਊਲਾਇੰਸ ਆਮ ਕਰਕੇ ਕੈਰੇਜ ਰਿਟਰਨ ਵਿੱਚ ਪਰਿਵਰਤਿਤ ਹੁੰਦੇ ਹਨ, ਲਾਈਨਫਾਈਡ ਕ੍ਰਮ ਜਦੋਂ ਟਰਮੀਨਲ ਡਰਾਈਵਰ ਦੁਆਰਾ ਆਊਟਪੁਟ ਹੁੰਦਾ ਹੈ. ਇਸ ਲਈ, ਜੇ ਤੁਸੀਂ ਇਕ ਪੈਟਰਨ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਸਪਸ਼ਟ ਤੌਰ ਤੇ ਦੋ ਲਾਈਨਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਤਾਂ, ਕਹਿ ਲਓ, printf ("foo \ nbar"), ਤੁਹਾਨੂੰ "foo \ r \ nbar" ਪੈਟਰਨ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ.
ਇਕੋ ਤਰਜਹੀ ਅਨੁਵਾਦ ਉਦੋਂ ਵਾਪਰਦਾ ਹੈ ਜਦੋਂ ਯੂਜ਼ਰ ਤੋਂ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, expect_user ਰਾਹੀਂ. ਇਸ ਕੇਸ ਵਿੱਚ, ਜਦੋਂ ਤੁਸੀਂ ਵਾਪਸ ਪ੍ਰੈਸ ਕਰੋਗੇ, ਤਾਂ ਇਸਦਾ ਅਨੁਵਾਦ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਵਿੱਚ ਕੀਤਾ ਜਾਵੇਗਾ ਜੇ ਆਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਉਸ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਜਿਹੜਾ ਉਸ ਦੇ ਟਰਮੀਨਲ ਨੂੰ ਕੱਚਾ ਮੋਡ (ਟੇਲਨੈੱਟ) ਦੀ ਤਰ੍ਹਾਂ ਸੈਟ ਕਰਦਾ ਹੈ, ਪਾਸ ਹੁੰਦਾ ਹੈ, ਇਕ ਸਮੱਸਿਆ ਹੋ ਸਕਦੀ ਹੈ, ਕਿਉਂਕਿ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਸਹੀ ਰਿਟਰਨ ਦੀ ਉਮੀਦ ਹੈ. (ਕੁਝ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਅਸਲ ਵਿੱਚ ਉਹ ਮੁਆਫ ਕਰਨਾ ਹੁੰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਉਹ ਆਪਣੇ ਆਪ ਨਵੇਂ-ਆਇਆਂ ਨੂੰ ਰਿਟਰਨ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਨਗੇ, ਪਰ ਜ਼ਿਆਦਾਤਰ ਨਹੀਂ ਕਰਦੇ.) ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇਹ ਪਤਾ ਲਗਾਉਣ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੇ ਆਪਣੇ ਟਰਮੀਨਲ ਨੂੰ ਕੱਚਾ ਢੰਗ ਵਿੱਚ ਰੱਖਿਆ ਹੈ.
ਨਵੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਰਿਟਰਨ ਨਾਲ ਬਦਲਣ ਦੀ ਬਜਾਏ, ਹੱਲ ਹੈ "stty raw" ਕਮਾਂਡ ਵਰਤਣ ਲਈ, ਜੋ ਕਿ ਅਨੁਵਾਦ ਨੂੰ ਰੋਕ ਦੇਵੇਗੀ. ਨੋਟ ਕਰੋ, ਹਾਲਾਂਕਿ, ਇਸ ਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਪਕਾਇਆ ਲਾਈਨ-ਸੰਪਾਦਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਹੀਂ ਮਿਲਣਗੀਆਂ
ਸੰਚਾਰਿਤ ਢੰਗ ਨਾਲ ਆਪਣੇ ਟਰਮੀਨਲ ਨੂੰ ਕੱਚਾ ਮੋਡ ਸੈੱਟ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਇਹ ਸਮੱਸਿਆ ਫਿਰ ਨਹੀਂ ਪੈਦਾ ਹੋ ਸਕੇ.
ਸਕਰਿਪਟਾਂ ਦੀ ਆਸ ਵਿੱਚ ਇਹ ਅਕਸਰ ਪਾਸਵਰਡ (ਜਾਂ ਹੋਰ ਪ੍ਰਾਈਵੇਟ ਜਾਣਕਾਰੀ) ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਉਪਯੋਗੀ ਹੁੰਦਾ ਹੈ. ਇਸ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਕੰਪਿਊਟਰ ਉੱਤੇ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਦੁਆਰਾ ਐਕਸੈਸ ਕੀਤੇ ਜਾਣ ਦੀ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ, ਸਕਰਿਪਟ ਤੋਂ ਗੁਪਤ-ਕੋਡ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਇੱਕ ਸ਼ਾਨਦਾਰ ਵਿਚਾਰ ਮੰਨਿਆ ਗਿਆ ਹੈ ਤਾਂ ਕਿ ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਬਦਿਕ ਜੋੜਿਆ ਜਾ ਸਕੇ. ਫਿਰ ਵੀ, ਕਦੇ-ਕਦੇ ਅਜਿਹੀ ਏਮਬੈਡਿੰਗ ਸਿਰਫ ਇੱਕ ਹੀ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ.
ਬਦਕਿਸਮਤੀ ਨਾਲ, ਯੂਨੈਕਸ ਫਾਇਲ ਸਿਸਟਮ ਕੋਲ ਸਕ੍ਰਿਪਟਾਂ ਬਣਾਉਣ ਦਾ ਕੋਈ ਸਿੱਧਾ ਤਰੀਕਾ ਨਹੀਂ ਹੈ, ਜੋ ਕਿ ਚੱਲਣ ਯੋਗ ਪਰ ਪੜ੍ਹਨਯੋਗ ਨਹੀਂ ਹਨ. ਸਿਸਟਮ ਜੋ ਕਿ setgid ਸ਼ੈੱਲ ਸਕਰਿਪਟਾਂ ਨੂੰ ਸਹਿਯੋਗ ਦਿੰਦਾ ਹੈ ਅਸਿੱਧੇ ਤੌਰ ਤੇ ਇਹ ਇਸ ਤਰਾਂ ਕਰ ਸਕਦੇ ਹਨ:
ਆਸਾਨ ਸਕ੍ਰਿਪਟ ਬਣਾਓ (ਜਿਸ ਵਿੱਚ ਗੁਪਤ ਡੇਟਾ ਹੈ) ਆਮ ਵਾਂਗ ਇਸ ਦੇ ਅਨੁਮਤੀਆਂ ਨੂੰ 750 (-ਆਰ-ਐਕਸ-ਐਕਸ ---) ਬਣਾਓ ਅਤੇ ਇੱਕ ਭਰੋਸੇਯੋਗ ਸਮੂਹ ਦੀ ਮਲਕੀਅਤ ਬਣਾਓ, ਭਾਵ, ਇੱਕ ਸਮੂਹ ਜਿਸ ਨੂੰ ਇਸਨੂੰ ਪੜ੍ਹਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਗਈ ਹੈ. ਜੇ ਜਰੂਰੀ ਹੋਵੇ, ਇਸ ਉਦੇਸ਼ ਲਈ ਇੱਕ ਨਵਾਂ ਸਮੂਹ ਬਣਾਓ ਅੱਗੇ, ਇੱਕ / bin / sh ਸਕ੍ਰਿਪਟ ਨੂੰ ਅਨੁਮਤੀਆਂ 2751 (-rwxr -s -x) ਦੇ ਨਾਲ ਉਸੇ ਗਰੁੱਪ ਦੁਆਰਾ ਪਹਿਲਾਂ ਹੀ ਬਣਾਉ.
ਨਤੀਜਾ ਇੱਕ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਕਿਸੇ ਦੁਆਰਾ ਵੀ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ (ਅਤੇ ਪੜ੍ਹ ਸਕਦਾ ਹੈ). ਜਦੋਂ ਮੰਗੀ ਜਾਂਦੀ ਹੈ, ਇਹ ਆਸ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦਾ ਹੈ.
& # 34; ਵੀ ਦੇਖੋ & # 34;
Tcl (3), libexpect (3)
" ਐਕਸਪੋਲਟਿੰਗ ਐਕਸਪਟ : ਏ ਟੀਐਲਸੀ-ਬੇਸਡ ਟੂਲਕਿੱਟ ਆਟੋਮੈਟਿੰਗ ਇੰਟਰਐਕਟਿੰਗ ਪ੍ਰੋਗ੍ਰਾਮਜ਼" ਡੌਨ ਲਿਬਜ਼, ਪਪੀ. 602, ਆਈਐਸਬੀਏਨ 1-56592-090-2, ਓ ਰੈਲੀ ਐਂਡ ਐਸੋਸੀਏਟਸ, 1995.
"ਉਮੀਦ ਕਰੋ: ਡੋਨ ਲਿਬ੍ਸ ਦੁਆਰਾ" ਇੰਟਰੈਕਟਰੀ ਦੇ ਬੇਕਾਬੂ ਫਿਟ ਹੋਣ ਦਾ ਕਾਰਨ, 1990 ਦੀ ਯੂਨਾਈਟਿਡ ਕਾਨਫਰੰਸ, ਅਨਾਹੈਮ, ਕੈਲੀਫੋਰਨੀਆ, ਜੂਨ 11-15, 1990 , ਦੀ ਕਾਰਜਕਾਰੀ.
ਮੈਂ ਡੌਨ ਲਿਬਜ਼ ਦੁਆਰਾ "ਸਿਸਟਮ ਪ੍ਰਬੰਧਨ ਕਾਰਜਾਂ ਨੂੰ ਆਟੋਮੇਟ ਕਰਨ ਦੀ ਉਮੀਦ ਦਾ ਇਸਤੇਮਾਲ ਕਰਨਾ", 1990 ਦੀਆਂ ਯੂਐਸਸੀਐਕਸ ਵੱਡੀ ਇੰਸਟਾਲੇਸ਼ਨ ਪ੍ਰਣਾਲੀ ਪ੍ਰਸ਼ਾਸਨ ਕਾਨਫਰੰਸ, ਕੋਲੋਰਾਡੋ ਸਪ੍ਰਿੰਗਸ, ਕੋਲੋਰਾਡੋ, 17 ਅਕਤੂਬਰ, 1990, ਦੀ ਕਾਰਵਾਈ.
ਮੈਂ "ਟੀਐਚਡੀ: ਏ ਐਂਮਬੈਡੇਬਲ ਕਮਾਂਡ ਲੈਂਗੂਏਜ" ਜੋਹਨ ਓਸਟਰਹੌਟ ਦੁਆਰਾ, ਵਿੰਟਰ 1990 ਯੂਐਸਨੀਕਸ ਕਾਨਫਰੰਸ, ਵਾਸ਼ਿੰਗਟਨ, ਡੀ.ਸੀ., 22-26 ਜਨਵਰੀ, 1990 ਦੀ ਪ੍ਰਕਿਰਿਆ. ਮੈਂ "ਆਸ ਕਰਦਾ ਹਾਂ: ਡੌਨ ਲਿਬ੍ਸ, ਕੰਪਿਊਟਿੰਗ ਪ੍ਰਣਾਲੀ ਦੁਆਰਾ" ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਇੰਟਰਐਕਟਿਵ ਪ੍ਰੋਗਰਾਮ " , ਵੋਲ. 4, ਨੰ. 2, ਯੂਨੀਵਰਸਿਟੀ ਆਫ਼ ਕੈਲੇਫੋਰਨੀਆ ਪ੍ਰੈਸ ਜਰਨਲਸ, ਨਵੰਬਰ 1991..ਮੈਂ "ਰੈਗਰੇਸ਼ਨ ਟੈਸਲਿੰਗ ਐਂਡ ਕਨਫੋਰਮੈਂਸ ਟੈਸਿਟਿੰਗ ਇੰਟਰਐਕਟਿਵ ਪ੍ਰੋਗਰਾਮਜ਼", ਡੌਨ ਲਿਸੇਜ਼ ਦੁਆਰਾ, ਪ੍ਰੀਕਾਈਡਿੰਗਜ਼ ਆਫ਼ ਦੀ ਸਮੀਰ 1992 ਯੂਐਸਨੀਕਸ ਕਾਨਫਰੰਸ, ਪੀਪੀ 135-144, ਸੈਨ ਐਂਟੋਨੀਓ, ਜੂਨ 12-15, 1992. ਮੈਂ "ਕਿਿਬਿਟ - ਮਲਟੀਪਲ ਇੰਟਰੈਕਟਿਵ ਪ੍ਰੋਗਰਾਮ ਨਾਲ ਜੁੜਨਾ", ਡੌਨ ਲਿਬ੍ਸ ਦੁਆਰਾ, ਸੌਫਟਵੇਅਰ - ਪ੍ਰੈਕਟਿਸ ਐਂਡ ਐਕਸਪਿਰੀਅਸ, ਜੌਨ ਵਿਲੇ ਐਂਡ ਸਨਜ਼, ਵੈਸਟ ਸਸੈਕਸ, ਇੰਗਲੈਂਡ, ਵੋਲ.
23, ਨੰ. 5, ਮਈ, 1993. ਮੈਂ "ਡੀ ਡਬਗਰ ਫਾਰ ਟੀ.ਐਲ.ਐਲ.ਪੀ. ਅੈਕਸਟ੍ਰੇਸ਼ਨਜ਼", ਡੌਨ ਲਿਬੇਸ ਦੁਆਰਾ, 1993 ਟੀਐਲਐਲ / ਟੀਐਕਸ ਵਰਕਸ਼ਾਪ ਦੀ ਕਾਰਵਾਈ, ਬਰਕਲੇ, ਸੀਏ, ਜੂਨ 10-11, 1993
ਲੇਖਕ
ਡੌਨ ਲਿਬੇਜ਼, ਨੈਸ਼ਨਲ ਇੰਸਟੀਚਿਊਟ ਆਫ ਸਟੈਂਡਰਡ ਐਂਡ ਟੈਕਨੋਲੋਜੀ
ਪਾਬੰਦੀ
ਪ੍ਰੇਰਨਾ ਲਈ ਜੌਨ ਔਸਟਰਹਾਉਟ ਲਈ Tcl, ਅਤੇ ਸਕਾਟ ਪੇਸਿਲੀ ਲਈ ਧੰਨਵਾਦ. ਆਕਟੋਕੰਪਿਗਰੇਸ਼ਨ ਕੋਡ ਦੀ ਉਮੀਦ ਲਈ ਰੋਬ ਸੈਟੋਏ ਦਾ ਧੰਨਵਾਦ.
ਇਤਿਹਾਸ ਫਾਇਲ ਬਹੁਤ ਉਮੀਦਾਂ ਦੇ ਵਿਕਾਸ ਦੇ ਦਸਤਾਵੇਜ਼ ਪੇਸ਼ ਕਰਦੀ ਹੈ. ਇਹ ਦਿਲਚਸਪ ਪਾਠ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਇਸ ਸੌਫਟਵੇਅਰ ਲਈ ਹੋਰ ਸਮਝ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ. ਇਸ ਵਿਚ ਜ਼ਿਕਰ ਕੀਤੇ ਲੋਕਾਂ ਦਾ ਧੰਨਵਾਦ ਜਿਸ ਨੇ ਮੈਨੂੰ ਬੱਗ ਫਿਕਸ ਭੇਜਿਆ ਅਤੇ ਹੋਰ ਮਦਦ ਦਿੱਤੀ.
ਅਮਰੀਕੀ ਸਰਕਾਰ ਦੁਆਰਾ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਡਿਜਾਈਨ ਅਤੇ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣ ਦੇ ਅਮਲ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਇਸ ਲਈ ਜਨਤਕ ਖੇਤਰ ਵਿੱਚ ਹੈ. ਹਾਲਾਂਕਿ ਲੇਖਕ ਅਤੇ NIST ਕ੍ਰੈਡਿਟ ਨੂੰ ਪਸੰਦ ਕਰੇਗਾ ਜੇਕਰ ਇਹ ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਦਸਤਾਵੇਜ ਜਾਂ ਉਹਨਾਂ ਦੇ ਹਿੱਸੇ ਵਰਤੇ ਜਾਂਦੇ ਹਨ.