This is ilisp.info, produced by makeinfo version 4.6 from ilisp.texi.

INFO-DIR-SECTION Lisp Programming
START-INFO-DIR-ENTRY
* ILisp: (ilisp).       Inferior Lisp mode.
END-INFO-DIR-ENTRY

   This file documents ILISP.

   This is edition 0.23 of the ILISP manual for ILISP Version: 5.12

     Copyright (C) 1991,1992,1993 Todd Kaufmann
                   1993,1994 Ivan Vasquez
                   1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
                   1996, 1997, 1998, 1999 Marco Antoniotti and Rick Campbell

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.


File: ilisp.info,  Node: Top,  Next: Distribution,  Prev: (dir),  Up: (dir)

   This Info file documents ILISP, a GNU Emacs interface for a Lisp
running in a buffer.

* Menu:

* Distribution::                How to get the latest ILISP distribution.

* Acknowledgements::            Acknowledgements
* Introduction::                An introduction to ILISP and its features.
* Installation::                How to install ILISP.
* Starting up::                 How to run a Lisp process using ILISP.

* Keybindings::                 A word about the keys used by ILISP.
* Buffers of ILISP::            Buffers used by ILISP, and their commands.
* ILISP Commands::
* Customization::               Description of ILISP variables and hooks.
* Dialects::                    How ILISP knows how to communicate with Lisp,
                                    and how to define new dialects.

Indices:
* Concept index::               General concepts.
* Key index::                   ILISP key sequences.
* Command index::               Commands by name.
* Variable index::              Variables and hooks that influence ILISP's
								   behavior.

* Function index::              Internal Emacs Lisp functions.


File: ilisp.info,  Node: Distribution,  Next: Acknowledgements,  Prev: Top,  Up: Top

How to get the latest ILISP distribution.
*****************************************

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.

   General information on ILISP is available at:
     http://ilisp.cons.org/

   The project site, which provides access to the CVS source tree, bug
database, mailing lists and other resources, is hosted at SourceForge:
     http://sourceforge.net/projects/ilisp/

   The following mailing lists are available:
`ilisp-announce'
     Subscribe to this list if you want to receive public announcements
     regarding ILISP.

`ilisp-devel'
     This is the list for people who want to be actively involved in the
     development of ILISP.

`ilisp-help'
     This is the list for asking usage questions regarding ILISP.

`ilisp-cvs'
     Subscribe to this list _only_ if you want to monitor the CVS
     repository activity.

   You can subscribe to the lists and access the archives via the
general information pages:
   * `http://lists.sourceforge.net/mailman/listinfo/ilisp-announce'

   * `http://lists.sourceforge.net/mailman/listinfo/ilisp-devel'

   * `http://lists.sourceforge.net/mailman/listinfo/ilisp-help'

   * `http://lists.sourceforge.net/mailman/listinfo/ilisp-cvs'

   You may send bug reports, questions, suggestions, etc. to
`ilisp-help' or `ilisp-devel'.  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.

* Menu:

* FTP and Web directions::              FTP and Web directions


File: ilisp.info,  Node: FTP and Web directions,  Up: Distribution

FTP and Web directions
======================

You can get the distribution file, `ilisp-x.y.z.tar.gz'
(`ilisp-x.y.z.zip'), via HTTP or anonymous FTP at the following
addresses:

   * `http://sourceforge.net/project/showfiles.php?group_id=3957'

   * `http://www2.cons.org:8000/ftp-area/ilisp/'

   * `ftp://ftp2.cons.org/pub/languages/lisp/ilisp/'


   If you use a tty ftp client, just log in as 'anonymous'.

   Please report any problems to the `ilisp-help' mailing list.  *Note
Distribution::.

Unpack and install:

   `% "gzip -dc ilisp-x.y.z.tar.gz | tar xf -"'

or

   `% "unzip ilisp-x.y.z.zip"'

   *Note Installation::.


File: ilisp.info,  Node: Acknowledgements,  Next: Introduction,  Prev: Distribution,  Up: Top

Acknowledgements
****************

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, Daniel
Barlow, Guido Bosch, Tim Bradshaw, David Braunegg, Thomas M. Breuel,
Craig Brozefsky, Rick Campbell, Hans Chalupsky, Kimball Collins,
William Deakin, 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, Utz-Uwe
Haus, Jim Healy, Matthias Hoelzl, Christopher Hoover, Larry Hunter, Ben
Hyde, Chuck Irvine, Mark Kantrowitz, Michael Kashket, Matthias Koeppe,
Qiegang Long, Christian Lynbech, Erik Naggum, Dan Pierson, Yusuf Pisan,
Frank Ritter, Ole Rohne, Jeffrey Mark Siskind, Neil Smithline, Richard
Stallman, Larry Stead, Jason Trenouth, Christof Ullwer, Reini Urban,
Bjorn Victor, Edmund Weitz, 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 the `ilisp-devel'
mailing list so that they can be merged into the master source. *Note
Distribution::.

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


File: ilisp.info,  Node: Introduction,  Next: Installation,  Prev: Acknowledgements,  Up: Top

Introduction
************

ILISP is an interface from GNU Emacs to an inferior Lisp.  It has the
following features:

   * Runs under Emacs-18, Emacs-19, Emacs-20, and XEmacs-19.

   * Support for multiple Common Lisp (including Allegro, CLISP and
     CMU), XLisp and Scheme dialects on multiple machines even at the
     same time.

   * Dynamically sized pop-up windows that can be buried and scrolled
     from any window.

   * Packages are properly handled including the distinction between
     exported and internal symbols.

   * Synchronous, asynchronous or batch eval and compile of files,
     regions, definitions and sexps with optional switching and
     automatic calling.

   * Arglist, documentation, describe, inspect and macroexpand.

   * Completion of filename components and Lisp symbols including
     partial matches.

   * Find source both with and without help from the inferior Lisp,
     including CLOS methods, multiple definitions and multiple files.

   * Edit the callers of a function with and without help from the
     inferior Lisp.

   * Trace/untrace a function.

   * `M-q' ("Fill-paragraph") works properly on paragraphs in comments,
     strings and code.

   * Find unbalanced parentheses.

   * Super brackets.

   * Handles editing, entering and indenting full Lisp expressions.

   * Next, previous, and similar history mechanism compatible with
     comint.

   * Handles Lisp errors.

   * Uniform interface to Lisp debuggers.

   * Result histories are maintained in the inferior Lisp.

   * Does not create spurious symbols and handles case issues.

   * Online manuals for ILISP and Common Lisp.



File: ilisp.info,  Node: Installation,  Next: Starting up,  Prev: Introduction,  Up: Top

How to install ILISP
********************

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-x.y.z.tar.gz', to
the location where you would like to install it. Next extract the
archive, see *Note FTP and Web directions::. You may need root
privileges to perform these operations.

* Menu:

* Configuration and compilation::
* Files of ILISP::


File: ilisp.info,  Node: Configuration and compilation,  Next: Files of ILISP,  Up: Installation

Configuration and compilation
=============================

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. Be sure to check that `LN' and `HyperSpec' have appropriate
values for your system, *especially if you are a Windows user*.

   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
processes, an `Ilisp' menu with all available commands. To enable this
feature, set to `t' the variable `ilisp-*enable-cl-easy-menu-p*' in
`ilisp-def.el' for the Common Lisp dialects, and
`ilisp-*enable-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. If you are a Windows user, and you don't have GNU `make',
you can still compile ILISP by running the `icompile.bat' batch file
(be sure to customize for your system the variables mentioned by the
comment at the top).

   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 Xanalys Inc. have made publicly available on the Web
the Common Lisp HyperSpec, an HTML version of the full text of the ANSI
Common Lisp specification:
     http://www.xanalys.com/software_tools/reference/HyperSpec/
   It is also possible to get a local copy of the HyperSpec, whose
latest version is currently v6, by downloading the file
`HyperSpec-6-0.tar.gz' from the above mentioned site.

   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 used to
