This section describes how to add Expect to another Tcl-based program. I will use the tclsh program as an example. tclsh is the “Tcl shell” that comes with Tcl. tclsh comes with no other extensions, but you can use it as a template for creating a Tcl-based program with other extensions.

The Tcl source directory contains the template in tclAppInit.c. Copy this file to a new directory and look inside it at the function Tcl_AppInit. You will find the following lines:

if (Tcl_Init(interp) == TCL_ERROR) {
    return TCL_ERROR;
}

After this line, add code to initialize Expect:

if (Exp_Init(interp) == TCL_ERROR) {
    return TCL_ERROR;
}

You may want to add other extensions as well. Generally, you can add the extension initializations in any order unless they attempt to use the same command names. In that case, the later extensions “win”. The basic Tcl commands are actually created before Tcl_Init; however, it must still appear first. Other XXX_Init functions generally define commands for each extension themselves.

Add a line near the top of the file (anywhere after the include of "tcl.h“) to include the declaration of Exp_Init and other Expect definitions. The include looks like this:

#include "expect_tcl.h"

Now compile the tclAppInit.c file with the following command:

cc -I/usr/local/include tclAppInit.c -L/usr/local/lib 
     -lexpect -ltcl -lm

You may need to adjust this command depending on your installation. The −i flag describes the directory where the include files of Tcl, Expect, and other extensions live. Similarly, the -L flag lists where the libraries are. You can have multiple −i and -L flags. The end of the command names particular libraries. You need the Expect library (-lexpect), the Tcl library (-ltcl), and libraries for any other extensions. Most systems need the math library (-lm) and you may also need others depending on your system. If this does not work, look at the Tcl and Expect Makefiles to see what libraries they use on your system.

If the tclAppInit.c file compiled and linked, the compiler leaves an a.out file in the current directory. It is an executable file that understands Tcl commands, Expect commands, and any other extensions you have defined. You can rename and move this to whatever and wherever you want.

If you are using C++ or if any of the extensions use C++, you will need to make an extra step. You must use C to compile tclAppInit.c and C++ for the final command linking everything together into one executable. Some C++ compilers require that the main function also be compiled with C++. Because the Tcl library supplies the default main, you may need to extract or recreate this and compile it with C++.

It is likely that the idea of a library-based main will be revisited in the future. But in all but the simplest of programs, you are likely to want to create your own main anyway—for example, so that you can handle flag and file arguments appropriately to your application.

When using tclsh or any other program to which you have added Exp_Init, you may encounter differences between it and Expect.

You can add other extensions to Expect similarly to the way I described adding extensions to tclsh. However, by adding extensions to Expect, you keep aspects of Expect, such as Expect’s command-line argument handling.

The Expect source directory contains the template for Expect in exp_main_exp.c. Copy this file to a new directory and look inside it at the main function. You will find the statements (not necessarily in this order):

if (Tcl_Init(interp) == TCL_ERROR) {
    return TCL_ERROR;
}
if (Exp_Init(interp) == TCL_ERROR) {
    return TCL_ERROR;
}

Most other extensions can be added by calling XXX_Init, where XXX is the extension prefix. The actual call should look similar to the ones for Tcl and Expect.

You can generally put the other XXX_Init calls in any order unless the extensions attempt to use the same command names. In that case, the later extensions “win”. Note that the basic Tcl commands are created before Tcl_Init. Other XXX_Init functions generally define commands for each extension themselves.

Add any include lines near the top of the file (anywhere after the include of "tcl.h“) as appropriate to your extension.

Compile the exp_main_exp.c file with the following command.

cc -I/usr/local/include exp_main_exp.c ... 
      -L/usr/local/lib -lexpect -ltcl -lm

You may need to adjust this command depending on your installation. The −i flag describes the directory where the include files of Tcl, Expect, and other extensions live. Similarly, the -L flag lists where the libraries are. You can have multiple −i and -L flags. The end of the command names particular libraries. You need the Expect library (-lexpect), the Tcl library (-ltcl), and libraries for any other extensions. Replace the "..." with whatever .o files or libraries you need. Most systems need the math library (-lm) and you may also need others depending on your system. If this does not work, look at the Tcl and Expect Makefiles to see what libraries they use on your system.

If the exp_main_exp.c file compiled and linked, the compiler leaves an a.out file in the current directory. It is an executable file that understands Tcl commands, Expect commands, and any other extensions you have defined. You can rename and move this to whatever and wherever you want.

Note that if you are using C++ or any of the extensions use C++, you will need to make an extra step, using C to compile exp_main_exp.c and C++ for the final command which links everything together into one executable.

Adding extensions to Expectk is very similar to adding them to Expect. This section describes only the differences.

The template exp_main_tk.c should be used instead of exp_main_exp.c.

Linking requires the Tk library, so the compile line should look like this:

cc -I/usr/local/include exp_main_tk.c ... 
      -L/usr/local/lib -lexpect -ltk -ltcl -lX11 -lm

As with adding extensions to Expect, you may need to adjust this command also. If this does not work, look at the Tcl and Expect Makefiles to see what libraries they use on your system.

Expect normally uses a script to control its execution. This means that to run an Expect application, you need both an Expect interpreter and a script.

It is possible to combine the script and the interpreter together, producing a single executable that does not depend on any other files. This executable can be copied to new machines. The machines must be binary compatible and the script must make sense on the new machine. For example, programs that are spawned by the script must exist on the new machine. Stand-alone executables that run a particular script are often called compiled, although that is not the usual definition of the word.

Compiled scripts are large. Each one must contain the script plus the executable code for Expect. If you use a single Expect application on a computer, then a compiled script makes sense. If you use more than one Expect application, compiled scripts are just a waste of space. Other than space, there are no significant differences in functionality between compiled scripts and file-based scripts.

To create a compiled Expect script using the exp_main_exp.c template, replace all of the calls to the Expect interpretation phase (such as exp_interpret_cmdfilename) with a call to Tcl_Eval. As an argument to Tcl_Eval, pass the string representing the file contents.

Tcl_Eval(interp,cmdstring);

The string representation of the command must be in writeable memory. One way to guarantee this is to declare it in the following style:

static char cmdstring[] = "spawn prog; expect . .";

Calling Tcl_Eval with a string in read-only memory is a common error. Compare the declaration above with the following entry which allows the string to be placed in read-only memory:

char *cmdstring = "spawn prog; expect . .";   /* WRONG */

Any source statements must be removed from the command string. Some Tcl extensions make substantial use of files for storing Tcl commands. All of these file references must be removed in the same way as the script file itself.

Writing C and C++ code that uses the Expect extension is similar to writing C code that uses Tcl. For example, you can call Tcl_Eval to execute any Expect or Tcl command. The following statements spawn a telnet process and print the new spawn id. Notice the explicit declaration of telnet_cmd as an array instead of a pointer to a string constant. The array declaration guarantees that the characters are put into writeable memory—a requirement of Tcl_Eval.

char *spawn_id;
char telnet_cmd[] = "spawn telnet";

Tcl_Eval(interp,telnet_cmd);
spawn_id = Tcl_GetVar(interp,"spawn_id",0);
printf("spawn id is %s
",spawn_id);

It is possible to call Expect’s commands directly. However, this is a little harder and there is generally no good reason to do so, so it is not documented here.

A number of functions and variables are explicitly made public with C and C++ interfaces. Including the file expect_tcl.h gains access to these public symbols. They are defined in this section. Most of them are useful for writing your own main customized from Expect or tclsh. The descriptions are brief since most of the functional aspects are described in Chapter 9 (p. 209).

The first group of variables are shared by the Tcl-less Expect library, the Expect extension, and the Expect program. In this chapter, only their use in the Expect extension and program will be described.

int exp_disconnected;

int exp_is_debugging;

int exp_loguser;