You are previewing Exploring Expect.

Exploring Expect

Cover of Exploring Expect by Don Libes Published by O'Reilly Media, Inc.
  1. Exploring Expect
    1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
    2. A Note Regarding Supplemental Files
    3. Preface
      1. Expect—Why another tool?
      2. Tcl—A Little History
      3. Acknowledgments
      4. We’d Like to Hear From You
    4. How To Read This Book
      1. Notational Conventions
      2. Exercises
    5. 1. Intro—What Is Expect?
      1. Ouch, Those Programs Are Painful!
      2. A Very Brief Overview
      3. A First Script—dialback
      4. Total Automation
      5. Differing Behavior When Running Non-Interactively
      6. Partial Automation
      7. Dangerous, Unfriendly, Or Otherwise Unlikable User Interfaces
      8. Graphical Applications
      9. A Little More About Tcl
      10. Job Control
      11. Background Processes
      12. Using Expect With Other Programs
      13. Using Expect On UNIX
      14. Using Expect On Other Operating Systems
      15. Using Expect In Real Applications
      16. Using Expect In Commercial Applications—Legalese
      17. Obtaining Expect and the Examples
      18. Expect And Tcl Resources
      19. Exercises
    6. 2. Tcl—Introduction And Overview
      1. Everything Is A String
      2. Quoting Conventions
      3. Expressions
      4. Braces—Deferring Evaluation
      5. Control Structures
      6. More On Expressions
      7. Lists
      8. More Ways To Manipulate Strings
      9. Arrays
      10. Indirect References
      11. Handling Errors
      12. Evaluating Lists As Commands
      13. Passing By Reference
      14. Working With Files
      15. File I/O
      16. Executing UNIX Commands
      17. Environment Variables
      18. Handling Unknown Commands
      19. Libraries
      20. Is There More To Tcl?
      21. Exercises
    7. 3. Getting Started With Expect
      1. The send Command
      2. The expect Command
      3. Anchoring
      4. What Happens When Input Does Not Match
      5. Pattern-Action Pairs
      6. Example—Timed Reads In The Shell
      7. The spawn Command
      8. The interact Command
      9. Example—Anonymous ftp
      10. Exercises
    8. 4. Glob Patterns And Other Basics
      1. The * Wildcard
      2. More Glob Patterns
      3. Backslashes
      4. Handling Timeout
      5. Handling End Of File (eof)
      6. Hints On The spawn Command
      7. Back To Eof
      8. The close Command
      9. Programs That Ignore Eof
      10. The wait Command
      11. Exercises
    9. 5. Regular Expressions
      1. Regular Expressions—A Quick Start
      2. Identifying Regular Expressions And Glob Patterns
      3. Using Parentheses To Override Precedence
      4. Using Parentheses For Feedback
      5. More On The timed–read Script
      6. Pattern Matching Strategy
      7. Nested Parentheses
      8. Always Count Parentheses Even Inside Of Alternatives
      9. Example—The Return Value From A Remote Shell
      10. Matching Customized Prompts
      11. Example—A Smart Remote Login Script
      12. What Else Gets Stored In expect_out
      13. More On Anchoring
      14. Exercises
    10. 6. Patterns, Actions, And Limits
      1. Matching Anything But
      2. Really Complex Patterns
      3. Really Simple Patterns
      4. Matching One Line And Only One Line
      5. Tcl’s string match Command
      6. Tcl’s regexp Command
      7. Tcl’s regsub Command
      8. Ignoring Case
      9. All Those Other String Functions Are Handy, Too
      10. Actions That Affect Control Flow
      11. Example—rogue
      12. Character Graphics
      13. More Actions That Affect Control Flow
      14. Matching Multiple Times
      15. Recognizing Prompts (Yet Again)
      16. Speed Is On Your Side
      17. Controlling The Limits Of Pattern Matching Input
      18. The full_buffer Keyword
      19. Double Buffering
      20. Perpetual Buffering
      21. The Politics Of Patterns
      22. Expecting A Null Character
      23. Parity
      24. Length Limits
      25. Comments In expect Commands
      26. Restrictions On expect Arguments
      27. eval—Good, Bad, And Ugly
      28. Exercises
    11. 7. Debugging Patterns And Controlling Output
      1. Pattern Debugging
      2. Enabling Internal Diagnostics
      3. Logging Internal Diagnostics
      4. Disabling Normal Program Output
      5. The log_user Command
      6. Example—su2
      7. Recording All Expect Output
      8. Sending Messages To The Log
      9. About File Names
      10. Log And Diagnostic State
      11. Exercises
    12. 8. Handling A Process And A User
      1. The send_user Command
      2. The send_error Command
      3. The expect_user Command
      4. Dealing With Programs That Reprompt
      5. Dealing With Programs That Miss Input
      6. Sleeping
      7. Line Versus Character-Oriented And Other Terminal Modes
      8. Echoing
      9. Prompting For A Password On Behalf Of A Program
      10. Security And Insecurity
      11. Resetting The Terminal Upon Exit
      12. More On The stty Command
      13. The system Command
      14. Redirecting The Standard Input Or Output
      15. The expect_tty Command
      16. The send_tty Command
      17. Exercises
    13. 9. The Expect Program
      1. Expect—Just Another Program
      2. Invoking Scripts Without Saying “expect”
      3. Rewriting The #! Line
      4. The .exp Extension
      5. The—And Other Flags
      6. The —c Flag
      7. The -f Flag
      8. Writing The #! Line
      9. The −i Flag
      10. The -n And -N Flags
      11. The -d Flag
      12. The -D Flag
      13. The -b Flag
      14. The - Flag
      15. The interpreter Command
      16. Exercises
    14. 10. Handling Multiple Processes
      1. The spawn_id Variable
      2. Example—chess Versus chess
      3. Example—Automating The write Command
      4. How exp_continue Affects spawn_id
      5. The Value Of spawn_id Affects Many Commands
      6. Symbolic Spawn Ids
      7. Job Control
      8. Procedures Introduce New Scopes
      9. How Expect Writes Variables In Different Scopes
      10. Predefined Spawn Ids
      11. Exercises
    15. 11. Handling Multiple Processes Simultaneously
      1. Implicit Versus Explicit Spawn Ids
      2. Waiting From Multiple Processes Simultaneously
      3. Example—Answerback
      4. Which Pattern Goes With Which Spawn Id
      5. Which Spawn Id Matched
      6. Spawn Id Lists
      7. Example—Connecting Together Two Users To An Application
      8. Example—Timing All Commands
      9. Matching Any Spawn Id Already Listed
      10. The expect_before And expect_after Commands
      11. Indirect Spawn Ids
      12. Exercises
    16. 12. Send
      1. Implicit Versus Explicit Spawn Ids
      2. Sending To Multiple Processes
      3. Sending Without Echoing
      4. Sending To Programs In Cooked Mode
      5. Sending Slowly
      6. Sending Humanly
      7. Sending Nulls
      8. Sending Breaks
      9. Sending Strings That Look Like Flags
      10. Sending Character Graphics
      11. Comparing send To puts
      12. Exercises
    17. 13. Spawn
      1. The Search Path
      2. Philosophy--Processes Are Smart
      3. Treating Files As Spawned Processes
      4. Opening Ttys
      5. Bugs And Workarounds
      6. Process Pipelines And Ptys
      7. Automating xterm
      8. Checking For Errors From spawn
      9. spawn -noecho
      10. Example—unbuffer
      11. Obtaining Console Output
      12. Setting Pty Modes From spawn
      13. Hung Ptys
      14. Restrictions On Spawning Multiple Processes
      15. Getting The Process Id From A Spawn Id
      16. Using File I/O Commands On Spawned Processes
      17. Exercises
    18. 14. Signals
      1. Signals
      2. Signals In Spawned Processes
      3. Notes On Specific Signals
      4. When And Where Signals Are Evaluated
      5. Overriding The Original Return Value
      6. Using A Different Interpreter To Process Signals
      7. Exit Handling
      8. Exercises
    19. 15. Interact
      1. The interact Command
      2. Simple Patterns
      3. Exact Matching
      4. Matching Patterns From The Spawned Process
      5. Regular Expressions
      6. What Happens To Things That Do Not Match
      7. More Detail On Matching
      8. Echoing
      9. Avoiding Echoing
      10. Giving Feedback Without -echo
      11. Telling The User About New Features
      12. Sending Characters While Pattern Matching
      13. The continue And break Actions
      14. The return Action
      15. The Default Action
      16. Detecting End-Of-File
      17. Matching A Null Character
      18. Timing Out
      19. More On Terminal Modes (Or The -reset Flag)
      20. Example—Preventing Bad Commands
      21. Exercises
    20. 16. Interacting With Multiple Processes
      1. Connecting To A Process Other Than The Currently Spawned Process
      2. Connecting To A Process Instead Of The User
      3. Example—rz And sz Over rlogin
      4. Redirecting Input And Output
      5. Default Input And Output
      6. Controlling Multiple Processes—kibitz
      7. Combining Spawn Ids In A Single -input Or -output
      8. Which Spawn Id Matched
      9. Indirect Spawn Ids
      10. An Extended Example—xkibitz
      11. Exercises
    21. 17. Background Processing
      1. Putting Expect In The Background
      2. Running Expect Without A Controlling Terminal
      3. Disconnecting The Controlling Terminal
      4. The fork Command
      5. The disconnect Command
      6. Reconnecting
      7. Using kibitz From Other Expect Scripts
      8. Mailing From Expect
      9. A Manager For Disconnected Processes—dislocate
      10. Expect As A Daemon
      11. Example—Automating Gopher and Mosaic telnet Connections
      12. Exercises
    22. 18. Debugging Scripts
      1. Tracing
      2. Logging
      3. Command Tracing
      4. Variable Tracing
      5. Example—Logging By Tracing
      6. UNIX System Call Tracing
      7. Tk And tkinspect
      8. Traditional Debugging
      9. Debugger Command Overview And Philosophy
      10. Stepping Over Procedure Calls
      11. Stepping Into Procedure Calls
      12. Where Am I
      13. The Current Scope
      14. Moving Up And Down The Stack
      15. Returning From A Procedure
      16. Continuing Execution
      17. Defining Breakpoints
      18. Help
      19. Changing Program Behavior
      20. Changing Debugger Behavior
      21. Exercises
    23. 19. Expect + Tk = Expectk
      1. Tk—A Brief Technical Overview
      2. Expectk
      3. The send Command
      4. An Extended Example—tkpasswd
      5. The expect Command And The Tk Event Loop
      6. The expect_background Command
      7. Multiple Spawn Ids In expect_background
      8. Background Actions
      9. Example—A Dumb Terminal Emulator
      10. Example—A Smarter Terminal Emulator
      11. Using The Terminal Emulator For Testing And Automation
      12. Exercises
    24. 20. Extended Examples
      1. Encrypting A Directory
      2. File Transfer Over telnet
      3. You Have Unread News—tknewsbiff
      4. Exercises
    25. 21. Expect, C, And C++
      1. Overview
      2. Linking
      3. Include Files
      4. Ptys And Processes
      5. Allocating Your Own Pty
      6. Closing The Connection To The Spawned Process
      7. Expect Commands
      8. Regular Expression Patterns
      9. Exact Matching
      10. Matching A Null
      11. What Characters Matched
      12. When The Number Of Patterns Is Not Known In Advance
      13. Expecting From Streams
      14. Running In The Background
      15. Handling Multiple Inputs And More On Timeouts
      16. Output And Debugging Miscellany
      17. Pty Trapping
      18. Exercises
    26. 22. Expect As Just Another Tcl Extension
      1. Adding Expect To Another Tcl-based Program
      2. Differences Between Expect And The Expect Extension In Another Program
      3. Adding Extensions To Expect
      4. Adding Extensions To Expectk
      5. Creating Script-less Expect Programs
      6. Functions And Variables In The Expect Extension
      7. Exercises
    27. 23. Miscellaneous
      1. Random Numbers
      2. Example—Generating Random Passwords
      3. The Expect Library
      4. Expect Versions
      5. Timestamps
      6. The time Command
      7. Exercises
    28. A. Appendix—Commands and Variables
      1. Commands And Flags
      2. Variables
    29. Index
    30. About the Author
    31. SPECIAL OFFER: Upgrade this ebook with O’Reilly

