ಲಿನಕ್ಸ್ / ಯುನಿಕ್ಸ್ ಕಮಾಂಡ್ ಎಕ್ಸ್ಪೆಕ್ಟ್

ನಿರೀಕ್ಷೆ ಒಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಕಾರ ಇತರ ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಮಾತಾಡುವ ಒಂದು ಪ್ರೋಗ್ರಾಂ. ಸ್ಕ್ರಿಪ್ಟ್ ಅನುಸರಿಸಿ, ಎಕ್ಸ್ಪೆಕ್ಟ್ ಪ್ರೋಗ್ರಾಂನಿಂದ ಏನು ನಿರೀಕ್ಷಿಸಬಹುದು ಮತ್ತು ಸರಿಯಾದ ಪ್ರತಿಕ್ರಿಯೆ ಇರಬೇಕು ಎಂದು ತಿಳಿದಿದೆ. ವಿವರಣಾತ್ಮಕ ಭಾಷೆ ಸಂವಾದ ನಿರ್ದೇಶಿಸಲು ಶಾಖೆ ಮತ್ತು ಉನ್ನತ ಮಟ್ಟದ ನಿಯಂತ್ರಣ ರಚನೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದರ ಜೊತೆಯಲ್ಲಿ, ಬಳಕೆದಾರನು ನಿಯಂತ್ರಣವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಇಚ್ಛೆಯಿದ್ದಾಗ ನೇರವಾಗಿ ಸಂವಹನ ಮಾಡಬಹುದು, ನಂತರ ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ನಿಯಂತ್ರಣವನ್ನು ಹಿಂದಿರುಗಿಸಬಹುದು.

ಎಕ್ಸ್ಪೆಕ್ಕ್ ಎಂಬುದು ಎಕ್ಸ್ಪೆಕ್ಟ್ ಮತ್ತು ಟಿಕೆ ಮಿಶ್ರಣವಾಗಿದೆ. ಇದು ನಿರೀಕ್ಷೆ ಮತ್ತು ಟಿಕೆನ ಆಶಯದಂತೆಯೇ ವರ್ತಿಸುತ್ತದೆ. ನಿರೀಕ್ಷಿಸಬಹುದು ಟಿ ಅಥವಾ ಟಿ ಇಲ್ಲದೆ ಸಿ ಅಥವಾ ಸಿ ++ ನಲ್ಲಿ ನೇರವಾಗಿ ಬಳಸಬಹುದು.

"ಎಕ್ಸ್ಪೆಕ್ಟ್" ಎಂಬ ಹೆಸರು ಯುಯುಸಿಪಿ, ಕರ್ಮಿಟ್ ಮತ್ತು ಇತರ ಮೋಡೆಮ್ ನಿಯಂತ್ರಣ ಕಾರ್ಯಕ್ರಮಗಳಿಂದ ಜನಪ್ರಿಯಗೊಳಿಸಲ್ಪಟ್ಟ ಸರಣಿಗಳನ್ನು ಕಳುಹಿಸುವ / ನಿರೀಕ್ಷಿಸುವ ಪರಿಕಲ್ಪನೆಯಿಂದ ಬರುತ್ತದೆ. ಆದಾಗ್ಯೂ ಯುಯುಸಿಪಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಎಕ್ಸ್ಪೆಕ್ಟ್ ಅನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸಲಾಗುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಇದು ಬಳಕೆದಾರ-ಮಟ್ಟದ ಆಜ್ಞೆಯಂತೆ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಕೆಲಸವನ್ನು ಮನಸ್ಸಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ. ನಿರೀಕ್ಷಿಸಿ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಹಲವಾರು ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಮಾತನಾಡಬಹುದು.

ಏನು ನಿರೀಕ್ಷಿಸಬಹುದು

ಉದಾಹರಣೆಗೆ, ನಿರೀಕ್ಷೆ ಆಜ್ಞೆಯನ್ನು ಮಾಡಬಹುದಾದ ಕೆಲವು ವಿಷಯಗಳು ಇಲ್ಲಿವೆ:

• ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ಗೆ ಮರಳಿ ಡಯಲ್ ಮಾಡಲು ಕಾಸ್ ಮಾಡಿ, ಆದ್ದರಿಂದ ನೀವು ಕರೆಗೆ ಪಾವತಿಸದೆಯೇ ಲಾಗ್ ಇನ್ ಮಾಡಬಹುದು.
• ಆಟವನ್ನು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಸೂಕ್ತವಾದ ಸಂರಚನೆಯು ಕಾಣಿಸದಿದ್ದರೆ, ಅದನ್ನು ಪುನಃ ಪುನರಾರಂಭಿಸಿ) ಅದು ಮಾಡುವವರೆಗೆ, ತದನಂತರ ನಿಮಗೆ ನಿಯಂತ್ರಣವನ್ನು ಹಸ್ತಾಂತರಿಸು.
• Fsck ಅನ್ನು ಚಲಾಯಿಸಿ, ಅದರ ಪ್ರಶ್ನೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ, ಪೂರ್ವನಿರ್ಧರಿತ ಮಾನದಂಡವನ್ನು ಆಧರಿಸಿ, "ಹೌದು" ಅಥವಾ "ಇಲ್ಲ" ಎಂದು ಉತ್ತರಿಸಿ ಅಥವಾ ನಿಮಗೆ ನಿಯಂತ್ರಣವನ್ನು ಮರಳಿ ಕೊಡಿ.
• ಮತ್ತೊಂದು ನೆಟ್ವರ್ಕ್ಗೆ ಸಂಪರ್ಕಪಡಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಮೇಲ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹಿಂಪಡೆಯಿರಿ ಇದರಿಂದಾಗಿ ಇದು ನಿಮ್ಮ ಸ್ಥಳೀಯ ಸಿಸ್ಟಮ್ಗೆ ಕಳುಹಿಸಲ್ಪಟ್ಟಂತೆ ಕಾಣುತ್ತದೆ.
• ಪರಿಸರವಿಜ್ಞಾನ ವೇರಿಯಬಲ್ಗಳು, ಪ್ರಸಕ್ತ ಡೈರೆಕ್ಟರಿ, ಅಥವಾ ರೋಡ್ಜಿನ್, ಟೆಲ್ನೆಟ್, ಟಿಪ್, ಸು , ಅಥವಾ ಚಾಗ್ಪಿಪ್ನಂತಹ ಯಾವುದೇ ರೀತಿಯ ಮಾಹಿತಿಯನ್ನು ಪಡೆದುಕೊಳ್ಳಿ.

ಶೆಲ್ ಈ ಕಾರ್ಯಗಳನ್ನು ಏಕೆ ನಿರ್ವಹಿಸಬಾರದೆಂದು ಹಲವಾರು ಕಾರಣಗಳಿವೆ. ನಿರೀಕ್ಷಿಸಿ ಎಲ್ಲಾ ಸಾಧ್ಯವಿದೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಬಳಕೆದಾರರ ನಡುವೆ ಸಂವಹನ ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಾಲನೆ ಮಾಡಲು ಎಕ್ಸ್ಪೆಕ್ಟ್ ಉಪಯುಕ್ತವಾಗಿದೆ. ಅಗತ್ಯವಿರುವ ಎಲ್ಲವುಗಳೆಂದರೆ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಪ್ರೋಗ್ರಾಮ್ ಆಗಿ ನಿರೂಪಿಸಬಹುದು. ಪ್ರೋಗ್ರಾಂ ನಿಯಂತ್ರಿಸುವುದನ್ನು ನಿಲ್ಲಿಸದೆ ಬಳಕೆದಾರರಿಗೆ ನಿಯಂತ್ರಣವನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು. ಅಂತೆಯೇ, ಬಳಕೆದಾರರು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ನಿಯಂತ್ರಣವನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು.

ಬಳಕೆ

ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆದೇಶಗಳ ಪಟ್ಟಿಗಾಗಿ cmdfile ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ. # ಬೆಂಬಲಿಸುವ ಸಿಸ್ಟಮ್ಗಳಲ್ಲಿ ನಿರೀಕ್ಷಿತವಾಗಿ ನಿರೀಕ್ಷಿಸಬಹುದು! ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಲ್ಲದು ಮತ್ತು ಲಿಪಿಯಲ್ಲಿ ಮೊದಲ ಸಾಲು ಮಾಡುವ ಮೂಲಕ ಸಂಕೇತ:

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

ನಿಜಕ್ಕೂ, ಜೀವನವನ್ನು ನಿರೀಕ್ಷಿಸುವಾಗ ಮಾರ್ಗವು ನಿಖರವಾಗಿ ವಿವರಿಸಬೇಕು. / usr / local / bin ಕೇವಲ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

-c ಫ್ಲ್ಯಾಗ್ ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಯಾವುದಕ್ಕೂ ಮುಂಚಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆದೇಶವನ್ನು ಆದ್ಯತೆ ಮಾಡುತ್ತದೆ. ಶೆಲ್ನಿಂದ ಮುರಿಯುವುದನ್ನು ತಪ್ಪಿಸಲು ಆಜ್ಞೆಯನ್ನು ಉಲ್ಲೇಖಿಸಬೇಕು. ಈ ಆಯ್ಕೆಯನ್ನು ಅನೇಕ ಬಾರಿ ಬಳಸಬಹುದು. ಬಹು ಕಮಾಂಡ್ಗಳನ್ನು ಸಿ-ಸಿಲಿಯೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಸೆಮಿಕೋಲನ್ಗಳೊಂದಿಗೆ ಬೇರ್ಪಡಿಸುತ್ತದೆ. ಅವರು ಕಾಣಿಸಿಕೊಳ್ಳುವ ಆದೇಶದಲ್ಲಿ ಆದೇಶಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಎಕ್ಸ್ಪೆಕ್ಕ್ ಬಳಸುವಾಗ, ಈ ಆಯ್ಕೆಯನ್ನು -command ಎಂದು ಸೂಚಿಸಲಾಗಿದೆ.

-d ಫ್ಲ್ಯಾಗ್ ಕೆಲವು ಡಯಗ್ನೊಸ್ಟಿಕ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಶಕ್ತಗೊಳಿಸುತ್ತದೆ, ಇದು ಪ್ರಾಥಮಿಕವಾಗಿ ಆಂತರಿಕ ಚಟುವಟಿಕೆಗಳ ನಿರೀಕ್ಷೆಗಳನ್ನು ಮತ್ತು ಸಂವಾದದಂತಹ ಆಜ್ಞೆಗಳನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ. ಈ ಧ್ವಜವು "exp_internal 1" ನಂತೆಯೇ ಒಂದು ನಿರೀಕ್ಷಿತ ಸ್ಕ್ರಿಪ್ಟ್ ಆರಂಭದಲ್ಲಿ ಅದೇ ಪರಿಣಾಮವನ್ನು ಹೊಂದಿದೆ, ಜೊತೆಗೆ ಎಕ್ಸ್ಪೆಕ್ಟ್ ಆವೃತ್ತಿಯನ್ನು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.

-D ಫ್ಲ್ಯಾಗ್ ಸಂವಾದಾತ್ಮಕ ದೋಷಸೂಚಕವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಒಂದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಅನುಸರಿಸಬೇಕು. ಮೌಲ್ಯವು ಶೂನ್ಯವಲ್ಲದಿದ್ದರೆ ಅಥವಾ ಒಂದು ^ ಸಿ ಒತ್ತಿದರೆ ಅಥವಾ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಟ್ ಆಗಿದ್ದರೆ, ಅಥವಾ ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಇತರ ಸೂಕ್ತವಾದ ಡೀಬಗ್ಗರ್ ಕಮಾಂಡ್ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತಿದ್ದರೆ, ಡಿಬಗ್ಗರ್ ಮುಂದಿನ Tcl ಕಾರ್ಯವಿಧಾನದ ಮೊದಲು ನಿಯಂತ್ರಣವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಎಕ್ಸ್ಪೆಕ್ಕ್ ಬಳಸುವಾಗ, ಈ ಆಯ್ಕೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ - ಡೀಬಗ್.

-f ಫ್ಲ್ಯಾಗ್ ಆದೇಶಗಳನ್ನು ಓದಬೇಕಾದ ಫೈಲ್ ಅನ್ನು ಆದ್ಯತೆ ಮಾಡುತ್ತದೆ. # ಅನ್ನು ಬಳಸುವಾಗ ಮಾತ್ರ ಧ್ವಜ ಸ್ವತಃ ಐಚ್ಛಿಕವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ! ಸಂಕೇತನ, ಆದ್ದರಿಂದ ಇತರ ವಾದಗಳು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಸರಬರಾಜು ಮಾಡಬಹುದು. ಎಕ್ಸ್ಪೆಕ್ಕ್ ಬಳಸುವಾಗ, ಈ ಆಯ್ಕೆಯು -ಫೈಲ್ ಎಂದು ಸೂಚಿಸಲಾಗಿದೆ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಕಮ್ಯಾಂಡ್ ಫೈಲ್ ಮೆಮೊರಿಗೆ ಓದಲು ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. ಒಂದು ಸಮಯದಲ್ಲಿ ಫೈಲ್ಗಳನ್ನು ಒಂದು ಸಾಲಿನ ಓದಲು ಕೆಲವೊಮ್ಮೆ ಅಪೇಕ್ಷಣೀಯವಾಗಿದೆ. ಅನಿಯಂತ್ರಿತ ಫೈಲ್ಗಳನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಒತ್ತಾಯಿಸಲು, -b ಧ್ವಜವನ್ನು ಬಳಸಿ. ಎಕ್ಸ್ಪೆಕ್ಕ್ ಬಳಸುವಾಗ, ಈ ಆಯ್ಕೆಯನ್ನು -buffer ಎಂದು ಸೂಚಿಸಲಾಗಿದೆ.

ಸ್ಟ್ರಿಂಗ್ "-" ಅನ್ನು ಒಂದು ಕಡತನಾಮವಾಗಿ ಸರಬರಾಜು ಮಾಡಿದರೆ, ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಬದಲಿಗೆ ಓದುತ್ತದೆ. "-" ಹೆಸರಿನ ಫೈಲ್ನಿಂದ ಓದಲು "./-" ಅನ್ನು ಬಳಸಿ.

-i ಫ್ಲ್ಯಾಗ್ ಕಾರಣಗಳು ಕಡತದಿಂದ ಅವುಗಳನ್ನು ಓದುವ ಬದಲು ಆಜ್ಞೆಗಳಿಗೆ ಉತ್ತೇಜಿಸುವಂತೆ ನಿರೀಕ್ಷಿಸಿ. ಪ್ರಾಂಪ್ಟ್ ನಿರ್ಗಮನ ಆದೇಶದ ಮೂಲಕ ಅಥವಾ EOF ಮೇಲೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಆಜ್ಞಾ ಕಡತ ಅಥವಾ -c ಅನ್ನು ಬಳಸದೆ ಇದ್ದಲ್ಲಿ -i ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಊಹಿಸಲಾಗಿದೆ. ಎಕ್ಸ್ಪೆಕ್ಕ್ ಅನ್ನು ಬಳಸುವಾಗ, ಈ ಆಯ್ಕೆಯನ್ನು -ಇನ್ಆರ್ಯಾಕ್ಟಿವ್ ಎಂದು ಸೂಚಿಸಲಾಗಿದೆ.

- ಆಯ್ಕೆಗಳ ಅಂತ್ಯವನ್ನು ಬೇರ್ಪಡಿಸಲು ಬಳಸಬಹುದು. ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ಆಯ್ಕೆಯ ಆಯ್ಕೆಯಂತಹ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸಬೇಕಾದರೆ ಅದನ್ನು ಅರ್ಥೈಸಿಕೊಳ್ಳದಿದ್ದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಇದನ್ನು ಸುಲಭವಾಗಿ # ನಲ್ಲಿ ಇರಿಸಬಹುದು! ಎಕ್ಸ್ಪೆಕ್ಟ್ ಮೂಲಕ ಯಾವುದೇ ಧ್ವಜ ರೀತಿಯ ವ್ಯಾಖ್ಯಾನವನ್ನು ತಡೆಗಟ್ಟಲು ಲೈನ್. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನವು ವೇರಿಯೇಬಲ್ ಆರ್ಗ್ವಿನಲ್ಲಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಹೆಸರನ್ನು ಒಳಗೊಂಡಂತೆ ಮೂಲ ವಾದಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

#! / usr / local / bin / expect -

# ಗೆ ವಾದಗಳನ್ನು ಸೇರಿಸುವಾಗ ಸಾಮಾನ್ಯ getopt (3) ಮತ್ತು execve (2) ಸಂಪ್ರದಾಯಗಳನ್ನು ಗಮನಿಸಬೇಕು ಎಂಬುದನ್ನು ಗಮನಿಸಿ! ಸಾಲು.

$ Exp_library / expect.rc ಎಂಬ ಕಡತವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, -N ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಬಳಸದೆ ಇದ್ದಲ್ಲಿ ಅದು ಮೂಲವಾಗಿ ಮೂಲವಾಗಿರುತ್ತದೆ. (ಎಕ್ಸ್ಪೆಕ್ಕ್ ಬಳಸುವಾಗ, ಈ ಆಯ್ಕೆಯನ್ನು -NORC ಎಂದು ಸೂಚಿಸಲಾಗುತ್ತದೆ.) ತಕ್ಷಣದ ನಂತರ, -n ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಬಳಸದೆ ಇದ್ದಲ್ಲಿ, ~ / .expect.rc ಫೈಲ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮೂಲವಾಗಿರುತ್ತದೆ. ಪರಿಸರ ವೇರಿಯಬಲ್ DOTDIR ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ಅದನ್ನು ಕೋಶವಾಗಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು .expect.rc ಅಲ್ಲಿಂದ ಓದಲಾಗುತ್ತದೆ. ಎಕ್ಸ್ಪೆಕ್ಕ್ ಬಳಸುವಾಗ, ಈ ಆಯ್ಕೆಯನ್ನು -norc ಎಂದು ಸೂಚಿಸಲಾಗಿದೆ. ಯಾವುದೇ -c ಧ್ವಜಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ ಮಾತ್ರ ಈ ಸೋರ್ಸಿಂಗ್ ಸಂಭವಿಸುತ್ತದೆ.

-v ಕಾರಣಗಳು ಅದರ ಆವೃತ್ತಿ ಸಂಖ್ಯೆ ಮತ್ತು ನಿರ್ಗಮನವನ್ನು ಮುದ್ರಿಸಲು ನಿರೀಕ್ಷಿಸಿ. ದೀರ್ಘ ಧ್ವಜ ಹೆಸರುಗಳನ್ನು ಬಳಸುವ ಎಕ್ಸ್ಪೆಕ್ಕ್ನಲ್ಲಿನ ಅನುಗುಣವಾದ ಧ್ವಜವು -ವರ್ಗಾವಣೆಯಾಗಿದೆ.

ಐಚ್ಛಿಕ ಆರ್ಗ್ಗಳನ್ನು ಪಟ್ಟಿಗೆ ನಿರ್ಮಿಸಲಾಗಿದೆ ಮತ್ತು ವೇರಿಯೇಬಲ್ ಎಂಬ ಆರ್ಆರ್ವ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. argc ಯನ್ನು ಆರ್ಗ್ವ್ ಉದ್ದಕ್ಕೆ ಆರಂಭಿಸಲಾಗುತ್ತದೆ.

ಯಾವುದೇ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸದಿದ್ದರೆ ಆರ್ಗ್ವೆ 0 ನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ ಅಥವಾ ಬೈನರಿ ಹೆಸರಿನೆಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನವುಗಳು ಲಿಪಿಯ ಹೆಸರನ್ನು ಮತ್ತು ಮೊದಲ ಮೂರು ವಾದಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ:

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

ಆದೇಶಗಳು

ನಿರೀಕ್ಷೆ ಟೂಲ್ ಕಮಾಂಡ್ ಭಾಷೆ ಬಳಸುತ್ತದೆ. Tcl ನಿಯಂತ್ರಣ ಹರಿವನ್ನು (ವೇಳೆ, ಮುರಿಯಲು,), ಅಭಿವ್ಯಕ್ತಿ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು ಪುನರಾವರ್ತನೆ ಮತ್ತು ಕಾರ್ಯವಿಧಾನದ ವ್ಯಾಖ್ಯಾನದಂತಹ ಹಲವಾರು ಇತರ ಲಕ್ಷಣಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಬಳಸಲಾದ ಆದೇಶಗಳು ಆದರೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ (ಸೆಟ್, ವೇಳೆ, ಎಕ್ಸೆಕ್) Tcl ಆದೇಶಗಳು. ನಿರೀಕ್ಷಿಸಿ ಹೆಚ್ಚುವರಿ ಆಜ್ಞೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ ಸೂಚಿಸದೆ ಇದ್ದಲ್ಲಿ, ಆಜ್ಞೆಗಳು ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ.

ಆಜ್ಞೆಗಳನ್ನು ವರ್ಣಮಾಲೆಯಂತೆ ಪಟ್ಟಿಮಾಡಲಾಗಿದೆ, ಇದರಿಂದಾಗಿ ಅವುಗಳು ಬೇಗನೆ ನೆಲೆಗೊಳ್ಳಬಹುದು. ಆದಾಗ್ಯೂ, ಸ್ಪಾನ್ನ ವಿವರಣೆಗಳನ್ನು ಓದುವುದು, ನಿರೀಕ್ಷಿಸುವುದು ಮತ್ತು ಸಂವಹನ ಮಾಡುವುದರಿಂದ ಆ ಕ್ರಮದಲ್ಲಿ ಹೊಸ ಬಳಕೆದಾರರು ಸುಲಭವಾಗಿ ಪ್ರಾರಂಭಿಸಬಹುದು.

ಮುಚ್ಚಿ [-ಸ್ಲೇವ್] [-ಒಕ್ಸ್ಸೆಕ್ 0 | 1] [-i spawn_id]

ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚುತ್ತದೆ. ಹೆಚ್ಚಿನ ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳು ತಮ್ಮ STDIN ಮತ್ತು ನಿರ್ಗಮನದ ಮೇಲೆ EOF ಅನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ; ಹಾಗಾಗಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲಲು ಸಾಕಾಗುವುದಿಲ್ಲ. ಹೆಸರಿನ spawn_id ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಮುಚ್ಚುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು -i ಧ್ವಜವು ಘೋಷಿಸುತ್ತದೆ.

ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯು ಹೊರಬಂದಾಗ ಮತ್ತು ನಿಸ್ಸಂದೇಹವಾಗಿ ಮುಚ್ಚುವಾಗ ಎರಡೂ ಪರಸ್ಪರ ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ಸಂವಹಿಸುತ್ತದೆ, ಆದರೆ ನೀವು "exec kill $ pid" ಎಂದು ಹೇಳುವ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಂದು ಹಾಕಿದರೆ, ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ಹತ್ತಿರ ಕರೆ ಮಾಡಬೇಕು .

-ಒನ್ಸೆಕ್ ಫ್ಲ್ಯಾಗ್ ಸ್ಪಾನ್ ಐಡಿ ಅನ್ನು ಯಾವುದೇ ಹೊಸ ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಮುಚ್ಚಲಾಗಿದೆಯೇ ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯು ಮೇಲ್ಪದರವಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಒಂದು ಸ್ಪಾವ್ನ್ ಐಡಿ ಅನ್ನು ಮುಕ್ತಗೊಳಿಸಲು, ಮೌಲ್ಯವನ್ನು 0. ಬಳಸಿ. ಶೂನ್ಯೇತರ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವು ಸ್ಪಾನ್ ಯಾವುದೇ ಹೊಸ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ ಎಂದು ಒತ್ತಾಯಿಸುತ್ತದೆ.

-ಸ್ಲೇವ್ ಧ್ವಜವು ಸ್ಪಾವ್ನ್ ಐಡಿಗೆ ಸಂಬಂಧಿಸಿದ ಗುಲಾಮರನ್ನು ಮುಚ್ಚುತ್ತದೆ. ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚಿದಾಗ, ಅದು ಇನ್ನೂ ತೆರೆದಿದ್ದರೆ ಗುಲಾಮನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮುಚ್ಚಲ್ಪಡುತ್ತಾನೆ.

ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚಲಾಗಿದೆಯೇ ಅಥವಾ ಸ್ಪಷ್ಟವಾಗಿ ಮುಚ್ಚಲಾಗಿದೆಯೇ ಎಂಬುದರ ಕುರಿತು ಯಾವುದೇ ಸಂಬಂಧವಿಲ್ಲ, ಅನುಗುಣವಾದ ಕರ್ನಲ್ ಪ್ರಕ್ರಿಯೆ ಸ್ಲಾಟ್ ಅನ್ನು ತೆರವುಗೊಳಿಸಲು ನೀವು ಕಾಯಬೇಕು. ಪ್ರಕ್ರಿಯೆ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚುವುದರಿಂದ ಅದು ಹೊರಹೋಗಲು ಯಾವುದೇ ಗ್ಯಾರಂಟಿ ಇಲ್ಲದಿರುವುದರಿಂದ ನಿಕಟ ಆಜ್ಞೆಯು ಕಾಯುವಿಕೆಯನ್ನು ಕರೆಯುವುದಿಲ್ಲ.

ಡಿಬಗ್ [[-now] 0 | 1]

ಹೇಳಿಕೆಗಳ ಮೂಲಕ ಹೆಜ್ಜೆ ಹಾಕಲು ಮತ್ತು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ಗಳನ್ನು ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಟಿಎಲ್ಎಲ್ ದೋಷಸೂಚಕವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ.

ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳಿಲ್ಲದೆ, ಡಿಬಗ್ಗರ್ ಚಾಲನೆಯಲ್ಲಿಲ್ಲದಿದ್ದರೆ 1 ಮರಳುತ್ತದೆ, ಇಲ್ಲವಾದರೆ 0 ಮರಳುತ್ತದೆ.

1 ವಾದದೊಂದಿಗೆ, ದೋಷಸೂಚಕವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. 0 ರ ವಾದದೊಂದಿಗೆ, ದೋಷಸೂಚಕವನ್ನು ನಿಲ್ಲಿಸಲಾಗಿದೆ. 1 ವಾದವನ್ನು -now ಧ್ವಜವು ಮುಂಚಿತವಾಗಿ ಮುಂಚಿತವಾಗಿದ್ದರೆ, ಡೀಬಗರ್ ಅನ್ನು ತಕ್ಷಣವೇ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಡಿಬಗ್ಗರ್ ಮುಂದಿನ Tcl ಹೇಳಿಕೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಡಿಬಗ್ ಆಜ್ಞೆಯು ಯಾವುದೇ ಬಲೆಗಳನ್ನು ಬದಲಿಸುವುದಿಲ್ಲ. ಇದನ್ನು ಆರಂಭಿಸಿ -D ಧ್ವಜದೊಂದಿಗೆ ನಿರೀಕ್ಷಿಸಿ.

ಸಂಪರ್ಕ ಕಡಿತ ಆಜ್ಞೆಯು ಟರ್ಮಿನಲ್ನಿಂದ ಫೊರ್ಕ್ ಮಾಡಿದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಪರ್ಕಿಸುತ್ತದೆ . ಇದು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ. ಪ್ರಕ್ರಿಯೆಯು ತನ್ನದೇ ಆದ ಪ್ರಕ್ರಿಯೆ ಸಮೂಹವನ್ನು ನೀಡಲಾಗುತ್ತದೆ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ I / O ಅನ್ನು / dev / null ಗೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ.

ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಮುಂದುವರಿಸಲು ಕೆಳಗಿನ ತುಣುಕು ಸಂಪರ್ಕ ಕಡಿತಗೊಳಿಸುತ್ತದೆ.

ವೇಳೆ {[fork]! = 0} ಸಂಪರ್ಕ ಕಡಿತಗೊಂಡಿದೆ. . .

ಮುಂದಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ನಂತರ ಪ್ರತಿ ಬಾರಿಯೂ ಅದು ರನ್ ಆಗುವ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಒತ್ತಾಯಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಪೂರೈಸುತ್ತದೆ ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಟೈಪ್ ಮಾಡಬೇಕು.

send_user "ಪಾಸ್ವರ್ಡ್? \" ನಿರೀಕ್ಷಿತ_ಸೂಸರ್ -re "(. *) \ n" ಫಾರ್ {} ಫಾರ್ {{{ಫಾರ್ಕ್]! = 0} {ಸ್ಲೀಪ್ 3600; ಮುಂದುವರಿಸು} ಸಂಪರ್ಕ ಕಡಿತಗೊಳಿಸು priv_prog ಪಾಸ್ವರ್ಡ್ ನಿರೀಕ್ಷಿಸು: "$ expect_out ಅನ್ನು ಕಳುಹಿಸಿ 1, ಸ್ಟ್ರಿಂಗ್) \ r ". . . ನಿರ್ಗಮನ}

ಶೆಲ್ ಅಸಮಕಾಲಿಕ ಪ್ರಕ್ರಿಯೆಯ ವೈಶಿಷ್ಟ್ಯವನ್ನು (&) ಕಡಿತಗೊಳಿಸುವುದನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಅನುಕೂಲವೆಂದರೆ ನಿರೀಕ್ಷೆ ಡಿಸ್ಕನೆಕ್ಷನ್ಗೆ ಮುಂಚಿತವಾಗಿ ಟರ್ಮಿನಲ್ ನಿಯತಾಂಕಗಳನ್ನು ಉಳಿಸಬಹುದು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಹೊಸ ಪಿಟಿಗಳಿಗೆ ಅನ್ವಯಿಸಬಹುದು. ಜೊತೆಗೆ, ಟರ್ಮಿನಲ್ನ ನಿಯತಾಂಕಗಳನ್ನು ಓದಲು ನಿರೀಕ್ಷೆಯಿಲ್ಲ ಏಕೆಂದರೆ ಟರ್ಮಿನಲ್ ಈಗಾಗಲೇ ಸಮಯದಿಂದ ಸಂಪರ್ಕ ಕಡಿತಗೊಂಡಿದೆ ನಿಯಂತ್ರಣ ನಿರೀಕ್ಷೆಯನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ.

ನಿರ್ಗಮನ [-ಓಟ್ಸ್] [ಸ್ಥಿತಿ]

ಕಾರಣಗಳು ನಿರ್ಗಮಿಸಲು ನಿರೀಕ್ಷಿಸಿ ಅಥವಾ ಹಾಗೆ ಮಾಡಲು ತಯಾರು.

