Eli   Documents
Eli: Translator Construction Made Easy

General Information

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

Tutorials

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

Reference Manuals

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

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
Mail Home

New Features of Eli4.0

Next Chapter Table of Contents

Changes to the Eli User-Interface

Invocation of Eli

Eli is built on top of the Odin-System. Up to Version 3.8.3 of the Eli-System, an Odin-Version was integrated in the Eli-System. With the years passing, this odin-system was debugged and adapted to the Eli-System thus making it difficult to integrate new Odin-Versions developed by the author. While Odin is still distributed with Eli, the directories for the two are now completely separated. Eli is actually a set of Odin packages.

What does this mean for the Eli-User?

While an `eli' invocation script is still provided, all it does is to set an Odin environment variable, ODINPATH, to the location of the Eli packages and then invoke the `odin' invocation script. Note that the command-line options for this script are different than those older versions of Eli had. Read the manual page for `odin' to learn more about the command-line options.

In order to start using Eli, you should set up your account with a few environment-variable settings. First, you must enter the Path to the Odin-System into your Environment-variable `PATH'. Since the exact commandline differs in different shells, the following example is valid for usage in `csh'-compatible shells: 

   setenv PATH /usr/local/eli/Odin/bin:$PATH
   setenv MANPATH /usr/local/eli/Odin/man:$MANPATH

If you wish to use the `odin' script directly, rather than using the `eli' script, you will have to set the ODINPATH environment variable to point to the directory where the Eli packages are installed. For example, you might execute the following command before issuing calls to `odin'. 

   setenv ODINPATH /usr/local/eli/ELI4.0

By default, Odin maintains a cache directory `.ODIN' in your home-directory. If you dislike this, you can supply a new definition in the environment-variable `ODINCACHE'.

Note that with this new version of Odin you can specify Odin requests to execute on the command-line. Odin will execute the requests and return to the shell. If you do not provide any command-line requests, Odin will come up interactively, which looks like this: 

   Eli Version 4.0 (? for help, ^D to exit) (local)
   ->

Using Eli

In this section, only the main differences between the usage of the Odin-System and the Eli-System up to Version 3.8.3 will be pointed out. For a more complete introduction, please refer to Overview of Eli User Interface Reference Manual.

An Odin command that simply specifies an object makes sure that this object is up to date. Up to version 3.8.3 of Eli, such an object was immediately displayed on the Terminal. This is no longer the case. For example, the command x.specs:exe:warning will generate a file containing all the warnings and errors while deriving the executable from the given specification. Odin will not display the warnings, however.

To display an object, append a > to the derivation. A < appended to an object will invoke your editor with the filename of the generated object. By appending a ! and a command, you can invoke a unix-command with the filename of the generated object. 

   x.specs+arg=(i):run     # Make up-to-date
   x.specs:parsable<       # To your editor
   x.specs>                # To standard output
   x.specs:exe>x.exe       # To file x.exe
   x.specs:source>src      # To directory src
   x.specs:absyntax!more   # Start 'more' with product

If an object is executable (e.g. the derivation to `:help' yields an executable object), this object is immediately executed upon deriving it. So a derivation x.specs:exe:help starts the help-browser with the error- and warning messages occured while deriveing the executable. If you append a `>' to the request, you will get the generated executable shellscript displayed.

Another change in the user interface is, that the history mechanism has been dropped. Instead, you can browse in older commandlines using the arrow-keys of your keyboard, See User Interface of Quick Reference for Eli 4.0, for further information.

Changed names for derived objects

In the following, you will see a list with the names of legal derivations for Eli Version 3.8.3. After each derivation, a Eli4.0 substitute will be mentioned. Derivations that have not changed will not be mentioned here.

:err
:err has been predefined in Odin to mean an object with the raw error output from a derivation (Eli3.8-name was :.error) The Eli4.0 name for this is :error.
:warn
:warn has been predefined in Odin to mean an object with the raw error and warning output from a derivation (Eli3.8-name was :.warning) The Eli4.0 name for this is :warning.
+arg=(filename):stdout
Odin has now a more powerful method of executing a generated object. Here, a directory in which the execution should be performed is the main option. The commandline must be supplied in the option +cmd. From there, the standard output or the error output can be obtained as objects. A substitute for x.specs+arg=(in):stdout is now 
   . +cmd=(x.specs:exe) (in):stdout
For further information, See Supply Command Line Parameters of Products and Parameters Reference.
:gencode
is a list of generated .c and .h files generated from the processor-specification. To display such a list, use a derivation to :viewlist which starts a browser session with the given list. In total, use :gencode:viewlist instead of the given Eli3.8-derivation.

This technique also applies to other derivations, for example :showFe:viewlist, :showMe:viewlist, :allspecs:viewlist and :source:viewlist.

Next Chapter Table of Contents