ftp.bath.ac.uk: /pub/eulisp/feel-V0.7.tar.Z 

Welcome to FEEL.

Compiling: 
	You ought to be able to type 'make' in the source directory,
and get a working system (maybe after changing some variables). Read
the Makefile and the manual for the options that may need changing for
your system. You may need to do a 'make depend' to get the
dependencies right (Assuming you have X11).  For the spectacularly
lazy, there is a sun4 executable in the AddOns directory (This also
has a dbm and pvm interface) compiled in.

To run Feel, use the script 'feel' in the bin directory.

The bytecode interpreter:
This exists, but is very experimental. Contact me if you want to
compile code, and I'll give you the relevant details. A couple of
dumped images are supplied in the distribution.


Extremely brief intro to EuLisp:

Eulisp is a lisp dialect with the following features:

Reflective Object system 
Telos replaces Common Lisp's defclass and defstruct with similarly
named constructions, which differ in syntax. Check the definition for
details (or defs.em for the real truth). 

Module system
EuLisp code is generally written as a set of modules, with an explicit
interface. Two Modules cannot import each other --- the importation
graph has to be a DAG. In practice, this can be circumvented by
(ab)using generics.

Dynamic binding is different, as is the defining forms for (module)
global variables --- it is (deflocal foo <optional-value>).
There is also defconstant for immutable globals.

Read the definition for more details.

Brief intro to using feel ---

Feel takes 2 important options:
-heap <n> runs feel with n meg of heap space --- general allocation area
-stack-space <n> runs feel with n meg of stack space --- 'C' and static
allocation area. If feel stops with 'stack space wimped out' increase
this parameter.

Feel is oganised into modules. Each module is a separate namespace,
and by default imports and exports no bindings. 
Initially you are in the root module, which contains no useful
bindings. Interpreted modules are expected to have a '.em' suffix.

In any module,
(!> module-name) will enter a module, loading it if necessary. It
first looks for the file in the current directory, then down the
environment variable FEEL_LOAD_PATH. All bindings in that module then
become available. To interacively import one module into another, use
(import <mod-name>)

(!>> module-name) is the same as !>, except that it always loads the
module from disk.

(loaded-modules) gives the list of currently loaded modules (including
the internal ones, which are in turn re-exported by standard0).

(load-module module-name) will load the module and print the
resulting module. This is the easiest way of finding out what a module
exports. 

(load-path) gives the current value of the load path (see above).
(set-load-path x) sets the load path.

The !> and !>> forms can be used anywhere, while the others can only
be invoked from the root module. !root will always return to the root
module. 

Error handler:
!exit exits the error handler
!b gives a backtrace
!q gives a quick backtrace

Ignore messages saying 'GC Error: ptr=<n> (recovered)' --- They do not
mean anything much. 

Feel May occasionaly print a message like:

Compiled Elvira initialisation code error!!!

Trapping unhandled non-continuable "error"
	Check for initcode module--- It is needed

This implies that the initialisation code cannot be found. Set the 
FEEL_LOAD_PATH shell variable to include the Feel source directory.

