1. Chapter 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

2. Chapter 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

3. Chapter 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

4. Chapter 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

5. Chapter 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

6. Chapter 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

7. Chapter 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

8. Chapter 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

9. Chapter 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

10. Chapter 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

11. Chapter 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

12. Chapter 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

13. Chapter 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

14. Chapter 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

15. Chapter 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

16. Chapter 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

17. Chapter 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

18. Chapter 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

19. Chapter 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

20. Chapter 20 Extended Examples

    1. Encrypting A Directory

    2. File Transfer Over telnet

    3. You Have Unread News—tknewsbiff

    4. Exercises

21. Chapter 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

22. Chapter 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

23. Chapter 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

1. Appendix A Appendix—Commands and Variables

   1. Commands And Flags

   2. Variables

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal featured on the cover of Exploring Expect is a chimpanzee, a primate of the Pongidae family, which also includes orangutans and gorillas. The chimpanzee is the mostly closely related to man of all animals, biochem ically, physiologically, behaviorally, and in brain structure. Chimpanzees are known to express emotions similar to those commonly associated with humans, including anger, affection, sadness, and happiness. They also display behavior similar to that of humans in their ability and inclination to pick up, examine, and manipulate objects. Until recently it was believed that humans are the only animals able to build tools. It has since been discovered that chimpanzees often build simple instruments to help retrieve food from holes in the ground, logs, or other hard-to-reach places.

Chimpanzees use a vast array of facial expressions, postures, and gestures to communicate with each other, in addition to at least 32 different sounds. There is some evidence to suggest that chimpanzees are able to learn symbolic languages.

The natural habitat of the chimpanzee is western Africa, from Sierra Leone to the Great Lakes east of the Congo. Living primarily in forested areas, chimpanzees will spend 50 to 70 percent of their time in trees. They are omnivores, eating primarily fruits and vegetables, but they will also hunt and eat small animals. They live in family groups, which consist of about twice as many females as males. While adult chimpanzees are not monogamous, there is a close bond between a young chimp and its parents, and this bond remains unbroken for life. Chimpanzees are very sociable and affectionate animals, and frequently hug, kiss, stroke each other, or hold hands. Violent fights often break out within a social group. The loser of the fight makes up to the winner by displaying submissive behavior and conciliatory gestures. In this way they maintain the social harmony.

Though able to, the chimpanzee rarely walks erect on both feet. Short arm muscles prevent simultaneous extension of the wrists and fingers. Because of this, chimpanzees are unable to walk with their hands flat; when walking on all fours, only the knuckles of their hands touch the ground. Unlike human feet, chimpanzee feet also have an opposing toe, but it is used mainly for climbing and for walking on precarious footing. The foot is rarely used for picking up objects. UNIX and its attendant programs can be unruly beasts. Nutshell Handbooks help you tame them. ... Edie Freedman designed this cover and the entire UNIX bestiary that appears on other Nutshell Handbooks. The beasts themselves are adapted from 19th-century engravings from the Dover Pictorial Archive. The cover layout was produced with Adobe Photoshop 2.5 and Quark XPress 3.3 for the Macintosh, using the Adobe ITC Garamond font.

The inside layout was designed by Edie Freedman and Jennifer Niederst and implemented by Mike Sierra in FrameMaker using Adobe ITC Garamond and New Courier fonts. The figures were created in FrameMaker by Don Libes. The colophon was written by Clairemarie Fisher O'Leary.