include all of them in the `extra' directory of the distribution tree.
However, because of some changes to the CLHS only Erik Naggum's version
is now distributed.  If you want to use one of the others, please
contact the other authors.

   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.

   Digital Press has made publicly available online, as a service to the
Lisp community, the full text of the book "Common Lisp, The Language"
(by Guy L. Steele Jr., 2nd edition, Digital Press, 1990, ISBN
1-55558-041-6; a.k.a. "CLtL2") in a number of formats, including HTML.
ILISP provides support, contributed by Utz-Uwe Haus, for looking up Lisp
symbols in the HTML version of the book and displaying the relevant
sections with a Web browser.  See the file `extra/cltl2.el' for more
information on configuring this feature. *Note Documentation
functions::, for usage instructions.

   The `ilisp.emacs' file provides sample instructions for making
ILISP's CLtL2 support access a local copy of the book.  What has been
said above about `browse-url' configuration also applies to CLtL2
lookup.

   Note that, althouth Steele's book is a well written and useful
resource, it covers the Common Lisp language in the state it was a few
years before ANSI standardization.  If you need an accurate description
of ANSI Common Lisp, see the above mentioned HyperSpec instead.

   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
documentation from the Texinfo and TeX 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'. Note that some of the output
formats may not be supported for certain documents.

   The ILISP reference card is available as a TeX source file. Check the
comments at the beginning of the file if you need to generate a version
with a different number of columns (the default is 3).


File: ilisp.info,  Node: Files of ILISP,  Prev: Configuration and compilation,  Up: Installation

Files of ILISP
==============

The files included with the ILISP distribution are:

`bridge.el'
     Process to process communication.

`comint-ipc.el'
     Extensions for sending commands and getting results.

`comint-v18.el'
     The basic comint abstraction.  You only need this if running
     Emacs-18.

`completer.el'
     Partial completion code.

`custom-ilisp.el'
     ILISP customization.

`docs/'
     Directory containing the documentation.

`extra/'
     Directory containing contributed packages.

`icompile.bat'
     Windows batch file for compiling ILISP (useful if you don't have
     GNU `make').

`ilcompat.el'
     Compatibility code between FSF-18, FSF-19, FSF-20, LEmacs-19 and
     XEmacs.

`ild.el'
     Uniform interface to Lisp debuggers.

`ilfsf18.el'
     Support for GNU Emacs v18.

`ilfsf19.el'
     Support for GNU Emacs v19.

`ilfsf20.el'
     Support for GNU Emacs v20.

`ilisp-acl.el'
     Allegro Common Lisp dialect definition.

`ilisp-aut.el'
     Autoload definitions.

`ilisp-bat.el'
     ILISP batch code module.

`ilisp-bug.el'
     ILISP bug submittal code.

`ilisp-ccl.el'
     Corman Common Lisp dialect definition.

`ilisp-chs.el'
     Haible and Stoll's CLISP Common Lisp dialect definition.

`ilisp-cl-easy-menu.el'
     ILISP menu definition (Common Lisp dialects) for the Easymenu
     package.

`ilisp-cl.el'
     Common Lisp dialect definition.

`ilisp-cmp.el'
     ILISP completer related code.

`ilisp-cmt.el'
     Comint related code/setup.

`ilisp-cmu.el'
     CMU CL Common Lisp dialect definition.

`ilisp-def.el'
     Variable definitions.

`ilisp-dia.el'
     Code for customizing dialects

`ilisp-doc.el'
     ILISP mode documenation.

`ilisp-ext.el'
     Standalone lisp-mode extensions.

`ilisp-hi.el'
     High level interface code.

`ilisp-hlw.el'
     Xanalys/Harlequin LispWorks Common Lisp dialect definition.

`ilisp-hnd.el'
     Error handling.

`ilisp-imenu.el'
     ILISP specific code for imenu.

`ilisp-ind.el'
     Indentation code.

`ilisp-inp.el'
     Buffer input module.

`ilisp-kcl.el'
     Kyoto Common Lisp dialect definition.

`ilisp-key.el'
     Keymap setups, including `ilisp-lispm-bindings'.

`ilisp-kil.el'
     Interface to reset/kill/abort inferior Lisp.

`ilisp-low.el'
     Low level interface code.

`ilisp-luc.el'
     Lucid/Liquid Common Lisp dialect definition.

`ilisp-mak.el'
     Code for supporting the ILISP build process.

`ilisp-menu.el'
     Menu definitions.

`ilisp-mnb.el'
     Menubar definition code.

`ilisp-mod.el'
     ILISP mode definition.

`ilisp-mov.el'
     Buffer-point movement code.

`ilisp-openmcl.el'
     OpenMCL dialect definition.

`ilisp-out.el'
     Output handling, include typeout window (a popper replacement).

`ilisp-prc.el'
     Process handling code.

`ilisp-prn.el'
     Parenthesis handling.

`ilisp-rng.el'
     Match ring code.

`ilisp-s2c.el'
     Scheme->C Scheme dialect definition.

`ilisp-sbcl.el'
     Steel Bank Common Lisp dialect definition.

`ilisp-sch.el'
     Scheme dialects definitions.

`ilisp-scheme-easy-menu.el'
     ILISP menu definition (Scheme dialects) for the Easymenu package.

`ilisp-snd.el'
     ilisp-send definitions and associated code.

`ilisp-src.el'
     ILISP source code module.

`ilisp-sym.el'
     ILISP symbol handling.

`ilisp-utl.el'
     Misc. utilities.

`ilisp-val.el'
     Buffer value interface.

`ilisp-xfr.el'
     Transfer between Lisp <-> Emacs code.

`ilisp-xls.el'
     XLisp and XLisp-Stat dialects definitions.

`ilisp.el'
     File to be loaded, loads in all necessary parts of ILISP.

`ilisp.emacs'
     File with sample `.emacs' code for ILISP.

`ilisp.texi'
     Texinfo file for ILISP.

`illuc19.el'
     Support for Lucid Emacs v19.

`ilxemacs.el'
     Support for XEmacs.

`*.lisp'
     Support code for Common Lisp.  Each dialect will have one of these
     files.

`*.scm'
     Support code for Scheme.  Each dialect will have one of these
     files.



File: ilisp.info,  Node: Starting up,  Next: Keybindings,  Prev: Installation,  Up: Top

How to run a Lisp process using ILISP
*************************************

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.

   * `cormanlisp' Corman Common Lisp by Roger Corman.

   * `drscheme-jr' DrScheme-jr by Rice University's PLT.

   * `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 Xanalys/Harlequin Ltd.

   * `lispworks' LispWorks Common Lisp from Xanalys/Harlequin Ltd.

   * `lucid' Lucid Common Lisp, currently supported by
     Xanalys/Harlequin Ltd.

   * `mzscheme' MzScheme by Rice University's PLT.

   * `oaklisp' Oaklisp scheme.

   * `openmcl' OpenMCL.

   * `sbcl' Steel Bank 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, *Note Defining new dialects::, and *Note
Customization::. If anyone figures out support for other dialects, I
would be happy to include it in future releases.  *Note 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
        cormanlisp
        kcl
          akcl
            gcl
            ecl
          ibcl
        lispworks
        lucid
          liquid
        openmcl
        sbcl
      scheme
        chez
        guile
        mzscheme
          drscheme-jr
        oaklisp
        Scheme->C (still "in fieri")
        scm
        snow
        stk
      xlisp
        xlispstat


File: ilisp.info,  Node: Keybindings,  Next: Buffers of ILISP,  Prev: Starting up,  Up: Top

A word about the keys used by ILISP
***********************************

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:

   * Everywhere you see <C-z> given as a prefix key, substitute <C-c>.

   * If the second part of the keybinding is a plain alphabetic
     character, the modern binding is (usually) the same character with
     the `Control' key held down.  Thus, the old keybinding (given in
     full) `<C-z> w' would be `<C-c> C-w' in the new system.

   * If the second part of the keybinding is _already_ a `Control'
     character, then translate it to the corresponding `Meta' character
     instead (because many of the former control characters were
     evicted by the change described in the previous item).  Thus, the
     old `<C-z> C-n' is now `<C-c> M-n'.


   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.


File: ilisp.info,  Node: Buffers of ILISP,  Next: ILISP Commands,  Prev: Keybindings,  Up: Top

Buffers used by ILISP, and their commands
*****************************************

