-*- Mode: Text; Syntax: ANSI-English; Package: CL-USER; Base: 10. -*-
$Id: README,v 1.6 2004/03/17 13:38:07 ihatchondo Exp $

				    ECLIPSE

				  Version 0.03


                   Copyright (C) 2000-2001-2002 Iban HATCHONDO
			       <hatchond@yahoo.fr>



For complete instructions on how to use Eclipse, please read the
manual.  This file contains only intallation instructions and some
other general information. 
Eclipse comes without ABSOLUTELY NO WARRANTY. See the COPYING file for
details.

I would love to receive feedback/coments/idea/bugreports, so feel free
to send me any comments you might have.

Finally, I only compiled and tested Eclipse with CMUCL/SBCL/CLISp. It should
work for other ANSI CL implementations, but the Makefile may have to
be modified, I guess. 
I have test it under x86 and Sparc ultra 1 with solaris, XFree86, Xorg, and
XFree86 under Cygwin.



Requirements :
--------------

In order to use Eclipse, you need the following to work on your
machine :
 - Common Lisp (see the <http://www.cons.org/cmucl> for a free implementation)
 - Loop (it usually comes with the standard, at least for CMUCL and ACL)
 - CLX library (AINSI CL implementation of the Xlib)
 - One of the following System Definition Facility:
   - MK-Defsystem library (<http://sourceforge.net/projects/clocc/>)
   - ASDF (Another System Definition Facility) (<http://www.cliki.net/asdf>)
 - GNOME/KDE (optional)

You can find all the Lisp parts in the Debian CMU CL packages
(<http://www.debian.org/distrib/packages>), I recommand them.

 - A core image of the language that includes CLX and defsystem (and
   loop if needed). See the core creation section for more information.



Compilation & Install :
-----------------------

shell $ ./configure
shell $ make
shell $ make install

should work. (at least for CMUCL, SBCL and CLISP)

See ./configure --help for options that can be used.

The particular --enable and --with options recognized:

  --with-core-switch=arg  
     your lisp command line argument to start a specific image
     for example -core for cmucl or --core for sbcl

  --with-load-switch=arg  lisp command line argument to load a file
  --with-eval-switch=arg  lisp command line argument to eval forms
  --with-save-lisp=name   lisp function name to save a lisp image
  --with-quit-form=form   lisp form to exit your lisp system
  --with-lisp-system=feature  lisp system feature name (:cmu, :sbcl, ...)
     Use this option when your lisp system is one of the known systems
     (currently sbcl or cmucl) but its executable name is not the usual 
     one. (cmucl executable name is lisp, sbcl one is sbcl for example).

  --with-initfile=FILE    where to find your eclipse startup file
  --with-lisp=DIR or FILE where to find your lisp system
  --with-initcore=FILE    the name of the core to use when compiling
  --with-corename=FILE    what is the name of the core image to dump
  --with-coredest=DIR     what is the destination of the dumped core image
  --with-gnome-entry-dir=[PATH]  path to the gnome WM entries directory.
  --enable-compile-into-core=[yes|no]  compile to core


Notes on installation :
------------------------

Eclipse can be run in one of two different organisations. Either
eclipse is compiled into an imagefile or eclipse is compiled to fasl
files which are loaded upon startup.

The choice between the two is controlled by the configuration option
`--enable-compile-into-core'. If this option is set to "no" eclipse
will only compile to fasl files and no imagefile will be generated.

This has implications for the installation procedure. If the fasl file
organisation is used, eclipse will run off the fasl files as they were
generated in the source directory. Only in the imagefile case will the
`install' target generate a fully standalone installation that will be
independent of the source directory.

The actual values of the different eclipse specific options will be
printed out as the last thing of running the configuration script.

Core creation :
---------------

In order to run Eclipse, you need a Lisp core file that contains:

   - CLX, the Common Lisp interface to the X Window System
   - mk:defsystem, the portable, free defsystem facility or asdf, 
     the "Another System Definition Facility".


1. For CMU CL:
    Get, the file "clx-library.x86f" from an appropriate site
    (Debian, or cons.org, according to the system you are running).
   For other CL implementations, you will probably find everything you
   need from sourceforge.net under the project named CLOCC.
   (see <http://sourceforge.net/projects/clocc/>).

2. Get the mk:defsystem from sourceforge.net (the file is called defsystem.lisp)

3. Compile the file defsystem.lisp

4. Run a fresh Lisp

6. Load the compiled files for clx and defsystem.

7. Dump an image.


Here is an example of this operation for CMU CL:

CMU Common Lisp release x86-linux 2.4.22 3 October 2000 build 1154, 
running on localhost.localdomain
Send questions to cmucl-help@cons.org. and bug reports to cmucl-imp@cons.org.
Loaded subsystems:
    Python 1.0, target Intel x86
    CLOS based on PCL version:  September 16 92 PCL (f)
* (load "/usr/local/src/cmucl-2.4.22/subsystems/clx-library.x86f")

; Loading #p"/usr/local/src/cmucl-2.4.22/subsystems/clx-library.x86f".
T
* (load "/usr/local/src/cmucl-2.4.22/subsystems/defsystem-library.x86f")

; Loading #p"/usr/local/src/cmucl-2.4.22/subsystems/defsystem-library.x86f".
T
* (save-lisp "custom-lisp+clx+defsystem.core")
[Doing purification: Done.]
[Undoing binding stack... done]
[Saving current lisp image into lisp-custom.core:
Writing 20842624 bytes from the Read-Only space at 0x10000000.
Writing 2954992 bytes from the Static space at 0x28000000.
Writing 4096 bytes from the Dynamic space at 0x48000000.
done.]

Process inferior-lisp finished

Now create a symlink in your standard cmucl directory from your custom
image to lisp.core to start lisp with the new image by default.
Otherwise use the CMUCL shell option -core. (see CMUCL manual for
complete information).