Subversion Repositories or1k

This file is INSTALL.  It contains installation instructions for Expect.

If you do not have Tcl, get it (Expect's README explains how) and

install it.  The rest of these instructions assume that you have Tcl

installed.

If you are installing Expect on a single architecture, or are just

trying it out to see whether it is worth installing, follow the

"Simple Installation" below.  If you are installing Expect on multiple

architectures or the "Simple Installation" instructions are not

sufficient, see "Sophisticated Installations" below.

--------------------

Permissions

--------------------

On a Cray, you must be root to compile Expect.  See the FAQ for why

this is.

If you want shared libs on Linux, you must be root in order to run

ldconfig.  See the ldconfig man page for more info.

--------------------

Simple Installation

--------------------

By default, the Tcl source directory is assumed to be in the same

directory as the Expect source directory.  For example, in this

listing, Expect and Tcl are both stored in /usr/local/src:

        /usr/local/src/tcl8.0           (actual version may be different)

        /usr/local/src/expect-5.24      (actual version may be different)

If Tcl is stored elsewhere, the easiest way to deal with this is to

create a symbolic link to its real directory.  For example, from the

Expect directory, type:

        ln -s /some/where/else/src/tcl8.0 ..

The same applies for Tk, if you have it.  (Tk is optional.)

Run "./configure".  This will generate a Makefile (from a prototype

called "Makefile.in") appropriate to your system.  (This step must be

done in the foreground because configure performs various tests on

your controlling tty.  If you want to do this step in the background

in the future, automate it using Expect!)

Most people will not need to make any changes to the generated

Makefile and can go on to the next step.  If you want though, you can

edit the Makefile and change any definitions as appropriate for your

site.  All the definitions you are likely to want to change are

clearly identified and described at the beginning of the file.

To build only the stand-alone Expect program, run "make expect".  This

is appropriate even if you still haven't decided whether to install

Expect, are still curious about it, and want to do the minimum

possible in order to experiment with it.

To build everything, run "make".  If "configure" found Tk and X on

your system, this will build "expectk" (Expect with Tk).

Once expect is built, you can cd to the example directory and try out

some of the examples (see the README file in the example directory).

"make install" will install Expect.  If you built Expectk, that will

be installed as well.  So will the documentation and some of the most

useful examples.

If you want shared libs on Linux, you must now su to root and run

ldconfig on the shared library.  See the ldconfig man page for more

info.

A handful of people running "pure" 4.2BSD systems have noted that

expect fails to link due to lack of getopt and vprintf.  You can get

these from uunet or any good archive site.

--------------------

Sophisticated Installations

--------------------

The following instructions provide some suggestions for handling

complex installations.

--------------------

Changing Defaults

--------------------

The configure script allows you to customize the Expect configuration

for your site; for details on how you can do this, type "./configure

-help" or refer to the autoconf documentation (not included here).

Expect's configure supports the following flags in addition to the

standard ones:

        --verbose               Cause configure to describe

                                what it is checking and what it decides.

        --enable-shared         Compile Expect as a shared library if it

                                can figure out how to do that on this

                                platform.  (You must have already

                                compiled Tcl with this flag.)

        --disable-load          This switch is ignored so that you can

                                configure Expect with the same configure

                                command as Tcl.  If you want to disable

                                dynamic loading, configure Tcl with this

                                flag and then reconfigure Expect.

        --enable-gcc            This switch is ignored so that you can

                                configure Expect with the same configure

                                command as Tcl.  If you want to enable gcc,

                                configure Tcl with it and then reconfigure

                                Expect.  Expect will inherit the definition

                                that way.  It is not safe to modify the

                                Makefile to use gcc by hand.  If you do

                                this, then information related to dynamic

                                linking will be incorrect.

        --with-tclconfig=...    Specifies the directory containing Tcl's

                                configure file (tclConfig.sh).

        --with-tclinclude=...   Specifies the directory containing Tcl's

                                private include files (such as tclInt.h)

        --with-tkconfig=...     Specifies the directory containing Tk's

                                configure file (tkConfig.sh).

        --with-tkinclude=...    Specifies the directory containing Tk's

                                private include files (such as tkInt.h)

Some of the defaults in "configure" can be overridden by environment

variables.  This is a convenience intended for environments that are

likely to affect any program that you configure and install.

The following environment variables are supported.  If you use these,

consider adding them to your .login file so that other installation

scripts can make use of them.

CC              C compiler

CFLAGS          Flags to C compiler

CPPFLAGS        Flags to C preprocessor

LDFLAGS         Flags to linker

LIBS            Libraries

CONFIG_SHELL    Shell for configure and Make

Settings can also be given on the command line.  For example, you

could tell configure about flags from a Bourne-compatible shell as

follows:

     CFLAGS=-O2 LIBS=-lposix ./configure

Although configure will do some searching for Tcl (and all of this

discussion holds true for Tk as well), configure likes to find the Tcl

source directory in the parent directory of Expect and will use that

Tcl if it exists.  To make sure Tcl can be found this way (if it is

located somewhere else), create a symbolic link in Expect's parent

directory to where the Tcl directory is.

By default, configure uses the latest Tcl it can find.  You can

override this by creating a symbolic link of "tcl" which points to the

release you want.

If you can't or don't want to create symbolic links, you can instead

indicate where Tcl and Tk are by using the following environment variables:

with_tclconfig          Directory containing Tcl configure file (tclConfig.h)

with_tclinclude         Directory containing Tcl include files

with_tkinclude          Directory containing Tk include files

with_tkconfig           Directory containing Tk binary library (tkConfig.h)

--------------------

Multiple-Architecture Installation

--------------------

You might want to compile a software package in a different directory

from the one that contains the source code.  Doing this allows you to

compile the package for several architectures simultaneously from the

same copy of the source code and keep multiple sets of object files on

disk.

To compile the package in a different directory from the one

containing the source code, you must use a version of make that

supports the VPATH variable.  GNU make and most other recent make

programs can do this.

cd to the directory where you want the object files and executables to

go and run configure.  configure automatically checks for the source

code in the directory that configure is in and in ..  If configure

reports that it cannot find the source code, run configure with the

option --srcdir=dir, where dir is the directory that contains the

source code.

You can save some disk space by installing architecture-independent

files (e.g., scripts, include files) in a different place than

architecture-dependent files (e.g., binaries, libraries).  To do this,

edit the Makefile after configure builds it, or have configure create

the Makefile with the right definitions in the first place.  To have

configure do it, use the following options to configure:

        --prefix=indep

        --exec-prefix=dep

where dep is the root of the tree in which to store

architecture-dependent files and indep is the root in which to

store -dependent files.  For example, you might invoke configure this

way:

        configure --prefix=/usr/local/bin --exec-prefix=/usr/local/bin/arch

--------------------

Test Suite

--------------------

Patterned after the Tcl test suite, I have begun building a test suite

in the subdirectory "test".  It is still incomplete however you may

use by typing "make test" in this directory.  You should then see a

printout of the test files processed.  If any errors occur, you'll see

a much more substantial printout for each error.  See the README file

in the "tests" directory for more information on the test suite.

Note that the test suite assumes the existence of certain programs to

use as interactive programs.  If you are missing these or they behave

differently, errors may be reported.  Similarly, the test suite

assumes certain other things about your system, such as the sane stty

parameters.

You may also try some of the programs distribute in the example

directory (see the README file in the example directory).  They are a

strong indication of whether Expect works or not.  If you have any

problems with them, let me know.

--------------------

Uninstalling

--------------------

"make uninstall" removes all the files that "make install" creates

(excluding those in the current directory).

--------------------

Cleaning Up

--------------------

Several "clean" targets are available to reduce space consumption of

the Expect source.  The two most useful are as follows:

"make clean" deletes all files from the current directory that were

created by "make"

"make distclean" is like "make clean", but it also deletes files

created by "configure"

Other targets can be found in the Makefile.  They follow the GNU

Makefile conventions.