-ಒನ್ಕ್ಸಿಟ್ ಫ್ಲ್ಯಾಗ್ ಮುಂದಿನ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ನಿರ್ಗಮನ ಹ್ಯಾಂಡ್ಲರ್ ಆಗಿ ಬಳಸಿಕೊಳ್ಳುವಂತೆ ಮಾಡುತ್ತದೆ. ವಾದವಿಲ್ಲದೆ, ಪ್ರಸ್ತುತ ನಿರ್ಗಮನ ಹ್ಯಾಂಡ್ಲರ್ ಮರಳಿದೆ.

-ಅನಾಕ್ಸಿಟ್ ಧ್ವಜವು ನಿರ್ಗಮಿಸಲು ತಯಾರಾಗಲು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಆದರೆ ವಾಸ್ತವವಾಗಿ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ಗೆ ನಿಯಂತ್ರಣವನ್ನು ಹಿಂತಿರುಗಿಸುವ ನಿಟ್ಟನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ. ಬಳಕೆದಾರ-ನಿರ್ಧಾರಿತ ನಿರ್ಗಮನ ಹ್ಯಾಂಡ್ಲರ್ನ ಜೊತೆಗೆ ಆಂತರಿಕ ಹ್ಯಾಂಡ್ಲರ್ಗಳ ನಿರೀಕ್ಷೆ ಇದೆ. ಇನ್ನೂ ಹೆಚ್ಚಿನ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಾರದು. ನೀವು ಇತರ ಟಿಎಲ್ಎಲ್ ಎಕ್ಸ್ಟೆನ್ಶನ್ಗಳೊಂದಿಗೆ ನಿರೀಕ್ಷಿಸುತ್ತಿರುವುದನ್ನು ರನ್ ಮಾಡುತ್ತಿದ್ದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಪ್ರಸಕ್ತ ಇಂಟರ್ಪ್ರಿಟರ್ (ಮತ್ತು TK ಪರಿಸರದಲ್ಲಿ ವೇಳೆ ಮುಖ್ಯ ವಿಂಡೋ) ಉಳಿದಂತೆ ಇತರ Tcl ವಿಸ್ತರಣೆಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಬಹುದು. ನಿರೀಕ್ಷೆಯ ವೇಳೆ ನಿರ್ಗಮನವನ್ನು ಮತ್ತೆ ಕರೆಯಲಾಗುವುದು (ಆದರೆ ಇದು ಸಂಭವಿಸಬಹುದು), ಹ್ಯಾಂಡ್ಲರ್ಗಳು ಮರುಪ್ರಸಾರಗೊಳ್ಳುವುದಿಲ್ಲ.

ನಿರ್ಗಮಿಸಿದ ನಂತರ, ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಎಲ್ಲಾ ಸಂಪರ್ಕಗಳನ್ನು ಮುಚ್ಚಲಾಗಿದೆ. ಮುಚ್ಚಿದ ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ಮುಚ್ಚುವಿಕೆಯನ್ನು EOF ಎಂದು ಕಂಡುಹಿಡಿಯಲಾಗುತ್ತದೆ. ನಿರ್ಗಮನವು ಸಾಮಾನ್ಯವಾದ _exit (2) ಕಾರ್ಯವಿಧಾನವನ್ನು ಮೀರಿದ ಯಾವುದೇ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. ಹೀಗಾಗಿ, EOF ಗಾಗಿ ಪರೀಕ್ಷಿಸದೆ ಇರುವ ಪ್ರಕ್ರಿಯೆಗಳು ಚಾಲನೆಯಾಗುವುದನ್ನು ಮುಂದುವರೆಸಬಹುದು. (ವಿವಿಧ ಪರಿಸ್ಥಿತಿಗಳು ನಿರ್ಧರಿಸಲು ಪ್ರಮುಖವಾಗಿವೆ, ಉದಾಹರಣೆಗೆ, ಒಂದು ಬೆಳವಣಿಗೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಯಾವ ಸಂಕೇತಗಳನ್ನು ಕಳುಹಿಸಲಾಗುವುದು, ಆದರೆ ಅವುಗಳು ವ್ಯವಸ್ಥೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತವೆ, ವಿಶಿಷ್ಟವಾಗಿ ನಿರ್ಗಮನ (3) ಅಡಿಯಲ್ಲಿ ದಾಖಲಾಗಿವೆ.) ಮುಂದುವರೆಸುವ ಪ್ರಕ್ರಿಯೆಗಳು init ಮೂಲಕ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಲ್ಪಡುತ್ತವೆ.

ಸ್ಥಿತಿ (ಅಥವಾ 0 ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದಲ್ಲಿ) ನಿರೀಕ್ಷಿಸುವ ನಿರ್ಗಮನ ಸ್ಥಿತಿಯಂತೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಲಿಪಿಯ ಅಂತ್ಯವು ತಲುಪಿದರೆ ನಿರ್ಗಮನವು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ.

exp_continue [-continue_timer]
Exp_continue ಎಂಬ ಆಜ್ಞೆಯು ಸ್ವತಃ ಸಾಮಾನ್ಯವಾಗಿ ವಾಪಸಾಗುವುದಕ್ಕಿಂತ ಹಿಂದಿರುಗುವುದನ್ನು ಮುಂದುವರೆಸುವುದನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ . ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ exp_continue ಕಾಲಾವಧಿ ಟೈಮರ್ ಅನ್ನು ಮರುಹೊಂದಿಸುತ್ತದೆ. -continue_timer ಫ್ಲ್ಯಾಗ್ ಟೈಮರ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸದಂತೆ ತಡೆಯುತ್ತದೆ. (ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ನಿರೀಕ್ಷಿಸಿ ನೋಡಿ.)

exp_internal [-f ಕಡತ] ಮೌಲ್ಯ
ಮೌಲ್ಯವು ಶೂನ್ಯವಲ್ಲದಿದ್ದರೆ stderr ಗೆ ನಿರೀಕ್ಷಿಸಿರಿ ಆಂತರಿಕ ರೋಗನಿರ್ಣಯದ ಮಾಹಿತಿಯನ್ನು ಕಳುಹಿಸಲು ಮತ್ತಷ್ಟು ಆಜ್ಞೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಮೌಲ್ಯವು 0 ಆಗಿದ್ದರೆ ಈ ಔಟ್ಪುಟ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ. ರೋಗನಿರ್ಣಯದ ಮಾಹಿತಿಯು ಪ್ರತಿ ಅಕ್ಷರವನ್ನು ಪಡೆದುಕೊಂಡಿರುತ್ತದೆ ಮತ್ತು ಮಾದರಿಗಳ ವಿರುದ್ಧ ಪ್ರಸ್ತುತ ಉತ್ಪನ್ನವನ್ನು ಹೊಂದಿಸಲು ಮಾಡಿದ ಪ್ರತಿಯೊಂದು ಪ್ರಯತ್ನವನ್ನೂ ಒಳಗೊಂಡಿದೆ.

ಐಚ್ಛಿಕ ಫೈಲ್ ಸರಬರಾಜು ಮಾಡಿದರೆ, ಎಲ್ಲಾ ಸಾಮಾನ್ಯ ಮತ್ತು ಡೀಬಗ್ ಔಟ್ಪುಟ್ಗಳನ್ನು ಆ ಫೈಲ್ಗೆ (ಮೌಲ್ಯದ ಮೌಲ್ಯದ ಹೊರತಾಗಿ ) ಬರೆಯಲಾಗುತ್ತದೆ. ಹಿಂದಿನ ಯಾವುದೇ ಡಯಗ್ನೊಸ್ಟಿಕ್ ಔಟ್ಪುಟ್ ಫೈಲ್ ಅನ್ನು ಮುಚ್ಚಲಾಗಿದೆ.

-ಇನ್ಫೋ ಧ್ವಜವು ಇತ್ತೀಚಿನ ಇತ್ತೀಚಿನ ಮಾಹಿತಿಯಲ್ಲದ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳ ವಿವರಣೆಯನ್ನು ಮರಳಿ ನೀಡಲು exp_internal ಕಾರಣವಾಗುತ್ತದೆ.

exp_open [args] [-i spawn_id]
ಮೂಲ ಸ್ಪಾನ್ ಐಡಿಗೆ ಅನುಗುಣವಾದ Tcl ಫೈಲ್ ಐಡೆಂಟಿಫೈಯರ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಕಡತ ಗುರುತಿಸುವಿಕೆ Tcl ಯ ಮುಕ್ತ ಆಜ್ಞೆಯಿಂದ ತೆರೆಯಲ್ಪಟ್ಟಂತೆ ಅದನ್ನು ಬಳಸಬಹುದು. (ಸ್ಪಾನ್ ಐಡಿ ಇನ್ನು ಮುಂದೆ ಬಳಸಬಾರದು.ಒಂದು ಕಾಯುವಿಕೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಾರದು.

-ಲಿವಿಯೋಪೆನ್ ಫ್ಲ್ಯಾಗ್ ಸ್ಪಾನ್ ಐಡಿ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಆದೇಶಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು. ಸ್ಪಾವ್ನ್ ಐಡಿನಲ್ಲಿ ಕಾಯುವಿಕೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು.

exp_pid [-i spawn_id]
ಪ್ರಸ್ತುತ ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗೆ ಅನುಗುಣವಾದ ಪ್ರಕ್ರಿಯೆಯ ಐಡಿ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. -i ಧ್ವಜವನ್ನು ಬಳಸಿದರೆ, ಪಿಡ್ ನೀಡಲಾದ ಸ್ಪಾನ್ ಐಡಿಗೆ ಅನುಗುಣವಾಗಿ ಮರಳಿದೆ.

exp_send
ಕಳುಹಿಸಲು ಅಲಿಯಾಸ್ ಆಗಿದೆ.

exp_send_error
send_error ಗೆ ಅಲಿಯಾಸ್ ಆಗಿದೆ.

exp_send_log
ಇದು send_log ಗಾಗಿ ಅಲಿಯಾಸ್ ಆಗಿದೆ.

exp_send_tty
send_tty ಗೆ ಅಲಿಯಾಸ್ ಆಗಿದೆ.

exp_send_user
send_user ಗೆ ಅಲಿಯಾಸ್ ಆಗಿದೆ.

exp_version [[-exit] ಆವೃತ್ತಿ]
ಎಕ್ಸ್ಪ್ಟೆಕ್ಟ್ ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಹೊಂದಬಲ್ಲ ಎಂದು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಲು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಯಾವುದೇ ಚರ್ಚೆಗಳಿಲ್ಲದೆ, ಎಕ್ಸ್ಪೆಕ್ಟ್ನ ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಯನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗಿದೆ. ಈ ಆವೃತ್ತಿಯನ್ನು ನಿಮ್ಮ ಲಿಪಿಯಲ್ಲಿ ಎನ್ಕೋಡ್ ಮಾಡಬಹುದು. ನೀವು ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸುತ್ತಿಲ್ಲ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದ್ದರೆ, ನೀವು ಹಿಂದಿನ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ಆವೃತ್ತಿಗಳು ಚುಕ್ಕೆಗಳಿಂದ ಬೇರ್ಪಟ್ಟ ಮೂರು ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಮೊದಲನೆಯದು ಪ್ರಮುಖ ಸಂಖ್ಯೆ. ವಿವಿಧ ಪ್ರಮುಖ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ನಿರೀಕ್ಷಿಸಿರುವ ಆವೃತ್ತಿಗಳಿಗೆ ಬರೆಯಲಾದ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು ಬಹುತೇಕ ಖಚಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಪ್ರಮುಖ ಸಂಖ್ಯೆಗಳು ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ exp_version ಒಂದು ದೋಷವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಎರಡನೆಯದು ಚಿಕ್ಕ ಸಂಖ್ಯೆ. ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಗಿಂತ ಹೆಚ್ಚಿನ ಸಣ್ಣ ಸಂಖ್ಯೆಯ ಆವೃತ್ತಿಯೊಂದಕ್ಕೆ ಬರೆದ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು ಕೆಲವು ಹೊಸ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಅವಲಂಬಿಸಿರಬಹುದು ಮತ್ತು ರನ್ ಆಗದಿರಬಹುದು. ಪ್ರಮುಖ ಸಂಖ್ಯೆಗಳು ಹೊಂದಾಣಿಕೆಯಾದರೆ exp_version ಒಂದು ದೋಷವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆದರೆ ಸ್ಕ್ರಿಪ್ಟ್ ಸಣ್ಣ ಸಂಖ್ಯೆಯು ಚಾಲನೆಯಲ್ಲಿರುವ ಎಕ್ಸ್ಪೆಕ್ಟ್ಗಿಂತ ಹೆಚ್ಚಾಗಿದೆ .

ಮೂರನೆಯದು ಆವೃತ್ತಿ ಹೋಲಿಕೆಯಲ್ಲಿ ಯಾವುದೇ ಪಾತ್ರವನ್ನು ವಹಿಸುವ ಸಂಖ್ಯೆಯಾಗಿದೆ. ಆದರೆ, ಹೆಚ್ಚುವರಿ ದಸ್ತಾವೇಜನ್ನು ಅಥವಾ ಆಪ್ಟಿಮೈಸೇಶನ್ ಮೂಲಕ ಸಾಫ್ಟ್ವೇರ್ ವಿತರಣೆಯನ್ನು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಬದಲಿಸಿದಾಗ ಅದು ಹೆಚ್ಚಾಗುತ್ತದೆ. ಪ್ರತಿ ಹೊಸ ಚಿಕ್ಕ ಆವೃತ್ತಿಗೆ ಇದು 0 ಗೆ ಮರುಹೊಂದಿಸಲಾಗುತ್ತದೆ.

-ಎಕ್ಸಿಟ್ ಫ್ಲ್ಯಾಗ್ನೊಂದಿಗೆ, ಪ್ರಿಂಟ್ಗಳನ್ನು ದೋಷದಲ್ಲಿ ನಿರೀಕ್ಷಿಸಿ ಮತ್ತು ಆವೃತ್ತಿ ಹಳೆಯದಾದಿದ್ದರೆ ನಿರ್ಗಮಿಸುತ್ತದೆ.

ಪ್ಯಾಟ್ನ್ [ದೇಹ]
ನಮೂನೆಯು ಒಂದು ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಯ ಔಟ್ಪುಟ್ಗೆ ಸರಿಹೊಂದುವವರೆಗೆ, ನಿಗದಿತ ಕಾಲಾವಧಿ ಮುಗಿದಿದೆ, ಅಥವಾ ಒಂದು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ ತನಕ ಕಾಯುತ್ತದೆ. ಅಂತಿಮ ದೇಹವು ಖಾಲಿಯಾಗಿದ್ದರೆ, ಇದನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು.

ಇತ್ತೀಚಿನ ನಿರೀಕ್ಷೆಗಿಂತ ಮೊದಲಿನ ಆಜ್ಞೆಯಿಂದ ಪ್ಯಾಟರ್ನ್ಸ್ ಯಾವುದೇ ಇತರ ಮಾದರಿಗಳಿಗಿಂತ ಮೊದಲು ಬಳಸಲ್ಪಡುತ್ತದೆ. ಅತ್ಯಂತ ಇತ್ತೀಚಿನ ನಿರೀಕ್ಷೆ- ಆಜ್ಞೆಯಿಂದ ಮಾಡಲಾದ ಪ್ಯಾಟರ್ನ್ಸ್ ಯಾವುದೇ ಇತರ ಮಾದರಿಗಳ ನಂತರ ಸೂಚ್ಯವಾಗಿ ಬಳಸಲ್ಪಡುತ್ತವೆ.

ಸಂಪೂರ್ಣ ನಿರೀಕ್ಷಣಾ ಹೇಳಿಕೆಗೆ ವಾದಗಳು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಸಾಲಿನ ಅಗತ್ಯವಿದ್ದರೆ, ಪ್ರತಿಯೊಂದು ಸಾಲುಗಳನ್ನು ಬ್ಯಾಕ್ಸ್ಲಾಶ್ನೊಂದಿಗೆ ಕೊನೆಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಎಲ್ಲಾ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳನ್ನು "ಬ್ರೇಸ್ಡ್" ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು. ಈ ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ, ಕಟ್ಟುಪಟ್ಟಿಗಳ ಹೊರತಾಗಿಯೂ ಸಾಮಾನ್ಯ Tcl ಪರ್ಯಾಯಗಳು ಸಂಭವಿಸುತ್ತವೆ.

ಒಂದು ನಮೂನೆ ಕೀವರ್ಡ್ ಎಫ್ಎಫ್ ಆಗಿದ್ದರೆ , ಅನುಗುಣವಾದ ದೇಹವನ್ನು ಫೈಲ್ನ ಅಂತ್ಯದ ಮೇಲೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಒಂದು ಮಾದರಿ ಕೀವರ್ಡ್ ಅವಧಿ ಮೀರಿದ್ದರೆ , ಕಾಲಾವಧಿಯಲ್ಲಿ ಅನುಗುಣವಾದ ದೇಹದ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. ಕಾಲಾವಧಿಯ ಕೀವರ್ಡ್ ಬಳಸದಿದ್ದರೆ, ಕಾಲಾವಧಿಯಲ್ಲಿ ಒಂದು ಸೂಚ್ಯ ಶೂನ್ಯ ಕ್ರಿಯೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ ಕಾಲಾವಧಿ ಅವಧಿಯು 10 ಸೆಕೆಂಡುಗಳು ಆದರೆ "ಸೆಟ್ ಟೈಮ್ಔಟ್ 30" ಆಜ್ಞೆಯಿಂದ 30 ಗೆ ಉದಾಹರಣೆಗೆ, ಹೊಂದಿಸಬಹುದಾಗಿದೆ. ಅನಂತ ಸಮಯಮೀರಿದ ಮೌಲ್ಯವನ್ನು -1 ರಿಂದ ಗೊತ್ತುಪಡಿಸಬಹುದು. ಒಂದು ನಮೂನೆ ಕೀವರ್ಡ್ ಡೀಫಾಲ್ಟ್ ಆಗಿದ್ದರೆ, ಅನುಗುಣವಾದ ದೇಹವನ್ನು ಕಾಲಾವಧಿ ಅಥವಾ ಅಂತ್ಯದ ಫೈಲ್ ಮೇಲೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಒಂದು ಮಾದರಿಯು ಹೋಲಿಕೆಯಾದರೆ, ಅನುಗುಣವಾದ ದೇಹವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ದೇಹದ ಫಲಿತಾಂಶವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು (ಅಥವಾ ಯಾವುದೇ ಮಾದರಿಯು ಹೊಂದಿರದಿದ್ದರೆ ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್). ಬಹು ಮಾದರಿಯು ಹೊಂದಾಣಿಕೆಯಾಗುವ ಸಂದರ್ಭದಲ್ಲಿ, ಮೊದಲ ಬಾರಿಗೆ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಒಂದು ದೇಹವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಪ್ರತಿ ಬಾರಿ ಹೊಸ ಔಟ್ಪುಟ್ ಆಗಮಿಸಿದಾಗ, ಅದನ್ನು ಪಟ್ಟಿ ಮಾಡಲಾದ ಕ್ರಮದಲ್ಲಿ ಪ್ರತಿ ಮಾದರಿಗೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ಒಂದು ಪ್ರಾಂಪ್ಟ್ ನಂತಹ ಕೊನೆಯ ಮಾದರಿಯನ್ನು ಕಾಣಿಸಿಕೊಳ್ಳಲು ಖಾತರಿಪಡಿಸುವ ಮೂಲಕ ಪಂದ್ಯದ ಅನುಪಸ್ಥಿತಿಯಲ್ಲಿ ನೀವು ಪರೀಕ್ಷಿಸಬಹುದಾಗಿದೆ. ಯಾವುದೇ ಪ್ರಾಂಪ್ಟ್ ಇಲ್ಲದ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು ಕಾಲಾವಧಿ ತೆಗೆದುಕೊಳ್ಳಬೇಕು (ನೀವು ಕೈಯಾರೆ ಸಂವಹನ ನಡೆಸುತ್ತಿದ್ದರೆ).

ನಮೂನೆಗಳನ್ನು ಮೂರು ವಿಧಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನಮೂನೆಗಳನ್ನು Tcl ಯ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚ್ ಆಜ್ಞೆಯಂತೆ ಸೂಚಿಸಲಾಗಿದೆ. (ಇಂತಹ ಮಾದರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ "ಗ್ಲೋಬ್" ಮಾದರಿಗಳೆಂದು ಕರೆಯಲ್ಪಡುವ ಸಿ-ಶೆಲ್ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳಿಗೆ ಹೋಲುತ್ತವೆ). ಫ್ಲ್ಯಾಗ್ಗಳನ್ನು ಹಾಗೆ ಮಾಡಲು ನಿರೀಕ್ಷಿಸದಂತಹ ಮಾದರಿಗಳನ್ನು ರಕ್ಷಿಸಲು -gl ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಬಳಸಬಹುದು. "-" ಆರಂಭಗೊಂಡು ಯಾವುದೇ ಮಾದರಿಯನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ರಕ್ಷಿಸಬೇಕು. ("-" ಪ್ರಾರಂಭವಾಗುವ ಎಲ್ಲಾ ತಂತಿಗಳು ಭವಿಷ್ಯದ ಆಯ್ಕೆಗಳಿಗಾಗಿ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ.)

ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ತುಣುಕು ಯಶಸ್ವಿ ಲಾಗಿನ್ಗಾಗಿ ಕಾಣುತ್ತದೆ. ( ಸ್ಥಗಿತವು ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಬೇರೆಡೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಕಾರ್ಯವಿಧಾನವೆಂದು ಭಾವಿಸಲಾಗಿದೆ.)

{ಬಿಡುವಿಲ್ಲದ {ನಿರತವಾದ \ n; exp_continue} ವಿಫಲಗೊಂಡಿದೆ "ಅಮಾನ್ಯವಾದ ಗುಪ್ತಪದ" ವಿಫಲಗೊಂಡಿದೆ ಕಾಲಾವಧಿ ಸ್ಥಗಿತಗೊಳಿಸು ಸಂಪರ್ಕವನ್ನು ಸ್ಥಗಿತಗೊಳಿಸು}

ಅದು ಜಾಗವನ್ನು ಒಳಗೊಂಡಿರುವ ಕಾರಣ ನಾಲ್ಕನೆಯ ಮಾದರಿಯಲ್ಲಿ ಉಲ್ಲೇಖಗಳು ಅವಶ್ಯಕವಾಗಿರುತ್ತವೆ, ಅದು ಕ್ರಿಯೆಯಿಂದ ಮಾಡಲಾದ ಮಾದರಿಯನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ. ಅದೇ ಕ್ರಿಯೆ (3 ನೆಯ ಮತ್ತು 4 ನೆಯಂತಹವು) ಹೊಂದಿರುವ ವಿಧಾನಗಳು ಮತ್ತೆ ಕ್ರಿಯೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದು ರಿಜೆಕ್ಸ್ ಶೈಲಿಯ ಶೈಲಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಕೆಳಗಿಳಿಯಬಹುದು (ಕೆಳಗೆ ನೋಡಿ). ಗ್ಲೋಬ್-ಶೈಲಿಯ ಮಾದರಿಗಳನ್ನು ರಚಿಸುವ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಳನ್ನು Tcl ಮ್ಯಾನ್ಯುವಲ್ನಲ್ಲಿ ಕಾಣಬಹುದು.

Regexp- ಶೈಲಿಯ ಮಾದರಿಗಳು Tcl ಯ ರೆಜೆಕ್ಸ್ ("ಸಾಮಾನ್ಯ ಅಭಿವ್ಯಕ್ತಿ" ಗಾಗಿ ಸಣ್ಣ) ಆದೇಶದಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲ್ಪಟ್ಟ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಅನುಸರಿಸುತ್ತವೆ. ರೆಗ್ಜೆಪ್ ಮಾದರಿಗಳನ್ನು ಧ್ವಜದಿಂದ ಪರಿಚಯಿಸಲಾಗಿದೆ. ಹಿಂದಿನ ಉದಾಹರಣೆಯನ್ನು ರೀಜೆಕ್ಸ್ ಬಳಸಿ ಹಿಂದಿನ ಉದಾಹರಣೆಯನ್ನು ಬರೆಯಬಹುದು:

{ಬಿಡುವಿಲ್ಲದ {ನಿರತವಾದ \ n; exp_continue} - ಅಥವಾ "ವಿಫಲವಾಗಿದೆ | ಅಮಾನ್ಯವಾದ ಪಾಸ್ವರ್ಡ್" ಕಾಲಾವಧಿ ಸ್ಥಗಿತಗೊಳಿಸಿ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಗಿತಗೊಳಿಸು}

ಎರಡೂ ಬಗೆಯ ಮಾದರಿಗಳು "ಅನುಪಯುಕ್ತವಾಗಿರುತ್ತವೆ". ಇದರರ್ಥ ನಮೂನೆಗಳು ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್ಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕಿಲ್ಲ, ಆದರೆ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಎಲ್ಲಿಯಾದರೂ ಪಂದ್ಯವನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು ಮತ್ತು ಅಂತ್ಯಗೊಳಿಸಬಹುದು (ಎಲ್ಲವೂ ಸರಿಹೊಂದದವರೆಗೆ). ಸ್ಟ್ರಿಂಗ್ನ ಆರಂಭಕ್ಕೆ ಹೊಂದಿಸಲು ^ ಅನ್ನು ಬಳಸಿ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಹೊಂದಿಸಲು $. ಸ್ಟ್ರಿಂಗ್ನ ಅಂತ್ಯದವರೆಗೆ ನೀವು ನಿರೀಕ್ಷಿಸದಿದ್ದಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್ ಮಧ್ಯದಲ್ಲಿ ನಿಮ್ಮ ಪ್ರತಿಸ್ಪಂದನಗಳು ಸುಲಭವಾಗಿ ಕೊನೆಗೊಳ್ಳಬಹುದು, ಏಕೆಂದರೆ ಅವುಗಳು ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಪ್ರತಿಧ್ವನಿಯಾಗುತ್ತವೆ. ಇನ್ನೂ ಸರಿಯಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತಿರುವಾಗ, ಔಟ್ಪುಟ್ ಅಸಹಜವಾಗಿ ಕಾಣುತ್ತದೆ. ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ನ ಕೊನೆಯಲ್ಲಿ ಅಕ್ಷರಗಳನ್ನು ನಿಖರವಾಗಿ ವಿವರಿಸಿದರೆ $ ನ ಬಳಕೆಯನ್ನು ಪ್ರೋತ್ಸಾಹಿಸಲಾಗುತ್ತದೆ.

ಅನೇಕ ಸಂಪಾದಕರಲ್ಲಿ, ^^ ಮತ್ತು $ ಅನುಕ್ರಮವಾಗಿ ಕ್ರಮಗಳು ಆರಂಭ ಮತ್ತು ಅಂತ್ಯಕ್ಕೆ ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತವೆ. ಆದಾಗ್ಯೂ, ನಿರೀಕ್ಷೆ ಲೈನ್ ಆಧಾರಿತವಲ್ಲ ಏಕೆಂದರೆ, ಈ ಅಕ್ಷರಗಳು ಪ್ರಸ್ತುತ ಹೊಂದಾಣಿಕೆಯ ಬಫರ್ ನಿರೀಕ್ಷೆಯಲ್ಲಿ ಡಾಟಾದ ಆರಂಭ ಮತ್ತು ಅಂತ್ಯದೊಂದಿಗೆ (ರೇಖೆಗಳಿಗೆ ವಿರುದ್ಧವಾಗಿ) ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತವೆ. (ಅಲ್ಲದೆ, "ಸಿಸ್ಟಮ್ ಅಜೀರ್ಣ" ದಲ್ಲಿ ಕೆಳಗಿನ ಟಿಪ್ಪಣಿ ನೋಡಿ.)

-ex ಫ್ಲ್ಯಾಗ್ ಮಾದರಿಯನ್ನು "ನಿಖರವಾದ" ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಹೊಂದಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. *, ^, ಇತ್ಯಾದಿಗಳ ಯಾವುದೇ ವ್ಯಾಖ್ಯಾನವನ್ನು ಮಾಡಲಾಗಿಲ್ಲ (ಆದರೂ ಸಾಮಾನ್ಯ ಟಿಎಲ್ಎಲ್ ಸಂಪ್ರದಾಯಗಳನ್ನು ಇನ್ನೂ ಗಮನಿಸಬೇಕು). ನಿಖರವಾದ ಮಾದರಿಗಳು ಯಾವಾಗಲೂ ಅಸಂಘಟಿತವಾಗುತ್ತವೆ.

-ನೋಕೇಸ್ ಫ್ಲ್ಯಾಗ್ ಔಟ್ಪುಟ್ನ ದೊಡ್ಡ ಅಕ್ಷರಗಳನ್ನು ಸಣ್ಣಕ್ಷರಗಳಂತೆ ಹೋಲುವಂತೆ ಮಾಡುತ್ತದೆ. ಮಾದರಿ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

ಔಟ್ಪುಟ್ ಓದುತ್ತಿದ್ದಾಗ, 2000 ಕ್ಕೂ ಹೆಚ್ಚು ಬೈಟ್ಗಳು ಹಿಂದಿನ ಬೈಟ್ಗಳನ್ನು "ಮರೆತುಹೋಗಿ" ಒತ್ತಾಯಿಸುತ್ತದೆ. Match_max ಕಾರ್ಯದೊಂದಿಗೆ ಇದನ್ನು ಬದಲಾಯಿಸಬಹುದು. (ಅತಿ ದೊಡ್ಡ ಮೌಲ್ಯಗಳು ನಮೂನೆ matcher ಅನ್ನು ನಿಧಾನಗೊಳಿಸಬಹುದು ಎಂದು ಗಮನಿಸಿ.) ಪೇಸ್ಟ್ಲಿಸ್ಟ್ ಪೂರ್ಣ_ಬಫೆರ್ ಆಗಿದ್ದರೆ , match_max ಬೈಟ್ಗಳು ಸ್ವೀಕರಿಸಲ್ಪಟ್ಟರೆ ಮತ್ತು ಇತರ ಮಾದರಿಗಳು ಹೊಂದಿಕೆಯಾಗದೇ ಹೋದರೆ ಅನುಗುಣವಾದ ದೇಹವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. Full_buffer ಕೀವರ್ಡ್ ಬಳಸಲಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ, ಮರೆತುಹೋದ ಅಕ್ಷರಗಳನ್ನು ನಿರೀಕ್ಷೆಗೆ (ಬಫರ್) ಬರೆಯಲಾಗುತ್ತದೆ.

ಪೇಟ್ಲಿಸ್ಟ್ ಕೀಲಿಪದವು ಶೂನ್ಯವಾಗಿದ್ದರೆ ಮತ್ತು ಶೂನ್ಯಗಳನ್ನು ಅನುಮತಿಸಲಾಗುವುದು (ತೆಗೆದುಹಾಕುವುದರ ಮೂಲಕ), ಒಂದೇ ಎಎಸ್ಸಿಐಐ 0 ಅನ್ನು ಹೊಂದಿಕೆಯಾದರೆ ಅನುಗುಣವಾದ ದೇಹವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಗ್ಲೋಬ್ ಅಥವಾ ರಿಜೆಕ್ಸ್ ಮಾದರಿಗಳ ಮೂಲಕ 0 ಬೈಟ್ಗಳನ್ನು ಹೊಂದಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಒಂದು ಮಾದರಿ (ಅಥವಾ eof ಅಥವಾ full_buffer) ಅನ್ನು ಹೊಂದಿದ ನಂತರ, ಹೊಂದಾಣಿಕೆಯಾಗುವ ಮತ್ತು ಹಿಂದೆ ಹೊಂದದ ಔಟ್ಪುಟ್ ಅನ್ನು ವೇರಿಯಬಲ್ ನಿರೀಕ್ಷಿತ_ಆತ (ಬಫರ್) ನಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ. 9 ರಗ್ಜೆಪ್ ಸಬ್ಸ್ಟ್ರಿಂಗ್ ಪಂದ್ಯಗಳಿಗೆ ಅಪ್ಪೌಟ್_ಔಟ್ (1, ಸ್ಟ್ರಿಂಗ್) ಮೂಲಕ expect_out (9, ಸ್ಟ್ರಿಂಗ್) ಮೂಲಕ ಅಸ್ಥಿರಗಳಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ. -ವೈಶಿಷ್ಟ್ಯಗಳ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಮಾದರಿಗೆ ಮೊದಲು ಬಳಸಿದರೆ , 10 ತಂತಿಗಳ ಆರಂಭಿಕ ಮತ್ತು ಅಂತ್ಯದ ಸೂಚ್ಯಂಕಗಳು ( lrange ಗೆ ಸೂಕ್ತವಾದ ರೂಪದಲ್ಲಿ) ವೇರಿಯಬಲ್ಗಳಲ್ಲಿ ನಿರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ ನಿರೀಕ್ಷೆ_ಎಕ್ಸ್ (ಎಕ್ಸ್, ಪ್ರಾರಂಭ) ಮತ್ತು ನಿರೀಕ್ಷೆ_ಔಟ್ (ಎಕ್ಸ್, ಎಂಡ್) ಎಂದರೆ ಎಕ್ಸ್ ಎಂದರೆ ಅಂಕಿಯ, ಬಫರ್ನ ಸಬ್ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಾನಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ. 0 ಇಡೀ ಮಾದರಿಗೆ ಹೊಂದಿಕೊಂಡಿರುವ ತಂತಿಗಳನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ ಮತ್ತು ಗ್ಲೋಬ್ ಪ್ಯಾಟರ್ನ್ಸ್ಗೆ ಮತ್ತು ರೆಜೆಕ್ಸ್ ಪ್ಯಾಟರ್ನ್ಸ್ಗಾಗಿ ರಚಿಸಲ್ಪಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದು ಪ್ರಕ್ರಿಯೆಯು "abcdefgh \ n" ನ ಉತ್ಪತ್ತಿಯನ್ನು ಉತ್ಪಾದಿಸಿದ್ದರೆ, ಅದರ ಫಲಿತಾಂಶ:

ನಿರೀಕ್ಷಿಸಿ "ಸಿಡಿ"

ಕೆಳಗಿನ ಹೇಳಿಕೆಗಳು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬಂದಂತೆ:

expect_out (0, ಸ್ಟ್ರಿಂಗ್) cd ಸೆಟ್ expect_out (ಬಫರ್) abcd ಅನ್ನು ಹೊಂದಿಸಿ

ಮತ್ತು "efgh \ n" ಔಟ್ಪುಟ್ ಬಫರ್ನಲ್ಲಿ ಉಳಿದಿದೆ. ಒಂದು ಪ್ರಕ್ರಿಯೆಯು "abbbcabkkkka \ n" ಔಟ್ಪುಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸಿದರೆ, ಅದರ ಫಲಿತಾಂಶ:

ನಿರೀಕ್ಷೆ-ಸೂಚ್ಯಂಕಗಳು- "b (b *). * (k +)"

ಕೆಳಗಿನ ಹೇಳಿಕೆಗಳು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬಂದಂತೆ:

set_out (0, start) 1 ಸೆಟ್ expect_out (0, end) 10 ಸೆಟ್ expect_out (0, ಸ್ಟ್ರಿಂಗ್) 10 ಸೆಟ್ expect_out (0, ಸ್ಟ್ರಿಂಗ್) bbbcabkkkk set_out (1, ಪ್ರಾರಂಭಿಸಿ) ಸೆಟ್ 2 ಸೆಟ್ expect_out (1, ಅಂತ್ಯ) 3 ಸೆಟ್ expect_out (1, ಸ್ಟ್ರಿಂಗ್) ಬಿಬಿ ನಿರೀಕ್ಷಿತ ಸೆಟ್ (2, ಪ್ರಾರಂಭ) 10 ಸೆಟ್ expect_out (2, ಅಂತ್ಯ) 10 ಸೆಟ್ ನಿರೀಕ್ಷೆ_ಔಟ್ (2, ಸ್ಟ್ರಿಂಗ್) ಕೆ ಸೆಟ್ expect_out (ಬಫರ್) abbbcabkkkk

ಮತ್ತು "a \ n" ಔಟ್ಪುಟ್ ಬಫರ್ನಲ್ಲಿ ಉಳಿದಿದೆ. "*" (ಮತ್ತು -re ". *") ಮಾದರಿಯು ಔಟ್ಪುಟ್ ಬಫರ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಯಿಂದ ಯಾವುದೇ ಹೆಚ್ಚಿನ ಔಟ್ಪುಟ್ ಅನ್ನು ಓದದೆಯೇ ಚಿಗುರು ಮಾಡುತ್ತದೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ನಿರೀಕ್ಷಿತ ಆಂತರಿಕ ಬಫರ್ಗಳಿಂದ ಹೊಂದಾಣಿಕೆಯಾಗುವ ಔಟ್ಪುಟ್ ಅನ್ನು ತಿರಸ್ಕರಿಸಲಾಗುತ್ತದೆ. -ನಾಟ್ರಾನ್ಸ್ಫರ್ ಫ್ಲ್ಯಾಗ್ನ ಮಾದರಿಯನ್ನು ಪೂರ್ವಪ್ರತ್ಯಯಗೊಳಿಸುವುದರ ಮೂಲಕ ಇದನ್ನು ತಡೆಗಟ್ಟಬಹುದು. ಪ್ರಯೋಗದಲ್ಲಿ ಈ ಧ್ವಜವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ (ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಮಾಡುವಾಗ ಅನುಕೂಲಕ್ಕಾಗಿ "-ಅಲ್ಲ" ಎಂದು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಬಹುದು).

ಹೊಂದಾಣಿಕೆಯ ಉತ್ಪನ್ನದೊಂದಿಗೆ (ಅಥವಾ eof ಅಥವಾ full_buffer) ಸಂಬಂಧಿಸಿದ ಸ್ಪಾನ್ ಐಡಿ expect_out (spawn_id) ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲ್ಪಡುತ್ತದೆ.

ಸಮಯ-ಸಮಯದ ಧ್ವಜವು ಕಾಲಾವಧಿಯ ವೇರಿಯಬಲ್ ಮೌಲ್ಯವನ್ನು ಬಳಸುವ ಬದಲು ಕೆಳಗಿನ ಮೌಲ್ಯವನ್ನು ಕಾಲಾವಧಿಯಾಗಿ ಬಳಸುವಂತೆ ನಿರೀಕ್ಷಿಸುತ್ತದೆ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಮಾದರಿಗಳು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಔಟ್ಪುಟ್ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ, ಆದರೆ -i ಫ್ಲ್ಯಾಗ್ ಹೆಸರಿಸಲಾದ spawn_id ಪಟ್ಟಿಯ ಔಟ್ಪುಟ್ ಅನ್ನು ಈ ಕೆಳಗಿನ ಮಾದರಿಗಳಿಗೆ (ಮುಂದಿನ -i ವರೆಗೆ ) ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಘೋಷಿಸುತ್ತದೆ. Spawn_id ಪಟ್ಟಿಯು spawn_ids ನ ಜಾಗದಿಂದ ಬೇರ್ಪಟ್ಟ ಪಟ್ಟಿಯಾಗಿರಬೇಕು ಅಥವಾ spawn_ids ನ ಅಂತಹ ಪಟ್ಟಿಯನ್ನು ಉಲ್ಲೇಖಿಸುವ ವೇರಿಯೇಬಲ್ ಆಗಿರಬೇಕು.

ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ಪ್ರಕ್ರಿಯೆಯು $ process2 ಎಂಬ ಹೆಸರಿನ spawn_id ಯಿಂದ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯಿಂದ "ಸಂಪರ್ಕಿತ" ಅಥವಾ "ಕಾರ್ಯನಿರತ", "ವಿಫಲವಾಗಿದೆ" ಅಥವಾ "ಅಮಾನ್ಯ ಪಾಸ್ವರ್ಡ್" ಗೆ ಕಾಯುತ್ತದೆ.

{-i $ proc2 ಬಿಡುವಿಲ್ಲದ {ಬಿಡುವಿಲ್ಲದ ಇರಿಸುತ್ತದೆ \ n; exp_continue} - ಅಥವಾ "ವಿಫಲವಾಗಿದೆ | ಅಮಾನ್ಯವಾದ ಪಾಸ್ವರ್ಡ್" ಕಾಲಾವಧಿ ಸ್ಥಗಿತಗೊಳಿಸಿ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಗಿತಗೊಳಿಸು}

ಜಾಗತಿಕ ವೇರಿಯೇಬಲ್ any_spawn_id ಮೌಲ್ಯವು ಪ್ರಸ್ತುತ ನಿರೀಕ್ಷೆಯ ಆದೇಶದಲ್ಲಿ ಎಲ್ಲಾ ಇತರ -ಐ ಧ್ವಜಗಳೊಂದಿಗೆ ಹೆಸರಿಸಲಾದ ಯಾವುದೇ ಸ್ಪಾನ್_ಐಡಿಗಳಿಗೆ ಮಾದರಿಗಳನ್ನು ಹೊಂದಿಸಲು ಬಳಸಬಹುದು. A_i ಧ್ವಜದಿಂದ ಯಾವುದೇ-ಫ್ಲಾಗ್ನಿಂದ spawn_id (ಅಂದರೆ, ತಕ್ಷಣವೇ -i ಯಿಂದ ಅನುಸರಿಸಲಾಗುತ್ತದೆ) any_spawn_id ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ನಿರೀಕ್ಷಿಸುವ ಅದೇ ಮಾದರಿಯ ಯಾವುದೇ ಇತರ ಮಾದರಿಗಳಿಗೆ ಲಭ್ಯವಾಗುತ್ತದೆ.

ಸ್ಪಾ-ಐಡಿಗಳ ಪಟ್ಟಿಗಾಗಿ ವೇರಿಯಬಲ್ ಅನ್ನು ಓದುವ ಸಂದರ್ಭದಲ್ಲಿ -i ಫ್ಲ್ಯಾಗ್ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಅನ್ನು ಸಹ ಹೆಸರಿಸಬಹುದು. ಬದಲಾಗುವಾಗಲೆಲ್ಲಾ ವೇರಿಯಬಲ್ ಅನ್ನು ಪುನಃ ಓದಲಾಗುತ್ತದೆ. ಆಜ್ಞೆಯು ಮರಣದಂಡನೆಯಲ್ಲಿದ್ದಾಗ I / O ಮೂಲವನ್ನು ಬದಲಾಯಿಸುವ ಒಂದು ಮಾರ್ಗವನ್ನು ಇದು ಒದಗಿಸುತ್ತದೆ. ಈ ರೀತಿ ಒದಗಿಸಲಾದ ಸ್ಪಾನ್ ಐಡಿಗಳು "ಪರೋಕ್ಷ" ಸ್ಪಾನ್ ಐಡಿಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.

ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುವಂತೆ ಬ್ರೇಕ್ ಮತ್ತು ನಿಯಂತ್ರಣದ ರಚನೆಯನ್ನು ಉಂಟುಮಾಡುವ ಕ್ರಮಗಳು (ಅಂದರೆ, ಫಾರ್ , ಫಾರ್ ). Exp_continue ಎಂಬ ಆಜ್ಞೆಯು ಸ್ವತಃ ಸಾಮಾನ್ಯವಾಗಿ ವಾಪಸಾಗುವುದಕ್ಕಿಂತ ಹಿಂದಿರುಗುವುದನ್ನು ಮುಂದುವರೆಸುವುದನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ .

ಸ್ಪಷ್ಟವಾದ ಲೂಪ್ಗಳನ್ನು ತಪ್ಪಿಸಲು ಅಥವಾ ಪುನರಾವರ್ತಿತ ಹೇಳಿಕೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ರೊಗ್ನಿನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಒಂದು ತುಣುಕಿನ ಭಾಗವಾಗಿದೆ. Explcontinue ರೆಡ್ಜಿನ್ ಪಾಸ್ವರ್ಡ್ಗಾಗಿ ಅಪೇಕ್ಷಿಸಿದಲ್ಲಿ ಎರಡನೆಯ ನಿರೀಕ್ಷೆಯ ಹೇಳಿಕೆಯನ್ನು (ಮತ್ತೆ ಪ್ರಾಂಪ್ಟ್ಗಾಗಿ ನೋಡಬೇಕಾದರೆ) ಬರೆಯುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

{ಹೋಸ್ಟ್: $ stty -echo send_user "ಪಾಸ್ವರ್ಡ್ ($ ಬಳಕೆದಾರರಿಗೆ) $ ಹೋಸ್ಟ್ನಲ್ಲಿ ನಿರೀಕ್ಷಿಸಿ:" ನಿರೀಕ್ಷಿತ_ಯುಸರ್ -ರೆ "(. *) \ n" send_user "\ n" ನಿರೀಕ್ಷಿಸು "$ ನಿರೀಕ್ಷಿತ_ಅನ್ನು (1, ಸ್ಟ್ರಿಂಗ್) \ r" stty echo exp_continue} ತಪ್ಪಾಗಿದೆ {send_user "ಅಮಾನ್ಯವಾದ ಪಾಸ್ವರ್ಡ್ ಅಥವಾ ಖಾತೆಯು \ n" ನಿರ್ಗಮನ} ಕಾಲಾವಧಿಗೆ {send_user "$ ಹೋಸ್ಟ್ ಸಮಯಕ್ಕೆ ಸಂಪರ್ಕವನ್ನು \ n" ನಿರ್ಗಮಿಸು} eof {send_user \ "ಹೋಸ್ಟ್ಗೆ ಸಂಪರ್ಕವು ವಿಫಲವಾಗಿದೆ: $ ನಿರೀಕ್ಷ_ಔಟ್ (ಬಫರ್)" ನಿರ್ಗಮನ} ಮರು $ ಪ್ರಾಂಪ್ಟ್}

ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ತುಣುಕು ಬಳಕೆದಾರರಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿದ್ದ ಸಂವಹನವನ್ನು ಮಾರ್ಗದರ್ಶಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಟರ್ಮಿನಲ್ ಅನ್ನು ಕಚ್ಚಾ ಕ್ರಮದಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ. ಬಳಕೆದಾರನು "+" ಅನ್ನು ಒತ್ತಿದರೆ, ಒಂದು ವೇರಿಯೇಬಲ್ ಹೆಚ್ಚಾಗುತ್ತದೆ. "P" ಒತ್ತಿದರೆ, ಪ್ರಕ್ರಿಯೆಗೆ ಹಲವಾರು ರಿಟರ್ನ್ಗಳನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ಬಹುಶಃ ಅದನ್ನು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಇರಿಸಲು, ಮತ್ತು "i" ಪ್ರಕ್ರಿಯೆಯು ಬಳಕೆದಾರರೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂವಹನ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸ್ಕ್ರಿಪ್ಟ್ನಿಂದ ನಿಯಂತ್ರಣವನ್ನು ದೂರವಿರಿಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರಸಕ್ತ ಕ್ರಿಯೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ ಪ್ರಸಕ್ತದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಮುಂದುವರಿಸಲು ನಿರೀಕ್ಷಿಸುವಂತೆ exp_continue ಅನುಮತಿಸುತ್ತದೆ.