Expect And Tcl Resources

This book contains a great deal of information about Expect and Tcl. Yet there are other resources that you may find useful. I will occasionally refer to some of these resources. The others are just for extra reading on your own.

Important Reading Material

The software for Expect, Tcl, and related packages include online manuals often called man pages. This is the definitive reference material. I will occasionally use the phrase Tcl reference material, for example, to refer to the Tcl man pages. As with most references, the reference material does not provide a lot of background or examples. Nevertheless, it is the most crucial documentation and therefore comes with the software itself.

I encourage you to use TkMan for reading man pages. Written by Tom Phelps at the University of California at Berkeley, TkMan provides an extremely pleasant GUI for browsing man pages. I cannot describe all the nice features of TkMan in this small space. Instead I will merely say that I now actually look forward to reading man pages as long as I can do it with TkMan. TkMan is written in Tcl and Tk and offers a splendid example of their power. Instructions on how to obtain TkMan can be found in the Tcl FAQ (see page 19).

Authoritatively written by the author of Tcl and Tk, John Ousterhout’s Tcl and the Tk Toolkit (Addison-Wesley, 1994) is really four books in one, all written in a very readable and balanced style. Two of the books introduce Tcl and Tk. The other two describe how to write extensions for Tcl and Tk. If you find yourself writing many Expect scripts or becoming interested in applying Tcl to other projects, I strongly recommend you read this book.