`*DIALECT*'
     The Lisp listener buffer.  Forms can be entered in this buffer in,
     and they will be sent to Lisp when you hit return if the form is
     complete.  This buffer is in ilisp-mode, which is built on top of
     comint-mode, and all comint commands such as history mechanism and
     job control are available.

`LISP-MODE-BUFFERS'
     A buffer is assumed to contain Lisp source code if its major mode
     is in the list `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*''
     Used for listing completions of symbols or files by the completion
     commands.  *Note Completion::.

`*Aborted Commands*'
     *Note Interrupts::.

`*Errors*'
`*Output*'
`*Error Output*'
     used to pop-up results and errors from the inferior Lisp.

`*ilisp-send*'
     Buffer containing the last form sent to the inferior Lisp.

`*Edit-Definitions*'
`*All-Callers*'
     *Note Source code commands::.

`*Last-Changes*'
`*Changed-Definitions*'
     *Note Batch commands::.

* Menu:

* Typeout windows::              temporary windows used for display.
* Switching buffers::           Switching buffers


File: ilisp.info,  Node: Typeout windows,  Next: Switching buffers,  Up: Buffers of ILISP

Typeout windows
===============

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.

`<C-z> 1   (ilisp-bury-output)'
     deletes and buries the typeout output window.

`<C-z> v   (ilisp-scroll-output)'
     scrolls the output window if it is showing, otherwise does nothing.
     If it is called with a negative prefix, it will scroll backwards.

`<C-z> G   (ilisp-grow-output)'
     will grow the output window if showing by the prefix number of
     lines.


   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.


File: ilisp.info,  Node: Switching buffers,  Prev: Typeout windows,  Up: Buffers of ILISP

Switching buffers
=================

Commands to make switching between buffers easier.

`<C-z> b   (switch-to-lisp)'
     will pop to the current ILISP buffer or if already in an ILISP
     buffer, it will return to the buffer that last switched to an
     ILISP buffer.  With a prefix, it will also go to the end of the
     buffer.  If you do not want it to pop, set `pop-up-windows' to nil.

`M-C-l   (previous-buffer-lisp)'
     will switch to the last visited buffer in the current window or
     the Nth previous buffer with a prefix.



File: ilisp.info,  Node: ILISP Commands,  Next: Customization,  Prev: Buffers of ILISP,  Up: Top

ILISP Commands
**************

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.

* Menu:

* Eval and compile functions::
* Documentation functions::
* Macroexpansion::
* Tracing functions::
* Package Commands::
* Source code commands::        Working on several files
* Batch commands::              Grouping changes for eval/compile
* Files and directories::
* Keyboard modes::              Interactive and raw keyboard modes
* Interrupts::                  Interrupts, aborts, and errors
* Debuggers::                   Interface to Lisp debuggers
* Command history::
* Completion::
* Miscellany::                  Indentation, parenthesis balancing,
				  and comment commands.


File: ilisp.info,  Node: Eval and compile functions,  Next: Documentation functions,  Up: ILISP Commands

Eval and compile functions
==========================

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.

`<C-z>'
     The prefix-key for most ILISP commands.  This can be changed by
     setting the variable `ilisp-*prefix*'.

`RET   (return-ilisp)'
     In ILISP-mode buffer, sends the current form to lisp if complete,
     otherwise creates a new line and indents.  If you edit old input,
     the input will be copied to the end of the buffer first and then
     sent.

`C-]   (close-and-send-lisp)'
     Closes the current sexp, indents it, and then sends it to the
     current inferior Lisp.

`LFD   (newline-and-indent-lisp)'
     Insert a new line and then indent to the appropriate level.  If
     called at the end of the inferior Lisp buffer and an sexp, the
     sexp will be sent to the inferior Lisp without a trailing newline.

`<C-z> e   (eval-defun-lisp)'
`M-C-x   (eval-defun-lisp)'
`<C-z> C-e   (eval-defun-and-go-lisp)'
     Send the defun to Lisp.

`<C-z> r   (eval-region-lisp)'
`<C-z> C-r   (eval-region-and-go-lisp)'

`<C-z> n   (eval-next-sexp-lisp)'
`<C-z> C-n   (eval-next-sexp-and-go-lisp)'

`<C-z> c   (compile-defun-lisp)'

`<C-z> C-c   (compile-defun-lisp-and-go)'
     When `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.

`<C-z> w   (compile-region-lisp)'
`<C-z> C-w   (compile-region-and-go-lisp)'

   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.


File: ilisp.info,  Node: Documentation functions,  Next: Macroexpansion,  Prev: Eval and compile functions,  Up: ILISP Commands

Documentation functions
=======================

`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.  *Note
Configuration and compilation::.

`<C-z> a   (arglist-lisp)'
     Return the arglist of the current function.  With a numeric
     prefix, the leading paren will be removed and the arglist will be
     inserted into the buffer.

`<SPC>   (ilisp-arglist-message-lisp-space)'
     Display the value of the argument list of a symbol followed by
     <SPC>. _To enable this feature you have to set
     `ilisp-*arglist-message-lisp-space-p*' to `t'._

`<C-z> d   (documentation-lisp)'
     Infers whether function or variable documentation is desired.
     With a negative prefix, you can specify the type of documentation
     as well.  With a positive prefix the documentation of the current
     function call is inserted into the buffer.

`<C-z> i   (describe-lisp)'
     Describe the previous sexp (it is evaluated).  If there is no
     previous sexp and if called from inside an ILISP buffer, the
     previous result will be described.

`<C-z> I   (inspect-lisp)'
     Switch to the current inferor Lisp and inspect the previous sexp
     (it is evaluated).  If there is no previous sexp and if called
     from inside an ILISP buffer, the previous result will be inspected.

`<C-z> H   (hyperspec-lookup)'
     Look up a standard symbol in the Common Lisp HyperSpec and display
     the relevant section.

`<C-z> L or <C-z> M-l   (cltl2-lookup)'
     Look up a Common Lisp symbol in the CLtL2 book and display the
     relevant section.

`<C-z> D   (fi:clman)'
`<C-z> A   (fi:clman-apropos)'
     If the Franz online Common Lisp manual is available, get
     information on a specific symbol.  `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.



File: ilisp.info,  Node: Macroexpansion,  Next: Tracing functions,  Prev: Documentation functions,  Up: ILISP Commands

Macroexpansion
==============

`<C-z> M   (macroexpand-lisp)'
`<C-z> m   (macroexpand-1-lisp)'
     These commands apply to the next sexp.  If called with a positive
     numeric prefix, the result of the macroexpansion will be inserted
     into the buffer.  With a negative prefix, prompts for expression
     to expand.



File: ilisp.info,  Node: Tracing functions,  Next: Package Commands,  Prev: Macroexpansion,  Up: ILISP Commands

Tracing functions
=================

`<C-z> t   (trace-defun-lisp)'
     traces the current defun.   When called with a numeric prefix the
     function will be untraced.  When called with negative prefix,
     prompts for function to be traced.

`<C-z> C-t   (trace-defun-lisp-break)'
     traces the current defun and enters the debugger whenever that
     function is invoked.  When called with a numeric prefix the
     function will be untraced.  When called with negative prefix,
     prompts for function to be traced.


File: ilisp.info,  Node: Package Commands,  Next: Source code commands,  Prev: Tracing functions,  Up: ILISP Commands

Package Commands
================

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-hash-form-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 "in-package" form corresponding to
`ilisp-hash-form-regexp' in the buffer each time an inferior Lisp mode
command is executed.

`<C-z> P   (set-package-lisp)'
     Set the inferior Lisp package to the current buffer's package or
     with a prefix to a manually entered package.

`<C-z> p   (set-buffer-package-lisp)'
     Set the buffer's package from the buffer.  If it is called with a
     prefix, the package can be set manually.



File: ilisp.info,  Node: Source code commands,  Next: Batch commands,  Prev: Package Commands,  Up: ILISP Commands

Source Code Commands
====================

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:
   * try the inferior Lisp,

   * try a tags file if defined,

   * try all buffers in one of `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'
     Define a set of files to be used by the source code commands.

`M-.   (edit-definitions-lisp)'
     Find definition of a symbol.

`M-,   (next-definition-lisp)'
     Find next (previous) definition.

`<C-z> ^   (edit-callers-lisp)'
     Find all callers of a function, and edit the first.

`M-`   (next-caller-lisp)'
     Edit next (previous) caller of function set by `edit-callers-lisp'.

