Expect reads cmdfile for a list of commands to execute. Expect
may also be invoked implicitly on systems which support the #!
notation by marking the script executable, and making the first
line in your script:
#!/usr/local/bin/expect -f
Of course, the path must accurately describe where Expect lives.
/usr/local/bin is just an example.
The -c flag prefaces a command to be executed before any in the
script. The command should be quoted to prevent being broken up
by the shell. This option may be used multiple times. Multiple
commands may be executed with a single -c by separating them with
semicolons. Commands are executed in the order they appear.
(When using Expectk, this option is specified as -command.)
The -d flag enables some diagnostic output, which primarily
reports internal activity of commands such as expect and
interact. This flag has the same effect as "exp_internal 1" at
the beginning of an Expect script, plus the version of Expect is
printed. (The strace command is useful for tracing statements,
and the trace command is useful for tracing variable
assignments.) (When using Expectk, this option is specified as
-diag.)
The -D flag enables an interactive debugger. An integer value
should follow. The debugger will take control before the next
Tcl procedure if the value is non-zero or if a ^C is pressed (or
a breakpoint is hit, or other appropriate debugger command
appears in the script). See the README file or SEE ALSO (below)
for more information on the debugger. (When using Expectk, this
option is specified as -Debug.)
The -f flag prefaces a file from which to read commands from.
The flag itself is optional as it is only useful when using the
#! notation (see above), so that other arguments may be supplied
on the command line. (When using Expectk, this option is
specified as -file.)
By default, the command file is read into memory and executed in
its entirety. It is occasionally desirable to read files one
line at a time. For example, stdin is read this way. In order
to force arbitrary files to be handled this way, use the -b flag.
(When using Expectk, this option is specified as -buffer.) Note
that stdio-buffering may still take place however this shouldn't
cause problems when reading from a fifo or stdin.
If the string "-" is supplied as a filename, standard input is
read instead. (Use "./-" to read from a file actually named
"-".)
The -i flag causes Expect to interactively prompt for commands
instead of reading them from a file. Prompting is terminated via
the exit command or upon EOF. See interpreter (below) for more
information. -i is assumed if neither a command file nor -c is
used. (When using Expectk, this option is specified as
-interactive.)
-- may be used to delimit the end of the options. This is useful
if you want to pass an option-like argument to your script
without it being interpreted by Expect. This can usefully be
placed in the #! line to prevent any flag-like interpretation by
Expect. For example, the following will leave the original
arguments (including the script name) in the variable argv.
#!/usr/local/bin/expect --
Note that the usual getopt(3) and execve(2) conventions must be
observed when adding arguments to the #! line.
The file $exp_library/expect.rc is sourced automatically if
present, unless the -N flag is used. (When using Expectk, this
option is specified as -NORC.) Immediately after this, the file
~/.expect.rc is sourced automatically, unless the -n flag is
used. If the environment variable DOTDIR is defined, it is
treated as a directory and .expect.rc is read from there. (When
using Expectk, this option is specified as -norc.) This sourcing
occurs only after executing any -c flags.
-v causes Expect to print its version number and exit. (The
corresponding flag in Expectk, which uses long flag names, is
-version.)
Optional args are constructed into a list and stored in the
variable named argv. argc is initialized to the length of argv.
argv0 is defined to be the name of the script (or binary if no
script is used). For example, the following prints out the name
of the script and the first three arguments:
send_user "$argv0 [lrange $argv 0 2]\n"
