General Information

	Eli: Translator Construction Made Easy
	Global Index
	Frequently Asked Questions
	Typical Eli Usage Errors

Tutorials

	Quick Reference Card
	Guide For new Eli Users
	Release Notes of Eli
	Tutorial on Name Analysis
	Tutorial on Scope Graphs
	Tutorial on Type Analysis
	Typical Eli Usage Errors

Reference Manuals

	User Interface
	Eli products and parameters
	LIDO Reference Manual
	Typical Eli Usage Errors

Libraries

	Eli library routines
	Specification Module Library

Translation Tasks

	Lexical analysis specification
	Syntactic Analysis Manual
	Computation in Trees

Tools

	LIGA Control Language
	Debugging Information for LIDO
	Graphical ORder TOol

FunnelWeb User's Manual

	Pattern-based Text Generator
	Property Definition Language
	Operator Identification Language
	Tree Grammar Specification Language
	Command Line Processing
	COLA Options Reference Manual

Generating Unparsing Code

Monitoring a Processor's Execution

Administration

System Administration Guide

Eli System Administration Guide

Installation

Eli is distributed as source text, which must be configured and compiled before the system is usable. An extra (optional) installation step creates a library that takes advantage of versioned packages (see Versioned packages). There are two reasons for installing Eli:

Existing packages are not overwritten by new versions, leaving current caches unchanged until they are reset by a -R parameter on the eli command (see Packages in the cache). Thus the timing of an upgrade can be tailored to individual projects.
The distribution directory contains a lot of "scaffolding" that is used to build tools, but is not required to execute Eli. By installing the system and then deleting the distribution directory, you can eliminate all of this extraneous material.

Installing Eli

As described in the Eli distribution's `README' file, you can build the system by running configure followed by make. A subsequent invocation of make install will install Eli in the directory that you specified by the --prefix parameter when you configured the distribution. Typical settings are --prefix=/usr/local and --prefix=/opt/eli. (Your home directory is used if no --prefix parameter is supplied to the configure command.)

Installation will add the following files and directories to the specified directory (the `man', `bin', and `lib' sub-directories will be created by the installation process if they don't already exist):

`man/man1/odin.1': Man page for Odin.
`bin/odin': Command script
`bin/eli': Command script
`lib/Eli': The library of Eli packages.
`lib/Odin': The library of Odin packages.

Each package directory in these libraries contains a subdirectory for each distinct version of that package, plus meta-information defining the latest version. When a cache is built from a set of packages, the meta-information is used to establish links to the latest version in each set. The packages themselves are not copied to the cache.

When a new version of Eli is installed, the following changes are made to the libraries:

If the `version' file of a package has not changed, but some of the other files in that package have changed, the new files replace the old in the appropriate subdirectory.
Otherwise, a new subdirectory of the package directory in the library is created. It's name is the content of the `version' file. The necessary files are copied into this new directory, and the meta-information is updated to indicate that the new directory is the latest.

Since each cache links to a specific version subdirectory of the package, changes will only affect it if the package version has not changed. If the package version has changed, the previous subdirectory remains undisturbed. Thus an existing cache will be affected only by defect repairs that do not alter any visible behavior (see Versioned packages).

Installing additional packages

Locally-developed packages can be added to existing libraries, or new libraries can be created to hold them. A new library is typically created as a new subdirectory of the directory specified by the --prefix parameter when Eli was configured.

For example, you might create the directory `/opt/eli/Packages' to hold additional packages that should be a part of the set from which every cache was built. If you then set the environment variable ODINPATH to /opt/eli/Packages, the command eli -R would create a cache from those packages, the standard Eli packages, and the standard Odin packages (see Packages in the cache).

You can add a package directory or package collection directory `dir' to a library directory `lib' by the following Eli request:

-> dir +d_dest=(lib) :installpkg

Directory `dir' must be built (if necessary) and all irrelevant files (e.g. `Makefile', `README', `CVS', source files) removed before this request is made. If `dir' is a package directory, it must contain `*.dg' and `version' files; if it is a package collection directory, it must contain a `PKGLST' file (see Versioned packages).

Packages installed via :installpkg behave exactly like the standard versioned packages: repairs will be effective in existing caches but changes in behavior will not (see Installing Eli).