`M-x who-calls-lisp'
     List all the callers of a function.

`M-?   (search-lisp)'
     Search for string (regular expression) in current tags,
     `lisp-directory' files or buffers.  Use `next-definition-lisp' to
     find next occurence.

`M-"   (replace-lisp)'
     Replace a string (regular expression) in files.



File: ilisp.info,  Node: Batch commands,  Next: Files and directories,  Prev: Source code commands,  Up: ILISP Commands

Batch commands
==============

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)'
     Mark (unmark) current defun as changed.

`<C-z> * e   (eval-changes-lisp)'
`<C-z> * c   (compile-changes-lisp)'
     Call with a positive prefix to keep changes.

`<C-z> * 0   (clear-changes-lisp)'

`<C-z> * l   (list-changes-lisp)'


File: ilisp.info,  Node: Files and directories,  Next: Keyboard modes,  Prev: Batch commands,  Up: ILISP Commands

Files and directories
=====================

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.

`C-x C-f   (find-file-lisp)'
     will find a file.  If it is in a string, that will be used as the
     default if it matches an existing file.  Symbolic links are
     expanded so that different references to the same file will end up
     with the same buffer.

`<C-z> l   (load-file-lisp)'
     will load a file into the inferior Lisp.  You will be given the
     opportunity to save the buffer if it has changed and to compile
     the file if the compiled version is older than the current
     version. For `<whatever>.system' files, which are used by
     DEFSYSTEM tools, no compilation or loading of possibly existing
     `<whatever>.binary-extension' is attempted.

`<C-z> k   (compile-file-lisp)'
     will compile a file in the current inferior Lisp.

`<C-z> !   (default-directory-lisp)'
     sets the default inferior Lisp directory to the directory of the
     current buffer.  If called in an inferior Lisp buffer, it sets the
     Emacs `default-directory' to the Lisp default directory.



File: ilisp.info,  Node: Keyboard modes,  Next: Interrupts,  Prev: Files and directories,  Up: ILISP Commands

Switching between interactive and raw keyboard modes
====================================================

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^]"))'


File: ilisp.info,  Node: Interrupts,  Next: Debuggers,  Prev: Keyboard modes,  Up: ILISP Commands

Interrupts, aborts, and errors
==============================

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:

`C-c C-c   (interrupt-subjob-ilisp)'
     Send a keyboard interrupt signal to lisp.

`<C-z> g    (abort-commands-lisp)'
     Abort all running or unsent commands.

`M-x panic-lisp (panic-lisp)'
     Reset the ILISP process state.

`<C-z> z   (reset-ilisp)'
     Reset Lisp to top-level.

`C-d   (delete-char-or-pop-ilisp)'
     If at end of buffer, pop a level in break loop.


   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.


File: ilisp.info,  Node: Debuggers,  Next: Command history,  Prev: Interrupts,  Up: ILISP Commands

Interface to Lisp debuggers
===========================

ILD is an interface to Lisp debuggers, currently the ones of the AKCL,
Allegro, CLISP, CMU CL, Corman Lisp 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:

`M-a   (ild-abort)'
     Abort.

`M-c   (ild-continue)'
     Continue.

`M-C-n   (ild-next)'
     Next stack frame (with numeric argument _n_, move to the next
     _n_-th stack frame).

`M-C-p   (ild-previous)'
     Previous stack frame (with numeric argument _n_, move to the
     previous _n_-th stack frame).

`C-c <   (ild-top)'
     Top stack frame.

`C-c >   (ild-bottom)'
     Bottom stack frame.

`M-b   (ild-backtrace)'
     Backtrace.

`M-C-d   (ild-locals)'
     Display all local variables.

`M-C-l   (ild-local)'
     Display a particular local variable (with numeric argument _n_,
     display the _n_-th local variable).

`M-C-s   (ild-step)'
     Step to the next breakpoint.

`C-c r   (ild-return)'
     Return.

`M-C-r   (ild-retry)'
     Retry.

`C-x t   (ild-trap-on-exit)'
     Trap on exit.

`C-c L   (select-lisp)'
     Select Lisp interaction buffer.

`<C-z> C-s   (slow-lisp)'
     Set compiler options for maximal debuggability.

`<C-z> C-f   (fast-lisp)'
     Set compiler options for fastest but least debuggable code.


File: ilisp.info,  Node: Command history,  Next: Completion,  Prev: Debuggers,  Up: ILISP Commands

Command history
===============

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.

`M-n   (comint-next-input)'
`M-p   (comint-previous-input)'
     Cycle through the input history.

`M-s    (comint-previous-similar-input)'
     Cycle through input that has the string typed so far as a prefix.

`M-N    (comint-psearch-input)'
     Search forwards for prompt.

`M-P    (comint-msearch-input)'
     Search backwards for prompt.

`C-c R   (comint-msearch-input-matching)'
     Search backwards for occurrence of prompt followed by string which
     is prompted for (_not_ a regular expression).

   See `comint-mode' documentation for more information on `comint'
commands.


File: ilisp.info,  Node: Completion,  Next: Miscellany,  Prev: Command history,  Up: ILISP Commands

Completion
==========

Commands to reduce number of keystrokes.

`M-TAB   (complete-lisp)'
     will try to complete the previous symbol in the current inferior
     Lisp.  Partial completion is supported unless
     `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.

`M-RET   (complete)'
     will complete the current symbol to the most recently seen symbol
     in Emacs that matches what you have typed so far.  Executing it
     repeatedly will cycle through potential matches.  This is from the
     TMC completion package and there may be some delay as it is
     initially loaded.



File: ilisp.info,  Node: Miscellany,  Prev: Completion,  Up: ILISP Commands

Miscellany
==========

Indentation, parenthesis balancing, movement and comment commands.

`TAB   (indent-line-ilisp)'
     indents for Lisp.  With prefix, shifts rest of expression rigidly
     with the current line.

`M-C-q   (indent-sexp-ilisp)'
     will indent each line in the next sexp.

`M-q   (reindent-lisp)'
     will reindent the current paragraph if in a comment or string.
     Otherwise it will close the containing defun and reindent it.

`C-a   (bol-ilisp)'
     will go after the prompt as defined by `comint-prompt-regexp' or
     `ilisp-other-prompt' or to the left margin with a prefix.

`DEL   (backward-delete-char-untabify)'
     converts tabs to spaces as it moves back.

`<C-z> ;   (comment-region-lisp)'
     will put prefix copies of `comment-start' before and
     `comment-end''s after the lines in region.  To uncomment a region,
     use a minus prefix.

`<C-z> )   (find-unbalanced-lisp)'
     will find unbalanced parens in the current buffer.  When called
     with a prefix it will look in the current region.



File: ilisp.info,  Node: Customization,  Next: Dialects,  Prev: ILISP Commands,  Up: Top

ILISP Customization
*******************

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
        cormanlisp
        kcl
          akcl
            gcl
            ecl
          ibcl
        lispworks
        lucid
          liquid
        openmcl
        sbcl
      scheme
        chez
        guile
        mzscheme
          drscheme-jr
        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 Mode Hooks:
`ilisp-site-hook'
     Executed when file is loaded

`ilisp-load-hook'
     Executed when file is loaded

`ilisp-mode-hook'
     Executed when an ilisp buffer is created

`ilisp-init-hook'
     Executed after inferior Lisp is initialized and the first prompt is
     seen.

`DIALECT-hook'
     Executed when dialect is set

   Variables you might want to set in a hook or dialect:
`ilisp-*prefix*'
     Keys to prefix ilisp key bindings

`ilisp-program'
     Program to start for inferior Lisp

`ilisp-motd'
     String printed on startup with version

`lisp-wait-p'
     Set to `t' for synchronous sends

`ilisp-handle-errors'
     Set to `t' for ilisp to handle errors from the underlying Lisp.

