Slime

Requires ECL threads.

This should work with any Slime version that plays together with ECL.

Prepare

Add to your ~/.emacs file:

(add-to-list 'load-path "~/slime/") ; slime path
(require 'slime)
(slime-setup '(slime-fancy))

Add to your ~/.swank.lisp file (or copy file eql5/slime/.swank.lisp in your home directory):
(Please note: this isn't really optional -- you need to set this option for a useful Slime + EQL.)
```
(setf swank:*globally-redirect-io* t) ; show print output in Emacs
```
Copy file eql5/slime/eql-start-swank.lisp in your slime/ directory
Optionally:
In order to indent qlet correctly, edit your slime/contrib/slime-cl-indent.el file and add a line:
```
(let* (as let)) ; already there
(qlet (as let)) ; new
```

Run

Run the swank server (the command line option -slime can be omitted if the file name contains "start-swank"), optionally passing a Lisp file:
```
eql5 <path-to-slime>/eql-start-swank.lisp [file.lisp]
```
Run Emacs and do: Meta-X slime-connect (please note: use slime-connect) and hit Return 2 times (confirming the default values).
Please note: if :dont-close is set to T in eql-start-swank.lisp, quitting/restarting Emacs will not affect a running EQL program, that is: if you quit/restart Emacs, you can connect to the same swank/EQL you left when quitting Emacs.

Loading files

If you experience slow loading of files (compared to direct loading), use qload instead of load, which will reduce all thread switches during the load process to a single one.

Another case where you need to use qload is when you use Qt classes which use threads internally (see e.g. examples/X-extras/move-blocks.lisp).

Help

For help see the qapropos, qproperties and qgui functions.

To kill the swank process (Slime), use function qquit / qq (since quitting Emacs will not kill it).

Notes

Please note that you need to manually delete the file eql5/slime/thread-safe.fas* after every upgrade of either ECL or EQL (it will then be compiled automatically next time you use Slime).

All EQL functions are wrapped in qrun* (see eql5/slime/thread-safe.lisp), so it's safe to call them either directly from the REPL or using 'eval region' (or from any other ECL thread).

If the Slime REPL hangs, you can simply try to connect again (losing the old connection): no need to restart Lisp.

This Slime mode is both convenient and simple to use, but conses a little more for every EQL function call.
If you absolutely want direct EQL function calls, please see the less convenient Slime REPL Hook mode.

How does it work?