General Information

 o Eli: Translator Construction Made Easy
 o Global Index
 o Frequently Asked Questions

Tutorials

 o Quick Reference Card
 o Guide For new Eli Users
 o Release Notes of Eli
 o Tutorial on Name Analysis
 o Tutorial on Type Analysis

Reference Manuals

 o User Interface
 o Eli products and parameters
 o LIDO Reference Manual

Libraries

 o Eli library routines
 o Specification Module Library

Translation Tasks

 o Lexical analysis specification
 o Syntactic Analysis Manual
 o Computation in Trees

Tools

 o LIGA Control Language
 o Debugging Information for LIDO
 o Graphical ORder TOol

 o FunnelWeb User's Manual

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

 o Generating Unparsing Code

 o Monitoring a Processor's Execution

Administration

 o System Administration Guide

 Questions, Comments, ....

Eli System Administration Guide

Next Chapter Table of Contents


Installing Eli

Eli is a collection of packages defining processes needed to build a translator from specifications. These processes are managed by an expert system called Odin. Odin is designed to manage complex software construction activities of any kind, and is therefore a stand-alone tool that is completely independent of Eli.

The Eli distribution contains a version of Odin that is capable of managing the Eli software construction process. That version of Odin will be built automatically when you run configure followed by make in the distribution directory.

As described in the distribution's `README' file, you can use Eli from the distribution directory without further installation. Because the distribution directory contains source code, however, it is much larger than necessary to simply run Eli (see the end of the distribution's `README' file for typical sizes). Therefore we recommend that you run the make install command and then delete the distribution directory.

Running make install will install both Odin and the Eli packages in the directory you specified by the --prefix parameter when you configured the distribution. (Your home directory is used if no --prefix parameter was supplied to the configure command.)

The installation process will result in the following files and directories being added to the directory in which Eli is installed (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 file to execute Odin with its basic packages.

`bin/eli'
Command file to execute Odin with the Eli packages added to the basic Odin packages.

`lib/Eli'
The Eli package directory.

`lib/Odin'
The Odin package directory.

These files and directories can be moved to other locations, provided that certain references are updated to reflect the change:

  • The Odin man page file and the `eli' command file can be moved freely without changing any other file.

  • If the `odin' command file is moved, the `eli' command file must be updated to invoke it from its new location.

  • If the `Eli' package directory is moved, the `eli' command file must be updated to refer to its new location.

  • If the `Odin' package directory is moved, either the `odin' command file must be updated to refer to its new location, or the environment variable ODINPKGS must be set to the full path name of the new location.

If you want to install Eli on multiple architectures, you will need a separate build for each. That means running through the configure-make cycle described in the configuration directory's `README' file for each architecture. Usually a multi-architecture installation has a distinct file system for multi-architecture software. That file system is managed in such a way that its name is the same on every architecture, but the actual storage referenced is architecture-specific. Your strategy for such a system is simple:

  1. Have the system administrator create a directory in the multi-architecture file system that is owned by you. Suppose that directory has the name `/tools/Eli'.

  2. For each architecture, go to a machine having that architecture and run the following sequence of commands:

    ./configure --prefix=/tools/Eli
    make
    make install
    make distclean
    

  3. Put `/tools/Eli/bin' in your path.

You will now be able to execute the command eli on each architecture.

If you need a multi-architecture implementation, and space is at a premium, you can replace multiple copies of architecture-independent files by symbolic links to a single copy. Typically, about half of an installed Eli system can be shared. This implies, for example, that you can have three shared versions but only consume disk space equivalent to two separate versions.

The `elilink' script in the `Eli' sub-directory of the distribution can be used to set up this sharing:

elilink working-directory master-directory

Master-directory is a directory containing an installed version of Eli which is to be used as the complete master copy. It will be unchanged by elilink. working-directory is another installed version of Eli which is to share files with the master directory. That is, files in working-directory which are identical to their counterparts in master-directory will be linked to the master copy. `Elilink' produces messages to let you know what it is doing as it performs the link operations.

`Elilink' calls itself recursively. This means that you will either need to put the script in a directory that is on your PATH or change the script so that it knows where to look. If you want to do the latter, change the ELILINK= line near the top of the script to point to where the script resides.


Next Chapter Table of Contents