`ilisp-display-output-function'
     The name of a function which displays ILISP output.

`lisp-no-popper'
     Set to `t' to have all output in inferior Lisp

`ilisp-*use-frame-for-output*'
     Set to `t' (default) to have multiline output in a distinct
     emacs-frame.

`ilisp-*use-frame-for-arglist-output-p*'
     Set to `t' (default) to have multiline arglist-output in a seperate
     emacs-frame.

`ilisp-bindings-*bind-space-p*'
     Set to `t' to have the SPC-key bound to
     #'ilisp-arglist-message-lisp-space.

`ilisp-*arglist-message-lisp-space-p*'
     Set to `t' to display the arglist of the current function
     displayed, after you hit SPC.

`ilisp-*enable-imenu-p*'
     Set to `t' to enable ilisp-imenu, that provides an index of all
     lisp-functions/definitions in a file.

`lisp-show-status'
     Set to `nil' to stop showing process status

`ilisp-*prefix-match*'
     Set to `t' if you do not want partial completion

`ilisp-filter-regexp'
     Input history filter

`ilisp-filter-length'
     Input history minimum length

`ilisp-other-prompt'
     Prompt for non- top-level read-eval print loops


File: ilisp.info,  Node: Dialects,  Next: Concept index,  Prev: Customization,  Up: Top

Dialects
********

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.

* Menu:

* Defining new dialects::
* Writing new commands::


File: ilisp.info,  Node: Defining new dialects,  Next: Writing new commands,  Up: Dialects

Defining new dialects
=====================

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.


File: ilisp.info,  Node: Writing new commands,  Prev: Defining new dialects,  Up: Dialects

Writing new commands
====================

Basic tools for creating new commands:
`deflocal'
     Define a new buffer local variable.

`ilisp-dialect'
     List of dialect types.  For specific dialect clauses.

`lisp-symbol'
     Create a symbol.

`lisp-symbol-name'
     Return a symbol's name

`lisp-symbol-delimiter'
     Return a symbol's qualification

`lisp-symbol-package'
     Return a symbol's package

`lisp-string-to-symbol'
     Convert string to symbol

`lisp-symbol-to-string'
     Convert symbol to string

`lisp-buffer-symbol'
     Convert symbol to string qualified for buffer

`lisp-previous-symbol'
     Return previous symbol

`lisp-previous-sexp'
     Return previous sexp

`lisp-def-name'
     Return name of current definition

`lisp-function-name'
     Return previous function symbol

`ilisp-read'
     Read an sexp with completion, arglist, etc

`ilisp-read-symbol'
     Read a symbol or list with completion

`ilisp-completing-read'
     Read from choices or list with completion