Although Ousterhout’s book does not cover all the features of Tcl and Tk, it nonetheless may be the place to turn for your questions left unanswered by Exploring Expect. For example, Tcl and the Tk Toolkit provide a more thorough treatment of some of the exotic features of Tcl. Ousterhout also provides a number of fascinating historical asides as well as some philosophical notes that contrast interestingly with my own.

Other Books

Software Solutions in C edited by Dale Schumacher (Academic Press, to appear) includes a chapter by Henry Spencer on the implementation of his regular expression pattern matcher which is used by Tcl and Expect. His explanation of how pattern matching is actually accomplished is lucid and fascinating. This book is intended for C programming experts, but it may provide additional insight on designing efficient patterns and otherwise using patterns effectively.

Practical Programming in Tcl and Tk by Brent Welch (Prentice Hall, to appear) focuses on the more useful parts of Tcl, Tk, and several important extensions. With his own perspective, Welch provides very good explanations of topics that have proven tricky to people even after reading Ousterhout’s book. Welch also illustrates Tcl scripting and C programming issues by way of numerous program fragments, providing many building blocks that can be used in your own applications.

Other Online Documentation

The Tcl Frequently Asked Questions List (FAQ) contains many common questions and answers that somehow do not belong in either the manual pages or books. For example, the FAQ contains lists of Tcl extensions, documents, ftp sites, and of course common questions and answers. The FAQ was created by Larry Virden and is available from the Tcl archive on the Internet site as tcl/docs/tcl-faq.partXXX, where XXX represents part numbers and file types. The file Index in the same directory lists the literal file names. The Tcl archive is maintained by Sam Kimery.