stty raw -echo expect_after {-i $ user_spawn_id "p" {send "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "quit" exit}

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, exp_continue ಕಾಲಾವಧಿ ಟೈಮರ್ ಅನ್ನು ಮರುಹೊಂದಿಸುತ್ತದೆ. Exp_continue ಅನ್ನು -continue_timer ಫ್ಲ್ಯಾಗ್ನೊಂದಿಗೆ ಕರೆದರೆ ಟೈಮರ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸುವುದಿಲ್ಲ.

expect_after [expect_args]
ನಿರೀಕ್ಷೆ ಮತ್ತು expect_after ಎರಡೂ ಹೊಂದಾಣಿಕೆಗಳಿಂದ ಮಾದರಿಗಳನ್ನು ಬಳಸಿದರೆ ಹೊರತುಪಡಿಸಿ ನಿರೀಕ್ಷೆಗೆ ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ expect_before ಆಜ್ಞೆಯನ್ನು ನೋಡಿ.

expect_background [expect_args]
ನಿರೀಕ್ಷಿಸಿದಂತೆ ಅದೇ ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಅದು ತಕ್ಷಣವೇ ಹಿಂದಿರುಗುತ್ತದೆ. ಹೊಸ ಇನ್ಪುಟ್ ಆಗಮಿಸಿದಾಗ ಮಾದರಿಗಳನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಮಾದರಿ ಕಾಲಾವಧಿ ಮತ್ತು ಡೀಫಾಲ್ಟ್ ನಿರೀಕ್ಷೆ- ಹಿನ್ನಲೆಗೆ ಅರ್ಥಹೀನವಾಗಿರುತ್ತವೆ ಮತ್ತು ಮೌನವಾಗಿ ತಿರಸ್ಕರಿಸಲ್ಪಡುತ್ತವೆ. ಇಲ್ಲವಾದರೆ, expect_background ಆಜ್ಞೆಯು ನಿರೀಕ್ಷೆಗಿಂತ ಮುಂಚಿತವಾಗಿ ಮತ್ತು expect_after ಮಾದರಿಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ನಿರೀಕ್ಷೆ- ಹಿನ್ನೆಲೆ ಕ್ರಿಯೆಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದಾಗ, ಅದೇ ಸ್ಪಾನ್ ಐಡಿಗಾಗಿ ಹಿನ್ನೆಲೆ ಪ್ರಕ್ರಿಯೆ ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ. ಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಂಡಾಗ ಹಿನ್ನೆಲೆ ಸಂಸ್ಕರಣೆಯನ್ನು ಅನಿರ್ಬಂಧಿಸಲಾಗಿದೆ. ಹಿನ್ನೆಲೆ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿರ್ಬಂಧಿಸಲಾಗಿದೆಯಾದರೂ, ಅದೇ ಸ್ಪಾನ್ ಐಡಿನಲ್ಲಿ ಒಂದು (ಮುನ್ನೆಲೆ) ನಿರೀಕ್ಷೆ ಮಾಡಲು ಸಾಧ್ಯವಿದೆ.

Expect_background ಅನ್ನು ಅನಿರ್ಬಂಧಿಸಲಾಗಿದೆ ಆದರೆ ನಿರೀಕ್ಷೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಪಾನ್ ಐಡಿಗಾಗಿ ನಿರೀಕ್ಷೆ_ಬ್ಯಾಕ್ಗ್ರೌಂಡ್ ಅನ್ನು ಹೊಸ ನಿರೀಕ್ಷೆ-ಬ್ಯಾಕ್ಗ್ರೌಂಡ್ ಅನ್ನು ಅದೇ ಸ್ಪಾನ್ ಐಡಿನೊಂದಿಗೆ ಘೋಷಿಸುವುದರ ಮೂಲಕ ಅಳಿಸಲಾಗುತ್ತದೆ. ನಿರೀಕ್ಷೆ- ಬ್ಯಾಕ್ಗ್ರೌಂಡ್ ಅನ್ನು ಮಾದರಿಯೊಂದಿಗೆ ಘೋಷಿಸುವುದರಿಂದ ನೀಡಲಾದ ಸ್ಪಾನ್ ಐಡಿ ಅನ್ನು ಹಿನ್ನಲೆಯಲ್ಲಿ ನಮೂನೆಗಳನ್ನು ಹೊಂದಿಸುವ ಸಾಮರ್ಥ್ಯದಿಂದ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

expect_before [expect_args]
ನಿರೀಕ್ಷಿಸಿದಂತೆ ಅದೇ ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಅದು ತಕ್ಷಣವೇ ಹಿಂದಿರುಗುತ್ತದೆ. ಅದೇ ರೀತಿಯ ಸ್ಪಾವ್ನ್ ಐಡಿನೊಂದಿಗೆ ಇತ್ತೀಚಿನ ನಿರೀಕ್ಷೆಯಿಂದ ಮಾದರಿ-ಜೋಡಿ ಜೋಡಿಗಳು ಯಾವುದೇ ಮುಂದಿನ ಆಜ್ಞೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು . ಒಂದು ಮಾದರಿಯು ಹೋಲುತ್ತದೆಯಾದರೆ, ಆಜ್ಞೆಯನ್ನು ಸ್ವತಃ ಆಜ್ಞೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಂತೆ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಆಜ್ಞೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಯೋಜಿತ ಶಕ್ತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಅಪೇಕ್ಷಿಸುವ ಮತ್ತು ನಿರೀಕ್ಷಿಸುವ ಎರಡೂ ಮಾದರಿಗಳು ಹೊಂದಾಣಿಕೆಯಾಗಬಹುದಾಗಿದ್ದರೆ, ನಿರೀಕ್ಷೆ- ಪೂರ್ವ ಮಾದರಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಯಾವುದೇ ಮಾದರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಸ್ಪಾನ್ ಐಡಿ ಅನ್ನು ಯಾವುದೇ ನಮೂನೆಗಳಿಗೆ ಪರಿಶೀಲಿಸಲಾಗುವುದಿಲ್ಲ.

ಒಂದು -ಐ ಧ್ವಜದಿಂದ ಅತಿಕ್ರಮಿಸದಿದ್ದರೆ, expect_before ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಸಮಯದ ಅವಧಿಯಲ್ಲಿ ಸ್ಪಾನನ್ ಐಡಿಗೆ ವಿರುದ್ಧವಾಗಿ ನಮೂನೆಗಳು ಹೊಂದಾಣಿಕೆಯಾಗುವ ನಿರೀಕ್ಷೆಯಿದೆ (ಅದರ ಮಾದರಿಯು ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೂ).

-ಐಫೋ ಫ್ಲ್ಯಾಗ್ ಇದು ಯಾವ ಮಾದರಿಯು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತದೆ ಎಂಬುದರ ಪ್ರಸ್ತುತ ವಿಶೇಷಣಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೊದಲು ನಿರೀಕ್ಷಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಇದು ಪ್ರಸಕ್ತ ಸ್ಪಾನ್ ಐಡಿ ಕುರಿತು ವರದಿ ಮಾಡುತ್ತದೆ. ಆ ಸ್ಪಾನ್ ಐಡಿ ಕುರಿತು ಮಾಹಿತಿಗಾಗಿ ಐಚ್ಛಿಕ ಸ್ಪಾನ್ ಐಡಿ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ನೀಡಬಹುದು. ಉದಾಹರಣೆಗೆ

expect_before -info -i $ proc

ಹೆಚ್ಚಿನ ಒಂದು ಸ್ಪಾನ್ ಐಡಿ ವಿವರಣೆಯನ್ನು ನೀಡಬಹುದು. ಧ್ವಜ-ನಿರ್ದೇಶನ ಪರೋಕ್ಷ ವಿಶೇಷಣಗಳಿಂದ ಮಾತ್ರ ಬರುವ ನೇರ ಸ್ಪಾನ್ ಐಡಿಗಳನ್ನು ನಿಗ್ರಹಿಸುತ್ತದೆ.

ಸ್ಪಾನ್ ಐಡಿ ಸ್ಪೆಸಿಫಿಕೇಶನ್ನ ಬದಲಾಗಿ, ಫ್ಲ್ಯಾಗ್ "-ಎಲ್ಲ" ಎಲ್ಲಾ ಸ್ಪಾನ್ ಐಡಿಗಳ ಬಗ್ಗೆ ವರದಿ ಮಾಡಲು "-ಇನ್ಫೋ" ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

-ಇನ್ಫೋ ಧ್ವಜದ ಔಟ್ಪುಟ್ ನಿರೀಕ್ಷೆಗೆ ಮೊದಲು ವಾದವನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದು.

expect_tty [expect_args]
ನಿರೀಕ್ಷೆಯಂತೆ ಆದರೆ ಇದು / dev / tty ಯಿಂದ (ಅಂದರೆ ಬಳಕೆದಾರರಿಂದ ಕೀಸ್ಟ್ರೋಕ್ಗಳು) ಅಕ್ಷರಗಳನ್ನು ಓದುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಓದುವಿಕೆಯನ್ನು ಬೇಯಿಸಿದ ಮೋಡ್ನಲ್ಲಿ ನಡೆಸಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ರೇಖೆಗಳು ಅವುಗಳನ್ನು ನೋಡಲು ನಿರೀಕ್ಷಿಸುವ ಸಲುವಾಗಿ ಹಿಂದಿರುಗಿದ ನಂತರ ಕೊನೆಗೊಳ್ಳಬೇಕು. ಇದನ್ನು ಸ್ಟಟಿ ಮೂಲಕ ಬದಲಾಯಿಸಬಹುದು (ಕೆಳಗಿರುವ ಸ್ಟಟಿ ಆಜ್ಞೆಯನ್ನು ನೋಡಿ).

ನಿರೀಕ್ಷಿತ_ಯುಸರ್ [ನಿರೀಕ್ಷ_ಆಗಗಳು]
ನಿರೀಕ್ಷೆಯಂತೆ ಆದರೆ ಅದು stdin (ಅಂದರೆ ಬಳಕೆದಾರರಿಂದ ಕೀಸ್ಟ್ರೋಕ್ಗಳು) ಪಾತ್ರಗಳನ್ನು ಓದುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಓದುವಿಕೆಯನ್ನು ಬೇಯಿಸಿದ ಮೋಡ್ನಲ್ಲಿ ನಡೆಸಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ರೇಖೆಗಳು ಅವುಗಳನ್ನು ನೋಡಲು ನಿರೀಕ್ಷಿಸುವ ಸಲುವಾಗಿ ಹಿಂದಿರುಗಿದ ನಂತರ ಕೊನೆಗೊಳ್ಳಬೇಕು. ಇದನ್ನು ಸ್ಟಟಿ ಮೂಲಕ ಬದಲಾಯಿಸಬಹುದು (ಕೆಳಗಿರುವ ಸ್ಟಟಿ ಆಜ್ಞೆಯನ್ನು ನೋಡಿ).

ಫೋರ್ಕ್
ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಹೊಸ ಪ್ರಕ್ರಿಯೆಯು ಪ್ರಸ್ತುತ ಎಕ್ಸ್ಪೆಕ್ಟ್ ಪ್ರಕ್ರಿಯೆಯ ಒಂದು ನಿಖರ ನಕಲಾಗಿದೆ. ಯಶಸ್ಸಿಗೆ, ಫೋರ್ಕ್ 0 ಹೊಸ (ಮಗು) ಪ್ರಕ್ರಿಯೆಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯ ಪ್ರಕ್ರಿಯೆ ID ಅನ್ನು ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ . ವೈಫಲ್ಯದಲ್ಲಿ (ಸಂಪನ್ಮೂಲಗಳ ಕೊರತೆಯ ಕಾರಣದಿಂದಾಗಿ, ಉದಾಹರಣೆಗೆ, ಸ್ವಾಪ್ ಸ್ಪೇಸ್, ​​ಮೆಮೊರಿ), ಫೋರ್ಕ್ -1 ಅನ್ನು ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆ ರಚಿಸಲಾಗಿಲ್ಲ.

ಮೂಲ ಪ್ರಕ್ರಿಯೆಯಂತೆಯೇ ನಿರ್ಗಮನದ ಆಜ್ಞೆಯ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಗಳು ಹೊರಬಂದವು. ಫಾರ್ಕ್ಡ್ ಪ್ರಕ್ರಿಯೆಗಳು ಲಾಗ್ ಫೈಲ್ಗಳಿಗೆ ಬರೆಯಲು ಅನುಮತಿಸಲಾಗಿದೆ. ಹೆಚ್ಚಿನ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ನೀವು ಡೀಬಗ್ ಮಾಡುವಿಕೆಯನ್ನು ಅಥವಾ ಲಾಗಿಂಗ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸದಿದ್ದರೆ, ಫಲಿತಾಂಶವು ಗೊಂದಲಕ್ಕೊಳಗಾಗುತ್ತದೆ.

ಕೆಲವು ಪಿಟಿಐ ಅನುಷ್ಠಾನಗಳನ್ನು ಅನೇಕ ಓದುಗರು ಮತ್ತು ಲೇಖಕರು ಗೊಂದಲಗೊಳಿಸಬಹುದು, ಕ್ಷಣವೂ ಸಹ. ಹೀಗಾಗಿ, ಮೊಟ್ಟೆಯಿಡುವ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಮುಂಚಿತವಾಗಿ ಫೋರ್ಕ್ಗೆ ಸುರಕ್ಷಿತವಾಗಿದೆ.

[string1 body1] ಸಂವಹನ ... [stringn [bodyn]]
ಬಳಕೆದಾರರಿಗೆ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಕೀಸ್ಟ್ರೋಕ್ಗಳು ​​ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯ stdout ಮತ್ತು stderr ಮರಳುತ್ತವೆ.

ಸ್ಟ್ರಿಂಗ್-ಬಾಡಿ ಜೋಡಿಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ಸ್ ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅನುಗುಣವಾದ ಸ್ಟ್ರಿಂಗ್ ನಮೂದಿಸಿದಾಗ ದೇಹದ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. (ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಸ್ಟ್ರಿಂಗ್ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ಕಳುಹಿಸಲ್ಪಡುವುದಿಲ್ಲ.) ಅಂತಿಮ ದೇಹದ ಕಾಣೆಯಾಗಿದೆ ವೇಳೆ ಇಂಟರ್ಪ್ರಿಟರ್ ಕಮಾಂಡ್, ಊಹಿಸಲಾಗಿದೆ.

ಇಡೀ ಸಂವಹನ ಹೇಳಿಕೆಗೆ ವಾದಗಳು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಸಾಲಿನ ಅಗತ್ಯವಿದ್ದರೆ, ಪ್ರತಿ ಸಾಲುಗಳು ಬೆನ್ನುಹೊರೆಯೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುವುದನ್ನು ತಪ್ಪಿಸಲು ಎಲ್ಲಾ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳನ್ನು "ಬ್ರೇಸ್ಡ್" ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು. ಈ ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ, ಕಟ್ಟುಪಟ್ಟಿಗಳ ಹೊರತಾಗಿಯೂ ಸಾಮಾನ್ಯ Tcl ಪರ್ಯಾಯಗಳು ಸಂಭವಿಸುತ್ತವೆ.

ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಕಮಾಂಡ್ ವ್ಯಾಖ್ಯಾನಿಸಿದ ಕೆಳಗಿನ ಸ್ಟ್ರಿಂಗ್-ಬಾಡಿ ಜೋಡಿಗಳೊಂದಿಗೆ ಸಂವಹಿಸುತ್ತದೆ: ^ ಝಡ್ ಒತ್ತಿದಾಗ, ಎಕ್ಸ್ಪೆಕ್ಟ್ ಅನ್ನು ಅಮಾನತ್ತುಗೊಳಿಸಲಾಗಿದೆ. ( -ರೆಸೆಟ್ ಫ್ಲ್ಯಾಗ್ ಟರ್ಮಿನಲ್ ಮೊಡೆಗಳನ್ನು ಪುನಃಸ್ಥಾಪಿಸುತ್ತದೆ.) ^ ಎ ಒತ್ತಿದರೆ, ಬಳಕೆದಾರನು "ನೀವು ನಿಯಂತ್ರಣ-ಎ ಯನ್ನು ಟೈಪ್ ಮಾಡಿದ್ದೀರಿ " ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯು a ^ A ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ. $ ಒತ್ತಿದಾಗ, ಬಳಕೆದಾರರು ದಿನಾಂಕವನ್ನು ನೋಡುತ್ತಾರೆ. ↑ ಸಿ ಸಿ ಒತ್ತಿದರೆ, ಎಕ್ಸ್ಪೇಕ್ಟ್ ಎಕ್ಸಿಟ್. "Foo" ಅನ್ನು ಪ್ರವೇಶಿಸಿದರೆ, ಬಳಕೆದಾರರು "ಬಾರ್" ಅನ್ನು ನೋಡುತ್ತಾರೆ. ~~ ಒತ್ತಿದಾಗ, ಎಕ್ಸ್ಪೆಕ್ಟ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಪರಸ್ಪರ ಕಾರ್ಯ ನಿರ್ವಹಿಸುತ್ತದೆ.

CTRLZ \ 032 ಸಂವಹನ {-ರೆಟ್ $ CTRLZ {exec ಕೊಲ್ಲು -STOP [ಪಿಡ್]} \ 001 {send_user "ನೀವು ನಿಯಂತ್ರಣ- A \ n"; ಕಳುಹಿಸು "\ 001"} $ {send_user "ದಿನಾಂಕ [ಗಡಿಯಾರ ಸ್ವರೂಪ [ಗಡಿಯಾರ ಸೆಕೆಂಡುಗಳು]]."} \ 003 ನಿರ್ಗಮನ foo {send_user "ಬಾರ್"} ~~}

ಸ್ಟ್ರಿಂಗ್-ಬಾಡಿ ಜೋಡಿಗಳಲ್ಲಿ, ತಂತಿಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ಸ್ ಎಂದು ಪಟ್ಟಿ ಮಾಡಲಾಗಿರುತ್ತದೆ. ಭಾಗಶಃ ಹೊಂದಾಣಿಕೆಯ ತಂತುಗಳನ್ನು ಉಳಿದ ಪ್ರಕ್ರಿಯೆಯ ನಿರೀಕ್ಷೆಯಲ್ಲಿ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ಕಳುಹಿಸುವುದಿಲ್ಲ. ಪಾತ್ರಗಳು ನಂತರ ಪ್ರವೇಶಿಸಿದರೆ ಅಂತಹ ಪಂದ್ಯಗಳು ಇನ್ನು ಮುಂದೆ ಇರಬಹುದು, ಸ್ಟ್ರಿಂಗ್ನ ಭಾಗವು ಬಹುಶಃ ಮತ್ತೊಂದು ಪಂದ್ಯವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಗದ ಪ್ರಕ್ರಿಯೆಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ಭಾಗಶಃ ಪಂದ್ಯಗಳ ಸಬ್ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಹೊಂದಿರುವ ತಂತಿಗಳು ನಂತರ ಹೊಂದಾಣಿಕೆಯಾಗಬಹುದು, ಪಂದ್ಯಕ್ಕೆ ಪ್ರಯತ್ನಿಸುವ ಮೂಲ ತಂತಿಗಳು ಅಂತಿಮವಾಗಿ ವಿಫಲವಾದಲ್ಲಿ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಾಣಿಕೆಯು ವೈಲ್ಡ್ ಕಾರ್ಡ್ಗಳಿಲ್ಲದೆ ನಿಖರವಾಗಿದೆ. (ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ನಿರೀಕ್ಷೆಯ ಆಜ್ಞೆಯು ಡೀಫಾಲ್ಟ್ ಆಗಿ ಗ್ಲೋಬ್-ಶೈಲಿಯ ಮಾದರಿಗಳನ್ನು ಬಳಸುತ್ತದೆ.) ಸಂವಹನ ಧ್ವಜಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಬಹುದಾದ ಮಾದರಿಗಳನ್ನು ರಕ್ಷಿಸಲು -ex ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಬಳಸಬಹುದು. "-" ಆರಂಭಗೊಂಡು ಯಾವುದೇ ಮಾದರಿಯನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ರಕ್ಷಿಸಬೇಕು. ("-" ಪ್ರಾರಂಭವಾಗುವ ಎಲ್ಲಾ ತಂತಿಗಳು ಭವಿಷ್ಯದ ಆಯ್ಕೆಗಳಿಗಾಗಿ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ.)

-re ಧ್ವಜ ಸ್ಟ್ರಿಂಗ್ನ್ನು ರಿಜೆಕ್ಸ್ ಶೈಲಿಯ ಮಾದರಿಯಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಹೊಂದಾಣಿಕೆಯ ಉಪಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು variable interact_out ನಲ್ಲಿ ಶೇಖರಿಸಿಡಲಾಗುತ್ತದೆ ನಿರೀಕ್ಷೆಯಂತೆ ವೇರಿಯೇಬಲ್ expect_out ನಲ್ಲಿ ಅದರ ಉತ್ಪನ್ನವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಸೂಚ್ಯಂಕಗಳ ಧ್ವಜವು ಸಹ ಬೆಂಬಲಿತವಾಗಿದೆ.

ಈ ನಮೂನೆಯು ಎಂಡ್-ಆಫ್-ಫೈಲ್ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಕ್ರಿಯೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಪ್ರತ್ಯೇಕ eof ಮಾದರಿಯು -ಔಟ್ಪುಟ್ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸಹ ಅನುಸರಿಸಬಹುದು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಔಟ್ಪುಟ್ ಅನ್ನು ಬರೆಯುವಾಗ ಈಫ್ ಅನ್ನು ಪತ್ತೆಮಾಡಿದರೆ ಅದು ಸರಿಹೊಂದುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತ ಈಫ್ ಕ್ರಿಯೆಯು "ಹಿಂತಿರುಗಿಸುತ್ತದೆ", ಆದ್ದರಿಂದ ಸಂವಹನವು ಯಾವುದೇ EOF ಗೆ ಹಿಂದಿರುಗುತ್ತದೆ.

ಮಾದರಿ ಕಾಲಾವಧಿ ಒಂದು ಕಾಲಾವಧಿಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ (ಸೆಕೆಂಡುಗಳಲ್ಲಿ) ಮತ್ತು ಕಾರ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟ ಸಮಯದವರೆಗೆ ಓದಲುಲ್ಲದಿದ್ದರೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಇತ್ತೀಚೆಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪ್ರಕ್ರಿಯೆಗೆ ಸಮಯಮೀರಿದ ನಮೂನೆ ಅನ್ವಯಿಸುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ ಸಮಯದ ಅವಧಿ ಇಲ್ಲ. ವಿಶೇಷ ವೇರಿಯಬಲ್ "ಕಾಲಾವಧಿ" ( ನಿರೀಕ್ಷಣಾ ಆಜ್ಞೆಯಿಂದ ಬಳಸಲ್ಪಡುತ್ತದೆ) ಈ ಕಾಲಾವಧಿಗೆ ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

ಉದಾಹರಣೆಗೆ, ಒಂದು ಗಂಟೆಯವರೆಗೆ ಯಾವುದನ್ನೂ ಟೈಪ್ ಮಾಡದ ಬಳಕೆದಾರರಿಗೆ ಆಟೋಲೊಗೌಟ್ ಮಾಡಲು ಆದರೆ ಇನ್ನೂ ಸಿಸ್ಟಮ್ ಸಿಸ್ಟಮ್ ಸಂದೇಶಗಳನ್ನು ಪಡೆಯುವ ಕೆಳಗಿನ ಹೇಳಿಕೆಯನ್ನು ಬಳಸಬಹುದು:

interact -input $ user_spawn_id ಕಾಲಾವಧಿ 3600 ರಿಟರ್ನ್ ಔಟ್ಪುಟ್ \ $ spawn_id

ಮಾದರಿಯು ಶೂನ್ಯದ ಕೀವರ್ಡ್ ಮತ್ತು ಶೂನ್ಯಗಳನ್ನು ಅನುಮತಿಸಿದರೆ (ತೆಗೆದುಹಾಕುವುದರ ಮೂಲಕ), ಒಂದೇ ASCII 0 ಹೊಂದಿಕೆಯಾದರೆ ಅನುಗುಣವಾದ ದೇಹವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಗ್ಲೋಬ್ ಅಥವಾ ರಿಜೆಕ್ಸ್ ಮಾದರಿಗಳ ಮೂಲಕ 0 ಬೈಟ್ಗಳನ್ನು ಹೊಂದಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಧ್ವಜದೊಂದಿಗೆ ಒಂದು ಮಾದರಿಯನ್ನು ಆವರಿಸುವುದು - ಉದ್ಧರಣವು ವೇರಿಯೇಬಲ್ interact_out (spawn_id) ಅನ್ನು spawn_id ಗೆ ಹೊಂದಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ, ಅದು ಮಾದರಿಯನ್ನು (ಅಥವಾ ಇಓಫ್) ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.

ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುವಂತೆ ಬ್ರೇಕ್ ಮತ್ತು ನಿಯಂತ್ರಣದ ರಚನೆಯನ್ನು ಉಂಟುಮಾಡುವ ಕ್ರಮಗಳು (ಅಂದರೆ, ಫಾರ್ , ಫಾರ್ ). ಆದಾಗ್ಯೂ, ಅದರ ಕರೆಮಾರಿಗೆ ಹಿಂದಿರುಗಲು ಪರಸ್ಪರ ಕಾರಣಗಳು ಉಂಟಾಗುತ್ತವೆ, ಆದರೆ ಇಂಟರ್_ ರಿಟರ್ನ್ ಉಂಟಾಗುವ ಸಂವಹನವು ತನ್ನ ಕಾಲರ್ನಲ್ಲಿ ಮರಳಲು ಕಾರಣವಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, "proc foo" ಸಂವಹನ ಎಂದು ಕರೆದರೆ ಅದು ಕ್ರಿಯೆಯ inter_return ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ, proc foo ಮರಳುತ್ತದೆ. (ಇದರರ್ಥ ಇಂಟರ್ಯಾಕ್ಟ್ ಕರೆಗಳು ಇಂಟರ್ಪ್ರಿಟರ್ ಟೈಪ್ ರಿಟರ್ನ್ ಸಂವಹನ ಮುಂದುವರೆಸಲು ಕಾರಣವಾಗಬಹುದು, ಆದರೆ inter_return ಅದರ ಕಾಲರ್ಗೆ ಮರಳಲು ಸಂವಹನ ಮಾಡುತ್ತದೆ.)

ಸಂವಹನ ಸಮಯದಲ್ಲಿ, ಕಚ್ಚಾ ಮೋಡ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಪಾತ್ರಗಳು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ರವಾನಿಸಬಹುದು. ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯು ಉದ್ಯೋಗ ನಿಯಂತ್ರಣ ಸಿಗ್ನಲ್ಗಳನ್ನು ಹಿಡಿದಿಲ್ಲದಿದ್ದರೆ, ಸ್ಟಾಪ್ ಸಿಗ್ನಲ್ ಅನ್ನು ಕಳುಹಿಸಿದರೆ ಅದು ನಿಷ್ಕ್ರಿಯಗೊಳ್ಳುತ್ತದೆ (ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಝಡ್). ಇದನ್ನು ಮರುಪ್ರಾರಂಭಿಸಲು, ಮುಂದುವರೆಯುವ ಸಂಕೇತವನ್ನು ಕಳುಹಿಸಿ (ಉದಾಹರಣೆಗೆ "ಕೊಲ್-CONT" ನಿಂದ). ನೀವು ಅಂತಹ ಒಂದು ಪ್ರಕ್ರಿಯೆಗೆ (^ ಝಡ್) SIGSTOP ಅನ್ನು ಕಳುಹಿಸಲು ನಿಜವಾಗಿಯೂ ಬಯಸಿದರೆ, ಮೊಟ್ಟೆಯಿಡುವ csh ಅನ್ನು ಮೊದಲು ಪರಿಗಣಿಸಿ ಮತ್ತು ನಂತರ ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಮ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ. ಮತ್ತೊಂದೆಡೆ, ನೀವು ಸ್ವತಃ ನಿರೀಕ್ಷಿಸಲು SIGSTOP ಅನ್ನು ಕಳುಹಿಸಲು ಬಯಸಿದರೆ, ಮೊದಲಿಗೆ ಇಂಟರ್ಪ್ರಿಟರ್ ಕರೆ (ಪ್ರಾಯಶಃ ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಅಕ್ಷರವನ್ನು ಬಳಸಿ), ಮತ್ತು ನಂತರ ಝಡ್ ಅನ್ನು ಒತ್ತಿರಿ.

ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯರೂಪಕ್ಕೆ ತರುವಲ್ಲಿ ತಪ್ಪಿಸಲು ಸ್ಟ್ರಿಂಗ್-ಬಾಡಿ ಜೋಡಿಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತ ರೂಪವಾಗಿ ಬಳಸಬಹುದು. ಸ್ಟ್ರಿಂಗ್-ಬಾಡಿ ಜೋಡಿಯ ದೇಹದ ಕಾರ್ಯಗತಗೊಳ್ಳುವಾಗ ಹಿಂದಿನ ಟರ್ಮಿನಲ್ ಮೋಡ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ವೇಗಕ್ಕೆ, ಕ್ರಮಗಳು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಕಚ್ಚಾ ಕ್ರಮದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತವೆ. -ರೆಟ್ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಟರ್ಮಿನಲ್ ಅನ್ನು ಮೊದಲು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಮೋಡ್ಗೆ ಮರುರೂಪಿಸುತ್ತದೆ (ಏಕರೂಪವಾಗಿ, ಬೇಯಿಸಿದ ಮೋಡ್). ಮೋಡ್ ಅನ್ನು ಸ್ವಿಚ್ ಮಾಡಿದಾಗ ಅಕ್ಷರಗಳು ಪ್ರವೇಶಿಸಲ್ಪಡುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ (ಕೆಲವು ಸಿಸ್ಟಮ್ಗಳಲ್ಲಿ ಟರ್ಮಿನಲ್ ಚಾಲಕದ ದುರದೃಷ್ಟಕರ ವೈಶಿಷ್ಟ್ಯ). ನಿಮ್ಮ ಕ್ರಿಯೆಯು ಬೇಯಿಸಿದ ಮೋಡ್ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ -ರೆಟ್ ಅನ್ನು ಬಳಸಲು ಮಾತ್ರ ಕಾರಣವಾಗಿದೆ.

-ಚಾಕೊ ಧ್ವಜ ಕೆಳಗಿನ ಅಕ್ಷರಗಳನ್ನು ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಓದಿದ ಪ್ರಕ್ರಿಯೆಗೆ ಹೋಲಿಸುವ ಅಕ್ಷರಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಭಾಗಶಃ ಟೈಪ್ ಮಾಡಲಾದ ಮಾದರಿಗಳಿಂದ ಬಳಕೆದಾರರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೋಡಬೇಕಾದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ.

ಒಂದು ಮಾದರಿಯನ್ನು ಪ್ರತಿಧ್ವನಿಸುತ್ತಿದ್ದರೆ ಆದರೆ ಅಂತಿಮವಾಗಿ ಹೊಂದಿಸಲು ವಿಫಲವಾದಲ್ಲಿ, ಪಾತ್ರಗಳು ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಯು ನಂತರ ಅವುಗಳನ್ನು ಪ್ರತಿಧ್ವನಿಸುತ್ತದೆ ವೇಳೆ, ಬಳಕೆದಾರರು ಪಾತ್ರಗಳನ್ನು ಎರಡು ಬಾರಿ ನೋಡುತ್ತಾರೆ. ಬಳಕೆದಾರನು ಮಾದರಿಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಅಸಂಭವವಾಗಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ -ಚಾಕೊ ಬಹುಶಃ ಸೂಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಆಯ್ದ ಭಾಗಗಳು rftp, ಪುನರಾವರ್ತಿತ- ftp ಸ್ಕ್ರಿಪ್ಟ್, ~ g, ~ p, ಅಥವಾ ~ l ಅನ್ನು ನಮೂದಿಸಲು, ಪ್ರಸ್ತುತ ಕೋಶವನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಪಡೆಯುವಂತೆ ಮಾಡಲು ಬಳಕೆದಾರನನ್ನು ಪ್ರೇರೇಪಿಸಿದಾಗ. ಇವು ಸಾಮಾನ್ಯ FTP ಆಜ್ಞೆಗಳಿಂದ ದೂರದಲ್ಲಿದೆ, ತಪ್ಪಾಗಿ ಹೊರತುಪಡಿಸಿ ಬಳಕೆದಾರನು ~ ನಂತರ ಟೈಪ್ ಮಾಡಲು ಅಸಂಭವವಾಗಿದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅವರು ಪ್ರಾಯಶಃ ಫಲಿತಾಂಶವನ್ನು ಹೇಗಾದರೂ ನಿರ್ಲಕ್ಷಿಸುತ್ತಾರೆ.

ಸಂವಹನ {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}

-ನೋಬಫರ್ ಫ್ಲಾಗ್ ಅಕ್ಷರಗಳನ್ನು ಓದಿದಂತೆ ಔಟ್ಪುಟ್ ಪ್ರಕ್ರಿಯೆಗೆ ಕೆಳಗಿನ ಮಾದರಿಯನ್ನು ಹೊಂದಿಸುವ ಅಕ್ಷರಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ.

ಪ್ರೋಗ್ರಾಂ ಪ್ರತಿಧ್ವನಿಗೆ ಮರಳಿಸಲು ನೀವು ಬಯಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಒಬ್ಬ ವ್ಯಕ್ತಿಯು ಡಯಾಯಿಂಗ್ ಮಾಡುತ್ತಿರುವ ಸ್ಥಳವನ್ನು (ಹೇಯ್ಸ್-ಶೈಲಿಯ ಮೋಡೆಮ್) ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಕೆಳಗಿನವುಗಳನ್ನು ಬಳಸಬಹುದು. ಪ್ರತಿ ಬಾರಿಯೂ "ಎಡ್ಡಿ" ಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಕ್ಯಾನ್ ಅನ್ನು ರೇಖೆಯ ಉಳಿದಂತೆ ನೋಡುತ್ತದೆ.

proc lognumber {} {interactact -nobuffer -re "(. *) \ r" ರಿಟರ್ನ್ $ ಲಾಗ್ ಇರಿಸುತ್ತದೆ "[ಕ್ಲಾಕ್ ಫಾರ್ಮ್ಯಾಟ್ [ಗಡಿಯಾರ ಸೆಕೆಂಡುಗಳು]]: $ ಇಂಟರ್ಯಾಕ್ಟ್_ಔಟ್ (1, ಸ್ಟ್ರಿಂಗ್)" ಡಯಲ್ ಮಾಡಿದೆ "ಇಂಟರ್ಯಾಕ್ಟ್ -ನೊಬಾಫರ್" ಎಎಡ್ಡಿ "ಲಾಗ್ನಂಬರ್

ಸಂವಹನ ಮಾಡುವಾಗ, log_user ನ ಹಿಂದಿನ ಬಳಕೆಯು ನಿರ್ಲಕ್ಷಿಸಲ್ಪಟ್ಟಿದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಸಂವಹನವು ಅದರ ಔಟ್ಪುಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ (ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ಪುಟ್ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ) ಏಕೆಂದರೆ ಬಳಕೆದಾರನು ಕುರುಡಾಗಿ ಸಂವಹನ ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ.

-o ಧ್ವಜವು ಈ ಕೆಳಗಿನ ಪ್ರಕ್ರಿಯೆಯ ಔಟ್ಪುಟ್ಗೆ ಅನುಸರಿಸಲು ಯಾವುದೇ ಕೆಳಗಿನ ಕೀ-ಬಾಡಿ ಜೋಡಿಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ ಟೆಲ್ನೆಟ್ ಸೆಶನ್ನಲ್ಲಿ ಅನಗತ್ಯ ಅಕ್ಷರಗಳನ್ನು ಕಳುಹಿಸುವ ಹೋಸ್ಟ್ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಸಂವಹನವು ಬಳಕೆದಾರನು stdin ಬರೆಯುವುದು ಮತ್ತು ನಿರೀಕ್ಷಿಸುವ ಪ್ರಕ್ರಿಯೆಯ stdout ಅನ್ನು ಓದುವುದು ಎಂದು ನಿರೀಕ್ಷಿಸುತ್ತದೆ . -u ಫ್ಲ್ಯಾಗ್ ("ಬಳಕೆದಾರ" ಗಾಗಿ) ಅದರ ಆರ್ಗ್ಯುಮೆಂಟ್ನಿಂದ ಹೆಸರಿಸಲ್ಪಟ್ಟ ಪ್ರಕ್ರಿಯೆಯಾಗಿ (ಇದು ಮೊಟ್ಟೆಯಿಟ್ಟುಕೊಂಡಿರುವ ಐಡಿ ಆಗಿರಬೇಕು) ಬಳಕೆದಾರರಿಗೆ ನೋಟವನ್ನು ಸಂವಹಿಸುತ್ತದೆ .

ಸ್ಪಷ್ಟವಾದ ಲೂಪ್ ಬಳಸದೆಯೇ ಇದು ಸಂಬಂಧವಿಲ್ಲದ ಎರಡು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಒಟ್ಟಾಗಿ ಸೇರಲು ಅನುಮತಿಸುತ್ತದೆ. ಡೀಬಗ್ ಮಾಡುವುದರಲ್ಲಿ ನೆರವಾಗಲು, ಡಯಾಗ್ನಾಸ್ಟಿಕ್ಸ್ ಯಾವಾಗಲೂ ಸ್ಟೆಡರ್ರ್ಗೆ ಹೋಗುವಾಗ ನಿರೀಕ್ಷಿಸಿ (ಅಥವಾ ಕೆಲವು ಲಾಗಿಂಗ್ ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವ ಮಾಹಿತಿಗಾಗಿ ಸ್ಟ್ಯಾಡ್ಔಟ್). ಇದೇ ಕಾರಣಕ್ಕಾಗಿ, ಇಂಟರ್ಪ್ರಿಟರ್ ಕಮಾಂಡ್ stdin ನಿಂದ ಸಂವಹನವನ್ನು ಓದುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ತುಣುಕು ಲಾಗಿನ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ನಂತರ ಅದು ಬಳಕೆದಾರನನ್ನು ತೋರಿಸುತ್ತದೆ (ತೋರಿಸಲಾಗಿಲ್ಲ), ಮತ್ತು ಅಂತಿಮವಾಗಿ ಇಬ್ಬರನ್ನು ಒಟ್ಟಿಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ. ಸಹಜವಾಗಿ, ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಲಾಗಿನ್ಗಾಗಿ ಬದಲಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದು ಶೆಲ್, ಬಳಕೆದಾರನು ಖಾತೆಯನ್ನು ಮತ್ತು ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಸರಬರಾಜು ಮಾಡದೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

spawn ಲಾಗಿನ್ ಸೆಟ್ ಲಾಗಿನ್ $ spawn_id ಸ್ಪಾವ್ನ್ ತುದಿ ಮೋಡೆಮ್ # ಡಯಲ್ ಇಂಟರ್ಯಾಕ್ಟ್ ಲಾಗಿನ್ ಬಳಕೆದಾರ # ಸಂಪರ್ಕ ಬಳಕೆದಾರರಿಗೆ ಮರಳಿ -u $ ಲಾಗಿನ್

ಬಹು ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಔಟ್ಪುಟ್ ಕಳುಹಿಸಲು, ಪ್ರತಿ-ಸ್ಪಾಟ್ ಐಡಿ ಪಟ್ಟಿಯನ್ನು ಒಂದು -ಔಟ್ಪುಟ್ ಧ್ವಜದಿಂದ ಆದ್ಯತೆ ಮಾಡಿ. ಒಂದು ಔಟ್ಪುಟ್ ಸ್ಪಾನ್ ಐಡಿಗಳನ್ನು ಒಂದು ಗುಂಪಿನ ಇನ್ಪುಟ್ -ಒಂದು ಇನ್ಪುಟ್ ಧ್ವಜದಿಂದ ಮುಂದೂಡಲ್ಪಟ್ಟ ಸ್ಪಾನ್ ಐಡಿ ಪಟ್ಟಿಯಿಂದ ನಿರ್ಧರಿಸಬಹುದು. ( -ಪುಪುಟ್ ಮತ್ತು -ಔಟ್ಪುಟ್ ಎರಡೂ ಒಂದೇ ರೀತಿಯ ರೂಪದಲ್ಲಿ -i ಧ್ವಜವನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು , ಯಾವುದೇ_ಸ್ಪಾನ್ಐಡಿ ಪರಸ್ಪರ ಸಂವಹನದಲ್ಲಿ ಅರ್ಥಪೂರ್ಣವಾಗಿಲ್ಲ.) ಕೆಳಗಿನ ಎಲ್ಲಾ ಫ್ಲ್ಯಾಗ್ಗಳು ಮತ್ತು ತಂತಿಗಳು (ಅಥವಾ ಮಾದರಿಗಳು) ಈ ಇನ್ಪುಟ್ಗೆ ಇನ್ನೊಂದಕ್ಕೆ ಅನ್ವಯಿಸುತ್ತವೆ - ಇನ್ಪುಟ್ ಫ್ಲ್ಯಾಗ್ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಯಾವುದೇ- ಇನ್ಪುಟ್ ಕಂಡುಬಂದರೆ, -ಔಟ್ಪುಟ್ "-ಇನ್ಪುಟ್ $ user_spawn_id -output" ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. (ಅಂತೆಯೇ, ಇನ್ಪುಟ್ ಹೊಂದಿಲ್ಲದ ಮಾದರಿಗಳೊಂದಿಗೆ .) ಒಂದು -ಪಿಪು ಸೂಚಿಸಿದ್ದರೆ, ಅದು $ user_spawn_id ಅನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ. ಎರಡನೆಯ- ಇನ್ಪುಟ್ ಸೂಚಿಸಿದ್ದರೆ, ಅದು $ spawn_id ಅನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿ -ಇನ್ಪುಟ್ ಫ್ಲ್ಯಾಗ್ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

$ Spawn_id ಮತ್ತು $ user_spawn_id (ಹಿಮ್ಮುಖದಲ್ಲಿ) ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾದ ತಮ್ಮ ಉತ್ಪನ್ನಗಳನ್ನು ಸೂಚಿಸಲು ಎರಡು ಸೂಚಿಸಿದ ಇನ್ಪುಟ್ ಪ್ರಕ್ರಿಯೆಗಳು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿರುತ್ತವೆ. ಯಾವುದೇ - ಔಟ್ಪುಟ್ ಫ್ಲ್ಯಾಗ್ನೊಂದಿಗೆ ಒಂದು- ಇನ್ಪುಟ್ ಫ್ಲ್ಯಾಗ್ ಗೋಚರಿಸಿದರೆ, ಆ ಪ್ರಕ್ರಿಯೆಯ ಪಾತ್ರಗಳನ್ನು ತಿರಸ್ಕರಿಸಲಾಗುತ್ತದೆ.

ಯಾವುದೇ- ಇನ್ಪುಟ್ ಅಥವಾ -ಔಟ್ಪುಟ್ ಫ್ಲ್ಯಾಗ್ಗಳನ್ನು ಬಳಸದಿದ್ದಾಗ -i ಫ್ಲ್ಯಾಗ್ ಪ್ರಸ್ತುತ spawn_id ಗೆ ಬದಲಿ ಸ್ಥಾನವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. A -i ಧ್ವಜವು -o ಧ್ವಜವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಪರೋಕ್ಷ ಸ್ಪಾನ್ ಐಡಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಂವಹನ ನಡೆಸುತ್ತಿರುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿದೆ. (ಪರೋಕ್ಷ ಸ್ಪಾನ್ ಐಡಿಗಳನ್ನು ನಿರೀಕ್ಷಣಾ ಆಜ್ಞೆಯ ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ.) ಪರೋಕ್ಷ ಸ್ಪಾನ್ ಐಡಿಗಳನ್ನು -i, -u, -input, ಅಥವಾ -output ಫ್ಲ್ಯಾಗ್ಗಳೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ವಿವರಣಕಾರರು [ವಾದಗಳು]
ಎಕ್ಸ್ಪೆಕ್ಟ್ ಮತ್ತು ಟಿಕ್ಎಲ್ ಆಜ್ಞೆಗಳಿಗೆ ಬಳಕೆದಾರರನ್ನು ಸಂವಾದಾತ್ಮಕವಾಗಿ ಪ್ರಚೋದಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ಪ್ರತಿ ಆಜ್ಞೆಯ ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.

ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುವಂತೆ ಬ್ರೇಕ್ ಮತ್ತು ನಿಯಂತ್ರಣದ ರಚನೆಯನ್ನು ಉಂಟುಮಾಡುವ ಕ್ರಮಗಳು (ಅಂದರೆ, ಫಾರ್ , ಫಾರ್ ). ಆದಾಗ್ಯೂ ಹಿಂದಿರುಗಿದವರು ಅದರ ಕರೆಮಾಡುವವರಿಗೆ ಹಿಂದಿರುಗಲು ಕಾರಣವಾಗುತ್ತದೆ, ಆದರೆ inter_return ಅದರ ಕರೆಮಾಡುವಲ್ಲಿ ಮರಳಿ ಉಂಟುಮಾಡಲು ಇಂಟರ್ಪ್ರಿಟರ್ಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, "proc foo" ಅನ್ನು ಇಂಟರ್ಪ್ರಿಟರ್ ಎಂದು ಕರೆಯಲಾಗಿದ್ದರೆ ಅದು ಆಕ್ಷನ್ inter_return ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ, proc foo ಮರಳುತ್ತದೆ. ಯಾವುದೇ ಆಜ್ಞೆಯು ಹೊಸ ಆಜ್ಞೆಗಳಿಗೆ ಉತ್ತೇಜಿಸುವುದನ್ನು ಮುಂದುವರೆಸಲು ಇಂಟರ್ಪ್ರಿಟರ್ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಪ್ರಾಂಪ್ಟ್ ಎರಡು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಮೊದಲ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯಮಾಪನ ಸ್ಟಾಕ್ನ ಆಳವನ್ನು ವಿವರಿಸುತ್ತದೆ (ಅಂದರೆ, ಎಷ್ಟು ಬಾರಿ Tcl_Eval ಅನ್ನು ಕರೆಯಲಾಗಿದೆ). ಎರಡನೇ ಪೂರ್ಣಾಂಕವೆಂದರೆ Tcl ಇತಿಹಾಸ ಗುರುತಿಸುವಿಕೆ. "ಪ್ರಾಂಪ್ಟ್ 1" ಎಂಬ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸುವ ಮೂಲಕ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಹೊಂದಿಸಬಹುದು, ಇದರ ರಿಟರ್ನ್ ಮೌಲ್ಯ ಮುಂದಿನ ಪ್ರಾಂಪ್ಟ್ ಆಗುತ್ತದೆ. ಹೇಳಿಕೆ ತೆರೆದ ಉಲ್ಲೇಖಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಆವರಣಗಳು, ಕಟ್ಟುಪಟ್ಟಿಗಳು, ಅಥವಾ ಬ್ರಾಕೆಟ್ಗಳು, ದ್ವಿತೀಯ ಪ್ರಾಂಪ್ಟನ್ನು (ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ "+>") ನ್ಯೂಲೈನ್ನಲ್ಲಿ ನೀಡಲಾಗುತ್ತದೆ. "ಪ್ರಾಂಪ್ಟ್ 2" ಎಂಬ ಕಾರ್ಯವಿಧಾನವನ್ನು ವಿವರಿಸುವ ಮೂಲಕ ದ್ವಿತೀಯ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಹೊಂದಿಸಬಹುದು.

ಇಂಟರ್ಪ್ರಿಟರ್ನ ಸಮಯದಲ್ಲಿ, ಬೇಯಿಸಿದ ಮೋಡ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಅದರ ಕಾಲರ್ ಕಚ್ಚಾ ಕ್ರಮವನ್ನು ಬಳಸುತ್ತಿದ್ದರೂ ಸಹ.

Stdin ಮುಚ್ಚಿದ್ದರೆ, -ಇಫ್ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಹೊರತು ಇಂಟರ್ಪ್ರಿಟರ್ ಹಿಂತಿರುಗುತ್ತದೆ, ಆ ಸಂದರ್ಭದಲ್ಲಿ ನಂತರದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಆಹ್ವಾನಿಸಲಾಗುತ್ತದೆ.

log_file [args] [[-a] ಕಡತ]
ಫೈಲ್ ಹೆಸರನ್ನು ಒದಗಿಸಿದರೆ, ಫೈಲ್ನಲ್ಲಿ ಅಧಿವೇಶನದ ನಕಲು (ಆ ಹಂತದಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುವ) log_file ರೆಕಾರ್ಡ್ ಮಾಡುತ್ತದೆ. ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ನೀಡದಿದ್ದರೆ log_file ರೆಕಾರ್ಡಿಂಗ್ ಅನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ. ಯಾವುದೇ ಹಿಂದಿನ ಲಾಗ್ ಫೈಲ್ ಮುಚ್ಚಲಾಗಿದೆ.

ಫೈಲ್ ಹೆಸರಿನ ಬದಲಿಗೆ, -ಓಪನ್ ಅಥವಾ -ಲಿವಪೆಪೆನ್ ಫ್ಲ್ಯಾಗ್ಗಳನ್ನು ಬಳಸುವುದರ ಮೂಲಕ Tcl ಫೈಲ್ ಐಡೆಂಟಿಫಯರ್ ಅನ್ನು ಒದಗಿಸಬಹುದು. ಇದು ಸ್ಪಾನ್ ಆಜ್ಞೆಯನ್ನು ಹೋಲುತ್ತದೆ. (ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ಸ್ಪಾನ್ ನೋಡಿ.)

Log_user ಕಮಾಂಡ್ನಿಂದ ಮುಚ್ಚಲ್ಪಟ್ಟ - ಧ್ವಜವು ಔಟ್ಪುಟ್ ಅನ್ನು ಲಾಗ್ ಮಾಡಲು ಒತ್ತಾಯಿಸುತ್ತದೆ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, log_file ಆಜ್ಞೆಯು ಅವುಗಳನ್ನು ಕತ್ತರಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ ಹಳೆಯ ಫೈಲ್ಗಳಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ, ಒಂದು ಅಧಿವೇಶನದಲ್ಲಿ ಲಾಗಿಂಗ್ ಆಗಲು ಮತ್ತು ಅನೇಕ ಬಾರಿ ಅದನ್ನು ಮಾಡಲು ಅನುಕೂಲವಾಗುವಂತೆ. ಫೈಲ್ಗಳನ್ನು ಮೊಟಕುಗೊಳಿಸಲು, -noappend ಫ್ಲ್ಯಾಗ್ ಬಳಸಿ.

-ಇನ್ಫೋ ಫ್ಲ್ಯಾಗ್ log_file ಗೆ ಕಾರಣವಾದ ಇತ್ತೀಚಿನ ಮಾಹಿತಿಯಲ್ಲದ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳ ವಿವರಣೆಯನ್ನು ಮರಳಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ.

log_user -ಇನ್ಫೋ | 0 | 1
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಕಳುಹಿಸುವ / ನಿರೀಕ್ಷಿಸುವ ಸಂವಾದವನ್ನು stdout ಗೆ ಲಾಗ್ ಮಾಡಲಾಗಿದೆ (ಮತ್ತು ತೆರೆದಿದ್ದರೆ ಒಂದು ಲಾಗ್ಫೈಲ್). Stdout ಗೆ ಲಾಗಿಂಗ್ ಅನ್ನು "log_user 0" ಆಜ್ಞೆಯಿಂದ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು "log_user 1" ಮೂಲಕ ಮರುಹೊಂದಿಸಲಾಗಿದೆ. ಲಾಗ್ಫೈಲ್ಗೆ ಪ್ರವೇಶಿಸುವುದರಿಂದ ಬದಲಾಗದೆ ಇರುತ್ತದೆ.

-ಇನ್ಫೋ ಫ್ಲ್ಯಾಗ್ log_user ಅನ್ನು ಇತ್ತೀಚಿನ ಮಾಹಿತಿಯಲ್ಲದ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳ ವಿವರಣೆಯನ್ನು ಮರಳಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ.

match_max [-d] [-i spawn_id] [ಗಾತ್ರ]
ಆಂತರಿಕವಾಗಿ ನಿರೀಕ್ಷಿಸುವ ಮೂಲಕ ಬಫರ್ ಗಾತ್ರವನ್ನು (ಬೈಟ್ಗಳಲ್ಲಿ) ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಯಾವುದೇ ಗಾತ್ರದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಇಲ್ಲದೆ, ಪ್ರಸ್ತುತ ಗಾತ್ರವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

-d ಧ್ವಜದೊಂದಿಗೆ, ಡೀಫಾಲ್ಟ್ ಗಾತ್ರವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ. (ಆರಂಭಿಕ ಡೀಫಾಲ್ಟ್ 2000 ಆಗಿದೆ.) -i ಫ್ಲಾಗ್ನೊಂದಿಗೆ, ಹೆಸರಿನ ಸ್ಪಾನ್ ಐಡಿಗಾಗಿ ಗಾತ್ರವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ.

ಓವರ್ಲೇ [- # spawn_id] [- # spawn_id] [...] ಪ್ರೋಗ್ರಾಂ [args]
ಪ್ರಸಕ್ತ ಎಕ್ಸ್ಪೆಕ್ಟ್ ಪ್ರೋಗ್ರಾಂನ ಬದಲಾಗಿ "ಪ್ರೊಗ್ರಾಮ್ ವಾದಗಳು" ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಇದು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಒಂದು ಬೇರ್ ಹೈಫನ್ ವಾದವು ಆಜ್ಞಾ ಹೆಸರಿನ ಮುಂಭಾಗದಲ್ಲಿ ಒಂದು ಹೈಫನ್ ಅನ್ನು ಲಾಗಿನ್ ಶೆಲ್ ಎಂದು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಎಲ್ಲಾ ಸ್ಪಾನ್_ಐಡಿಗಳು ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳಂತೆ ಹೊರತುಪಡಿಸಿ ಮುಚ್ಚಲ್ಪಡುತ್ತವೆ. ಹೆಸರಿಸಲಾದ ಫೈಲ್ ಗುರುತಿಸುವಿಕೆಗಳಲ್ಲಿ ಇವುಗಳನ್ನು ಮ್ಯಾಪ್ ಮಾಡಲಾಗುತ್ತದೆ.

ಹೊಸ ಪ್ರೊಗ್ರಾಮ್ ಅನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆದುಕೊಳ್ಳಲು ಗುರುತಿಸುವಿಕೆಯನ್ನು ಸಲ್ಲಿಸಲು Spawn_ids ಅನ್ನು ಮ್ಯಾಪ್ ಮಾಡಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ಸಾಲು ಚದುರಂಗದ ಮೂಲಕ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಅದನ್ನು ನಿಯಂತ್ರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ - ಚೆಸ್ ಮಾಸ್ಟರ್ ಎಂದು ಹೇಳುತ್ತಾರೆ.

ಓವರ್ಲೇ -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id ಚೆಸ್

"-u" ಸಂವಹನಕ್ಕಿಂತ ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ, ಆದಾಗ್ಯೂ, ನಿರೀಕ್ಷಿತ ಪ್ರಕ್ರಿಯೆಯು ಇನ್ನು ಮುಂದೆ ನಿಯಂತ್ರಣದಲ್ಲಿರುವುದಿಲ್ಲವಾದ್ದರಿಂದ ಇದು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲಾದ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ತ್ಯಾಗ ಮಾಡುತ್ತದೆ.

ಯಾವುದೇ ನಿಯಂತ್ರಣ ಟರ್ಮಿನಲ್ ಅನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಹೀಗಾಗಿ, ನೀವು ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಅನ್ನು ಕಡಿತಗೊಳಿಸಿ ಅಥವಾ ಮರುಮಾಡು ಮಾಡಿದರೆ, ಕೆಲಸದ ನಿಯಂತ್ರಣ (ಶೆಲ್ಗಳು, ಲಾಗಿನ್, ಇತ್ಯಾದಿ) ಮಾಡುವ ಕಾರ್ಯಕ್ರಮಗಳು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ.

ಸಮಾನತೆ [-d] [-i spawn_id] [ಮೌಲ್ಯ]
ಸಮಾನಾಂತರ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಉಳಿದುಕೊಂಡಿರಬೇಕೆ ಅಥವಾ ಪಾಲಿಸಬೇಕಾದ ಪ್ರಕ್ರಿಯೆಗಳ ಔಟ್ಪುಟ್ನಿಂದ ಹೊರತೆಗೆಯಬೇಕು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಮೌಲ್ಯವು ಶೂನ್ಯವಾಗಿದ್ದರೆ, ಸಮಾನತೆಯು ಹೊರತೆಗೆಯಲ್ಪಡುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದನ್ನು ಹೊರತೆಗೆಯಲಾಗುವುದಿಲ್ಲ. ಯಾವುದೇ ಮೌಲ್ಯ ವಾದವಿಲ್ಲದೆ, ಪ್ರಸ್ತುತ ಮೌಲ್ಯವು ಮರಳಿದೆ.

-d ಧ್ವಜದೊಂದಿಗೆ ಡೀಫಾಲ್ಟ್ ಪ್ಯಾರಿಟಿ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ. (ಆರಂಭಿಕ ಡೀಫಾಲ್ಟ್ 1, ಅಂದರೆ, ಪ್ಯಾರಿಟಿ ಹೊರತೆಗೆಯಲಾಗುವುದಿಲ್ಲ.) -ಐ ಫ್ಲಾಗ್ನೊಂದಿಗೆ, ಪ್ಯಾರಿಟಿ ಮೌಲ್ಯವನ್ನು ಹೆಸರಿಸಲಾದ ಸ್ಪಾನ್ ಐಡಿಗಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ಹೊಂದಿಸಲಾಗಿದೆ.

remove_nulls [-d] [-i spawn_id] [ಮೌಲ್ಯ]
ಮಾದರಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸುವ ಅಥವಾ ನಿರೀಕ್ಷೆಯ ನಿರೀಕ್ಷೆಯಲ್ಲಿ ಅಥವಾ ಸಂವಾದಾತ್ಮಕದಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದಕ್ಕೂ ಮುಂಚೆಯೇ ಮೊಟ್ಟೆಯೊಂದನ್ನು ಉಳಿದುಕೊಂಡಿರುವ ಪ್ರಕ್ರಿಯೆಗಳ ಔಟ್ಪುಟ್ನಿಂದ ಶೂನ್ಯಗಳು ಉಳಿಸಬಹುದೇ ಅಥವಾ ತೆಗೆದುಹಾಕುವುದನ್ನು ವಿವರಿಸುತ್ತದೆ . ಮೌಲ್ಯವು 1 ಆಗಿದ್ದರೆ, ಶೂನ್ಯವನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ. ಮೌಲ್ಯವು 0 ಆಗಿದ್ದರೆ, ಶೂನ್ಯವನ್ನು ತೆಗೆದುಹಾಕಲಾಗುವುದಿಲ್ಲ. ಯಾವುದೇ ಮೌಲ್ಯ ವಾದವಿಲ್ಲದೆ, ಪ್ರಸ್ತುತ ಮೌಲ್ಯವು ಮರಳಿದೆ.

-d ಫ್ಲ್ಯಾಗ್ನೊಂದಿಗೆ, ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ. (ಆರಂಭಿಕ ಡೀಫಾಲ್ಟ್ 1, ಅಂದರೆ, ಶೂನ್ಯವನ್ನು ತೆಗೆಯಲಾಗುತ್ತದೆ.) -i ಫ್ಲಾಗ್ನೊಂದಿಗೆ, ಹೆಸರಿಸಲ್ಪಟ್ಟ ಸ್ಪಾನ್ ಐಡಿಗಾಗಿ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ಹೊಂದಿಸಲಾಗಿದೆ.

ಶೂನ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕಲಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ, ಲಾಗ್ ಮತ್ತು stdout ಗೆ ಶೂನ್ಯ ಬೈಟ್ಗಳನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡುತ್ತದೆ.

[-flags] ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಕಳುಹಿಸಿ
ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ಸ್ಟ್ರಿಂಗ್ ಕಳುಹಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಆದೇಶ

"ಹಲೋ ವರ್ಲ್ಡ್ \ r" ಅನ್ನು ಕಳುಹಿಸಿ

ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ helloworld ಪಾತ್ರಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ. (Tcl ಒಂದು ಪ್ರಿಂಟ್ಫ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ - ಅನಿಯಂತ್ರಿತ ಸಂಕೀರ್ಣವಾದ ತಂತಿಗಳನ್ನು ರಚಿಸುವಂತಹ ಕಮಾಂಡ್ ( ಸ್ವರೂಪ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ).)

ಸಾಲು-ಬಫರ್ ಇನ್ಪುಟ್ನ ಪ್ರೊಗ್ರಾಮ್ಗಳು ಪಾತ್ರಗಳನ್ನು ಓದಲಾಗದಿದ್ದರೂ ಸಹ ಪಾತ್ರಗಳು ತಕ್ಷಣವೇ ಕಳುಹಿಸಲ್ಪಡುತ್ತವೆ. ರಿಟರ್ನ್ ಅಕ್ಷರವನ್ನು "\ r" ಎಂದು ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ಮುಂದಿನ ಧ್ವಜವನ್ನು ಧ್ವಜಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಯಾವುದೇ ವಾಕ್ಯವನ್ನು "-" ವಾಸ್ತವವಾಗಿ ಒಂದು ಧ್ವಜದಂತೆ ಕಾಣಿಸುತ್ತದೆಯೇ ಇಲ್ಲವೋ ಎಂದು ಮೊದಲು ಸೂಚಿಸಬಹುದು. ಧ್ವಜಗಳಂತೆ ಆಕಸ್ಮಿಕವಾಗಿ ಆಚರಿಸಲಾಗದ ವ್ಯತ್ಯಾಸಗಳಿಂದಾಗಿ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ತಂತಿಗಳನ್ನು ಸೂಚಿಸಲು ಇದು ವಿಶ್ವಾಸಾರ್ಹ ಕಾರ್ಯವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ("-" ಪ್ರಾರಂಭವಾಗುವ ಎಲ್ಲಾ ತಂತಿಗಳು ಭವಿಷ್ಯದ ಆಯ್ಕೆಗಳಿಗಾಗಿ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ.)

ಹೆಸರಿನ spawn_id ಗೆ ಸ್ಟ್ರಿಂಗ್ ಕಳುಹಿಸಲಾಗುವುದು -i ಫ್ಲ್ಯಾಗ್ ಘೋಷಿಸುತ್ತದೆ. Spawn_id ಎನ್ನುವುದು user_spawn_id ಆಗಿದ್ದರೆ, ಟರ್ಮಿನಲ್ ಕಚ್ಚಾ ಕ್ರಮದಲ್ಲಿದ್ದರೆ, ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿನ ಹೊಸ ಸಾಲುಗಳನ್ನು ರಿಟರ್ನ್-ನ್ಯೂ ಲೈನ್ ಸೀಕ್ವೆನ್ಸ್ಗಳಿಗೆ ಅನುವಾದಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅವು ಟರ್ಮಿನಲ್ ಬೇಯಿಸಿದ ಮೋಡ್ನಲ್ಲಿದ್ದಂತೆ ಗೋಚರಿಸುತ್ತವೆ. -ರಾ ಧ್ವಜ ಈ ಅನುವಾದವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

-ಎಲ್ಲಾ ಫ್ಲ್ಯಾಗ್ ಶೂನ್ಯ ಪಾತ್ರಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ (0 ಬೈಟ್ಗಳು). ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಒಂದು ಶೂನ್ಯವನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಎಷ್ಟು ಪೂರ್ಣ ಶೂನ್ಯವನ್ನು ಕಳುಹಿಸಲು ಸೂಚಿಸಲು ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ಅನುಸರಿಸಬಹುದು.

-break ಧ್ವಜವು ವಿರಾಮ ಸ್ಥಿತಿಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಸ್ಪಾನ್ ಐಡಿ "ಸ್ಪಾವ್ನ್-ಓಪನ್" ಮೂಲಕ ತೆರೆಯಲಾದ ಟಿಟಿ ಸಾಧನವನ್ನು ಸೂಚಿಸಿದರೆ ಮಾತ್ರ ಇದು ಅರ್ಥಪೂರ್ಣವಾಗಿರುತ್ತದೆ. ನೀವು ಸುಳಿವು ಮುಂತಾದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬೆಳೆಸಿದರೆ, ವಿರಾಮವನ್ನು ಉಂಟುಮಾಡಲು ನೀವು ತುದಿಗಳ ಸಮಾವೇಶವನ್ನು ಬಳಸಬೇಕು.

-ಸ್ ಧ್ವಜವು ಉತ್ಪಾದನೆಯನ್ನು "ನಿಧಾನವಾಗಿ" ಕಳುಹಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಸಾಮಾನ್ಯ ಪರಿಸ್ಥಿತಿ ತಪ್ಪಿಸಲು ಒಂದು ಕಂಪ್ಯೂಟರ್ ಇನ್ಪುಟ್ ಬಫರ್ ಅನ್ನು ಅದೇ ಬಫರ್ ಅನ್ನು ಎಂದಿಗೂ ಔಟ್ಪೈಪ್ ಮಾಡದಿರುವ ಮಾನವನಿಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಈ ಔಟ್ಪುಟ್ ಅನ್ನು ವೇರಿಯೇಬಲ್ "send_slow" ಮೌಲ್ಯದಿಂದ ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ, ಇದು ಎರಡು ಎಲಿಮೆಂಟ್ ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಮೊದಲ ಅಂಶವು ಪೂರ್ಣಾಂಕವಾಗಿದ್ದು, ಪರಮಾಣುಗಳನ್ನು ಕಳುಹಿಸಲು ಬೈಟ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಎರಡನೆಯ ಅಂಶವು ನೈಜ ಸಂಖ್ಯೆಯಾಗಿದ್ದು, ಅದು ಪರಮಾಣು ಕಳುಹಿಸುವಿಕೆಯನ್ನು ಬೇರ್ಪಡಿಸಬೇಕಾದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕಳುಹಿಸಿದ ಪ್ರತಿ 10 ಅಕ್ಷರಗಳ ನಡುವೆ 1 ಮಿಲಿಸೆಕೆಂಡ್ನೊಂದಿಗೆ ತಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು "ಕಳುಹಿಸು_ಸ್ಲೋ {10 .001}" ಅನ್ನು "ಕಳುಹಿಸು -ಎಸ್" ಒತ್ತಾಯಿಸುತ್ತದೆ.

-h ಧ್ವಜವು ವಾಸ್ತವವಾಗಿ ಮನುಷ್ಯನನ್ನು ಟೈಪ್ ಮಾಡುವಂತೆ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಕಳುಹಿಸಬಹುದು. ಪಾತ್ರಗಳ ನಡುವೆ ಮಾನವ-ರೀತಿಯ ವಿಳಂಬ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. (ಅಲ್ಗಾರಿದಮ್ ಈ ನಿರ್ದಿಷ್ಟ ಅನ್ವಯಕ್ಕೆ ಸರಿಹೊಂದುವಂತೆ ಮಾರ್ಪಾಡುಗಳೊಂದಿಗೆ ವೈಬುಲ್ ವಿತರಣೆಯನ್ನು ಆಧರಿಸಿದೆ.) ಈ ಔಟ್ಪುಟ್ ವೇರಿಯೇಬಲ್ "send_human" ಮೌಲ್ಯದಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುತ್ತದೆ, ಅದು ಐದು ಅಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಮೊದಲ ಎರಡು ಅಂಶಗಳು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಅಕ್ಷರಗಳ ಸರಾಸರಿ ಅಂತರ ಸಮಯ. ಮೊದಲನೆಯದನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಎರಡನೆಯದನ್ನು ಶಬ್ದದ ಅಂತ್ಯಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ, ಇಂತಹ ಪರಿವರ್ತನೆಗಳಲ್ಲಿ ಸಾಂದರ್ಭಿಕವಾಗಿ ಸಂಭವಿಸುವ ಸೂಕ್ಷ್ಮ ವಿರಾಮಗಳನ್ನು ಅನುಕರಿಸಲು. ಮೂರನೇ ನಿಯತಾಂಕವು ಒಂದು ವ್ಯತ್ಯಾಸದ ಅಳತೆಯಾಗಿದ್ದು, ಅಲ್ಲಿ 1 ಬಹಳ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುತ್ತದೆ, 1 ಯು ಸಮಂಜಸವಾಗಿ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು 10 ಬಹಳ ಸ್ಥಿರವಾಗಿದೆ. ಅಪರಿಮಿತತೆಯು 0 ಅಪರಿಮಿತವಾಗಿದೆ. ಕೊನೆಯ ಎರಡು ನಿಯತಾಂಕಗಳು ಅನುಕ್ರಮವಾಗಿ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಅಂತರ ಸಮಯ. ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಕೊನೆಯ ಮತ್ತು ಕೊನೆಯ ಸಮಯ ಬಳಸಲಾಗುತ್ತದೆ "ಕ್ಲಿಪ್". ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಟ ಕ್ಲಿಪ್ ಸಾಕಷ್ಟು ಮೌಲ್ಯಗಳನ್ನು ನೀಡಿದರೆ ಅಂತಿಮ ಸರಾಸರಿಯು ನಿರ್ದಿಷ್ಟ ಸರಾಸರಿಗಿಂತ ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ.

ಒಂದು ಉದಾಹರಣೆಯಾಗಿ, ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯು ವೇಗದ ಮತ್ತು ಸ್ಥಿರವಾದ ಬೆರಳಚ್ಚುಗಾರನನ್ನು ಎಮ್ಯುಲೇಟ್ಸ್ ಮಾಡುತ್ತದೆ:

ಸೆಟ್ send_human {1 .3 1 .05 2} send -h "ನಾನು ಹಸಿದಿದ್ದೇನೆ, ಊಟ ಮಾಡೋಣ."

ಹ್ಯಾಂಗೊವರ್ ನಂತರ ಕೆಳಗಿನವುಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಬಹುದು:

ಸೆಟ್_ಹ್ಯೂಮನ್ {.4 .4 .2.55 100} ಕಳುಹಿಸು -ಎಚ್ "ಗುಡ್ಡ್ ಪಾರ್ಟಿ ಲಾಶ್ ರಾತ್ರಿಯಲ್ಲಿ!"

ದೋಷಗಳು ಸಿಮ್ಯುಲೇಶನ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ತಪ್ಪು ದೋಷಗಳನ್ನು ಮತ್ತು ತಿದ್ದುಪಡಿಗಳನ್ನು ಕಳುಹಿಸುವ ವಾದದಲ್ಲಿ ದೋಷ ದೋಷ ಸರಿಪಡಿಸುವ ಸಂದರ್ಭಗಳನ್ನು ನೀವು ಹೊಂದಿಸಬಹುದು.

ಶೂನ್ಯ ಪಾತ್ರಗಳನ್ನು ಕಳುಹಿಸಲು ಧ್ವಜಗಳು, ವಿರಾಮಗಳನ್ನು ಕಳುಹಿಸುವುದಕ್ಕಾಗಿ, ನಿಧಾನವಾದ ಔಟ್ಪುಟ್ಗೆ ಒತ್ತಾಯಿಸಲು ಮತ್ತು ಮಾನವ-ಶೈಲಿಯ ಔಟ್ಪುಟ್ಗೆ ಪರಸ್ಪರ ಪ್ರತ್ಯೇಕವಾಗಿರುತ್ತವೆ. ಕೊನೆಯ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಒಂದನ್ನು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ. ಇದಲ್ಲದೆ, ಶೂನ್ಯ ಪಾತ್ರಗಳು ಅಥವಾ ವಿರಾಮಗಳನ್ನು ಕಳುಹಿಸಲು ಫ್ಲ್ಯಾಗ್ಗಳೊಂದಿಗೆ ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್ ವಾದವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿಲ್ಲ.

ಒಂದು ನಿರೀಕ್ಷೆಯ ಮೂಲಕ ಮೊದಲ ಕಳುಹಿಸುವಿಕೆಯನ್ನು ಮೊದಲು ಕಳುಹಿಸುವ ಮೊದಲು ಇದು ಒಳ್ಳೆಯದು. ಕಳುಹಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೂ, ಪ್ರಕ್ರಿಯೆ ಆರಂಭಿಸಲು ಪ್ರಾರಂಭವಾಗುವ ನಿರೀಕ್ಷೆ ನಿರೀಕ್ಷಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಪ್ರಕ್ರಿಯೆಯು ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು ಮೊದಲ ಕಳುಹಿಸಿದರೆ , ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಕಡೆಗಣಿಸುವ ಅಪಾಯವನ್ನು ನೀವು ರನ್ ಮಾಡುತ್ತೀರಿ. ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳು ಪ್ರಾಂಪ್ಟ್ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಒದಗಿಸದ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಈ ಕೆಳಗಿನಂತೆ ವಿಳಂಬದಿಂದ ನೀವು ಕಳುಹಿಸಬಹುದು :

# ಹೇಗೆ ಪ್ರವೇಶಿಸಬೇಕೆಂಬುದರ ಬಗ್ಗೆ ಹ್ಯಾಕರ್ಸ್ ಸುಳಿವುಗಳನ್ನು ತಪ್ಪಿಸಲು, # ಬಾಹ್ಯ ಗುಪ್ತಪದಕ್ಕಾಗಿ ಈ ವ್ಯವಸ್ಥೆಯು ಪ್ರಾಂಪ್ಟ್ ಮಾಡುವುದಿಲ್ಲ. # ಎಕ್ಸ್ಎನ್ಕ್ಗಾಗಿ 5 ಸೆಕೆಂಡ್ಗಳ ಕಾಲ ನಿರೀಕ್ಷಿಸಿ. ಸ್ಪಾನ್ ಟೆಲ್ನೆಟ್ ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ .s.cure.gov ನಿದ್ರೆ 5 ಪಾಸ್ವರ್ಡ್ ಕಳುಹಿಸು \ r

exp_send ಎನ್ನುವುದು ಕಳುಹಿಸಲು ಅಲಿಯಾಸ್ ಆಗಿದೆ . ನೀವು Expectk ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ಅಥವಾ Tk ಪರಿಸರದಲ್ಲಿ ನಿರೀಕ್ಷಿಸಬೇಕಾದ ಕೆಲವು ಭಿನ್ನತೆಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಸಂಪೂರ್ಣ ವಿಭಿನ್ನ ಉದ್ದೇಶಕ್ಕಾಗಿ Tk ನಿಂದ ಅದನ್ನು ಕಳುಹಿಸಬಹುದು . ಪರಿಸರದ ನಡುವಿನ ಹೊಂದಾಣಿಕೆಗಾಗಿ exp_send ಅನ್ನು ಒದಗಿಸಲಾಗಿದೆ. ಇತರ ಅಪೇಕ್ಷೆಯ ಇತರ ಕಳುಹಿಸುವ ಆಜ್ಞೆಗಳಿಗೆ ಇದೇ ಅಲಿಯಾಸ್ಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆ.

send_error [-flags] ಸ್ಟ್ರಿಂಗ್
ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗಿಂತ ಹೆಚ್ಚಾಗಿ ಔಟ್ಪುಟ್ ಅನ್ನು stderr ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಹೊರತುಪಡಿಸಿ, ಕಳುಹಿಸುವಂತೆ.

send_log [-] ಸ್ಟ್ರಿಂಗ್
ಲಾಗ್ ಫೈಲ್ಗೆ ಮಾತ್ರ ಕಳುಹಿಸಲಾಗುವುದು ಹೊರತುಪಡಿಸಿ ( log_file ನೋಡಿ.) ಕಳುಹಿಸಿಲ್ಲ, ಯಾವುದೇ ಲಾಗ್ ಫೈಲ್ ತೆರೆದಿದ್ದರೆ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ.

send_tty [-flags] ಸ್ಟ್ರಿಂಗ್
ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯ ಬದಲಿಗೆ ಔಟ್ಪುಟ್ ಅನ್ನು / dev / tty ಗೆ ಕಳುಹಿಸಲಾಗಿದೆ ಹೊರತುಪಡಿಸಿ, ಕಳುಹಿಸು ಹಾಗೆ.

send_user [-flags] ಸ್ಟ್ರಿಂಗ್
ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗಿಂತ ಔಟ್ಪುಟ್ ಅನ್ನು stdout ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಹೊರತುಪಡಿಸಿ, ಕಳುಹಿಸುವಂತೆ.

ನಿದ್ರೆ ಸೆಕೆಂಡುಗಳು
ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಸೆಕೆಂಡುಗಳ ಕಾಲ ಸ್ಕ್ರಿಪ್ಟ್ ನಿದ್ರೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಸೆಕೆಂಡುಗಳು ಒಂದು ದಶಮಾಂಶ ಸಂಖ್ಯೆಯಾಗಿರಬಹುದು. ನಿದ್ದೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸುವಾಗ ತಡೆಗಟ್ಟುವಿಕೆಗಳು (ಮತ್ತು ನೀವು ಎಕ್ಸ್ಪೆಕ್ಕ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ Tk ಘಟನೆಗಳು) ಸಂಸ್ಕರಿಸಲಾಗುತ್ತದೆ.

ಸ್ಪಾನ್ [ಆರ್ಗ್ಸ್] ಪ್ರೋಗ್ರಾಂ [args]
"ಪ್ರೊಗ್ರಾಮ್ ವಾದಗಳು" ಚಾಲನೆಯಲ್ಲಿರುವ ಒಂದು ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಅದರ stdin, stdout ಮತ್ತು stderr ಎಕ್ಸ್ಪೆಕ್ಟ್ ಸಂಪರ್ಕ, ಆದ್ದರಿಂದ ಅವರು ಇತರರು ಆಜ್ಞೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು ಓದಲು ಮತ್ತು ಬರೆಯಬಹುದು. ಈ ಪ್ರಕ್ರಿಯೆಯು ನಿಕಟವಾಗಿ ಮುರಿದುಹೋಗಿದೆ ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯು ಯಾವುದಾದರೂ ಫೈಲ್ ಐಡೆಂಟಿಫಯರ್ಗಳನ್ನು ಮುಚ್ಚಿದರೆ .

ಸ್ಪಾನ್ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ವೇರಿಯೇಬಲ್ spawn_id ಆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಉಲ್ಲೇಖಿಸುವ ವಿವರಣಾಕಾರಕ್ಕೆ ಹೊಂದಿಸಲಾಗಿದೆ. Spawn_id ನಿಂದ ವಿವರಿಸಿದ ಪ್ರಕ್ರಿಯೆಯನ್ನು " ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆ " ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. spawn_id ಅನ್ನು ಓದಬಹುದು ಅಥವಾ ಬರೆಯಬಹುದು, ಪರಿಣಾಮವಾಗಿ ಉದ್ಯೋಗ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸಬಹುದು.

user_spawn_id ಎನ್ನುವುದು ಒಂದು ವಿವರಣೆಯನ್ನು ಹೊಂದಿರುವ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಆಗಿದೆ, ಇದು ಬಳಕೆದಾರನನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, spawn_id ಈ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಸಿದಾಗ, expect_user ನಂತಹ ವರ್ತಿಸುವ ನಿರೀಕ್ಷೆ ಇದೆ .

.ನಾನು error_spawn_id ಯು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಎರರ್ ಅನ್ನು ಸೂಚಿಸುವ ವಿವರಣೆಯನ್ನು ಹೊಂದಿರುವ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಆಗಿದೆ. ಉದಾಹರಣೆಗೆ, spawn_id ಈ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಸಿದಾಗ, send_error ನಂತಹ ವರ್ತನೆಗಳನ್ನು ಕಳುಹಿಸಿ .

tty_spawn_id ಎನ್ನುವುದು / dev / tty ಅನ್ನು ಸೂಚಿಸುವ ವಿವರಣೆಯನ್ನು ಹೊಂದಿರುವ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಆಗಿದೆ. / Dev / tty ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ (ಕ್ರಾನ್, ನಲ್ಲಿ, ಅಥವಾ ಬ್ಯಾಚ್ ಲಿಪಿಯಲ್ಲಿ), ನಂತರ tty_spawn_id ಅನ್ನು ವಿವರಿಸಲಾಗಿಲ್ಲ. ಇದನ್ನು ಹೀಗೆ ಪರೀಕ್ಷಿಸಬಹುದು:

{{info vars tty_spawn_id]} {{/ dev / tty ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ} else {# / dev / tty ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ # ಬಹುಶಃ ಕ್ರಾನ್, ಬ್ಯಾಚ್, ಅಥವಾ ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ}

ಸ್ಪಾನ್ ಯುನಿಕ್ಸ್ ಪ್ರಕ್ರಿಯೆ ಐಡಿ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಯು ಹುಟ್ಟಿಕೊಂಡಲ್ಲಿ, 0 ಮರಳುತ್ತದೆ. ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ spawn_out (ಗುಲಾಮ, ಹೆಸರು) ಪಿಟಿ ಗುಲಾಮ ಸಾಧನದ ಹೆಸರಿಗೆ ಹೊಂದಿಸಲಾಗಿದೆ.

ಡೀಫಾಲ್ಟ್ ಆಗಿ, ಸ್ಪಾನ್ ಆಜ್ಞಾ ಹೆಸರು ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳನ್ನು ಪ್ರತಿಧ್ವನಿಸುತ್ತದೆ. -ನೊಯೊಕೊ ಫ್ಲ್ಯಾಗ್ ಇದನ್ನು ಮಾಡುವುದರಿಂದ ಉಂಟಾಗುತ್ತದೆ .

-console ಫ್ಲ್ಯಾಗ್ ಕನ್ಸೋಲ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗೆ ಮರುನಿರ್ದೇಶಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ಇದು ಎಲ್ಲಾ ಸಿಸ್ಟಮ್ಗಳಲ್ಲಿ ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.

ಆಂತರಿಕವಾಗಿ, ಸ್ಪಾವ್ನ್ ಪಿಟಿ ಯನ್ನು ಬಳಸುತ್ತದೆ, ಬಳಕೆದಾರರ tty ಯ ರೀತಿಯಲ್ಲಿ ಅದೇ ರೀತಿ ಆರಂಭಿಸಲಾಗಿದೆ. ಎಲ್ಲಾ ಸೆಟ್ಟಿಂಗ್ಗಳು "ಸ್ಯಾನ್" (ಸ್ಟ್ಯಾಟಿ (1) ಪ್ರಕಾರ) ಇದರಿಂದ ಮತ್ತಷ್ಟು ಆರಂಭಗೊಳ್ಳುತ್ತದೆ. ವೇರಿಯೇಬಲ್ stty_init ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ಇದು ಮುಂದಿನ ಸಂರಚನೆಯಂತೆ ಸ್ಟಿಟಿ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳ ಶೈಲಿಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲ್ಪಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, "ಸೆಟ್ stty_init ಕಚ್ಚಾ" ಮತ್ತಷ್ಟು ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗಳ ಟರ್ಮಿನಲ್ಗಳನ್ನು ಕಚ್ಚಾ ಮೋಡ್ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ಬಳಕೆದಾರರ tty ಆಧಾರದ ಮೇಲೆ ಆರಂಭಗೊಳ್ಳುವ- ನಾಟ್ಟಿಕಾಪಿಯನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. -ಆಯ್ಕೆ ಮಾಡಬೇಡಿ " ಸಾನ್ " ಆರಂಭವನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ಸ್ಪಾವ್ನ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಸ್ಪಾವ್ನ್ ಗಮನಾರ್ಹ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಂಡಿದೆ ಎಂದು ನೀವು ಗಮನಿಸಿದರೆ, ಅದು ಪ್ರಾಯಶಃ ಮದುವೆಯಾಗುವ ಪಿಟಿಗಳನ್ನು ಎದುರಿಸುತ್ತಿದೆ. ದೋಷಯುಕ್ತ ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ ತೊಡಕುಗಳನ್ನು ತಪ್ಪಿಸಲು ಹಲವು ಪರೀಕ್ಷೆಗಳು ಪಿಟಿಐಗಳಲ್ಲಿ ನಡೆಯುತ್ತವೆ. (ಈ ವಿವಾರ್ಡ್ ಪಿಟಿ ಪ್ರತಿ 10 ಸೆಕೆಂಡುಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.) ಎಕ್ಸ್ಪೆಕ್ಟ್ ಬೆಸ ರಾಜ್ಯಗಳಲ್ಲಿ ಅನೇಕ ptys ಎದುರಿಸುತ್ತಿದೆ ವೇಳೆ -d ಆಯ್ಕೆಯನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು ರನ್ನಿಂಗ್. ಈ ptys ಅನ್ನು ಜೋಡಿಸಲಾಗಿರುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ನೀವು ಕೊಲ್ಲಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ನಿಮ್ಮ ಏಕೈಕ ಅವಲಂಬನೆಯು ರೀಬೂಟ್ ಆಗಿರಬಹುದು.

ಎಕ್ಸೆಕ್ (2) ವಿಫಲವಾದಲ್ಲಿ ( ಪ್ರೋಗ್ರಾಂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ) ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ನೀಡಲಾಗದಿದ್ದರೆ, ಮುಂದಿನ ಸಂವಹನದ ಮೂಲಕ ಒಂದು ದೋಷ ಸಂದೇಶವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ಅಥವಾ ಪ್ರೋಗ್ರಾಂ ರನ್ ಆಗುತ್ತಿದ್ದರೆ ಮತ್ತು ದೋಷ ಸಂದೇಶವನ್ನು ಔಟ್ಪುಟ್ ಎಂದು ಉತ್ಪಾದಿಸುವಂತೆ ಆಜ್ಞೆಯನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು . ಈ ನಡವಳಿಕೆ ಸ್ಪಾನ್ ಅನುಷ್ಠಾನದ ನೈಸರ್ಗಿಕ ಪರಿಣಾಮವಾಗಿದೆ. ಆಂತರಿಕವಾಗಿ, ಸ್ಪಾರ್ನ್ ಫೋರ್ಕ್ಗಳು, ನಂತರ ಸ್ಪಾನೀಡ್ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ಸಂವಹನದಿಂದ ಹೊರತುಪಡಿಸಿ ಮೂಲ ಎಕ್ಸ್ಪೆಕ್ಟ್ ಪ್ರಕ್ರಿಯೆಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಪ್ರಕ್ರಿಯೆಯು ಯಾವುದೇ ಮಾರ್ಗವಿಲ್ಲ.

-ಓಪನ್ ಫ್ಲ್ಯಾಗ್ ಮುಂದಿನ ವಾದವನ್ನು ಟಿಎಲ್ಎಲ್ ಫೈಲ್ ಐಡೆಂಟಿಫೈಯರ್ ಎಂದು ಅರ್ಥೈಸಿಕೊಳ್ಳುವಂತೆ ಮಾಡುತ್ತದೆ (ಅಂದರೆ, ತೆರೆದ ಮೂಲಕ ಹಿಂದಿರುಗಿತು.) ಸ್ಪಾನ್ ಐಡಿ ಅನ್ನು ನಂತರದ ಪ್ರಕ್ರಿಯೆಯಾಗಿ ಬಳಸಬಹುದು . (ಫೈಲ್ ಐಡೆಂಟಿಫಯರ್ ಅನ್ನು ಇನ್ನು ಮುಂದೆ ಬಳಸಬಾರದು.) ಇದರಿಂದಾಗಿ ಕಚ್ಚಾ ಸಾಧನಗಳು, ಫೈಲ್ಗಳು ಮತ್ತು ಪೈಪ್ಲೈನ್ಗಳನ್ನು ಪಿಟಿಐ ಬಳಸದೆಯೇ ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗಳೆಂದು ಪರಿಗಣಿಸಬಹುದು. ಯಾವುದೇ ಸಂಬಂಧಿತ ಪ್ರಕ್ರಿಯೆ ಇಲ್ಲ ಎಂದು ಸೂಚಿಸಲು 0 ಮರಳಿದೆ. ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗೆ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚಿದಾಗ, ಅದು Tcl ಫೈಲ್ ಐಡೆಂಟಿಫೈಯರ್ ಆಗಿದೆ. -ಲಿವಿಯೋಪೆನ್ ಧ್ವಜವನ್ನು ಹೊರತುಪಡಿಸಿ -ಉದಾಹರಣೆಗೆ -ಉದಾಹರಣೆಗೆ ಸ್ಪಾನ್ ಐಡಿ ಅನ್ನು ಮುಚ್ಚಿದ ನಂತರ ಫೈಲ್ ಐಡೆಂಟಿಫಯರ್ ಅನ್ನು ತೆರೆಯಲು ಕಾರಣವಾಗುತ್ತದೆ.

-TY ಫ್ಲ್ಯಾಗ್ ಒಂದು ಪಿಟಿ ತೆರೆಯಲು ಕಾರಣವಾಗುತ್ತದೆ ಆದರೆ ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಯು ಹುಟ್ಟಿಕೊಂಡಿಲ್ಲ. ಯಾವುದೇ ಸಂಬಂಧಿತ ಪ್ರಕ್ರಿಯೆ ಇಲ್ಲ ಎಂದು ಸೂಚಿಸಲು 0 ಮರಳಿದೆ. Spawn_id ಎಂದಿನಂತೆ ಹೊಂದಿಸಲಾಗಿದೆ.

ವೇರಿಯೇಬಲ್ ಸ್ಪಾನ್_ಔಟ್ (ಗುಲಾಮ, ಎಫ್ಡಿ) ಪಿಟಿ ಗುಲಾಮಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಫೈಲ್ ಐಡೆಂಟಿಫೈಯರ್ಗೆ ಹೊಂದಿಸಲಾಗಿದೆ. ಇದನ್ನು "ಕ್ಲೋಸ್-ಸ್ಲೇವ್" ಬಳಸಿ ಮುಚ್ಚಬಹುದು.

-ಗ್ನೂರ್ ಧ್ವಜವು ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಿರ್ಲಕ್ಷಿಸಲ್ಪಡುವ ಸಂಕೇತವನ್ನು ಹೆಸರಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಸಂಕೇತಗಳಿಗೆ ಡೀಫಾಲ್ಟ್ ನಡವಳಿಕೆ ಸಿಗುತ್ತದೆ. ಪ್ರತಿ ಸಿಗ್ನಲ್ಗೆ ಪ್ರತ್ಯೇಕ ಧ್ವಜ ಬೇಕಾಗುತ್ತದೆ ಹೊರತುಪಡಿಸಿ ಸಿಗ್ನಲ್ಗಳನ್ನು ಟ್ರ್ಯಾಪ್ ಕಮ್ಯಾಂಡ್ನಲ್ಲಿ ಹೆಸರಿಸಲಾಗಿದೆ.

ಸ್ಟ್ರೇಸ್ ಮಟ್ಟ
ಮರಣದಂಡನೆಗೆ ಮುಂಚಿತವಾಗಿ ಮುದ್ರಿಸಬೇಕಾದ ಹೇಳಿಕೆಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ. (ಟಿಎಲ್ಎಲ್ನ ಜಾಡಿನ ಆಜ್ಞೆಯನ್ನು ವೇರಿಯಬಲ್ಗಳು ತೋರಿಸುತ್ತದೆ.) ಮಟ್ಟವು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಕರೆಯ ಸ್ಟಾಕ್ನಲ್ಲಿ ಎಷ್ಟು ದೂರದಲ್ಲಿದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯು ಮೊದಲ 4 ಹಂತಗಳ ಕರೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವಾಗ ನಿರೀಕ್ಷಿಸುತ್ತದೆ , ಆದರೆ ಅದರ ಕೆಳಗೆ ಯಾವುದೂ ಇಲ್ಲ.

-c "ಸ್ಟ್ರೇಸ್ 4" script.exp ನಿರೀಕ್ಷೆ

-ಇನ್ಫೋ ಫ್ಲ್ಯಾಗ್ ಸ್ಟ್ರೇಸ್ಗೆ ನೀಡಿದ ಇತ್ತೀಚಿನ ಮಾಹಿತಿಯಲ್ಲದ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳ ವಿವರಣೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಸ್ಟ್ಯಾಟಿ ವಾದಿಸುತ್ತಾರೆ
ಬಾಹ್ಯ ಸ್ಥಾಯಿ ಆಜ್ಞೆಯಂತೆ ಟರ್ಮಿನಲ್ ವಿಧಾನಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನಿಯಂತ್ರಣ ಟರ್ಮಿನಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲಾಗಿದೆ. ಇತರ ಟರ್ಮಿನಲ್ಗಳನ್ನು "ಆಜ್ಞೆಯ ಫಲಿತಾಂಶವಾಗಿ ಸ್ಥಿತಿಯನ್ನು ಹಿಂದಿರುಗಿಸುವ ವಿನಂತಿಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದು.ಯಾವುದೇ ಸ್ಥಿತಿಯನ್ನು ವಿನಂತಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ನಿಯಂತ್ರಿಸುವ ಟರ್ಮಿನಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಿದರೆ, ಕಚ್ಚಾ ಮತ್ತು ಪ್ರತಿಧ್ವನಿ ಲಕ್ಷಣಗಳ ಹಿಂದಿನ ಸ್ಥಿತಿಯನ್ನು ನಂತರದ ರೂಪದಲ್ಲಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ಆಜ್ಞೆಯಿಂದ ಬಳಸಲ್ಪಡುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಆರ್ಗ್ಯುಮೆಂಟುಗಳು ಕಚ್ಚಾ ಅಥವಾ -ಕಕ್ಡ್ ಟರ್ಮಿನಲ್ ಅನ್ನು ಕಚ್ಚಾ ಮೋಡ್ಗೆ ಇರಿಸಿ. -ರಚಿಸಿ ಅಥವಾ ಬೇಯಿಸಿದ ಆರ್ಗ್ಯುಮೆಂಟುಗಳು ಟರ್ಮಿನಲ್ ಅನ್ನು ಬೇಯಿಸಿದ ಮೋಡ್ ಆಗಿ ಇರಿಸಿ. ವಾದಗಳು ಪ್ರತಿಧ್ವನಿ ಮತ್ತು -ಚಾಕೊ ಕ್ರಮವಾಗಿ ಪ್ರತಿಧ್ವನಿ ಮತ್ತು ನೊಚಿಯೋ ಮೋಡ್ಗೆ ಟರ್ಮಿನಲ್ ಅನ್ನು ಹಾಕುತ್ತವೆ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ತಾತ್ಕಾಲಿಕವಾಗಿ ಪ್ರತಿಧ್ವನಿ ಮಾಡುವುದನ್ನು ಹೇಗೆ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಎಂಬೆಡಿಂಗ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಲು ಇದನ್ನು ಇಲ್ಲದಿದ್ದರೆ ಸ್ವಯಂಚಾಲಿತ ಲಿಪಿಯಲ್ಲಿ ಬಳಸಬಹುದು. (ಈ ಕೆಳಗಿನ ಹೆಚ್ಚಿನ ಚರ್ಚೆಗಳನ್ನು ಕೆಳಗೆ ನಿರೀಕ್ಷಿಸಿದಂತೆ ನೋಡಿ.)

stty -echo send_user "ಪಾಸ್ವರ್ಡ್:" expect_user -re "(. *) \ n" $ ನಿರೀಕ್ಷಿತ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಹೊಂದಿಸಿ (1, ಸ್ಟ್ರಿಂಗ್) ಸ್ಟ್ಯಾಟಿ ಪ್ರತಿಧ್ವನಿ

ವ್ಯವಸ್ಥೆಯು ವಾದಿಸುತ್ತದೆ
ಟರ್ಮಿನಲ್ನಿಂದ ಆದೇಶದಂತೆ ಟೈಪ್ ಮಾಡಿದಂತೆಯೇ sh (1) ಗೆ ಇನ್ಪುಟ್ ಆಗಿ args ನೀಡುತ್ತದೆ. ಶೆಲ್ ಕೊನೆಗೊಳ್ಳುವವರೆಗೆ ಕಾಯುವಿಕೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸಿ . Sh ನಿಂದ ಹಿಂದಿರುಗಿದ ಸ್ಥಾನವು exec ತನ್ನ ಹಿಂತಿರುಗಿದ ಸ್ಥಿತಿಯನ್ನು ನಿಭಾಯಿಸುವ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸುತ್ತದೆ.

ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಸ್ಕ್ಯಾಡ್ಔಟ್ ಅನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ಪುನರ್ನಿರ್ದೇಶಿಸುವ ಎಕ್ಸೆಕ್ಗೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ಸಿಸ್ಟಮ್ ಯಾವುದೇ ಪುನರ್ನಿರ್ದೇಶನವನ್ನು ನಿರ್ವಹಿಸುವುದಿಲ್ಲ (ಸ್ಟ್ರಿಂಗ್ ಸ್ವತಃ ಸೂಚಿಸುವ ಹೊರತುಪಡಿಸಿ). ಹೀಗಾಗಿ, ನೇರವಾಗಿ / dev / tty ಗೆ ಮಾತನಾಡಬೇಕಾದ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಿದೆ. ಅದೇ ಕಾರಣಕ್ಕಾಗಿ, ವ್ಯವಸ್ಥೆಯ ಫಲಿತಾಂಶಗಳು ಲಾಗ್ನಲ್ಲಿ ದಾಖಲಾಗಿಲ್ಲ.

ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ [args]
ಸಮಯಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಯಾವುದೇ ವಾದವಿಲ್ಲದೇ, ಯುಗವು ಹಿಂದಿರುಗಿದ ನಂತರ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆ.

-ಫಾರ್ಮ್ಯಾಟ್ ಧ್ವಜ ಸ್ಟ್ರಿಂಗ್ಟೈಮ್ಗಾಗಿನ POSIX ನಿಯಮಗಳ ಪ್ರಕಾರ ಮಾಡಲ್ಪಟ್ಟ ಪರ್ಯಾಯಗಳೊಂದಿಗೆ ಬದಲಾದ ವಾಕ್ಯವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗಾಗಿ% a ಅನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ವಾರದದಿನದ ಹೆಸರಿನಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ (ಅಂದರೆ, Sat). ಇತರರು:

% ಒಂದು ಸಂಕ್ಷಿಪ್ತ ವಾರದ ದಿನ ಹೆಸರು% ಒಂದು ಪೂರ್ಣ ವಾರದ ದಿನ% b ಸಂಕ್ಷಿಪ್ತ ತಿಂಗಳ ಹೆಸರು% B ಪೂರ್ಣ ತಿಂಗಳ ಹೆಸರು% c ನಲ್ಲಿ ದಿನಾಂಕದಂದು: Wed Oct 6 11:45:56 1993% ತಿಂಗಳಿನ ದಿನ (01-31% H ಗಂಟೆ (00-23)% ನಾನು ಗಂಟೆ (01-12)% j ದಿನ (001-366)% m ತಿಂಗಳು (01-12)% M ನಿಮಿಷ (00-59)% p am ಅಥವಾ pm% S ಸೆಕೆಂಡ್ (00-61) % u ದಿನ (1-7, ಸೋಮವಾರ ವಾರದ ಮೊದಲ ದಿನ)% U ವಾರ (00-53, ಮೊದಲ ಭಾನುವಾರ ವಾರದ ಮೊದಲ ದಿನ)% ವಾರದ ವಾರದ (01-53, ISO 8601 ಶೈಲಿ)% w ದಿನ (0- 6) ವಾರದ ವಾರದ (00-53, ಮೊದಲ ಸೋಮವಾರ ವಾರದ ಮೊದಲ ದಿನ)% x ದಿನಾಂಕದ ಸಮಯ: ಬುಧವಾರ 6 ಅಕ್ಟೋಬರ್ 1993 ರಲ್ಲಿ 23% 59,59% y (00-99) % Y ವರ್ಷದಲ್ಲಿ: 1993% Z ಸಮಯವಲಯ (ಅಥವಾ ನಿರ್ಣಯಿಸದಿದ್ದರೆ ಏನೂ) %% ಒಂದು ಶೇಕಡಾ ಚಿಹ್ನೆ

ಇತರೆ% ವಿಶೇಷಣಗಳು ಸ್ಪಷ್ಟೀಕರಿಸದವು. ಇತರ ಪಾತ್ರಗಳು ಒಳಪಡದ ಮೂಲಕ ಹಾದು ಹೋಗುತ್ತವೆ. ಕೇವಲ ಸಿ ಲೊಕೇಲ್ ಮಾತ್ರ ಬೆಂಬಲಿತವಾಗಿದೆ.

-ಸೆಕೆಂಡ್ಸ್ ಧ್ವಜವು ಹಲವಾರು ಸೆಕೆಂಡ್ಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ, ಇದು ಯುಗವನ್ನು ಯಾವ ರೂಪದಿಂದ ರೂಪಿಸಲು ಬಳಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

-gmt ಧ್ವಜವು ಟೈಮ್ಟಾಂಪ್ ಉತ್ಪಾದನೆಯನ್ನು GMT ಸಮಯವಲಯವನ್ನು ಬಳಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಯಾವುದೇ ಧ್ವಜವಿಲ್ಲದೇ, ಸ್ಥಳೀಯ ಸಮಯವಲಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಬಲೆ [[ಕಮಾಂಡ್] ಸಂಕೇತಗಳು]
ನೀಡಿರುವ ಆಜ್ಞೆಗಳನ್ನು ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಸಿಗ್ನಲ್ಗಳ ಭವಿಷ್ಯದ ರಶೀದಿಯ ಮೇಲೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ಆಜ್ಞೆಯನ್ನು ಜಾಗತಿಕ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಆಜ್ಞೆಯು ಇಲ್ಲದಿದ್ದರೆ, ಸಿಗ್ನಲ್ ಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಆಜ್ಞೆಯು SIG_IGN ಸ್ಟ್ರಿಂಗ್ ಆಗಿದ್ದರೆ, ಸಂಕೇತಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಆಜ್ಞೆಯು SIG_DFL ಸ್ಟ್ರಿಂಗ್ ಆಗಿದ್ದರೆ, ಸಿಗ್ನಲ್ಗಳು ಸಿಸ್ಟಮ್ ಡೀಫಾಲ್ಟ್ಗೆ ಕಾರಣವಾಗುತ್ತವೆ. ಸಂಕೇತಗಳು ಒಂದೇ ಸಿಗ್ನಲ್ ಅಥವಾ ಸಿಗ್ನಲ್ಗಳ ಪಟ್ಟಿ. ಸಿಗ್ನಲ್ಗಳ ಪ್ರಕಾರ ಸಂಕೇತಗಳನ್ನು ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಅಥವಾ ಸಾಂಕೇತಿಕವಾಗಿ ಸೂಚಿಸಬಹುದು (3). "SIG" ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು.

ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟುಗಳಿಲ್ಲ (ಅಥವಾ ಆರ್ಗ್ಯುಮೆಂಟ್ -ಸಂಖ್ಯೆ), ಬಲೆಗೆ ಪ್ರಸ್ತುತ ಎಕ್ಸಿಕ್ಯೂಟ್ ಮಾಡಲಾದ ಟ್ರ್ಯಾಪ್ ಆಜ್ಞೆಯ ಸಂಕೇತ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

-ಕೋಡ್ ಧ್ವಜ ಆಜ್ಞೆಯ ರಿಟರ್ನ್ ಕೋಡ್ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಆಜ್ಞೆಯು ಮೂಲಭೂತವಾಗಿ ಚಾಲನೆಯನ್ನು ಆರಂಭಿಸಿದಾಗ TC ಹಿಂದಿರುಗಬೇಕಿತ್ತು.

-interp ಫ್ಲ್ಯಾಗ್ ಆಜ್ಞೆಯನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಆಜ್ಞೆಯನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಾರಂಭದ ಸಮಯದಲ್ಲಿ ಸಕ್ರಿಯವಾಗಿ ವಿವರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಕಾರಣವಾಗುತ್ತದೆ.

-ಹೆಸರು ಧ್ವಜ ಟ್ರಾಪ್ ಆಜ್ಞೆಯನ್ನು ಪ್ರಸ್ತುತ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿರುವ ಟ್ರ್ಯಾಪ್ ಆಜ್ಞೆಯ ಸಿಗ್ನಲ್ ಹೆಸರನ್ನು ಹಿಂದಿರುಗಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ.

-ಮ್ಯಾಕ್ಸ್ ಧ್ವಜವು ಟ್ರ್ಯಾಪ್ ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿಸಬಹುದಾದ ದೊಡ್ಡ ಸಿಗ್ನಲ್ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, "ಟ್ರ್ಯಾಪ್ {send_user" ಔಚ್! "} SIGINT" ಆದೇಶವು "ಔಚ್!" ಪ್ರತಿ ಬಾರಿ ಬಳಕೆದಾರ ಪ್ರೆಸ್ ^ ಸಿ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, SIGINT (ಸಾಮಾನ್ಯವಾಗಿ ಸಿ ಅನ್ನು ಒತ್ತುವ ಮೂಲಕ ಉತ್ಪಾದಿಸಬಹುದು) ಮತ್ತು SIGTERM ಕಾರಣ ಎಕ್ಸ್ಪೆಕ್ಟ್ ಟು ಎಕ್ಸಿಟ್. ಎಕ್ಸ್ಪೆಕ್ಟ್ ಆರಂಭಗೊಂಡಾಗ ಡೀಫಾಲ್ಟ್ ಆಗಿ ರಚಿಸಲಾದ ಕೆಳಗಿನ ಬಲೆಗೆ ಇದು ಕಾರಣವಾಗಿದೆ.

ಟ್ರ್ಯಾಪ್ ನಿರ್ಗಮನ {SIGINT SIGTERM}

ದೋಷಸೂಚಕವನ್ನು ಪ್ರಾರಂಭಿಸಲು -D ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ನೀವು ಬಳಸಿದರೆ, ಸಂವಾದಾತ್ಮಕ ದೋಷಸೂಚಕವನ್ನು ಆರಂಭಿಸಲು SIGINT ಅನ್ನು ಮರು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಇದು ಕೆಳಗಿನ ಬಲೆಗೆ ಕಾರಣವಾಗಿದೆ:

ಬಲೆಗೆ {exp_debug 1} SIGINT

ಪರಿಸರ ವೇರಿಯಬಲ್ EXPECT_DEBUG_INIT ಅನ್ನು ಹೊಸ ಟ್ರ್ಯಾಪ್ ಆಜ್ಞೆಗೆ ಹೊಂದಿಸಿ ಡೀಬಗರ್ ಟ್ರ್ಯಾಪ್ ಅನ್ನು ಬದಲಾಯಿಸಬಹುದು.

ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ಬಲೆ ಆದೇಶಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ನೀವು ಈ ಎರಡನ್ನೂ ಅತಿಕ್ರಮಿಸಬಹುದು. ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಿಮ್ಮ ಸ್ವಂತ "ಬಲೆಗೆ ನಿರ್ಗಮಿಸುವ SIGINT" ಇದ್ದರೆ, ಇದು ಡೀಬಗರ್ ಟ್ರ್ಯಾಪ್ ಅನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ. ಬಳಕೆದಾರರು ಡೀಬಗರ್ಗೆ ಹೋಗುವುದನ್ನು ತಡೆಗಟ್ಟಲು ನೀವು ಬಯಸಿದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ನೀವು SIGINT ನಲ್ಲಿ ನಿಮ್ಮ ಸ್ವಂತ ಬಲೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಬಯಸಿದರೆ ಆದರೆ ಡೀಬಗರ್ಗೆ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಅದನ್ನು ಬಲೆಗೆ ಇರಿಸಿ, ಬಳಸಿ:

{! [exp_debug]} {trap mystuff SIGINT}

ಪರ್ಯಾಯವಾಗಿ, ನೀವು ಇತರ ಸಿಗ್ನಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಡೀಬಗರ್ಗೆ ಬಲೆ ಮಾಡಬಹುದು.

ನಿರೀಕ್ಷಿಸಿ ಆಂತರಿಕವಾಗಿ ಬಳಸಲ್ಪಟ್ಟಿರುವುದರಿಂದ SIGALRM ಗೆ ಕ್ರಮವನ್ನು ಅತಿಕ್ರಮಿಸಲು ಬಲೆಗೆ ಅವಕಾಶ ನೀಡುವುದಿಲ್ಲ. ಸಂಪರ್ಕ ಕಡಿತ ಆಜ್ಞೆಯು SIG_IGN ಗೆ SIGALRM ಅನ್ನು (ನಿರ್ಲಕ್ಷಿಸಿ) ಹೊಂದಿಸುತ್ತದೆ. ನಂತರದ ಸ್ಪಾವ್ನ್ ಆಜ್ಞೆಗಳಲ್ಲಿ ನೀವು ಅದನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿದಲ್ಲಿ ನೀವು ಇದನ್ನು ಮರುಹೊಂದಿಸಬಹುದು.

ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ಸಿಗ್ನಲ್ (3) ನೋಡಿ.

ನಿರೀಕ್ಷಿಸಿ [args]
ವಿಕಸನ ಪ್ರಕ್ರಿಯೆ (ಅಥವಾ ಯಾವುದೇ ಹೆಸರಿಲ್ಲದಿದ್ದರೆ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆ ) ತನಕ ವಿಳಂಬವಾಗುತ್ತದೆ.

ನಿರೀಕ್ಷಿಸಿ ಸಾಮಾನ್ಯವಾಗಿ ನಾಲ್ಕು ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಮೊದಲ ಪೂರ್ಣಾಂಕವು ಕಾಯುವ ಪ್ರಕ್ರಿಯೆಯ ಪಿಡ್ ಆಗಿದೆ. ಎರಡನೇ ಪೂರ್ಣಾಂಕವು ಅನುಗುಣವಾದ ಸ್ಪಾನ್ ಐಡಿ ಆಗಿದೆ. ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ ಮೂರನೇ ಪೂರ್ಣಾಂಕ -1 -1 ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ. ಮೂರನೇ ಪೂರ್ಣಾಂಕವು 0 ಆಗಿದ್ದರೆ, ನಾಲ್ಕನೇ ಪೂರ್ಣಾಂಕವು ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಹಿಂದಿರುಗಿದ ಸ್ಥಿತಿಯಾಗಿದೆ. ಮೂರನೆಯ ಪೂರ್ಣಾಂಕವು -1 ಆಗಿದ್ದರೆ, ನಾಲ್ಕನೇ ಪೂರ್ಣಾಂಕವು ಕಾರ್ಯವ್ಯವಸ್ಥೆಯಿಂದ ತಪ್ಪಾಗಿ ಹೊಂದಿಸಲ್ಪಟ್ಟ ಮೌಲ್ಯವಾಗಿದೆ. ಜಾಗತಿಕ ವೇರಿಯೇಬಲ್ errorCode ಸಹ ಹೊಂದಿಸಲಾಗಿದೆ.

ಕಾಯುವಿಕೆಯಿಂದ ಹಿಂತಿರುಗಿದ ಮೌಲ್ಯದ ಕೊನೆಯಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಅಂಶಗಳು ಗೋಚರಿಸಬಹುದು. ಐಚ್ಛಿಕ ಐದನೇ ಅಂಶವು ಮಾಹಿತಿಯ ವರ್ಗವನ್ನು ಗುರುತಿಸುತ್ತದೆ. ಪ್ರಸ್ತುತ, ಈ ಅಂಶಕ್ಕೆ ಮಾತ್ರ ಸಂಭವನೀಯ ಮೌಲ್ಯವು ಶಿಲ್ಕಿಲ್ಡ್ ಆಗಿದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮುಂದಿನ ಎರಡು ಮೌಲ್ಯಗಳು C- ಶೈಲಿಯ ಸಿಗ್ನಲ್ ಹೆಸರು ಮತ್ತು ಸಣ್ಣ ಪಠ್ಯ ವಿವರಣೆಯಾಗಿದೆ.

ಹೆಸರಿನ spawn_id ಗೆ ಅನುಗುಣವಾಗಿ ಕಾಯುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು -i ಫ್ಲ್ಯಾಗ್ ಘೋಷಿಸುತ್ತದೆ ( ಪ್ರಕ್ರಿಯೆ ಐಡಿ ಅಲ್ಲ). SIGCHLD ಹ್ಯಾಂಡ್ಲರ್ನೊಳಗೆ, ಸ್ಪಾನ್ ಐಡಿ -1 ಅನ್ನು ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ದಾರಿಹೋದ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಕಾಯುವ ಸಾಧ್ಯತೆಯಿದೆ.

-ಉತ್ತರ ಧ್ವಜವು ಕಾಯುವ ನಿರೀಕ್ಷೆಯ ಸೂಚನೆಯೊಂದಿಗೆ ತಕ್ಷಣವೇ ಹಿಂದಿರುಗುವ ನಿರೀಕ್ಷೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆಯು ನಿರ್ಗಮಿಸಿದಾಗ (ನಂತರ), ಇದು ಸ್ಪಷ್ಟ ಕಾಯುವಿಕೆ ಅಗತ್ಯವಿಲ್ಲದೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಣ್ಮರೆಯಾಗುತ್ತದೆ.

ನಿರೀಕ್ಷಣಾ ಆಜ್ಞೆಯನ್ನು "-i -1" ವಾದಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಫೋರ್ಕ್ಡ್ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ನಿರೀಕ್ಷಿಸಬಹುದು. ಮೊಟ್ಟೆಯಿಟ್ಟ ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಅದರ ಬಳಕೆಗೆ ಭಿನ್ನವಾಗಿ, ಈ ಆಜ್ಞೆಯನ್ನು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಯಾವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ ಎಂಬುದರ ಮೇಲೆ ಯಾವುದೇ ನಿಯಂತ್ರಣವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಪ್ರಕ್ರಿಯೆ ಐಡಿಗಾಗಿ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಬಹುದು.

ಗ್ರಂಥಾಲಯಗಳು

ಸ್ಕ್ರಿಪ್ಟುಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎರಡು ಅಂತರ್ನಿರ್ಮಿತ ಗ್ರಂಥಾಲಯಗಳನ್ನು ತಿಳಿದಿದೆ. ಇವುಗಳನ್ನು ಅಸ್ಥಿರ exp_library ಮತ್ತು exp_exec_library ನಲ್ಲಿ ಹೆಸರಿಸಿದ ಕೋಶಗಳಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಎರಡೂ ಇತರ ಲಿಪಿಗಳು ಬಳಸಬಹುದಾದ ಉಪಯುಕ್ತ ಫೈಲ್ಗಳನ್ನು ಹೊಂದಲು ಉದ್ದೇಶಿಸಲಾಗಿದೆ.

exp_library ವಾಸ್ತುಶಿಲ್ಪ-ಸ್ವತಂತ್ರ ಕಡತಗಳನ್ನು ಹೊಂದಿದೆ. exp_exec_library ಆರ್ಕಿಟೆಕ್ಚರ್-ಅವಲಂಬಿತ ಕಡತಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯನ್ನು ಅವಲಂಬಿಸಿ, ಎರಡೂ ಕೋಶಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಖಾಲಿಯಾಗಿರಬಹುದು. $ Exp_exec_library / cat-buffers ಎಂಬ ಕಡತದ ಅಸ್ತಿತ್ವವು ನಿಮ್ಮ / bin / cat ಬಫರ್ ಅನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ವಿವರಿಸುತ್ತದೆ.

ಮುದ್ರಿತ ಮುದ್ರಣ

ಸ್ಕ್ರಿಪ್ಟುಗಳನ್ನು ನಿರೀಕ್ಷಿಸಿ ಬಹಳ-ಮುದ್ರಣಕ್ಕಾಗಿ vgrind ವ್ಯಾಖ್ಯಾನ ಲಭ್ಯವಿದೆ. ನಿರೀಕ್ಷೆ ವಿತರಣೆ ಸರಿಯಾಗಿ ಸ್ಥಾಪಿಸಲ್ಪಟ್ಟಿರುವ vgrind ವ್ಯಾಖ್ಯಾನವನ್ನು ಊಹಿಸಿ, ನೀವು ಅದನ್ನು ಹೀಗೆ ಬಳಸಬಹುದು:

vgrind- ಆಕಾರ ಫೈಲ್

ಉದಾಹರಣೆಗಳು

ಮನುಷ್ಯ ಪುಟವು ವಿವರಿಸುವ ಎಲ್ಲವನ್ನೂ ಹೇಗೆ ಒಟ್ಟಿಗೆ ಸೇರಿಸುವುದು ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿಲ್ಲ. ವಿತರಣೆ ನಿರೀಕ್ಷೆಯ ಉದಾಹರಣೆ ಕೋಶದಲ್ಲಿ ಉದಾಹರಣೆಗಳು ಓದಲು ಮತ್ತು ಪ್ರಯತ್ನಿಸಲು ನಾನು ನಿಮ್ಮನ್ನು ಪ್ರೋತ್ಸಾಹಿಸುತ್ತೇವೆ. ಅವುಗಳಲ್ಲಿ ಕೆಲವು ನೈಜ ಕಾರ್ಯಕ್ರಮಗಳಾಗಿವೆ. ಕೆಲವರು ಕೆಲವು ತಂತ್ರಗಳನ್ನು ಸರಳವಾಗಿ ವಿವರಿಸುತ್ತಾರೆ, ಮತ್ತು ಸಹಜವಾಗಿ, ಒಂದೆರಡು ಕೇವಲ ತ್ವರಿತ ಭಿನ್ನತೆಗಳು. INSTALL ಫೈಲ್ ಈ ಕಾರ್ಯಕ್ರಮಗಳ ತ್ವರಿತ ಅವಲೋಕನವನ್ನು ಹೊಂದಿದೆ.

ಎಕ್ಸ್ಪೆಕ್ಟ್ ಪೇಪರ್ಸ್ (ನೋಡಿ ಇನ್ನು ನೋಡಿ) ಸಹ ಉಪಯುಕ್ತವಾಗಿದೆ. ಕೆಲವು ಪೇಪರ್ಸ್ ಎಕ್ಸ್ಪೆಕ್ಟ್ನ ಹಿಂದಿನ ಆವೃತ್ತಿಗಳಿಗೆ ಅನುಗುಣವಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತಿರುವಾಗ, ಅದರ ಜೊತೆಗಿನ ತರ್ಕಬದ್ಧತೆಗಳು ಇನ್ನೂ ಮಾನ್ಯವಾಗಿರುತ್ತವೆ ಮತ್ತು ಈ ಮ್ಯಾನ್ ಪುಟಕ್ಕಿಂತ ಹೆಚ್ಚು ವಿವರವಾಗಿ ಹೋಗುತ್ತವೆ.

ಕ್ಯಾವೆಟ್ಗಳು

ನಿರೀಕ್ಷೆಯ ಆಜ್ಞೆಯ ಹೆಸರುಗಳೊಂದಿಗೆ ವಿಸ್ತರಣೆಗಳು ಘರ್ಷಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಸಂಪೂರ್ಣ ವಿಭಿನ್ನ ಉದ್ದೇಶಕ್ಕಾಗಿ ಕಳುಹಿಸುವಿಕೆಯನ್ನು Tk ನಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಈ ಕಾರಣಕ್ಕಾಗಿ, ಹೆಚ್ಚಿನ ಎಕ್ಸ್ಪೆಕ್ಟ್ ಆಜ್ಞೆಗಳು "exp_XXXX" ಎಂದು ಸಹ ಲಭ್ಯವಿವೆ. "Exp", "inter", "spawn", ಮತ್ತು "timeout" ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಆಜ್ಞೆಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳು ಅಲಿಯಾಸ್ಗಳನ್ನು ಹೊಂದಿಲ್ಲ. ಪರಿಸರದ ನಡುವಿನ ಹೊಂದಾಣಿಕೆಗೆ ನೀವು ಬಯಸಿದಲ್ಲಿ ವಿಸ್ತರಿತ ಕಮಾಂಡ್ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ.

ಸ್ಕೋಪಿಂಗ್ನ ಬದಲಿಗೆ ಲಿಬರಲ್ ದೃಷ್ಟಿಕೋನವನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು . ನಿರ್ದಿಷ್ಟವಾಗಿ, ಎಕ್ಸ್ಪೆಕ್ಟ್ ಪ್ರೋಗ್ರಾಂಗೆ ನಿರ್ದಿಷ್ಟವಾದ ಆಜ್ಞೆಗಳಿಂದ ಓದಲಾಗುವ ಅಸ್ಥಿರಗಳನ್ನು ಸ್ಥಳೀಯ ವ್ಯಾಪ್ತಿಯಿಂದ ಮೊದಲಿಗೆ ಹುಡುಕಲಾಗುತ್ತದೆ ಮತ್ತು ಜಾಗತಿಕ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಕಂಡುಬಂದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಇದು ನಿರೀಕ್ಷಿಸುವಂತೆ ನೀವು ಬರೆಯುವ ಪ್ರತಿಯೊಂದು ಕಾರ್ಯವಿಧಾನದಲ್ಲಿ "ಜಾಗತಿಕ ಕಾಲಾವಧಿ" ಯನ್ನು ಇರಿಸುವ ಅಗತ್ಯವನ್ನು ಅನ್ಯಾಯಿಸುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, ಬರೆದಿರುವ ಅಸ್ಥಿರಗಳು ಯಾವಾಗಲೂ ಸ್ಥಳೀಯ ವ್ಯಾಪ್ತಿಯಲ್ಲಿರುತ್ತವೆ ("ಜಾಗತಿಕ" ಆಜ್ಞೆಯನ್ನು ನೀಡಲಾಗದ ಹೊರತು). ಸ್ಪಾನ್ ಅನ್ನು ಕಾರ್ಯವಿಧಾನದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ ಈ ಕಾರಣಗಳು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಸಮಸ್ಯೆಯಾಗಿದೆ. ಕಾರ್ಯವಿಧಾನದ ಹೊರಗೆ, spawn_id ಇನ್ನು ಮುಂದೆ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ, ಆದ್ದರಿಂದ ವಿಕಾಸದ ಪ್ರಕ್ರಿಯೆಯು ಇನ್ನು ಮುಂದೆ ಸ್ಕೋಪಿಂಗ್ ಮಾಡುವುದರಿಂದ ಪ್ರವೇಶಿಸುವುದಿಲ್ಲ. ಅಂತಹ ಕಾರ್ಯವಿಧಾನಕ್ಕೆ "ಜಾಗತಿಕ spawn_id" ಅನ್ನು ಸೇರಿಸಿ.

ನೀವು ಮಲ್ಟಿಸ್ಪಾನನಿಂಗ್ ಸಾಮರ್ಥ್ಯವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸದಿದ್ದರೆ (ಅಂದರೆ, ನಿಮ್ಮ ಸಿಸ್ಟಮ್ ಆಯ್ಕೆ ಮಾಡದಿದ್ದರೆ (ಬಿಎಸ್ಡಿ *. *), ಪೋಲ್ (ಎಸ್ವಿಆರ್ಆರ್ 2), ಅಥವಾ ಸಮಾನವಾದವು), ಒಂದೇ ಸಮಯದಲ್ಲಿ ಒಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು ಮಾತ್ರ ನಿರೀಕ್ಷಿಸಬಹುದು . ಈ ಸಂದರ್ಭದಲ್ಲಿ, spawn_id ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸಬೇಡ , ಅಥವಾ ಒಂದು ಪ್ರಕ್ರಿಯೆ ನಡೆಯುತ್ತಿರುವಾಗ ನೀವು ಎಕ್ಸೆಕ್ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಾರದು. ಇದಲ್ಲದೆ, ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ಪ್ರಕ್ರಿಯೆಗಳಿಂದ (ಬಳಕೆದಾರರಂತೆ ಸೇರಿದಂತೆ) ನೀವು ನಿರೀಕ್ಷಿಸಬಹುದು .

ಟರ್ಮಿನಲ್ ಪ್ಯಾರಾಮೀಟರ್ಗಳು ಸ್ಕ್ರಿಪ್ಟ್ಗಳಲ್ಲಿ ದೊಡ್ಡ ಪರಿಣಾಮವನ್ನು ಬೀರಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರತಿಧ್ವನಿಸುವಿಕೆಯನ್ನು ನೋಡಲು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಲಾಗಿದ್ದರೆ, ಪ್ರತಿಧ್ವನಿ ಆಫ್ ಮಾಡಿದ್ದರೆ ಅದು ತಪ್ಪಾಗಿ ವರ್ತಿಸುತ್ತದೆ. ಈ ಕಾರಣಕ್ಕಾಗಿ, ಪಡೆಗಳು ಸ್ಯಾನ್ ಟರ್ಮಿನಲ್ ನಿಯತಾಂಕಗಳನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ನಿರೀಕ್ಷಿಸಿ. ದುರದೃಷ್ಟವಶಾತ್, ಇದು ಇತರ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ವಿಷಯಗಳನ್ನು ಅಹಿತಕರವಾಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಎಮಾಕ್ಸ್ ಶೆಲ್ "ಸಾಮಾನ್ಯ" ಮ್ಯಾಪಿಂಗ್ಗಳನ್ನು ಬದಲಿಸಲು ಬಯಸುತ್ತದೆ: ಹೊಸ ಲೈನ್ಗಳು ಕ್ಯಾರೇಜ್-ರಿಟರ್ನ್ ನ್ಯೂಲೈನ್ಗಳಿಗೆ ಬದಲಾಗಿ ಹೊಸ ಲೈನ್ಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತವೆ ಮತ್ತು ಪ್ರತಿಧ್ವನಿ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ. ಇದು ಇನ್ಪುಟ್ ಲೈನ್ ಅನ್ನು ಸಂಪಾದಿಸಲು ಎಮ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ. ದುರದೃಷ್ಟವಶಾತ್, ನಿರೀಕ್ಷೆ ಬಹುಶಃ ಊಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಟರ್ಮಿನಲ್ ಪ್ಯಾರಾಮೀಟರ್ಗಳ ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಅತಿಕ್ರಮಿಸಬಾರದು ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು, ಆದರೆ ಅಂತಹ ಪರಿಸರದಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಬರೆಯುವಾಗ ನೀವು ಬಹಳ ಎಚ್ಚರಿಕೆಯಿಂದ ಇರಬೇಕು. ಎಮ್ಯಾಕ್ಸ್ನ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರತಿಧ್ವನಿ ಮತ್ತು ಅಂತ್ಯ-ಸಾಲಿನ ಮ್ಯಾಪಿಂಗ್ಗಳಂತಹ ವಿಷಯಗಳನ್ನು ಅವಲಂಬಿಸಿ ತಪ್ಪಿಸಿ.

ಒಂದು ಪಟ್ಟಿಯನ್ನು ( ನಿರೀಕ್ಷಿತ ರೂಪಾಂತರಗಳು ಮತ್ತು ಸಂವಹನ ) ದಲ್ಲಿ ವಾದಗಳನ್ನು ಸ್ವೀಕರಿಸಿದ ಆಜ್ಞೆಗಳು ಪಟ್ಟಿಯು ವಾಸ್ತವವಾಗಿ ಒಂದು ವಾದವಾಗಿದೆಯೇ ಅಥವಾ ಅನೇಕವಾದುದನ್ನು ನಿರ್ಧರಿಸಲು ಹ್ಯೂರಿಸ್ಟಿಕ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಪಟ್ಟಿಯು ನಿಜವಾಗಿ ಒಂದು ವಾದವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಅದು ಆ ಸಂದರ್ಭದಲ್ಲಿ ಮಾತ್ರ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ, ಅದು ಬಹುಸಂಖ್ಯೆಯ ಎಂಬೆಡೆಡ್ ಅನ್ನು ಹೊಂದಿರುವ \ n ಅವರ ನಡುವಿನ ಬಿಳಿಯಲ್ಲದ ಪಾತ್ರಗಳೊಂದಿಗೆ. ಇದು ಸಾಕಷ್ಟು ಅಸಂಭವನೀಯವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ, ಆದರೆ ಏಕ ವಾದವನ್ನು ಒಂದೇ ವಾದದಂತೆ ನಿರ್ವಹಿಸಲು ಒತ್ತಾಯಿಸಲು "-ನೋಬ್ರೇಸ್" ವಾದವನ್ನು ಬಳಸಬಹುದು. ಯಂತ್ರ-ರಚಿತ ಎಕ್ಸ್ಪೆಕ್ಟ್ ಕೋಡ್ನೊಂದಿಗೆ ಇದನ್ನು ಕಲ್ಪಿಸಲಾಗದಂತೆ ಬಳಸಬಹುದಾಗಿತ್ತು. ಅಂತೆಯೇ, -ಒಂದು ವಾದವು ಅನೇಕ ವಾದಗಳನ್ನು / ಕ್ರಿಯೆಗಳಂತೆ ಒಂದು ವಾದವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

ಬಗ್ಗಳು

"ಸೆಕ್ಸ್" ("ಸ್ಮಾರ್ಟ್ ಎಕ್ಸ್ಕ್" ಅಥವಾ "ಸೆಂಡ್-ಎಕ್ಸ್ಪೆಕ್ಟ್" ಗಾಗಿ) ಎಂಬ ಕಾರ್ಯಕ್ರಮವನ್ನು ಹೆಸರಿಸಲು ಅದು ನಿಜಕ್ಕೂ ಆಕರ್ಷಕವಾಗಿತ್ತು, ಆದರೆ ಒಳ್ಳೆಯ ಅರ್ಥದಲ್ಲಿ (ಅಥವಾ ಬಹುಶಃ ಪ್ಯುರಿಟನಿಸಂ) ಮೇಲುಗೈ ಸಾಧಿಸಿತು.

ಕೆಲವು ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಒಂದು ಶೆಲ್ ಅನ್ನು ಉರುಳಿಸಿದಾಗ, ಅದು ಟಿಟಿ ಯನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗದೆ ಇರಬಹುದು ಆದರೆ ಹೇಗಾದರೂ ಸಾಗುತ್ತದೆ ಎಂದು ದೂರಿತು. ಇದರರ್ಥ ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯು ನಿಯಂತ್ರಣ ನಿರೀಕ್ಷೆಯಿಲ್ಲದಿರುವ ನಿಯಂತ್ರಣವನ್ನು ಪಡೆದುಕೊಳ್ಳುವ ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೊಂದಿದೆ. ದಯವಿಟ್ಟು ಏನು ಎಂದು ತಿಳಿದುಕೊಳ್ಳಿ, ಮತ್ತು ಈ ಮಾಹಿತಿಯನ್ನು ನನಗೆ ಮತ್ತೆ ಕಳುಹಿಸಿ.

ಅಲ್ಟ್ರಿಕ್ಸ್ 4.1 (ಇಲ್ಲಿ ಸುಮಾರು ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳು) 1000000 ಕ್ಕಿಂತಲೂ ಮೀರಿದ ಸಮಯವನ್ನು 0 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ.

SIGCHLD ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ ಡಿಜಿಟಲ್ UNIX 4.0A (ಮತ್ತು ಬಹುಶಃ ಇತರ ಆವೃತ್ತಿಗಳು) pt ಗಳನ್ನು ನಿಯೋಜಿಸಲು ನಿರಾಕರಿಸುತ್ತವೆ. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ಅನುದಾನ ಪುಟವನ್ನು ನೋಡಿ.

ಐಆರ್ಐಎಕ್ಸ್ 6.0 ಪಿಟಿಐ ಅನುಮತಿಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಆದ್ದರಿಂದ ಬೇರೆಯವರು ಹಿಂದೆ ಬಳಸಿದ ಪಿಟಿ ಯನ್ನು ನಿಯೋಜಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಅದು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. IRIX 6.1 ಗೆ ನವೀಕರಿಸಿ.

ಟೆರ್ನೆಟ್ (ಸೂರ್ಯೋಸ್ 4.1.2 ಅಡಿಯಲ್ಲಿ ಮಾತ್ರ ಪರಿಶೀಲಿಸಲಾಗಿದೆ) TERM ಅನ್ನು ಹೊಂದಿಸದೆ ಹೋದರೆ. TERM ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದ CGI ಲಿಪಿಯಲ್ಲಿ ಮತ್ತು ಕ್ರಾನ್ ಅಡಿಯಲ್ಲಿ ಇದು ಒಂದು ಸಮಸ್ಯೆಯಾಗಿದೆ. ಆದ್ದರಿಂದ, ನೀವು ಅದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸಬೇಕು - ಯಾವ ಪ್ರಕಾರವು ಸಾಮಾನ್ಯವಾಗಿ ಅಸಂಬದ್ಧವಾಗಿದೆ. ಅದು ಏನನ್ನಾದರೂ ಹೊಂದಿಸಬೇಕಾಗಿದೆ! ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕೆಳಗಿನವುಗಳು ಸಾಕಾಗುತ್ತದೆ.

ಸೆಟ್ ಎನ್ವಿ (TERM) vt100

SHIP ಮತ್ತು HOME ಅನ್ನು ಹೊಂದಿಸದಿದ್ದರೆ ಸಲಹೆ (BSDI BSD / OS 3.1 i386 ಅಡಿಯಲ್ಲಿ ಮಾತ್ರ ಪರಿಶೀಲಿಸಲಾಗಿದೆ) ಸ್ಥಗಿತಗೊಳ್ಳುತ್ತದೆ. ಇದು ಕ್ರಾನ್ ಅಡಿಯಲ್ಲಿ, ಸಿಜಿಐ ಸ್ಕ್ರಿಪ್ಟ್ಗಳಲ್ಲಿ ಸಮಸ್ಯೆಯಾಗಿದೆ, ಇದು ಈ ಪರಿಸರದ ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ, ನೀವು ಅವುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸಬೇಕು - ಯಾವ ಪ್ರಕಾರವು ಸಾಮಾನ್ಯವಾಗಿ ಅಸಂಬದ್ಧವಾಗಿದೆ. ಅದು ಏನನ್ನಾದರೂ ಹೊಂದಿಸಬೇಕಾಗಿದೆ! ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕೆಳಗಿನವುಗಳು ಸಾಕಾಗುತ್ತದೆ.

ಸೆಟ್ env (SHELL) / ಬಿನ್ / ಷೆಡ್ ಸೆಟ್ env (HOME) / usr / local / bin

Ptys ನ ಕೆಲವು ಅಳವಡಿಕೆಗಳು ವಿನ್ಯಾಸಗೊಳಿಸಲ್ಪಟ್ಟಿವೆ, ಆದ್ದರಿಂದ ಪ್ರಕ್ರಿಯೆಯು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಅನ್ನು ಮುಚ್ಚಿದ ನಂತರ 10 ರಿಂದ 15 ಸೆಕೆಂಡ್ಗಳ ನಂತರ ಯಾವುದೇ ಓದದ ಔಟ್ಪುಟ್ ಅನ್ನು ಕರ್ನಲ್ ಎಸೆಯುತ್ತಾನೆ (ನಿಜವಾದ ಸಂಖ್ಯೆ ಅನುಷ್ಠಾನ-ಅವಲಂಬಿತವಾಗಿದೆ). ಹೀಗೆ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು

ಸ್ಪಾನ್ ದಿನಾಂಕ ನಿದ್ರೆ 20 ನಿರೀಕ್ಷೆ

ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ಇದನ್ನು ತಪ್ಪಿಸಲು, ಸ್ಪಾನ್ಗಿಂತ ಹೆಚ್ಚಾಗಿ ಎಕ್ಸ್ಕ್ಯೂನೊಂದಿಗೆ ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಆಹ್ವಾನಿಸಿ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಂಭಾವ್ಯವಾದರೂ, ಪ್ರಾಯೋಗಿಕವಾಗಿ ನಾನು ಈ ನಡವಳಿಕೆಯಿಂದ ನಿಜವಾದ ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮದ ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಕಳೆದುಕೊಳ್ಳುವ ಪರಿಸ್ಥಿತಿಯನ್ನು ಎಂದಿಗೂ ಎದುರಿಸಲಿಲ್ಲ.

ಮತ್ತೊಂದೆಡೆ, ಕ್ರಿಯಾ ಯುನಿಕೋಸ್ ಪಿಟಿಎಸ್ ಪ್ರಕ್ರಿಯೆಯು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಅನ್ನು ಮುಚ್ಚಿದ ತಕ್ಷಣವೇ ಓದದಿರುವ ಯಾವುದೇ ಔಟ್ಪುಟ್ ಅನ್ನು ಎಸೆದುಕೊಂಡಿರುತ್ತದೆ. ನಾನು ಇದನ್ನು ಕ್ರೇ ಎಂದು ವರದಿ ಮಾಡಿದ್ದೇನೆ ಮತ್ತು ಅವರು ಫಿಕ್ಸ್ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ.

ಕೆಲವೊಮ್ಮೆ ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ನಡುವೆ ವಿಳಂಬ ಅಗತ್ಯವಿದೆ, ಉದಾಹರಣೆಗೆ ಒಂದು ಟಿಟಿ ಇಂಟರ್ಫೇಸ್ UART ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಬದಲಿಸುತ್ತಿರುವಾಗ ಅಥವಾ ಆರಂಭ / ಸ್ಟಾಪ್ ಬಿಟ್ಗಳನ್ನು ಹುಡುಕುವ ಮೂಲಕ ಹೊಂದಾಣಿಕೆ ಬಾಡ್ ದರಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಇದು ಎರಡನೆಯ ಅಥವಾ ಎರಡಕ್ಕೂ ನಿದ್ದೆ ಮಾಡುವುದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಹಾರ್ಡ್ವೇರ್ ಇನ್ಪುಟ್ ಸ್ವೀಕರಿಸಲು ಸಿದ್ಧವಾಗುವವರೆಗೂ ಮತ್ತೆ ಪ್ರಯತ್ನಿಸುವುದು ಹೆಚ್ಚು ದೃಢವಾದ ತಂತ್ರವಾಗಿದೆ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಎರಡೂ ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತದೆ:

"9600 \ r" ವೇಗವನ್ನು ಕಳುಹಿಸಿ; ನಿದ್ರೆ 1 ನಿರೀಕ್ಷಿಸುತ್ತಿದೆ {ಸಮಯದ ಸಮಯ {ಕಳುಹಿಸು "\ r"; exp_continue} $ ಪ್ರಾಂಪ್ಟ್}

ಟ್ರ್ಯಾಪ್-ಕೋಡ್ ಟ್ರೆಕ್ನ ಈವೆಂಟ್ ಲೂಪ್ನಲ್ಲಿ ನಿಂತಿರುವ ಯಾವುದೇ ಆಜ್ಞೆಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ. ಈವೆಂಟ್ ಲೂಪ್ನಲ್ಲಿ, ಟಿಸಿಕ್ ಅಸೈನ್ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ಗಳಿಂದ ರಿಟರ್ನ್ ಕೋಡ್ಗಳನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ ಎಂಬುದು ಸಮಸ್ಯೆಯಾಗಿದೆ. ಟ್ರ್ಯಾಪ್ ಕೋಡ್ನಲ್ಲಿ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಹೊಂದಿಸುವುದು ಒಂದು ಪರಿಹಾರ. ಆಜ್ಞೆಯ ನಂತರ ತಕ್ಷಣವೇ ಧ್ವಜವನ್ನು ಪರಿಶೀಲಿಸಿ (ಅಂದರೆ, ನಿದ್ರೆ).

Expect_background ಆಜ್ಞೆಯನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತದೆ-ಸಮಯದ ವಾದಗಳು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಸಮಯ ಅವಧಿಗಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿಲ್ಲ.

& # 34; ನಿರೀಕ್ಷಿತ ಬಿಂದುಗಳು & # 34;

ನಿರೀಕ್ಷಿಸಬಹುದಾದ ಬಗ್ಗೆ ಕೆಲವು ವಿಷಯಗಳಿವೆ, ಇದು ಅಂತರ್ಬೋಧೆಯಿಲ್ಲ. ಈ ವಿಭಾಗವು ಕೆಲವು ಸಲಹೆಗಳೊಂದಿಗೆ ಈ ಕೆಲವು ವಿಷಯಗಳನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

ಶೆಲ್ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಹೇಗೆ ಗುರುತಿಸುವುದು ಎಂಬುದು ಸಾಮಾನ್ಯ ನಿರೀಕ್ಷೆ. ವಿಭಿನ್ನವಾಗಿ ಜನರು ಮತ್ತು ವಿಭಿನ್ನ ಚಿಪ್ಪುಗಳನ್ನು ವಿಭಿನ್ನವಾಗಿ ಕಸ್ಟಮೈಸ್ ಮಾಡಲಾಗಿರುವುದರಿಂದ, ಪ್ರಾಂಪ್ಟ್ ತಿಳಿಯದೆಯೇ ಒಗ್ಗೂಡಿಸುವ ರೋಡ್ಜಿನ್ ಅನ್ನು ಕಷ್ಟಪಡಿಸಬಹುದು. ಪರಿಸರದ ವೇರಿಯಬಲ್ EXPECT_PROMPT ಯಲ್ಲಿ ಬಳಕೆದಾರರು ತಮ್ಮ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು (ನಿರ್ದಿಷ್ಟವಾಗಿ, ಅದರ ಅಂತ್ಯದಲ್ಲಿ) ವಿವರಿಸುವ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಒಂದು ಸಮಂಜಸವಾದ ಸಮಾವೇಶವಾಗಿದೆ. ಕೆಳಗಿನ ರೀತಿಯ ಕೋಡ್ ಅನ್ನು ಬಳಸಬಹುದು. EXPECT_PROMPT ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಸಂಕೇತವು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಉತ್ತಮ ಅವಕಾಶವನ್ನು ಹೊಂದಿದೆ.

ಸೆಟ್ ಪ್ರಾಂಪ್ಟ್ "(% | # | \\ $) $"; # ಡೀಫಾಲ್ಟ್ ಪ್ರಾಂಪ್ಟ್ ಕ್ಯಾಚ್ {ಸೆಟ್ ಪ್ರಾಂಪ್ಟ್ $ env (EXPECT_PROMPT)} ನಿರೀಕ್ಷೆ -ರ $ ಪ್ರಾಂಪ್ಟ್

ನೀವು ನೋಡುವ ನಿರೀಕ್ಷೆಯಿರುವುದನ್ನು ಒಳಗೊಂಡಿರುವ ನಿರೀಕ್ಷೆಯ ಮಾದರಿಗಳನ್ನು ಬರೆಯಲು ನಾನು ನಿಮ್ಮನ್ನು ಪ್ರೋತ್ಸಾಹಿಸುತ್ತೇನೆ. ಇಡೀ ವಿಷಯವನ್ನು ನೋಡುವ ಮೊದಲು ಪ್ರಶ್ನೆಗೆ ಉತ್ತರ ನೀಡುವ ಸಾಧ್ಯತೆಯನ್ನು ಇದು ತಪ್ಪಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಅವುಗಳನ್ನು ನೋಡುವ ಮೊದಲು ನೀವು ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಆದರೆ, ನೀವು ಮುಂಚಿನ ಉತ್ತರಕ್ಕೆ, ನಿಮ್ಮ ಉತ್ತರವನ್ನು ಪ್ರಶ್ನೆಯ ಮಧ್ಯದಲ್ಲಿ ಪ್ರತಿಧ್ವನಿಸಿತು ಕಾಣಿಸಬಹುದು. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಪರಿಣಾಮವಾಗಿ ಸಂಭಾಷಣೆ ಸರಿಯಾಗಿರುತ್ತದೆ ಆದರೆ ಗೋಚರವಾಗುವಂತೆ ಕಾಣುತ್ತದೆ.

ಹೆಚ್ಚಿನ ಪ್ರಾಂಪ್ಟ್ಗಳು ಕೊನೆಯಲ್ಲಿ ಒಂದು ಸ್ಪೇಸ್ ಪಾತ್ರವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ftp ಯಿಂದ ಪ್ರಾಂಪ್ಟ್ 'f', 't', 'p', '>' ಮತ್ತು. ಈ ಪ್ರಾಂಪ್ಟನ್ನು ಸರಿಹೊಂದಿಸಲು, ಈ ಪ್ರತಿಯೊಂದು ಪಾತ್ರಗಳಿಗೆ ನೀವು ಖಾತೆಯನ್ನು ಹೊಂದಿರಬೇಕು. ಖಾಲಿ ಸೇರಿಸದಿರುವುದು ಸಾಮಾನ್ಯ ತಪ್ಪು. ಸ್ಪಷ್ಟವಾಗಿ ಖಾಲಿ ಹಾಕಿ.

ನೀವು ಫಾರ್ಮ್ ಎಕ್ಸ್ * ಮಾದರಿಯನ್ನು ಬಳಸಿದರೆ, * X ನ ಅಂತ್ಯದಿಂದ ಸ್ವೀಕರಿಸಲ್ಪಟ್ಟ ಎಲ್ಲಾ ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದ ಕೊನೆಯ ವಿಷಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. ಇದು ಅರ್ಥಗರ್ಭಿತವಾದದ್ದು ಆದರೆ ಸ್ವಲ್ಪ ಗೊಂದಲಮಯವಾಗಬಹುದು ಏಕೆಂದರೆ "ಕೊನೆಯ ವಿಷಯವು" ಎಂಬ ಪದವು ಕಂಪ್ಯೂಟರ್ನ ವೇಗ ಮತ್ತು I / O ಗಳ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕರ್ನಲ್ ಮತ್ತು ಸಾಧನ ಚಾಲಕದಿಂದ ಬದಲಾಗುತ್ತದೆ.

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ವಾಸ್ತವದಲ್ಲಿ ಹೆಚ್ಚಿನ ಪ್ರೋಗ್ರಾಂಗಳು ಒಂದು ಕಾಲವನ್ನು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಉತ್ಪತ್ತಿ ಮಾಡಿದಾಗ ಮಾನವರು ಬೃಹತ್ ಭಾಗಗಳಲ್ಲಿ (ಪರಮಾಣುಗಳಲ್ಲಿ) ಬರುವ ಪ್ರೊಗ್ರಾಮ್ ಔಟ್ಪುಟ್ಗಳನ್ನು ನೋಡುತ್ತಾರೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಊಹಿಸಬೇಕಾದರೆ, ಹಿಂದಿನ ಪ್ಯಾರಾಗ್ರಾಫ್ನ ಮಾದರಿಯಲ್ಲಿರುವ * ಪ್ರಸ್ತುತ ಸಾಲಿನಲ್ಲಿನ ಅಂತ್ಯಕ್ಕೆ ಮಾತ್ರ ಹೊಂದಾಣಿಕೆಯಾಗಬಹುದು, ಏಕೆಂದರೆ ಹೆಚ್ಚಿನದಾಗಿ ಕಂಡುಬಂದರೂ ಸಹ, ಪಂದ್ಯದ ಸಮಯದಲ್ಲಿ ಸ್ವೀಕರಿಸಿದ ಎಲ್ಲಾ ಔಟ್ಪುಟ್ ಎಂದು.

ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ಪರಿಗಣಿಸದ ಹೊರತು ಮತ್ತಷ್ಟು ಔಟ್ಪುಟ್ ಬರುತ್ತಿದೆ ಎಂದು ತಿಳಿದುಕೊಳ್ಳುವ ಮಾರ್ಗವಿಲ್ಲ ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು .

ಲೈನ್ ಆಧಾರಿತ ಬಫರಿಂಗ್ ಅವಲಂಬಿಸಿ ಸಹ ಅವಿವೇಕದ ಆಗಿದೆ. ಕಾರ್ಯಕ್ರಮಗಳು ವಿರಳವಾಗಿ ಅವರು ಮಾಡುವ ಬಫರಿಂಗ್ ಬಗೆಗಿನ ಭರವಸೆಗಳನ್ನು ಮಾಡುತ್ತವೆ, ಆದರೆ ಸಿಸ್ಟಮ್ ಅಜೀರ್ಣವು ಔಟ್ಪುಟ್ ಸಾಲುಗಳನ್ನು ಮುರಿಯಬಹುದು ಆದ್ದರಿಂದ ಆ ಸಾಲುಗಳು ತೋರಿಕೆಯಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಸ್ಥಳಗಳಲ್ಲಿ ಮುರಿಯುತ್ತವೆ. ಆದ್ದರಿಂದ, ನಮೂನೆಗಳನ್ನು ಬರೆಯುವಾಗ ನೀವು ಪ್ರಾಂಪ್ಟ್ನ ಕೊನೆಯ ಕೆಲವು ಅಕ್ಷರಗಳನ್ನು ವ್ಯಕ್ತಪಡಿಸಿದ್ದರೆ, ಹಾಗೆ ಮಾಡುವುದು ಬುದ್ಧಿವಂತವಾಗಿದೆ.

ಪ್ರೋಗ್ರಾಂನ ಕೊನೆಯ ಔಟ್ಪುಟ್ನಲ್ಲಿ ನೀವು ಮಾದರಿಯನ್ನು ಕಾಯುತ್ತಿದ್ದರೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಬದಲಿಗೆ ಏನನ್ನಾದರೂ ಹೊರಸೂಸುತ್ತದೆ, ಅದು ಕಾಲಾವಧಿ ಕೀವರ್ಡ್ದೊಂದಿಗೆ ನೀವು ಅದನ್ನು ಪತ್ತೆ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಕಾರಣ ನಿರೀಕ್ಷೆ ಸಮಯ ಮೀರುತ್ತದೆ ಎಂದು - ಬದಲಿಗೆ ಇದು ಒಂದು ಸೂಚನೆಯನ್ನು ಪಡೆಯುತ್ತದೆ. ಬದಲಿಗೆ ಅದನ್ನು ಬಳಸಿ. ಇನ್ನೂ ಉತ್ತಮ, ಎರಡೂ ಬಳಸಿ. ಆ ಮಾರ್ಗವು ಸುತ್ತಮುತ್ತ ಹೋದರೆ ಆ ಮಾರ್ಗವನ್ನು ನೀವು ಸಂಪಾದಿಸಬೇಕಾಗಿಲ್ಲ.

ಟರ್ಮಿನಲ್ ಡ್ರೈವರ್ನಿಂದ ಔಟ್ಪುಟ್ ಮಾಡಿದಾಗ ನ್ಯೂಲೈನ್ಗಳನ್ನು ಸಾಧಾರಣವಾಗಿ ಕ್ಯಾರೇಜ್ ರಿಟರ್ನ್, ಲೈನ್ ಫೀಡ್ ಸೀಕ್ವೆನ್ಸ್ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಹಾಗಾಗಿ, ಎರಡು ಸಾಲುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸುವ ಮಾದರಿಯನ್ನು ನೀವು ಬಯಸಿದರೆ, printf ("foo \ nbar") ನಿಂದ, ನೀವು "foo \ r \ nbar" ಮಾದರಿಯನ್ನು ಬಳಸಬೇಕು.

ನಿರೀಕ್ಷಿತ_ಯುಸರ್ ಮೂಲಕ ಬಳಕೆದಾರರು ಓದುವ ಸಂದರ್ಭದಲ್ಲಿ ಇದೇ ರೀತಿಯ ಅನುವಾದವು ಉಂಟಾಗುತ್ತದೆ . ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ರಿಟರ್ನ್ ಅನ್ನು ಒತ್ತಿದಾಗ, ಅದನ್ನು ಹೊಸಲೈನ್ಗೆ ಅನುವಾದಿಸಲಾಗುತ್ತದೆ. ನಿರೀಕ್ಷಿಸಿದರೆ ಅದರ ಟರ್ಮಿನಲ್ ಅನ್ನು ಕಚ್ಚಾ ಮೋಡ್ಗೆ (ಟೆಲ್ನೆಟ್ನಂತೆ) ಹೊಂದಿಸುವ ಪ್ರೋಗ್ರಾಂಗೆ ಅದು ಹಾದು ಹೋದರೆ, ಪ್ರೋಗ್ರಾಂ ನಿಜವಾದ ರಿಟರ್ನ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುವಂತೆ ಸಮಸ್ಯೆ ಇರುತ್ತದೆ. (ಕೆಲವೊಂದು ಕಾರ್ಯಕ್ರಮಗಳು ನಿಜವಾಗಿ ಕ್ಷಮಿಸುವವು, ಅವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಸಬರನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಭಾಷಾಂತರಿಸುತ್ತವೆ, ಆದರೆ ಹೆಚ್ಚಿನವು ಇಲ್ಲ.) ಶೋಚನೀಯವಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಕಚ್ಚಾ ಮೋಡ್ಗೆ ಅದರ ಟರ್ಮಿನಲ್ ಅನ್ನು ಹಾಕುವ ಮಾರ್ಗವಿಲ್ಲ.

ಹೊಸ ಲೈನ್ಗಳನ್ನು ಕೈಯಿಂದ ಹಿಂದಿರುಗಿಸುವುದರ ಬದಲಾಗಿ, ಅನುವಾದವನ್ನು "ಸ್ಟಾಟಿ ಕಚ್ಚಾ" ಎಂಬ ಆದೇಶವನ್ನು ಬಳಸುವುದು, ಇದು ಅನುವಾದವನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದರರ್ಥ ನೀವು ಬೇಯಿಸಿದ ಲೈನ್-ಎಡಿಟಿಂಗ್ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಪಡೆಯುವುದಿಲ್ಲ.

ಸಂವಾದಾತ್ಮಕವಾಗಿ ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಅನ್ನು ಕಚ್ಚಾ ಕ್ರಮಕ್ಕೆ ಹೊಂದಿಸುತ್ತದೆ ಆದ್ದರಿಂದ ಈ ಸಮಸ್ಯೆ ಆಗುವುದಿಲ್ಲ.

ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ನಿರೀಕ್ಷಿಸಿ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು (ಅಥವಾ ಇತರ ಖಾಸಗಿ ಮಾಹಿತಿ) ಶೇಖರಿಸಿಡಲು ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿರುವ ಯಾವುದಾದರೂ ಯಾರಿಗಾದರೂ ಪ್ರವೇಶಿಸಬಹುದಾದ ಕಾರಣದಿಂದಾಗಿ ಇದು ಶಿಫಾರಸು ಮಾಡಲಾಗಿಲ್ಲ. ಹೀಗಾಗಿ, ಸ್ಕ್ರಿಪ್ಟ್ನಿಂದ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಪರಸ್ಪರವಾಗಿ ಪ್ರಾಂಪ್ಟ್ ಮಾಡುವ ಮೂಲಕ ಅವುಗಳನ್ನು ಅಕ್ಷರಶಃ ಎಂಬೆಡ್ ಮಾಡುವುದಕ್ಕಿಂತ ಉತ್ತಮ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಅದೇನೇ ಇದ್ದರೂ, ಕೆಲವೊಮ್ಮೆ ಇಂತಹ ಅಂತರ್ಗತವು ಏಕೈಕ ಸಾಧ್ಯತೆಯಾಗಿದೆ.

ದುರದೃಷ್ಟವಶಾತ್, ಯುನಿಕ್ಸ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಆದರೆ ಓದಲಾಗದ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ರಚಿಸುವ ಯಾವುದೇ ನೇರ ಮಾರ್ಗವನ್ನು ಹೊಂದಿಲ್ಲ. Setgid ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟುಗಳನ್ನು ಬೆಂಬಲಿಸುವ ಸಿಸ್ಟಮ್ಸ್ ಪರೋಕ್ಷವಾಗಿ ಈ ರೀತಿಯಾಗಿ ಅನುಕರಿಸಬಹುದು:

ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸಿ (ಅದು ರಹಸ್ಯ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ) ಎಂದಿನಂತೆ. ಅದರ ಅನುಮತಿಗಳನ್ನು 750 (-rwxr-x ---) ಎಂದು ಮಾಡಿ ಮತ್ತು ನಂಬಿಕೆಯ ಗುಂಪಿನ ಮಾಲೀಕತ್ವವನ್ನು ಹೊಂದಿದೆ, ಅಂದರೆ, ಅದನ್ನು ಓದಲು ಅನುಮತಿಸಲಾದ ಗುಂಪು. ಅಗತ್ಯವಿದ್ದರೆ, ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಹೊಸ ಗುಂಪನ್ನು ರಚಿಸಿ. ಮುಂದೆ, ಮೊದಲಿನಂತೆಯೇ ಅದೇ ಗುಂಪಿನ ಒಡೆತನದ ಅನುಮತಿ 2751 (-rwxr-s - x) ನೊಂದಿಗೆ / bin / sh ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸಿ.

ಫಲಿತಾಂಶವು ಯಾರನ್ನಾದರೂ ಮರಣದಂಡನೆ (ಮತ್ತು ಓದಲು) ಮಾಡಬಹುದಾದ ಒಂದು ಸ್ಕ್ರಿಪ್ಟ್. ಆಹ್ವಾನಿಸಿದಾಗ, ಅದು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ .

& # 34; ಎಲ್ಲವನ್ನೂ ನೋಡಿ & # 34;

ಟಿಎಲ್ಎಲ್ (3), ಲೈಬೀಸ್ಪೆಕ್ಟ್ (3)
"ಎಕ್ಸ್ಪ್ಲೋರಿಂಗ್ ಎಕ್ಸ್ಪೆಕ್ಟ್: ಎ ಟಿಕ್-ಬೇಸ್ಡ್ ಟೂಲ್ಕಿಟ್ ಫಾರ್ ಆಟೊಮೇಟಿಂಗ್ ಇಂಟರಾಕ್ಟಿವ್ ಪ್ರೊಗ್ರಾಮ್ಸ್" ಡಾನ್ ಲಿಬಿಸ್, ಪಿಪಿ. 602, ಐಎಸ್ಬಿಎನ್ 1-56592-090-2, ಓ'ರೈಲಿ ಅಂಡ್ ಅಸೋಸಿಯೇಟ್ಸ್, 1995.
"ನಿರೀಕ್ಷಿಸಬಹುದು: ಡಾನ್ ಲಿಬೀಸ್ನಿಂದ ಆ ನಿಯಂತ್ರಿಸಲಾಗದ ಫಿಟ್ಸ್ ಆಫ್ ಇಂಟರಾಕ್ಟಿವಿಟಿ ಕ್ಯೂರಿಂಗ್", ಪ್ರೊಸೀಡಿಂಗ್ಸ್ ಆಫ್ ದಿ ಸಮ್ಮರ್ 1990 ಯುಎಸ್ಎನ್ಇಎಕ್ಸ್ ಕಾನ್ಫರೆನ್ಸ್, ಅನಾಹೆಮ್, ಕ್ಯಾಲಿಫೋರ್ನಿಯಾ, ಜೂನ್ 11-15, 1990.
ಡಾನ್ ಲಿಬೆಸ್, 1990 ಯುಎಸ್ಎನ್ಇಎಕ್ಸ್ ದೊಡ್ಡ ಅನುಸ್ಥಾಪನಾ ವ್ಯವಸ್ಥೆಗಳ ಆಡಳಿತಾತ್ಮಕ ಸಮ್ಮೇಳನ, ಕೊಲೊರಾಡೋ ಸ್ಪ್ರಿಂಗ್ಸ್, ಕೊಲೊರಾಡೋ, ಅಕ್ಟೋಬರ್ 17-19, 1990 ರ "ಪ್ರೊಸೀಡಿಂಗ್ಸ್" ಸಿಸ್ಟಮ್ ಅಡ್ಮಿನಿಸ್ಟ್ರೇಷನ್ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರೀಕ್ಷಿಸುತ್ತಿದೆ .
ಜಾನ್ ಓಸ್ಟರ್ಹೌಟ್, ಪ್ರೊಸೀಡಿಂಗ್ಸ್ ಆಫ್ ದಿ ವಿಂಟರ್ 1990 USENIX ಕಾನ್ಫರೆನ್ಸ್, ವಾಷಿಂಗ್ಟನ್, ಡಿ.ಸಿ., ಜನವರಿ 22-26, 1990. "ನಿರೀಕ್ಷಿಸಬಹುದು: ಇಂಟರ್ಯಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು" ಡಾನ್ ಲಿಬಿಸ್, ಕಂಪ್ಯೂಟಿಂಗ್ ಸಿಸ್ಟಮ್ಸ್ನಿಂದ "ಟಿಎಮ್ಎಲ್: ಆನ್ ಎಮ್ಡೇಡಬಲ್ ಕಮಾಂಡ್ ಲಾಂಗ್ವೇಜ್" , ಸಂಪುಟ. 4, ನಂ. 2, ಯುನಿವರ್ಸಿಟಿ ಆಫ್ ಕ್ಯಾಲಿಫೋರ್ನಿಯಾ ಪ್ರೆಸ್ ಜರ್ನಲ್ಸ್, ನವೆಂಬರ್ 1991. ಡಾನ್ ಲಿಬಿಸ್ನಿಂದ "ರಿಗ್ರೆಷನ್ ಟೆಸ್ಟಿಂಗ್ ಅಂಡ್ ಕನ್ಫಾರ್ಮನ್ಸ್ ಟೆಸ್ಟಿಂಗ್ ಇಂಟರಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಂಗಳು", ಪ್ರೊಸೀಡಿಂಗ್ಸ್ ಆಫ್ ದಿ ಸಮ್ಮರ್ 1992 ಯುಎಸ್ಎನ್ಇಎಕ್ಸ್ ಕಾನ್ಫರೆನ್ಸ್, ಪಿಪಿ. 135-144, ಸ್ಯಾನ್ ಆಂಟೋನಿಯೊ, ಟಿಎಕ್ಸ್, ಜೂನ್ 12-15, 1992. ಡಾನ್ ಲಿಬಿಸ್, ಸಾಫ್ಟ್ವೇರ್ - ಪ್ರಾಕ್ಟೀಸ್ & ಎಕ್ಸ್ಪೀರಿಯನ್ಸ್, ಜಾನ್ ವಿಲೇ & ಸನ್ಸ್, ವೆಸ್ಟ್ ಸಸೆಕ್ಸ್, ಇಂಗ್ಲೆಂಡ್, ಸಂಪುಟ, "ನಾನು ಕಿಬಿಟ್ಜ್-ಕನೆಕ್ಟಿಂಗ್ ಮಲ್ಟಿಪಲ್ ಇಂಟರಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಂಸ್ ಟುಗೆದರ್".

23, ಸಂಖ್ಯೆ 5, ಮೇ, 1993 .. ನಾನು "ಟಿಎಲ್ಎಲ್ ಅಪ್ಲಿಕೇಷನ್ಸ್ಗಾಗಿ ಡಿಬಗ್ಗರ್", ಡಾನ್ ಲಿಬೀಸ್ರಿಂದ, 1993 ಟಿಎಲ್ಎಲ್ / ಟಿಕೆ ಕಾರ್ಯಾಗಾರದ ಪ್ರೊಸೀಡಿಂಗ್ಸ್, ಬರ್ಕ್ಲಿ, ಸಿಎ, ಜೂನ್ 10-11, 1993.

AUTHOR

ಡಾನ್ ಲಿಬೆಸ್, ಸ್ಟ್ಯಾಂಡರ್ಡ್ಸ್ ಮತ್ತು ತಂತ್ರಜ್ಞಾನದ ರಾಷ್ಟ್ರೀಯ ಸಂಸ್ಥೆ

ACKNOWLEDGMENTS

ಸ್ಪೂರ್ತಿಗಾಗಿ ಟಿ.ಎಲ್.ಕೆಗೆ ಜಾನ್ ಔಸ್ಟರ್ಹೌಟ್ ಮತ್ತು ಸ್ಕಾಟ್ ಪೈಸ್ಲೇಯ್ಗೆ ಧನ್ಯವಾದಗಳು. ಎಕ್ಸ್ಪೆಕ್ಟ್ಸ್ ಆಟೋಕಾನ್ಫಿಗರೇಷನ್ ಕೋಡ್ಗಾಗಿ ರಾಬ್ ಸವೊಯ್ಗೆ ಧನ್ಯವಾದಗಳು.

ಹಿಸ್ಟರಿ ಕಡತವು ನಿರೀಕ್ಷೆಯ ವಿಕಾಸದ ಹೆಚ್ಚಿನ ಭಾಗಗಳನ್ನು ದಾಖಲಿಸುತ್ತದೆ. ಇದು ಆಸಕ್ತಿದಾಯಕ ಓದುವಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಈ ಸಾಫ್ಟ್ವೇರ್ಗೆ ಹೆಚ್ಚಿನ ಒಳನೋಟವನ್ನು ನೀಡುತ್ತದೆ. ನನಗೆ ದೋಷ ಪರಿಹಾರಗಳನ್ನು ಕಳುಹಿಸಿದ ಮತ್ತು ಇತರ ಸಹಾಯವನ್ನು ನೀಡಿದ ಜನರಿಗೆ ಧನ್ಯವಾದಗಳು.

ನಿರೀಕ್ಷೆಯ ವಿನ್ಯಾಸ ಮತ್ತು ಅನುಷ್ಠಾನವನ್ನು ಭಾಗಶಃ US ಸರ್ಕಾರವು ಪಾವತಿಸಿತು ಮತ್ತು ಆದ್ದರಿಂದ ಸಾರ್ವಜನಿಕ ಡೊಮೇನ್ನಲ್ಲಿದೆ. ಆದರೆ ಈ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ದಸ್ತಾವೇಜನ್ನು ಅಥವಾ ಅವುಗಳ ಭಾಗಗಳನ್ನು ಬಳಸಿದರೆ ಲೇಖಕ ಮತ್ತು ಎನ್ಐಎಸ್ಟಿ ಕ್ರೆಡಿಟ್ ಬಯಸುತ್ತಾರೆ.