Notes:
   * Special commands like arglist should use `ilisp-send' to send a
     message to the inferior Lisp.

   * Eval/compile commands should use `eval-region-lisp' or
     `compile-region-lisp'.



File: ilisp.info,  Node: Concept index,  Next: Key index,  Prev: Dialects,  Up: Top

Concept Index
*************

* Menu:

* *Aborted Commands* buffer <1>:         Interrupts.
* *Aborted Commands* buffer:             Buffers of ILISP.
* *All-Callers* buffer <1>:              Source code commands.
* *All-Callers* buffer:                  Buffers of ILISP.
* *Changed-Definitions* buffer:          Buffers of ILISP.
* *Completions* buffer:                  Buffers of ILISP.
* *Edit-Definitions* buffer <1>:         Buffers of ILISP.
* *Edit-Definitions* buffer:             Source code commands.
* *Error Output* buffer:                 Buffers of ILISP.
* *Errors* buffer:                       Buffers of ILISP.
* *ilisp-send* buffer:                   Buffers of ILISP.
* *Last-Changes* buffer <1>:             Batch commands.
* *Last-Changes* buffer:                 Buffers of ILISP.
* *Output* buffer:                       Buffers of ILISP.
* .el files:                             Files of ILISP.
* .emacs:                                Configuration and compilation.
* .lisp files <1>:                       Configuration and compilation.
* .lisp files:                           Files of ILISP.
* .scm files:                            Files of ILISP.
* Aborting commands:                     Interrupts.
* Aborting from a debugger:              Debuggers.
* Allegro CL <1>:                        Configuration and compilation.
* Allegro CL <2>:                        Starting up.
* Allegro CL:                            Documentation functions.
* and-go functions:                      Eval and compile functions.
* Anonymous FTP:                         FTP and Web directions.
* ANSI Common Lisp:                      Configuration and compilation.
* Apropos help:                          Documentation functions.
* Arglist Lisp:                          Documentation functions.
* Austin Kyoto Common Lisp:              Starting up.
* Backtrace:                             Debuggers.
* Bottom stack frame:                    Debuggers.
* Break loop:                            Interrupts.
* bridge.el:                             Files of ILISP.
* browse-url:                            Configuration and compilation.
* Buffer package:                        Package Commands.
* Buffer package caching:                Package Commands.
* buffers of ILISP:                      Buffers of ILISP.
* Bugs, reporting them:                  Distribution.
* bury output window:                    Typeout windows.
* Byte-compiling ILISP files:            Configuration and compilation.
* Call:                                  Eval and compile functions.
* Change commands:                       Batch commands.
* Chez Scheme:                           Starting up.
* Clearing changes:                      Batch commands.
* CLISP:                                 Starting up.
* CLtL2 <1>:                             Configuration and compilation.
* CLtL2:                                 Documentation functions.
* CMU Common Lisp:                       Starting up.
* comint-ipc.el:                         Files of ILISP.
* comint-mode:                           Command history.
* comint.el:                             Files of ILISP.
* Command history:                       Command history.
* Comment region:                        Miscellany.
* Common Lisp <1>:                       Starting up.
* Common Lisp:                           Configuration and compilation.
* Common Lisp HyperSpec <1>:             Documentation functions.
* Common Lisp HyperSpec:                 Configuration and compilation.
* Common Lisp Manual:                    Configuration and compilation.
* Common Lisp manual:                    Documentation functions.
* Common Lisp Manual:                    Configuration and compilation.
* Compile last form:                     Eval and compile functions.
* Compile region:                        Eval and compile functions.
* Compile/eval commands:                 Eval and compile functions.
* Compiler options:                      Debuggers.
* Compiling changes:                     Batch commands.
* Compiling files:                       Files and directories.
* Compiling ILISP files:                 Configuration and compilation.
* completer.el:                          Files of ILISP.
* Completion:                            Completion.
* Continuing from a debugger:            Debuggers.
* Converting tabs to spaces:             Miscellany.
* Corman Lisp:                           Starting up.
* Current directory:                     Files and directories.
* Currently running command:             Eval and compile functions.
* custom-ilisp.el:                       Files of ILISP.
* Customization:                         Customization.
* Debugger interface:                    Debuggers.
* Default directory:                     Files and directories.
* default.el:                            Configuration and compilation.
* Defining new dialects:                 Defining new dialects.
* DEFSYSTEM files:                       Files and directories.
* Defun:                                 Eval and compile functions.
* Describing bindings:                   Eval and compile functions.
* Describing Lisp objects:               Documentation functions.
* Dialect startup:                       Customization.
* Dialects:                              Dialects.
* Dialects supported:                    Starting up.
* Directories and files:                 Files and directories.
* Displaying commands:                   Eval and compile functions.
* Displaying local variables:            Debuggers.
* docs <1>:                              Configuration and compilation.
* docs:                                  Files of ILISP.
* Documentation:                         Configuration and compilation.
* Documentation Functions:               Documentation functions.
* Downloading ILISP:                     FTP and Web directions.
* DrScheme-jr:                           Starting up.
* easymenu package:                      Configuration and compilation.
* EcoLisp:                               Starting up.
* Errors:                                Interrupts.
* Eval region:                           Eval and compile functions.
* Eval'ing changes:                      Batch commands.
* Eval/compile commands:                 Eval and compile functions.
* Expanding macro forms:                 Macroexpansion.
* extra <1>:                             Configuration and compilation.
* extra:                                 Files of ILISP.
* features:                              Introduction.
* File changes:                          Batch commands.
* Filename completion:                   Completion.
* Files and directories:                 Files and directories.
* Files of ILISP:                        Files of ILISP.
* Find callers:                          Source code commands.
* Find file:                             Files and directories.
* Find unbalanced parens:                Miscellany.
* Finding source:                        Source code commands.
* First prompt:                          Customization.
* Franz manual <1>:                      Documentation functions.
* Franz manual <2>:                      Configuration and compilation.
* Franz manual:                          Documentation functions.
* FSF keyspace:                          Keybindings.
* FTP site:                              FTP and Web directions.
* Getting ILISP:                         FTP and Web directions.
* GNU Common Lisp:                       Starting up.
* Going after the prompt:                Miscellany.
* Group changes:                         Batch commands.
* grow output window:                    Typeout windows.
* GUILE:                                 Starting up.
* HISTORY:                               Distribution.
* Hooks:                                 Customization.
* How to get:                            FTP and Web directions.
* HyperSpec <1>:                         Configuration and compilation.
* HyperSpec:                             Documentation functions.
* Ibuki Common Lisp:                     Starting up.
* icompile.bat <1>:                      Configuration and compilation.
* icompile.bat:                          Files of ILISP.
* ilcompat.el:                           Files of ILISP.
* ILD:                                   Debuggers.
* ild.el:                                Files of ILISP.
* ilfsf18.el:                            Files of ILISP.
* ilfsf19.el:                            Files of ILISP.
* ilfsf20.el:                            Files of ILISP.
* ILISP buffers:                         Buffers of ILISP.
* Ilisp menu:                            Configuration and compilation.
* ILISP Mode Hooks:                      Customization.
* ilisp-acl:                             Files of ILISP.
* ilisp-all.elc:                         Configuration and compilation.
* ilisp-announce mailing list:           Distribution.
* ilisp-aut.el:                          Files of ILISP.
* ilisp-bat.el:                          Files of ILISP.
* ilisp-bug.el:                          Files of ILISP.
* ilisp-ccl.el:                          Files of ILISP.
* ilisp-chs.el:                          Files of ILISP.
* ilisp-cl-easy-menu.el:                 Files of ILISP.
* ilisp-cl.el:                           Files of ILISP.
* ilisp-cmp.el:                          Files of ILISP.
* ilisp-cmt.el:                          Files of ILISP.
* ilisp-cmu.el:                          Files of ILISP.
* ilisp-cvs mailing list:                Distribution.
* ilisp-def.el <1>:                      Configuration and compilation.
* ilisp-def.el:                          Files of ILISP.
* ilisp-devel mailing list <1>:          Distribution.
* ilisp-devel mailing list:              Acknowledgements.
* ilisp-dia.el:                          Files of ILISP.
* ilisp-doc.el:                          Files of ILISP.
* ilisp-ext.el:                          Files of ILISP.
* ilisp-help mailing list <1>:           FTP and Web directions.
* ilisp-help mailing list:               Distribution.
* ilisp-hi.el:                           Files of ILISP.
* ilisp-hlw.el:                          Files of ILISP.
* ilisp-hnd.el:                          Files of ILISP.
* ilisp-imenu.el:                        Files of ILISP.
* ilisp-ind.el:                          Files of ILISP.
* ilisp-inp.el:                          Files of ILISP.
* ilisp-kcl.el:                          Files of ILISP.
* ilisp-key.el:                          Files of ILISP.
* ilisp-kil.el:                          Files of ILISP.
* ilisp-low.el:                          Files of ILISP.
* ilisp-luc.el:                          Files of ILISP.
* ilisp-mak.el:                          Files of ILISP.
* ilisp-menu.el:                         Files of ILISP.
* ilisp-mnb.el:                          Files of ILISP.
* ilisp-mod.el:                          Files of ILISP.
* ilisp-mov.el:                          Files of ILISP.
* ilisp-openmcl.el:                      Files of ILISP.
* ilisp-out.el:                          Files of ILISP.
* ilisp-prc.el:                          Files of ILISP.
* ilisp-prn.el:                          Files of ILISP.
* ilisp-rng.el:                          Files of ILISP.
* ilisp-s2c.el <1>:                      Starting up.
* ilisp-s2c.el:                          Files of ILISP.
* ilisp-sbcl.el:                         Files of ILISP.
* ilisp-sch.el:                          Files of ILISP.
* ilisp-scheme-easy-menu.el:             Files of ILISP.
* ilisp-snd.el:                          Files of ILISP.
* ilisp-src.el:                          Files of ILISP.
* ilisp-sym.el:                          Files of ILISP.
* ilisp-utl.el:                          Files of ILISP.
* ilisp-val.el:                          Files of ILISP.
* ilisp-xfr.el :                         Files of ILISP.
* ilisp-xls.el:                          Files of ILISP.
* ilisp.el:                              Files of ILISP.
* ilisp.emacs <1>:                       Configuration and compilation.
* ilisp.emacs <2>:                       Files of ILISP.
* ilisp.emacs:                           Configuration and compilation.
* ilisp.texi:                            Files of ILISP.
* illuc19.el:                            Files of ILISP.
* ilxemacs.el:                           Files of ILISP.
* In-package form:                       Package Commands.
* Indentation:                           Miscellany.
* Input search:                          Command history.
* Inserting calls:                       Eval and compile functions.
* Inserting results:                     Eval and compile functions.
* INSTALLATION:                          Configuration and compilation.
* Installation:                          Installation.
* Interactive keyboard mode:             Keyboard modes.
* Interface to Lisp debuggers:           Debuggers.
* Internal ILISP functions:              Writing new commands.
* Interrupting commands:                 Interrupts.
* keybindings:                           Keybindings.
* Kyoto Common Lisp:                     Starting up.
* Last command:                          Command history.
* Lisp find file:                        Files and directories.
* Lisp menu:                             Configuration and compilation.
* List callers:                          Source code commands.
* Listing bindings:                      Eval and compile functions.
* Listing changes:                       Batch commands.
* Loading files:                         Files and directories.
* Local variables:                       Debuggers.
* Lucid Common Lisp:                     Starting up.
* Macroexpansion:                        Macroexpansion.
* Mailing lists:                         Distribution.
* Makefile:                              Configuration and compilation.
* Marking changes:                       Batch commands.
* Minibuffer completion:                 Documentation functions.
* Modeline status:                       Eval and compile functions.
* MzScheme:                              Starting up.
* Negative prefix:                       Documentation functions.
* Next definition:                       Source code commands.
* Next input:                            Command history.
* Next stack frame:                      Debuggers.
* Oaklisp:                               Starting up.
* OpenMCL:                               Starting up.
* Package commands:                      Package Commands.
* Parenthesis balancing:                 Miscellany.
* Partial completion:                    Completion.
* Pop in break loop:                     Interrupts.
* Previous commands:                     Command history.
* Previous definition:                   Source code commands.
* Previous lisp buffer:                  Switching buffers.
* Previous stack frame:                  Debuggers.
* Raw keyboard mode:                     Keyboard modes.
* Reducing Emacs startup time:           Configuration and compilation.
* Reference card:                        Configuration and compilation.
* Region commands:                       Eval and compile functions.
* Reindent lisp:                         Miscellany.
* Replace lisp:                          Source code commands.
* Reporting bugs:                        Distribution.
* Resetting Lisp:                        Interrupts.
* Retrying from a debugger:              Debuggers.
* Returning from a debugger:             Debuggers.
* Rigid indentation:                     Miscellany.
* Running Lisp:                          Starting up.
* SB Common Lisp:                        Starting up.
* Scheme:                                Starting up.
* Scheme->C:                             Starting up.
* SCM:                                   Starting up.
* scrolling output:                      Typeout windows.
* Search input:                          Command history.
* Selecting a Lisp interaction buffer:   Debuggers.
* Sending input to Lisp:                 Eval and compile functions.
* Set buffer package:                    Package Commands.
* Set default directory:                 Files and directories.
* Setting compiler options:              Debuggers.
* Similar input:                         Command history.
* Snow:                                  Starting up.
* Source Code Commands:                  Source code commands.
* Source modes:                          Source code commands.
* Stack backtrace:                       Debuggers.
* Stack frames:                          Debuggers.
* Starting up Lisp:                      Starting up.
* Startup time, how to reduce it:        Configuration and compilation.
* Status light:                          Eval and compile functions.
* Stepping to next breakpoint:           Debuggers.
* STk:                                   Starting up.
* Supported dialects:                    Starting up.
* Switching buffers:                     Switching buffers.
* Symbolic link expansion:               Files and directories.
* System definition files:               Files and directories.
* TMC completion:                        Completion.
* Top stack frame:                       Debuggers.
* Top-level, return to:                  Interrupts.
* Tracing defuns:                        Tracing functions.
* Trapping on exit from a debugger:      Debuggers.
* Turning off typeout windows:           Typeout windows.
* Typeout windows:                       Typeout windows.
* Uncomment region:                      Miscellany.
* Untracing defuns:                      Tracing functions.
* User manual:                           Configuration and compilation.
* Web site:                              FTP and Web directions.
* Windows, compiling under:              Configuration and compilation.
* XLisp:                                 Starting up.
* XLisp-Stat:                            Starting up.


File: ilisp.info,  Node: Key index,  Next: Command index,  Prev: Concept index,  Up: Top

Key Index
*********

* Menu:

* <C-z> !:                               Files and directories.
* <C-z> #:                               Keyboard modes.
* <C-z> ):                               Miscellany.
* <C-z> * 0:                             Batch commands.
* <C-z> * c:                             Batch commands.
* <C-z> * e:                             Batch commands.
* <C-z> * l:                             Batch commands.
* <C-z> 1:                               Typeout windows.
* <C-z> ;:                               Miscellany.
* <C-z> ^:                               Source code commands.
* <C-z> a:                               Documentation functions.
* <C-z> A:                               Documentation functions.
* <C-z> b:                               Switching buffers.
* <C-z> c:                               Eval and compile functions.
* <C-z> C-c:                             Eval and compile functions.
* <C-z> C-e:                             Eval and compile functions.
* <C-z> C-f:                             Debuggers.
* <C-z> C-n:                             Eval and compile functions.
* <C-z> C-r:                             Eval and compile functions.
* <C-z> C-s:                             Debuggers.
* <C-z> C-t:                             Tracing functions.
* <C-z> C-w:                             Eval and compile functions.
* <C-z> D:                               Documentation functions.
* <C-z> d:                               Documentation functions.
* <C-z> e:                               Eval and compile functions.
* <C-z> g:                               Interrupts.
* <C-z> G:                               Typeout windows.
* <C-z> g:                               Eval and compile functions.
* <C-z> H:                               Documentation functions.
* <C-z> I:                               Documentation functions.
* <C-z> i:                               Documentation functions.
* <C-z> k:                               Files and directories.
* <C-z> L:                               Documentation functions.
* <C-z> l:                               Files and directories.
* <C-z> m:                               Macroexpansion.
* <C-z> M:                               Macroexpansion.
* <C-z> M-l:                             Documentation functions.
* <C-z> n:                               Eval and compile functions.
* <C-z> P:                               Package Commands.
* <C-z> p:                               Package Commands.
* <C-z> prefix:                          Eval and compile functions.
* <C-z> r:                               Eval and compile functions.
* <C-z> s:                               Eval and compile functions.
* <C-z> SPC:                             Batch commands.
* <C-z> t:                               Tracing functions.
* <C-z> v:                               Typeout windows.
* <C-z> w:                               Eval and compile functions.
* <C-z> z:                               Interrupts.
* <SPC>:                                 Documentation functions.
* C-]:                                   Eval and compile functions.
* C-a:                                   Miscellany.
* C-c <:                                 Debuggers.
* C-c >:                                 Debuggers.
* C-c L:                                 Debuggers.
* C-c R:                                 Command history.
* C-c r:                                 Debuggers.
* C-d:                                   Interrupts.
* C-g:                                   Interrupts.
* C-x C-f:                               Files and directories.
* C-x t:                                 Debuggers.
* DEL:                                   Miscellany.
* LFD:                                   Eval and compile functions.
* M-":                                   Source code commands.
* M-,:                                   Source code commands.
* M-.:                                   Source code commands.
* M-?:                                   Source code commands.
* M-`:                                   Source code commands.
* M-a:                                   Debuggers.
* M-b:                                   Debuggers.
* M-c:                                   Debuggers.
* M-C-d:                                 Debuggers.
* M-C-l <1>:                             Debuggers.
* M-C-l:                                 Switching buffers.
* M-C-n:                                 Debuggers.
* M-C-p:                                 Debuggers.
* M-C-q:                                 Miscellany.
* M-C-r:                                 Debuggers.
* M-C-s:                                 Debuggers.
* M-C-x:                                 Eval and compile functions.
* M-n:                                   Command history.
* M-N:                                   Command history.
* M-p:                                   Command history.
* M-P:                                   Command history.
* M-q:                                   Miscellany.
* M-RET:                                 Completion.
* M-s:                                   Command history.
* M-TAB <1>:                             Documentation functions.
* M-TAB:                                 Completion.
* M-x io-bridge-ilisp:                   Keyboard modes.
* M-x lisp-directory:                    Source code commands.
* M-x who-calls-lisp:                    Source code commands.
* RET:                                   Eval and compile functions.
* TAB <1>:                               Miscellany.
* TAB:                                   Documentation functions.


