ILISP is "free"; this means that everyone is free to use it and free to redistribute it on a free basis. ILISP is not in the public domain; it is copyrighted and there are restrictions on its distribution, but these restrictions are designed to permit everything that a good cooperating citizen would want to do. What is not allowed is to try to prevent others from further sharing any version of ILISP that they might get from you. The precise conditions appears following this section.
The easiest way to get a copy of ILISP is from someone else who has it. You need not ask for permission to do so, or tell any one else; just copy it.
If you do start using the package, please send mail to
majordomo@cons.org to subscribe to the ILISP mailing
list. (A message with subscribe ilisp in the body should suffice.)
Please send bugs, questions or suggestions for discussion to
ilisp@cons.org. Message sent there will be distributed to all
subscribers. To report a bug you can also switch to the buffer where
the problem occurs, execute the M-x ilisp-bug command and follow
the displayed instructions. See the file `HISTORY' for a list of
known bugs and problems.
You can get the distribution file, ilisp-5.9.4.tar.gz
(ilisp-5.9.4.zip) via anonymous FTP or HTML at the following
addresses:
ftp://ftp2.cons.org/pub/languages/lisp/ilisp/, or
http://www2.cons.org:8000/ftp-area/ilisp/
If you use a tty ftp client, just log in as 'anonymous'.
Please report any problems to the mailing list ilisp@cons.org.
Unpack and install:
% gzip -dc ilisp-5.9.4.tar.gz | tar xf -
or
% unzip ilisp-5.9.4.zip
See section How to install ILISP.
ILISP replaces the standard inferior Lisp mode. ILISP is based on comint mode and derived from a number of different interfaces including Symbolics, CMU Common Lisp, and Thinking Machines.
There are many people that have taken the time to report bugs, make suggestions and even better send code to fix bugs or implement new features.
Thanks to Paolo Amoroso, Martin Atzmueller, David Bakash, Guido Bosch, Tim Bradshaw, David Braunegg, Thomas M. Breuel, Rick Campbell, Hans Chalupsky, Kimball Collins, Brian Dennis, David Duff, Tom Emerson, Michael Ernst, Scott Fahlman, Karl Fogel, Paul Fuqua (for the CMU-CL GC display code), David Gadbois, Robert P. Goldman, Marty Hall, Richard Harris, Jim Healy, Christopher Hoover, Larry Hunter, Ben Hyde, Chuck Irvine, Mark Kantrowitz, Michael Kashket, Qiegang Long, Christian Lynbech, Erik Naggum, Dan Pierson, Yusuf Pisan, Frank Ritter, Jeffrey Mark Siskind, Neil Smithline, Richard Stallman, Larry Stead, Jason Trenouth, Christof Ullwer, Bjorn Victor, Fred White, Ben Wing, Matsuo Yoshihiro, Jamie Zawinski and many others for bug reports, suggestions and code. Our apologies to anyone we may have forgotten.
Special thanks to Todd Kaufmann for the texinfo file, work on bridge, epoch-pop and for really exercising everything.
Please send bug reports, fixes and extensions to
ilisp@cons.org so that they can be merged into the master
source.
--Chris McConnell 1991-03-18 --Ivan Vazquez 1993-06-27 --Marco Antoniotti and Rick Campbell 1996-10-25 --Marco Antoniotti and Paolo Amoroso 1999-08-19
ILISP is an interface from GNU Emacs to an inferior Lisp. It has the following features:
Installation of ILISP and some initialization of your computing environment are described in this chapter. Please read the following sections carefully before getting started with ILISP.
Copy the ILISP distribution archive, e.g. ilisp-5.9.4.tar.gz, to
the location where you would like to install it. Next extract the
archive (See section FTP and Web directions). You may need root privileges to
perform these operations.
Some configuration needs to be done before compiling the Emacs Lisp
files that comprise ILISP. Start with the `Makefile' file, in the
section after the comment Various variables (you can
safely ignore the variables for configuring packaging and distribution,
which are intended for maintainers).
First, set the EMACS variable to be the pathname of the
Emacs you will be using ILISP with. This is the Emacs that will be used
to compile ILISP with.
If your Emacs supports the easymenu package, it is possible to
make ILISP add to Lisp mode buffers and buffers with inferior Lisp
processes, or to Scheme mode buffers and buffers with inferior Scheme
pProcesses, an Ilisp menu with all available commands. To enable
this feature, set to t the variable
enable-ilisp-cl-easy-menu-p in `ilisp-def.el' for the Common
Lisp dialects, and enable-ilisp-scheme-easy-menu-p for Scheme
dialects. Setting these variables also causes the default Lisp
menu to be removed before displaying the Ilisp one.
See the file `INSTALLATION' for additional configuration options and known problems for specific Lisp dialects.
Run make or make compile to build ILISP from source.
Ignore any compilation warnings unless they result in ILISP not
compiling completely.
For reducing the Emacs startup time you may run make
loadfile. This concatenates all `.elc' (the compiled Emacs Lisp
files) into an `ilisp-all.elc' file and removes the `*.elc'
files. So your Emacs can load one single compiled file faster than
a bunch of smaller compiled files.
To activate ILISP you should add appropriate Emacs Lisp forms to your `.emacs' or to the system-wide `default.el' file, depending on who will be using ILISP. These forms take care of starting it whenever you access a Lisp file or run an inferior Lisp process. You can copy relevant portions of the sample file `ilisp.emacs', which also shows how to customize some ILISP features.
You should add the directory where all of the ILISP Emacs Lisp files
reside to your load-path. There is an example of this in
`ilisp.emacs'.
As an alternative you could set up a `.ilisp' which contains the appropriate portions of `ilisp.emacs', in order to avoid cluttering too much `.emacs' or `default.el'.
The first time a dialect is started, the interface files will complain
about not being compiled, just ignore the message. Once a Lisp dialect
is started up, you should execute the command ilisp-compile-inits
which will compile the `*.lisp' files and write them to the same
directory as the ILISP files.
The binary files should have a unique
extension for each different combination of architecture and
Lisp dialect. You will need to change
ilisp-init-binary-extension and
ilisp-init-binary-command to get additional
extensions. The binary for each different architecture
should be different. If you want to build the interface
files into a Lisp world, you will also need to set
ilisp-load-inits to nil in the same place that
you change ilisp-program to load the Lisp
world.
There is an ilisp-site-hook for initializing site specific stuff
like program locations when ILISP is first loaded. You may want to
define appropriate autoloads in your system Emacs start up
file.
Example site init:
;;; CMU site
(setq ilisp-site-hook
'(lambda ()
(setq ilisp-motd "CMU ILISP V%s")
(setq expand-symlinks-rfs-exists t)
(setq allegro-program "/usr/local/acl5/lisp")
(setq lucid-program "/usr/misc/.lucid/bin/lisp")))
Kent Pitman and The Harlequin Group Ltd. have made publicly available on the Web the Common Lisp HyperSpec, an HTML version of the full text of the ANSI Common Lisp specification. Daniel Barlow, Stephen Carney and Erik Naggum independently developed Emacs Lisp packages for looking up Lisp symbols in the HyperSpec and displaying the relevant sections with a Web browser. ILISP includes all of them in the `extra' directory of the distribution tree. By default ILISP uses Naggum's package. If you want to use one of the others, see the comments at the beginning of the corresponding files.
The `ilisp.emacs' file provides sample instructions for making
Naggum's package access a local copy of the HyperSpec. Since the package
relies on the browse-url Emacs package, make sure that the latter
is properly configured.
Previous versions of ILISP provided commands for accessing the online
Common Lisp documentation shipped with Franz Inc.'s Allegro CL product
(fi:clman module). The public availability of the HyperSpec, and
the inclusion since version 5.9 of ILISP of the hyperspec
packages, make access to the Franz documentation no longer necessary. So
by default ILISP does not load the fi:clman module, but if you
still want to use its commands set the
ilisp-*use-fi-clman-interface-p* to t in
`ilisp-def.el'.
The ILISP documentation consists of a user manual and a reference card (the latter may not be up to date). Both of them are in the `docs' directory of the distribution tree.
The generation of GNU Info, DVI, PostScript and HTML versions of the
manual from the Texinfo source is controlled by the `Makefile' in
the `docs' directory. Run make docs or just make to
generate all of the formats. If you are interested in only some of them
then issue the appropriate command: make info for GNU Info,
make dvi for DVI, make ps for PostScript and make
html for HTML. To remove the intermediate files produced during the
generation of DVI output you can run make tmpclean.
The ILISP reference card is available in DVI and PostScript formats together with the TeX source. Check the comments at the beginning of the TeX source if you need to generate a version with a different number of columns.
The files included with the ILISP distribution are:
ilisp-lispm-bindings.
To start a Lisp use M-x run-ilisp, or a specific dialect like M-x allegro. If called with a prefix you will be prompted for a buffer name and a program to run. The default buffer name is the name of the dialect. The default program for a dialect will be the value of DIALECT-program or the value of ilisp-program inherited from a less specific dialect. If there are multiple Lisp's, use the dialect name or M-x select-ilisp (C-z S) to select the current ILISP buffer.
Entry into ILISP mode runs the hooks on comint-mode-hook and
ilisp-mode-hook and then DIALECT-hooks specific to Lisp
dialects in the nesting order above. Many dialects call
ilisp-load-init in their dialect setup.
These are the currently supported dialects.
allegro
Allegro Common Lisp from Franz Inc.
akcl
Austin Kyoto Common Lisp, the U. Texas derivative.
chez
Chez Scheme by Cadence Research Systems.
clisp-hs
CLISP by Haible and Stoll.
cmucl
CMU Common Lisp, the major development platform for ILISP so far.
common-lisp
Generic Common Lisp.
ecl
EcoLisp, the Embeddable Common Lisp by Beppe Attardi. A derivative of
KCL and AKCL.
gcl
GNU Common Lisp, the official GNU release. A derivative of AKCL.
guile
GUILE Scheme by the GNU Project.
ibcl
Ibuki Common Lisp, derived from KCL.
kcl
Kyoto Common Lisp, original version.
liquid
Liquid Common Lisp, the successor of Lucid Common Lisp supported by
Harlequin Ltd.
lispworks
LispWorks Common Lisp from Harlequin Ltd.
lucid
Lucid Common Lisp, currently supported by Harlequin Ltd.
oaklisp
Oaklisp scheme.
sblisp
SB Common Lisp
scheme
Generic Scheme.
scm
SCM Scheme by Aubrey Jeffer.
snow
Snow, STk Scheme without supoort for the Tk toolkit.
stk
STk scheme by Erick Gallesio.
xlisp
XLisp by David Betz.
xlispstat
XLisp-Stat, a derivative of XLisp for statistical computations.
Support for Scheme and XLisp dialects is experimental and your feedback is welcome. The `ilisp-s2c.el' file contains a first cut at defining the Scheme->C dialect, but it is neither compiled nor loaded by ILISP.
To define a new dialect, See section Defining new dialects and See section ILISP Customization. If anyone figures out support for other dialects, I would be happy to include it in future releases. See section Dialects.
The currently supported dialects are listed below so that the indentation correponds to the hierarchical relationship between dialects:
common-lisp
allegro
clisp-hs
cmulisp
kcl
akcl
gcl
ecl
ibcl
lispworks
lucid
liquid
sblisp
scheme
chez
guile (yep! Here it comes. Still incomplete though)
oaklisp
Scheme->C (still "in fieri")
scm
snow
stk
xlisp
xlispstat
By default, most ILISP commands are bound under the prefix key C-z. Unfortunately, these bindings predate the modern FSF Emacs keyspace policies, which stipulate that packages should use C-c as a prefix, and bind only control characters, digits, and a few specific punctuation chars under that prefix.
If you are already accustomed to the old ILISP bindings, don't worry -- we haven't changed the default. However, for new users who don't have old habits to unlearn, ILISP offers FSF-compliant bindings as an alternative to the default. To be compliant (and who wouldn't want to be compliant?), put this line in your `.emacs' or in the system-wide `default.el' file:
(setq ilisp-*use-fsf-compliant-keybindings* t)
This will cause the ILISP prefix key to be C-c, and also change some of the bindings underneath that prefix. After you do this, ILISP will be almost fully FSF-compliant; there are still a few bindings that technically violate the FSF policy, but we left them as they were because we judged that changing them would not have been an improvement.
Because the rest of this document was originally written for the old, default ILISP bindings, you'll need to make some mental translations if you choose FSF-compliance:
Where possible, the new bindings follow the above rules, but note that some exceptions were necessary. Most notably, the old C-c * bindings are all under C-c 8 now. The remaining exceptions are probably best discovered through regular use, as they tend to occur on obscure keys anyway. Remember that you can type C-h m at any time to see help on the current major mode, which will show (among other things) a list of all currently active keybindings.
*dialect*
lisp-mode-buffers
lisp-source-modes. If it's loaded into a buffer that is
in one of these major modes, it's considered a Lisp source file by
find-file-lisp, load-file-lisp and
compile-file-lisp.
Used by these commands to determine defaults.
*Completions**Aborted Commands*
*Errors*
*Output*
*Error Output*
*ilisp-send*
*Edit-Definitions*
*All-Callers*
*Last-Changes*
*Changed-Definitions*
All ILISP output is funneled through the function which is bound to
the hook ilisp-display-output-function. The function gets
a single argument, a string, and should make that output visible to
the user somehow.
One possible choice for output display is
ilisp-display-output-in-typeout-window,
which pops up a window at the top of the current screen which is
just large enough to display the output. This window can be
"remotely controlled" by the commands ilisp-scroll-output,
ilisp-bury-output, and ilisp-grow-output.
Unlike the old popper facility, the ilisp typeout window facility does not trounce on any existing Emacs functions or on any common key bindings, like C-x o.
Other built-in functions which might be useful as values for
ilisp-display-output-function include
ilisp-display-output-default,
ilisp-display-output-adaptively,
ilisp-display-output-in-lisp-listener,
ilisp-display-output-in-temp-buffer, and
ilisp-display-output-in-typeout-window.
The default display function is ilisp-display-output-default,
which obeys the lisp-no-popper variable.
Users are encouraged to write their own output display functions to get the exact desired behavior, displaying on a private Emacs screen, in a pop-up dialog box, or whetever.
An alternative to typeout windows is to always have the inferior Lisp
buffer visible and have all output go there. Setting
lisp-no-popper to t will cause all output to go to the
inferior Lisp buffer. Setting lisp-no-popper to 'message
will make output of one line go to the message window. Setting
comint-always-scroll to t will cause process output to
always be visible. If a command gets an error, you will be left in the
break loop.
Commands to make switching between buffers easier.
pop-up-windows to nil.
Most of these key bindings work in both Lisp Mode and ILISP mode. There are a few additional and-go bindings found in Lisp Mode.
In Lisp, the major unit of interest is a form, which is anything between two matching parentheses. Some of the commands here also refer to "defun," which is a list that starts at the left margin in a Lisp buffer, or after a prompt in the ILISP buffer. These commands refer to the "defun" that contains the point.
"A call" refers to a reference to a function call for a function or macro, or a reference to a variable. Commands which "insert a call" in the ILISP buffer will bring up the last command which matches it or else will insert a template for a call.
When an eval is done of a single form matching ilisp-defvar-regexp
the corresponding symbol will be unbound and the value assigned again.
When you send a form to Lisp, the status light will reflect the progress
of the command. In a Lisp mode buffer the light will reflect the status
of the currently selected inferior Lisp unless lisp-show-status
is nil. The very first inferior Lisp command executed may send some
forms to initialize the inferior Lisp. If you want to find out what
command is currently running, use the command C-z s
(status-lisp). If you call it with a prefix, the pending commands will
be displayed as well.
Note that in this table as elsewhere, the key C-z (ilisp-*prefix*) is used as a prefix character for ILISP commands, though this may be changed. For a full list of key-bindings, use M-x describe-mode or M-x describe-bindings while in an ILISP-mode buffer.
The eval/compile commands verify that their expressions are balanced and then send the form to the inferior Lisp. If called with a positive prefix, the result of the operation will be inserted into the buffer after the form that was just sent.
For commands which operate on a region, the result of the compile or eval is the last form in the region.
The `and-go' versions will perform the operation and then
immediately switch to the ILISP buffer where you will see the results of
executing your form. If eval-defun-and-go-lisp or
compile-defun-and-go-lisp is called with a prefix, a call for the
form will be inserted as well.
ilisp-*prefix*.
compile-defun-lisp is called in an inferior Lisp buffer with
no current form, the last form typed to the top-level will be compiled.
If any of the forms contain an interactive command, then the command
will never return. To get out of this state, you need to use
abort-commands-lisp (C-z g). If lisp-wait-p
is t, then EMACS will display the result of the command in the
minibuffer or a pop-up window. If lisp-wait-p is nil,
(the default) the send is done asynchronously and the results will be
brought up only if there is more than one line or there is an error. In
this case, you will be given the option of ignoring the error, keeping
it in another buffer or keeping it and aborting all pending sends. If
there is not a command already running in the inferior Lisp, you can
preserve the break loop. If called with a negative prefix, the sense of
lisp-wait-p will be inverted for the next command.
describe-lisp, inspect-lisp, arglist-lisp, and
documentation-lisp switch whether they prompt for a response or
use a default when called with a negative prefix. If they are
prompting, there is completion through the inferior Lisp by using
TAB or M-TAB. When entering an expression in the
minibuffer, all of the normal ILISP commands like arglist-lisp
also work.
Commands that work on a function will use the nearest previous function symbol. This is either a symbol after a `#'' or the symbol at the start of the current list.
The fi:clman and fi:clman-apropos commands for accessing
the Franz Allegro CL documentation are not enabled by default.
See section Configuration and compilation.
C-z a (arglist-lisp)
SPC (ilisp-arglist-message-lisp-space)
ilisp-*arglist-message-lisp-space-p* to t.
C-z d (documentation-lisp)
C-z i (describe-lisp)
C-z I (inspect-lisp)
C-z H (hyperspec-lookup)
C-z D (fi:clman)
C-z A (fi:clman-apropos)
fi:clman-apropos will get information apropos
a specific string. Some of the documentation is specific to the Allegro
dialect, but most of it is for standard Common Lisp.
The first time an inferior Lisp mode command is executed in a Lisp Mode
buffer, the package will be determined by using the regular expression
ilisp-package-regexp to find a package sexp and then passing that
sexp to the inferior Lisp through ilisp-package-command. For the
`common-lisp' dialect, this will find the first (in-package
PACKAGE) form in the file. A buffer's package will be displayed in the
mode line. If a buffer has no specification, forms will be evaluated in
the current inferior Lisp package.
Buffer package caching can be turned off by setting the variable
lisp-dont-cache-package to T. This will force ILISP to
search for the closest previous ilisp-package-regexp in the
buffer each time an inferior Lisp mode command is executed.
C-z P (set-package-lisp)
C-z p (set-buffer-package-lisp)
The following commands all deal with finding things in source code. The first time that one of these commands is used, there may be some delay while the source module is loaded. When searching files, the first applicable rule is used:
lisp-source-modes or all files
defined using lisp-directory.
M-x lisp-directory defines a set of files to be
searched by the source code commands. It prompts for a directory and
sets the source files to be those in the directory that match entries
in auto-mode-alist for modes in lisp-source-modes.
With a positive
prefix, the files are appended. With a negative prefix, all current
buffers that are in one of lisp-source-modes will be searched. This
is also what happens by default. Using this command stops using a
tags file.
edit-definitions-lisp, who-calls-lisp, and
edit-callers-lisp will switch whether they prompt for a response
or use a default when called with a negative prefix. If they are
prompting, there is completion through the inferior Lisp by using
TAB or M-TAB. When entering an expression in the
minibuffer, all of the normal ILISP commands like arglist-lisp
also work.
edit-definitions-lisp (M-.) will find a
particular type of definition for a symbol. It tries to use the rules
described above. The files to be searched are listed in the buffer
*Edit-Definitions*. If lisp-edit-files is nil, no search will be
done if not found through the inferior Lisp. The variable
ilisp-locator contains a function that when given the name and type
should be able to find the appropriate definition in the file. There
is often a flag to cause your Lisp to record source files that you
will need to set in the initialization file for your Lisp. The
variable is *record-source-files* in both allegro and lucid. Once a
definition has been found, next-definition-lisp
(M-,) will find the next definition
(or the previous definition with a prefix).
edit-callers-lisp (C-z ^) will generate a list of all
of the callers of a function in the current inferior Lisp and edit the
first caller using edit-definitions-lisp. Each successive call to
next-caller-lisp (M-`) will edit the next caller
(or the previous caller with a prefix). The list is stored in the
buffer *All-Callers*. You can also look at the callers by doing
M-x who-calls-lisp.
search-lisp (M-?) will search the current tags files,
lisp-directory files or buffers in one of lisp-source-modes for a
string or a regular expression when called with a prefix.
next-definition-lisp (M-,) will find the next definition
(or the previous definition with a prefix).
replace-lisp (M-") will replace a string (or a regexp with
a prefix) in the current tags files, lisp-directory files or
buffers in one of lisp-source-modes.
Here is a summary of the above commands (behavior when given prefix argument is given in parentheses):
M-x lisp-directory
M-. (edit-definitions-lisp)
M-, (next-definition-lisp)
C-z ^ (edit-callers-lisp)
M-` (next-caller-lisp)
edit-callers-lisp.
M-x who-calls-lisp
M-? (search-lisp)
lisp-directory files or buffers. Use next-definition-lisp
to find next occurence.
M-" (replace-lisp)
The following commands all deal with making a number of changes all at once. The first time one of these commands is used, there may be some delay as the module is loaded. The eval/compile versions of these commands are always executed asynchronously.
mark-change-lisp (C-z SPC) marks the current defun as
being changed. A prefix causes it to be unmarked. clear-changes-lisp
(C-z * 0) will clear all of the changes.
list-changes-lisp (C-z * l) will show the forms
currently marked.
eval-changes-lisp (C-z * e), or
compile-changes-lisp (C-z * c) will
evaluate or compile these changes as appropriate.
If called with a positive prefix, the changes will be kept.
If there is an error, the process will stop and show the error
and all remaining changes will remain in the list. All of the results
will be kept in the buffer *Last-Changes*.
Summary:
C-z SPC (mark-change-lisp)
C-z * e (eval-changes-lisp)
C-z * c (compile-changes-lisp)
C-z * 0 (clear-changes-lisp)
C-z * l (list-changes-lisp)
File commands in Lisp source-mode buffers keep track of the last used
directory and file. If the point is on a string, that will be the
default if the file exists. If the buffer is one of
lisp-source-modes, the buffer file will be the default. Otherwise,
the last file used in a lisp-source-mode will be used.
default-directory to the Lisp default directory.
There are two keyboard modes for interacting with the inferior Lisp, "interactive" and "raw". Normally you are in interactive mode where keys are interpreted as commands to EMACS and nothing is sent to the inferior Lisp unless a specific command does so. In raw mode, all characters are passed directly to the inferior Lisp without any interpretation as EMACS commands. Keys will not be echoed unless ilisp-raw-echo is T.
Raw mode can be turned on interactively by the command
raw-keys-ilisp (C-z #) and will continue until you
type C-g. Raw mode can also be turned on/off by inferior Lisp
functions if the command io-bridge-ilisp (M-x io-bridge-ilisp)
has been executed in the inferior Lisp either interactively or on a
hook. To turn on raw mode, a function should print ^[1^] and to turn
it off should print ^[0^]. An example in Common Lisp would be:
(progn (format t "1 ") (print (read-char)) (format t "0 "))
If you want to abort the last command you can use C-g.
If you want to abort all commands, you should use the command
abort-commands-lisp (C-z g). Commands that are
aborted will be put in the buffer *Aborted Commands* so that
you can see what was aborted. If you want to abort the currently
running top-level command, use interrupt-subjob-ilisp (C-c
C-c). As a last resort, M-x panic-lisp will reset the ILISP
state without affecting the inferior Lisp so that you can see what is
happening.
delete-char-or-pop-ilisp (C-d) will delete
prefix characters unless you are at the end of an ILISP buffer in
which case it will pop one level in the break loop.
reset-ilisp, (C-z z) will reset the current inferior
Lisp's top-level so that it will no longer be in a break loop.
Summary:
If lisp-wait-p is nil (the default),
all sends are done asynchronously and the results will be
brought up only if there is more than one line or there is an error.
In case, you will be given the option of ignoring the error, keeping
it in another buffer or keeping it and aborting all pending sends.
If there is not a command already running in the inferior Lisp, you can
preserve the break loop. If called with a negative prefix, the sense of
lisp-wait-p will be inverted for the next command.
ILD is an interface to Lisp debuggers, currently the ones of the AKCL, Allegro, CLISP, CMU CL and Lucid Common Lisp dialects. It uses a standard set of single-keystroke commands to interface to a variety of different debuggers and is vaguely modelled after the Symbolics debugger. It provides two key advantages: single keystrokes for moving up and down the stack, and a uniform interface to different debuggers.
Not all debugger commands are available in all implementations. Some are, but further work is needed. These are noted in the code (see the dialect definition files). If you know how to fix them please contact the ILISP maintainer.
Here is a list of the available ILD commands:
ILISP mode is built on top of comint-mode, the general
command-interpreter-in-a-buffer mode. As such, it inherits many
commands and features from this, including a command history mechanism.
Each ILISP buffer has a command history associated with it. Commands
that do not match ilisp-filter-regexp and that are longer than
ilisp-filter-length and that do not match the immediately prior
command will be added to this history.
See comint-mode documentation for more information on
`comint' commands.
Commands to reduce number of keystrokes.
ilisp-*prefix-match* is set to t.
(If you set it to t, inferior Lisp completions will be faster.)
With partial completion, `p--n' would complete to
`position-if-not' in Common Lisp.
If the symbol follows a left paren or a `#'', only symbols with
function cells will be considered.
If the symbol starts with a `*' or you call with a
positive prefix all possible completions will be considered.
Only external symbols are considered if there is a package qualification
with only one colon.
The first time you try to complete a string the longest common substring
will be inserted and the cursor will be left
on the point of ambiguity.
If you try to complete again, you can see the possible completions.
If you are in a string, then filename completion will be done instead.
And if you try to complete a filename twice, you will see a list of
possible completions.
Filename components are completed individually, so `/u/mi/' could
expand to `/usr/misc/'.
If you complete with a negative
prefix, the most recent completion (symbol or filename) will be undone.
Indentation, parenthesis balancing, movement and comment commands.
comint-prompt-regexp or
ilisp-other-prompt or to the left margin with a prefix.
comment-start before and
comment-end's after the lines in region. To uncomment a region,
use a minus prefix.
Starting a dialect runs the hooks on comint-mode-hook
and ilisp-mode-hook and then DIALECT-hooks specific
to dialects in the nesting order below.
common-lisp
allegro
clisp-hs
cmulisp
kcl
akcl
gcl
ecl
ibcl
lispworks
lucid
liquid
sblisp
scheme
chez
guile (yep! Here it comes. Still incomplete though)
oaklisp
Scheme->C (still "in fieri")
scm
snow
stk
xlisp
xlispstat
On the very first prompt in the inferior Lisp,
the hooks on ilisp-init-hook are run. For more information on
creating a new dialect or variables to set in hooks, see `ilisp.el'.
ilisp-site-hook
ilisp-load-hook
ilisp-mode-hook
ilisp-init-hook
DIALECT-hook
Variables you might want to set in a hook or dialect:
ilisp-*prefix*
ilisp-program
ilisp-motd
lisp-wait-p
t for synchronous sends
ilisp-handle-errors
t for ilisp to handle errors from the underlying Lisp.
ilisp-display-output-function
lisp-no-popper
t to have all output in inferior Lisp
ilisp-*use-frame-for-output*
t (default) to have multiline output in a distinct emacs-frame.
ilisp-*use-frame-for-arglist-output-p*
t (default) to have multiline arglist-output in a seperate
emacs-frame.
ilisp-bindings-*bind-space-p*
t to have the SPC-key bound to #'ilisp-arglist-message-lisp-space.
ilisp-*arglist-message-lisp-space-p*
t to display the arglist of the current function displayed,
after you hit SPC.
ilisp-*enable-imenu-p*
t to enable ilisp-imenu, that provides an index of all
lisp-functions/definitions in a file.
lisp-show-status
nil to stop showing process status
ilisp-*prefix-match*
t if you do not want partial completion
ilisp-filter-regexp
ilisp-filter-length
ilisp-other-prompt
A dialect of Lisp is a specific implementation. For the parts of Common Lisp which are well specified, they are usually the same. For the parts that are not (debugger, top-level loop, etc.), there is usually the same functionality but different commands.
ILISP provides the means to specify these differences so that the ILISP commands will use the specific command peculiar to an implementation, but still offer the same behavior with the same interface.
To define a new dialect use the macro defdialect. For examples,
look at the dialect definitions in `ilisp-acl.el',
`ilisp-cmu.el', `ilisp-kcl.el', `ilisp-luc.el'. There are
hooks and variables for almost anything that you are likely to need to
change. The relationship between dialects is hierarchical with the root
values being defined in setup-ilisp. For a new dialect, you only
need to change the variables that are different than in the parent
dialect.
Basic tools for creating new commands:
deflocal
ilisp-dialect
lisp-symbol
lisp-symbol-name
lisp-symbol-delimiter
lisp-symbol-package
lisp-string-to-symbol
lisp-symbol-to-string
lisp-buffer-symbol
lisp-previous-symbol
lisp-previous-sexp
lisp-def-name
lisp-function-name
ilisp-read
ilisp-read-symbol
ilisp-completing-read
Notes:
ilisp-send to send a
message to the inferior Lisp.
eval-region-lisp or
compile-region-lisp.
*Aborted Commands* buffer, *Aborted Commands* buffer
*All-Callers* buffer, *All-Callers* buffer
*Changed-Definitions* buffer
*Completions* buffer
*Edit-Definitions* buffer, *Edit-Definitions* buffer
*Error Output* buffer
*Errors* buffer
*ilisp-send* buffer
*Last-Changes* buffer, *Last-Changes* buffer
*Output* buffer
browse-url
comint-mode
easymenu package
Ilisp menu
Lisp menu
Commands available via M-x prefix.
Variables and hooks of ILISP.
enable-ilisp-cl-easy-menu-p
enable-ilisp-scheme-easy-menu-p
Internal functions of ILISP which can be used to write new commands.
This document was generated on 19 April 2001 using the texi2html translator version 1.51.