The Tcl FAQ can also be found on a number of other Internet sites. For example, it can be found on, which contains many other FAQs. The FAQ is also available through World Wide Web (WWW) as "“. The World Wide Web also provides access to other information on Tcl and Tk. The link "" contains links to other Tcl material with a focus on World Wide Web-related information such as browsers and HTML converters. Created by Mike Hopkirk, this link contains much other interesting and useful information as well. Another useful link is "“. Created by Wade Holst, this link concentrates on Tcl extensions. Included are a jobs database and an idea database. You can register ideas that you are working on and read what others are doing with Tcl. Many other Tcl-related WWW pages can be found in the Tcl FAQ.

A large number of scholarly papers on Expect and Tcl have appeared in journals and conference proceedings. These papers are not useful for people writing simple Expect scripts. Most of these papers are intended for computer scientists and cover topics such as implementation, performance, and comparisons to other methodologies. A Tcl bibliography is available on the Internet site in the directory tcl/docs. The same directory contains other miscellaneous documents such as quick reference cards and essays on miscellaneous topics.


A number of companies and individuals sell support for Tcl. These are described in the Tcl FAQ. Cygnus Support and Computerized Processes Unlimited sell support for Expect as well, and it is likely that other companies and individuals would also offer support if approached. This is not to mean that you will need support if you use Expect; however, it is not uncommon to find that management requires software be commercially supported before it is acceptable. As an aside, it may well be cost effective to have a professional support service solve your problems for you. Support can include modifications at your request, round-the-clock consulting by phone, site visits, and other services.

Cygnus Support
1937 Landings Drive
Mountain View, CA  94043
+1 (415) 903-1400

Computerized Processes Unlimited
4200 S. I-10 Service Rd., Suite 205
Metairie, LA 70006
+1 (504) 889-2784

Many questions can be also be answered with the help of the Usenet newsgroup comp.lang.tcl. This newsgroup contains announcements for new releases of Tcl and Tcl extensions. The newsgroup is the right place to post bug reports, fixes, observations, and, of course, humor. Many of the people who read it are experts at Tcl and Expect, and they will answer questions. Simple questions that can be found in a book or the FAQ are discouraged. But challenging problems or requests for advice are welcomed.

The comp.lang.tcl newsgroup can be subscribed to by mail. In addition, there are dozens of mailing lists on particular extensions and aspects of Tcl. All of these are documented in the FAQ.

The best content for your career. Discover unlimited learning on demand for around $1/day.