File: ilisp.info,  Node: Command index,  Next: Variable index,  Prev: Key index,  Up: Top

Command Index
*************

Commands available via `M-x' prefix.

* Menu:

* abort-commands-lisp <1>:               Eval and compile functions.
* abort-commands-lisp:                   Interrupts.
* akcl:                                  Starting up.
* allegro:                               Starting up.
* arglist-lisp:                          Documentation functions.
* backward-delete-char-untabify:         Miscellany.
* bol-ilisp:                             Miscellany.
* chez:                                  Starting up.
* clear-changes-lisp:                    Batch commands.
* clisp-hs:                              Starting up.
* close-and-send-lisp:                   Eval and compile functions.
* cltl2-lookup:                          Documentation functions.
* cmulisp:                               Starting up.
* comint-msearch-input:                  Command history.
* comint-msearch-input-matching:         Command history.
* comint-next-input:                     Command history.
* comint-previous-input:                 Command history.
* comint-previous-similar-input:         Command history.
* comint-psearch-input:                  Command history.
* comment-region-lisp:                   Miscellany.
* common-lisp:                           Starting up.
* compile-changes-lisp:                  Batch commands.
* compile-defun-and-go-lisp:             Eval and compile functions.
* compile-defun-lisp:                    Eval and compile functions.
* compile-defun-lisp-and-go:             Eval and compile functions.
* compile-file-lisp:                     Files and directories.
* compile-region-and-go-lisp:            Eval and compile functions.
* compile-region-lisp:                   Eval and compile functions.
* complete:                              Completion.
* complete-lisp:                         Completion.
* cormanlisp:                            Starting up.
* default-directory-lisp:                Files and directories.
* defdialect:                            Defining new dialects.
* delete-char-or-pop-ilisp:              Interrupts.
* describe-lisp:                         Documentation functions.
* documentation-lisp:                    Documentation functions.
* drscheme-jr:                           Starting up.
* ecl:                                   Starting up.
* edit-callers-lisp:                     Source code commands.
* edit-definitions-lisp:                 Source code commands.
* eval-changes-lisp:                     Batch commands.
* eval-defun-and-go-lisp:                Eval and compile functions.
* eval-defun-lisp:                       Eval and compile functions.
* eval-next-sexp-and-go-lisp:            Eval and compile functions.
* eval-next-sexp-lisp:                   Eval and compile functions.
* eval-region-and-go-lisp:               Eval and compile functions.
* eval-region-lisp:                      Eval and compile functions.
* fast-lisp:                             Debuggers.
* fi:clman <1>:                          Configuration and compilation.
* fi:clman:                              Documentation functions.
* fi:clman-apropos:                      Documentation functions.
* find-file-lisp:                        Files and directories.
* find-unbalanced-lisp:                  Miscellany.
* gcl:                                   Starting up.
* guile:                                 Starting up.
* hyperspec-lookup:                      Documentation functions.
* ibcl:                                  Starting up.
* ild-abort:                             Debuggers.
* ild-backtrace:                         Debuggers.
* ild-bottom:                            Debuggers.
* ild-continue:                          Debuggers.
* ild-local:                             Debuggers.
* ild-locals:                            Debuggers.
* ild-next:                              Debuggers.
* ild-previous:                          Debuggers.
* ild-retry:                             Debuggers.
* ild-return:                            Debuggers.
* ild-step:                              Debuggers.
* ild-top:                               Debuggers.
* ild-trap-on-exit:                      Debuggers.
* ilisp-arglist-message-lisp-space:      Documentation functions.
* ilisp-bug:                             Distribution.
* ilisp-bury-output:                     Typeout windows.
* ilisp-compile-inits:                   Configuration and compilation.
* ilisp-grow-output:                     Typeout windows.
* ilisp-scroll-output:                   Typeout windows.
* indent-line-ilisp:                     Miscellany.
* indent-sexp-ilisp:                     Miscellany.
* inspect-lisp:                          Documentation functions.
* interrupt-subjob-ilisp:                Interrupts.
* io-bridge-ilisp:                       Keyboard modes.
* kcl:                                   Starting up.
* lisp-directory:                        Source code commands.
* list-changes-lisp:                     Batch commands.
* load-file-lisp:                        Files and directories.
* lucid:                                 Starting up.
* macroexpand-1-lisp:                    Macroexpansion.
* macroexpand-lisp:                      Macroexpansion.
* make:                                  Configuration and compilation.
* make compile:                          Configuration and compilation.
* make docs:                             Configuration and compilation.
* make dvi:                              Configuration and compilation.
* make html:                             Configuration and compilation.
* make info:                             Configuration and compilation.
* make loadfile:                         Configuration and compilation.
* make ps:                               Configuration and compilation.
* mark-change-lisp:                      Batch commands.
* mzscheme:                              Starting up.
* newline-and-indent-lisp:               Eval and compile functions.
* next-caller-lisp:                      Source code commands.
* next-definition-lisp:                  Source code commands.
* oaklisp:                               Starting up.
* openmcl:                               Starting up.
* panic-lisp:                            Interrupts.
* previous-buffer-lisp:                  Switching buffers.
* raw-keys-ilisp:                        Keyboard modes.
* reindent-lisp:                         Miscellany.
* replace-lisp:                          Source code commands.
* reset-ilisp:                           Interrupts.
* return-ilisp:                          Eval and compile functions.
* run-ilisp:                             Starting up.
* sbcl:                                  Starting up.
* scheme:                                Starting up.
* scm:                                   Starting up.
* search-lisp:                           Source code commands.
* select-lisp:                           Debuggers.
* set-buffer-package-lisp:               Package Commands.
* set-package-lisp:                      Package Commands.
* setup-ilisp:                           Defining new dialects.
* slow-lisp:                             Debuggers.
* snow:                                  Starting up.
* status-lisp:                           Eval and compile functions.
* stk:                                   Starting up.
* switch-to-lisp:                        Switching buffers.
* trace-defun-lisp:                      Tracing functions.
* trace-defun-lisp-break:                Tracing functions.
* who-calls-lisp:                        Source code commands.
* xlisp:                                 Starting up.
* xlispstat:                             Starting up.


File: ilisp.info,  Node: Variable index,  Next: Function index,  Prev: Command index,  Up: Top

Variable Index
**************

Variables and hooks of ILISP.

* Menu:

* *record-source-files*:                 Source code commands.
* auto-mode-alist:                       Source code commands.
* comint-always-scroll:                  Typeout windows.
* comint-mode-hook:                      Customization.
* comint-prompt-regexp:                  Miscellany.
* default-directory:                     Files and directories.
* DIALECT-hook:                          Customization.
* EMACS:                                 Configuration and compilation.
* HyperSpec:                             Configuration and compilation.
* ilisp-*arglist-message-lisp-space-p* <1>: Customization.
* ilisp-*arglist-message-lisp-space-p*:  Documentation functions.
* ilisp-*enable-cl-easy-menu-p*:         Configuration and compilation.
* ilisp-*enable-imenu-p*:                Customization.
* ilisp-*enable-scheme-easy-menu-p*:     Configuration and compilation.
* ilisp-*prefix* <1>:                    Eval and compile functions.
* ilisp-*prefix*:                        Customization.
* ilisp-*prefix-match* <1>:              Completion.
* ilisp-*prefix-match*:                  Customization.
* ilisp-*use-fi-clman-interface-p*:      Configuration and compilation.
* ilisp-*use-frame-for-arglist-output-p*: Customization.
* ilisp-*use-frame-for-output*:          Customization.
* ilisp-*use-fsf-compliant-keybindings*: Keybindings.
* ilisp-bindings-*bind-space-p*:         Customization.
* ilisp-defvar-regexp:                   Eval and compile functions.
* ilisp-display-output-function:         Customization.
* ilisp-filter-length <1>:               Command history.
* ilisp-filter-length:                   Customization.
* ilisp-filter-regexp <1>:               Command history.
* ilisp-filter-regexp:                   Customization.
* ilisp-handle-errors:                   Customization.
* ilisp-hash-form-regexp:                Package Commands.
* ilisp-init-binary-command:             Configuration and compilation.
* ilisp-init-binary-extension:           Configuration and compilation.
* ilisp-init-hook:                       Customization.
* ilisp-load-hook:                       Customization.
* ilisp-load-inits:                      Configuration and compilation.
* ilisp-locator:                         Source code commands.
* ilisp-mode-hook:                       Customization.
* ilisp-motd:                            Customization.
* ilisp-other-prompt <1>:                Miscellany.
* ilisp-other-prompt:                    Customization.
* ilisp-program <1>:                     Configuration and compilation.
* ilisp-program:                         Customization.
* ilisp-raw-echo:                        Keyboard modes.
* ilisp-site-hook <1>:                   Customization.
* ilisp-site-hook:                       Configuration and compilation.
* lisp-dont-cache-package:               Package Commands.
* lisp-edit-files:                       Source code commands.
* lisp-no-popper <1>:                    Typeout windows.
* lisp-no-popper:                        Customization.
* lisp-show-status <1>:                  Customization.
* lisp-show-status:                      Eval and compile functions.
* lisp-source-modes:                     Source code commands.
* lisp-wait-p <1>:                       Interrupts.
* lisp-wait-p <2>:                       Customization.
* lisp-wait-p:                           Eval and compile functions.
* LN:                                    Configuration and compilation.
* pop-up-windows:                        Switching buffers.


File: ilisp.info,  Node: Function index,  Prev: Variable index,  Up: Top

Function Index
**************

Internal functions of ILISP which can be used to write new commands.

* Menu:

* compile-region-lisp:                   Writing new commands.
* deflocal:                              Writing new commands.
* eval-region-lisp:                      Writing new commands.
* ilisp-compile-inits:                   Configuration and compilation.
* ilisp-completing-read:                 Writing new commands.
* ilisp-dialect:                         Writing new commands.
* ilisp-package-command:                 Package Commands.
* ilisp-read:                            Writing new commands.
* ilisp-read-symbol:                     Writing new commands.
* ilisp-send:                            Writing new commands.
* lisp-buffer-symbol:                    Writing new commands.
* lisp-def-name:                         Writing new commands.
* lisp-function-name:                    Writing new commands.
* lisp-previous-sexp:                    Writing new commands.
* lisp-previous-symbol:                  Writing new commands.
* lisp-string-to-symbol:                 Writing new commands.
* lisp-symbol:                           Writing new commands.
* lisp-symbol-delimiter:                 Writing new commands.
* lisp-symbol-name:                      Writing new commands.
* lisp-symbol-package:                   Writing new commands.
* lisp-symbol-to-string:                 Writing new commands.



Tag Table:
Node: Top1191
Node: Distribution2401
Node: FTP and Web directions4681
Node: Acknowledgements5383
Node: Introduction7306
Node: Installation9052
Node: Configuration and compilation9679
Node: Files of ILISP17416
Node: Starting up21468
Node: Keybindings24885
Node: Buffers of ILISP27437
Node: Typeout windows28939
Node: Switching buffers31185
Node: ILISP Commands31822
Node: Eval and compile functions32684
Node: Documentation functions37089
Node: Macroexpansion39742
Node: Tracing functions40189
Node: Package Commands40831
Node: Source code commands42108
Node: Batch commands46045
Node: Files and directories47366
Node: Keyboard modes48853
Node: Interrupts50024
Node: Debuggers51897
Node: Command history53817
Node: Completion54981
Node: Miscellany56774
Node: Customization57901
Node: Dialects60659
Node: Defining new dialects61295
Node: Writing new commands61900
Node: Concept index63204
Node: Key index81330
Node: Command index87092
Node: Variable index94940
Node: Function index98648

End Tag Table
