Anonymous avatar Anonymous committed babe27e

Sync BBDB to version 2.32

Add ibuffer.el and search-buffers.el to edit-utils

Sync Eicq to version 0.2.14

Sync ilisp to version 5.11.1

Sync mailcrypt to version 3.5.6

Comments (0)

Files changed (81)

-Thanks to Guido Bosch, David Braunegg, Tim Bradshaw, Thomas M. Breuel,
-Hans Chalupsky, Kimball Collins, Brian Dennis, David Duff, Tom
-Emerson, Michael Ernst, Scott Fahlman, David Gadbois, Robert
-P. Goldman, Marty Hall, Richard Harris, Jim Healy, Christopher Hoover,
-Larry Hunter, Ben Hyde, Chuck Irvine, Michael Kashket, Mark
-Kantrowitz, Qiegang Long, Erik Naggum, Dan Pierson, Yusuf Pisan, Frank
-Ritter, Jeffrey Mark Siskind, Neil Smithline, Richard Stallman, Larry
-Stead, Jason Trenouth, Christof Ullwer, Bjorn Victor, Fred White, Ben
-Wing, Matsuo Yoshihiro, Jamie Zawinski, Paul Fuqua (for the CMU-CL GC
-display code) and Marco Antoniotti for bug reports, suggestions and
-code.  Our apologies to anyone we may have forgotten.
+Thanks to
+
+Chris McConnell (the author of the original ILISP),
+
+Paolo Amoroso,
+Martin Atzmueller,
+David Bakash,
+Daniel Barlow,
+Guido Bosch,
+Tim Bradshaw,
+David Braunegg,
+Thomas M. Breuel,
+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,
+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,
+Jeffrey Mark Siskind,
+Neil Smithline,
+Richard Stallman,
+Larry Stead,
+Jason Trenouth,
+Christof Ullwer,
+Bjorn Victor,
+Fred White,
+Ben Wing,
+Matsuo Yoshihiro,
+Jamie Zawinski
+
+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.
+
+And, of course, to the original author of ILISP, Chris McConnell.
+
+The ILISP Maintainers
 -------------------------------------------------------------------------------
 
 This file is part of ILISP.
-Version: 5.10.1
-Date:    15 June 1999
+Version: 5.11.1
+Date:    2001-06-06
 
 Copyright (C) 1990, 1991, 1992, 1993 Chris McConnell
               1993, 1994 Ivan Vasquez
               1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
               1996-2000 Marco Antoniotti and Rick Campbell
+              2001 Paolo Amoroso, Marco Antoniotti, Martin Atzmueller,
+                   Craig Brozefsky, William Deakin, Matthias Koeppe
 
 Other authors' names for which this Copyright notice also holds
-may appear later in this file.
+may appear later in this file, in the ACKNOWLEGMENTS file and in
+individual files (in which case the content of the file is to be
+intended to be copyrighted by that author).
 
-Send mail to 'majordomo@cons.org' to be included in the
-ILISP mailing list (a message with 'subscribe ilisp' in the body
-should suffice).  'ilisp@cons.org' is the general ILISP
-mailing list were bugs and improvements are discussed.
+Please visit the ILISP Project at Sourceforge
+(http://sourceforge.net/projects/ilisp) for news and support.
+ILISP mailing lists are also hosted at Sourceforge.
 
 -------------------------------------------------------------------------------
 
-2001-06-18  Ben Wing  <ben@xemacs.org>
+2001-07-01  Steve Youngs  <youngs@xemacs.org>
 
-	* Makefile (compile):
-	* ilisp-mak.el ((not (file-exists-p "ilcompat.el"))):
-	Fix to compile in the absence of an installed package tree.
+	* Import ilisp 5.11.1
 
 2001-05-11  Ben Wing  <ben@xemacs.org>
 
 FTP and WWW directions
 ======================
 
-You can get the distribution file, `ilisp-5.9.tar.gz'
-(`ilisp-5.9.zip') via anonymous FTP or HTML at the following
-addresses:
+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:
 
-    ftp://ftp2.cons.org/pub/languages/lisp/ilisp/
-or
-    http://www2.cons.org:8000/ftp-area/ilisp/
+  http://sourceforge.net/project/showfiles.php?group_id=3957
 
-If you use a tty ftp client, just log in as 'anonymous'.
+Please report any problems to the ilisp-help mailing list (see the README
+file for more info on the ILISP lists).
 
-Please report any problems to the mailing list 'ilisp@cons.org'.
+Enjoy,
 
-Enjoy
 
-The ILISP Maintainer
+The ILISP Maintainers
+
 
 ILISP HISTORY
 ===============================================================================
+Version: 5.11.
+
+New Version.
+
+Please refer to the ChangeLog entries to see what relevant changes
+have happened.  There are way too many changes.
+
+
+===============================================================================
 Version: 5.10.1.
 
 ILISP is on SOURCEFORGE!
 Many.
 
 -- More CLish conventions for naming variables.
-   Note that 'ilisp-refix' is now 'ilisp-*prefix*' . Check your ilisp
+   Note that 'ilisp-prefix' is now 'ilisp-*prefix*' . Check your ilisp
    initializations in your .emacs or wherever you keep them.
 
 -- Better FSF compliance (see variable
 -- The common lisp arglist printer has been prettified somewhat.
 
 -- Ilisp no longer tries to handle lisp errors by default.  This is
-   controlled by the variable ilisp-handle-errors.
+   controlled by the varible ilisp-handle-errors.
 
 -- Many of the hairy regexps used to located definitions have been
    broken out into separate variables. One is ilisp-cl-source-locater-patterns,
 
 FIRST INSTALLATION STEP: UNPACKING AND COMPILING.
 
-Copy the ILISP distribution archive, e.g. ilisp-5.9.4.tar.gz, to the
+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 (you
 may need root privileges to perform these operations):
 
-% gzip -dc ilisp-5.9.4.tar.gz | tar xf -
+% gzip -dc ilisp-x.y.z.tar.gz | tar xf -
 
 or:
 
-% unzip ilisp-5.9.4.zip
+% unzip ilisp-x.y.z.zip
 
 Some configuration needs to be done before compiling the Emacs Lisp files
 that comprise ILISP.  Start with the Makefile file, in the section after
 
 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.
+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 ENABLE-ILISP-CL-EASY-MENU-P in `ilisp-def.el' for the Common Lisp
-dialects, and ENABLE-ILISP-SCHEME-EASY-MENU-P for Scheme dialects.  Setting
-these variables also causes the default Lisp menu to be removed before
-displaying the Ilisp one.
+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 next section for additional configuration options and known
 problems for specific Lisp dialects.
 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'.
+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.
-Both of them are in the `docs' directory of the distribution tree.
+The ILISP documentation consists of a user manual and a reference card (the
+latter may not be up to date).  Both of them are in the `docs' directory of
+the distribution tree.
 
-The generation of GNU Info, DVI, PostScript and HTML versions of the manual
-from the Texinfo source is controlled by the `Makefile' in the `docs'
-directory.  Run `make docs' or just `make' to generate all of the formats.
-If you are interested in only some of them then issue the appropriate
-command: `make info' for GNU Info, `make dvi' for DVI, `make ps' for
-PostScript and `make html' for HTML.  To remove the intermediate files
-produced during the generation of DVI output you can run `make tmpclean'.
+The 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 `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 in DVI and PostScript formats
-together with the TeX source.  Check the comments at the beginning of the
-TeX source if you need to generate a version with a different number of
-columns.
+The 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).
 
 
 SECOND INSTALLATION STEP: DIALECT REQUIREMENTS.
 	of this setting.
 
 
-o Harlequin
+o Harlequin/Xanalys LispWorks
 
-	No known extra installation glitches
+        On Windows and Linux, the LispWorks executable should be resaved
+        without the GUI.  In addition, on Windows it MUST be resaved as a
+        console application to ensure correct interaction with Emacs shell
+        buffers.  Create a script (let's call it `console.lisp') including
+        the following:
+
+          (load-all-patches)
+          (save-image "lw41-console" :console t :environment nil)
+          (quit)
+
+        and run it using:
+
+          <dir>/lispworks-4100 -init <dir>/console.lisp
+
+        When the `lw41-console' image has been created, it can be used as
+        the value of the `lispworks-program' variable in ILISP.
+
+        If you are using LispWorks 4.1.19 with Emacs 20.4 or higher on
+        Windows, then you will need an additional patch
+        `emacs20-terminal-io', available from <lisp-support@xanalys.com>,
+        because Emacs has changed the coding-system used for comint
+        buffers.  The LispWorks for Windows 4.1.20 patch bundle includes
+        some more patches (LSC #7270, LSC #7727 and LSC #7291) that make it
+        work with ILISP.  For more information check the README file which
+        comes with the bundle.
 
 
 o Lucid
 
         The following lists some unusual ILISP behaviour related to CLISP.
         Some of these are of general interest, and should hopefully be
-        fixed in an upcoming ILISP distribution. Most of these points were
+        fixed in an upcomming ILISP distribution. Most of these points were
         reported by Bruno Haible.
 
         - On startup, ILISP presents a Lisp prompt and shortly afterwards
 
             (define-c-external (nobuff) void "nobuff")
             (nobuff)
+
+
+TIPS
+
+o Enlightment window manager under Gnome
+
+        If ILISP popup windows unexpectedly keep the input focus, in the
+        Enlightment Configuration Editor choose the "Beahvior" item and
+        toggle off all the "[...] get keyboard focus" items.
+
-ILISP 5.9.x
-===========
+ILISP 5.11.1
+============
 
-ILISP is a powerful GNU Emacs interface to many dialects of Lisp,
-including Lucid, Allegro, Harlequin LispWorks, GCL, KCL, AKCL, ECL, IBCL,
-and CMUCL.  Also some Scheme implementations are supported as well as
-a preliminary version of Xlisp/XlispStat.
+ILISP is a powerful GNU Emacs interface to many dialects of Lisp, including
+Lucid, Allegro, Xanalys/Harlequin LispWorks, GCL, KCL, AKCL, ECL, IBCL, and
+CMUCL.  Also some Scheme implementations are supported as well as a
+preliminary version of Xlisp/XlispStat.
 
-Written by Chris McConnell <ccm+@cs.cmu.edu> and now maintained by
-Marco Antoniotti <marcoxa@cons.org>.
+Written by Chris McConnell <ccm+@cs.cmu.edu> and now maintained by a group
+of programmers led by Marco Antoniotti <marcoxa@cons.org>.
 
 Please refer to the following files in this directory:
- HISTORY:	A detailed summary of changes over the course of ILISP's
-		existence.
- GETTING-ILISP:	Directions for obtaining this collection using
-		anonymous FTP.
- INSTALLATION:	Directions about how to install ILISP and specific
-		dialect needs.
 
-Please send bug reports, questions, suggestions, etc. to:
+  HISTORY       : A detailed summary of changes over the course of ILISP's
+                  existence.
+  GETTING-ILISP : Directions for obtaining this collection using
+                  anonymous FTP.
+  INSTALLATION  : Directions about how to install ILISP and specific
+                  dialect needs.
 
-  ILISP Discussion <ilisp@cons.org>
+General information on ILISP is available at:
 
-Please address all list administration messages, such as requests to
-subscribe or unsubscribe from ilisp@cons.org, to:
+  http://ilisp.cons.org
 
-  ILISP Administrivia <majordomo@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/
 
-See <http://ilisp.cons.org> for more information.
+The following mailing lists are available:
 
-Enjoy
+  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.
+
+Enjoy,
+
 
 The ILISP Maintainers
 Welcome to ILISP.
 
-ILISP is a GNU Emacs package for controlling an inferior process
-running a lisp dialect.  You can get ILISP at
-<http://ilisp.cons.org>.
+ILISP is a GNU Emacs package for controlling an inferior process running a
+Lisp dialect.  You can get ILISP at:
 
+  http://ilisp.cons.org
 
-ILISP is currently being maintained by Marco Antoniotti
-<marcoxa@cons.org> and Rick Campbell <campbell@c2.net>.
+The project site, which provides access to the CVS source tree, bug
+database, mailing lists and other resources, is hosted at SourceForge:
 
-There is an ILISP mailing list managed by `majordomo'.
-Please address all list administration messages, such as requests to
-subscribe or unsubscribe, to:
+  http://sourceforge.net/projects/ilisp/
 
-	  <majordomo@cons.org> ILISP Administrivia
+ILISP is currently being maintained by Paolo Amoroso <amoroso@mclink.it>,
+Marco Antoniotti <marcoxa@cons.org>, Martin Atzmueller
+<mna@users.sourceforge.net>, Craig Brozefsky <craig@onshore.com>,
+William Deakin <w.deakin@pindar.com> and Matthias Koeppe
+<mkoeppe@users.sourceforge.net>.
 
-To send a message to everyone on the list, address it to:
+The following mailing lists are available:
 
-          <ilisp@cons.org> ILISP Discussion
+  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.
 
-The list has had a very low volume lately, so you may not see messages
-for a while after subscribing.
+You can subscribe to the lists and access the archives via the general
+information pages:
 
-Please note that there is no "bug" list like ilisp-bugs@cons.org.
-The primary list serves the purpose of a general bug fix and
-discussion area.
+  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
 
-Enjoy
+You may send bug reports, questions, suggestions, etc. to ilisp-help or
+ilisp-devel.
+
+Enjoy,
+
 
 The ILISP Maintainers
 ;;; -*- Mode: Lisp -*-
 
 ;;; allegro.lisp --
-
+;;; ILISP Franz ACL dialect support definitions.
+;;;
 ;;; This file is part of ILISP.
-;;; Version: 5.10.1
+;;; Please refer to the file COPYING for copyrights and licensing
+;;; information.
+;;; Please refer to the file ACKNOWLEGDEMENTS for an (incomplete) list
+;;; of present and past contributors.
 ;;;
-;;; Copyright (C) 1990, 1991, 1992, 1993 Chris McConnell
-;;;               1993, 1994 Ivan Vasquez
-;;;               1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
-;;;               1996-2000 Marco Antoniotti and Rick Campbell
-;;;
-;;; Other authors' names for which this Copyright notice also holds
-;;; may appear later in this file.
-;;;
-;;; Send mail to 'majordomo@cons.org' to be included in the
-;;; ILISP mailing list. 'ilisp@cons.org' is the general ILISP
-;;; mailing list were bugs and improvements are discussed.
-;;;
-;;; ILISP is freely redistributable under the terms found in the file
-;;; COPYING.
+;;; $Id$
 
 ;;; Allegro initializations
 ;;; Author: Chris McConnell, ccm@cs.cmu.edu
 
 (in-package "ILISP")
 
-;;; 19990615 Patch suggested by Larry Hunter <hunter@nlm.nih.gov>
+;;; 20001203 Patch suggested by Larry Hunter <Larry.Hunter@uchsc.edu>
 ;;; EXCL::FN_SYMDEF is no longer available by default.
 
-#+allegro-v5.0 (require :llstructs)
+#+(or allegro-v5.0 allegro-v6.0) (eval-when (compile load) (require
+                                                            :llstructs))
 
 ;;;
 (defun ilisp-callers (symbol package)
+;;; -*- Mode: Lisp -*-
+
 ;;; cl-chs-init.lisp --
 ;;; Init file for CLisp H.S.
 ;;;
+;;; This file is part of ILISP.
+;;; Please refer to the file COPYING for copyrights and licensing
+;;; information.
+;;; Please refer to the file ACKNOWLEGDEMENTS for an (incomplete) list
+;;; of present and past contributors.
+;;;
+;;; $Id$
+
+;;; Old history logs.
+;;;
 ;;; 19990912 Marco Antoniotti
 ;;; Cleaned up for inclusion in 5.9.1.  See also file 'cl-ilisp.lisp'
 ;;; for related changes (e.g. in ILISP-ERRORS).
 ;;; -*- Mode: Lisp -*-
 
 ;;; cl-ilisp.lisp --
-
-;;; This file is part of ILISP.
-;;; Version: 5.10.1
-;;;
-;;; Copyright (C) 1990, 1991, 1992, 1993 Chris McConnell
-;;;               1993, 1994 Ivan Vasquez
-;;;               1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
-;;;               1996-2000 Marco Antoniotti and Rick Campbell
-;;;
-;;; Other authors' names for which this Copyright notice also holds
-;;; may appear later in this file.
-;;;
-;;; Send mail to 'majordomo@cons.org' to be included in the
-;;; ILISP mailing list. 'ilisp@cons.org' is the general ILISP
-;;; mailing list were bugs and improvements are discussed.
-;;;
-;;; ILISP is freely redistributable under the terms found in the file
-;;; COPYING.
-
-
-
 ;;; Common Lisp initializations
 ;;; Author: Chris McConnell, ccm@cs.cmu.edu
+;;;
+;;; This file is part of ILISP.
+;;; Please refer to the file COPYING for copyrights and licensing
+;;; information.
+;;; Please refer to the file ACKNOWLEGDEMENTS for an (incomplete) list
+;;; of present and past contributors.
+;;;
+;;; $Id$
 
+
+;;; Old history log.
 ;;;
 ;;; ange-ftp hack added by ivan Wed Mar 10 12:30:15 1993
 ;;; ilisp-errors *gc-verbose* addition ivan Tue Mar 16 03:21:51 1993
 
 (defvar *ilisp-message-addon-string* "ILISP:")
 
+(defmacro the-symbol-if-defined ((if-symbol
+                                  if-package
+                                  &optional else-symbol else-package)
+                                 &body body)
+  (let* ((sym-if (and (find-package if-package)
+                      (find-symbol (symbol-name if-symbol)
+                                   (find-package if-package))))
+          (sym-else
+           (unless sym-if
+             (and else-symbol
+                  (find-package else-package)
+                  (find-symbol (symbol-name else-symbol)
+                               (find-package else-package))))))
+    (if (consp (first body))
+      `(let ((the-symbol ,(or sym-if sym-else)))
+        ,@body)
+      `',(or sym-if  sym-else))))
+                   
+(defmacro the-function-if-defined ((if-function
+                                    if-package
+                                    &optional else-function else-package)
+                                   &body body)
+  (let* ((fun-if
+           (ignore-errors
+             (find-symbol (symbol-name if-function)
+                          (find-package if-package))))
+         (fun-else
+           (unless fun-if
+             (ignore-errors
+               (and else-function
+                    (find-symbol (symbol-name else-function)
+                                 (find-package else-package)))))))
+    (when (or fun-if fun-else)
+      (if (and (consp body) (not (consp (first body))))
+        `(,(or fun-if fun-else) ,@body)
+        `(let ((the-function (symbol-function ',(or fun-if fun-else))))
+          ,@body)))))
+      
+
 ;;; Martin Atzmueller 2000-01-15
 ;;; ilisp-message was mostly set up because Clisp expects an
 ;;; ~& or ~% before the message-string, otherwise it does not display anything!"
   ;; Marco Antoniotti: Jan 2 1995.
   #-lucid
   (ilisp-eval
-   (format nil "(funcall (compile nil '(lisp:lambda () ~A)))"
+   (format nil "(funcall (compile nil '(lambda () ~A)))"
 	   form)
    package
    filename)
-  
-  ;; The following piece of conditional code is left in the
-  ;; distribution just for historical purposes.
-  ;; It will disappear in the next release.
-  ;; Marco Antoniotti: Jan 2 1995.
-  #+lucid-ilisp-5.6
-  (labels ((compiler (form env)
-		     (if (and (consp form)
-			      (eq (first form) 'function)
-			      (consp (second form)))
-			 #-LCL3.0
-		       (evalhook `(compile nil ,form) nil nil env)
-		       #+LCL3.0
-		       ;; If we have just compiled a named-lambda, and the
-		       ;; name didn't make it in to the procedure object,
-		       ;; then stuff the appropriate symbol in to the
-		       ;; procedure object.
-		       (let* ((proc (evalhook `(compile nil ,form)
-					      nil nil env))
-			      (old-name (and proc (sys:procedure-ref proc 1)))
-			      (lambda (second form))
-			      (name (and (eq (first lambda)
-					     'lucid::named-lambda)
-					 (second lambda))))
-			 (when (or (null old-name)
-				   (and (listp old-name)
-					(eq :internal (car old-name))))
-			       (setf (sys:procedure-ref proc 1) name))
-			 proc)
-		       (evalhook form #'compiler nil env))))
-	  (let ((*evalhook* #'compiler))
-	    (ilisp-eval form package filename)))
   #+lucid
   ;; Following form is a patch provided by Christopher Hoover
   ;; <ch@lks.csi.com>
     (terpri)
     (values)))
 
-#| Original version
-(defun print-function-arglist (fn)
-  "Pretty arglist printer"
-  (let* ((a (get-function-arglist fn))
- 	 (arglist (ldiff a (member '&aux a))))
-	 (desc (ilisp-function-short-description fn)))
-    (break "sun la")
-    (format t "~&~s~a" fn (or desc ""))
-    (write-string ": ")
-    (if arglist
-	(write arglist :case :downcase :escape nil)
-      (write-string "()"))
-    (terpri)
-    (values)))
-|#
-
-
-
 (defun ilisp-generic-function-p (symbol)
   (let ((generic-p
 	 (find-symbol "GENERIC-FUNCTION-P"
 	   #+:sbcl
 	   (arglist symbol (symbol-package symbol))
 	   
-	   #-(or allegro lucid kcl ibcl ecl clisp cmu :sbcl)
+	   #-(or allegro lucid kcl ibcl ecl gcl lispworks clisp cmu :sbcl)
 	   (documentation symbol 'function)))))
 
 
 	 (*print-length* nil)
 	 (*print-level* nil)
 	 (*package* (ilisp-find-package package)))
-     ;; (break "Cheking ILISP-PRINT-INFO-MESSAGE")
      (cond ((null real-symbol)
 	    (format t "")
 	    ;; (ilisp-message t "symbol ~S not present in ~S." symbol package)
 
 (eval-when (load eval)
   (when
-      #+(and :CMU :CMU17)
+      #+(and :CMU (or :CMU17 :CMU18))
       (eval:interpreted-function-p #'ilisp-matching-symbols)
-      #-(and :CMU :CMU17)
+      #-(and :CMU (or :CMU17 :CMU18))
       (not (compiled-function-p #'ilisp-matching-symbols))
       (ilisp-message *standard-output*
 		     "File is not compiled, use M-x ilisp-compile-inits")))
 ;;; -*- Mode: Lisp -*-
 
 ;;; cmulisp.lisp --
-
+;;; ILISP CMU Common Lisp dialect support definitions.
+;;; Author: Todd Kaufmann    May 1990
+;;;
 ;;; This file is part of ILISP.
-;;; Version: 5.10.1
+;;; Please refer to the file COPYING for copyrights and licensing
+;;; information.
+;;; Please refer to the file ACKNOWLEGDEMENTS for an (incomplete) list
+;;; of present and past contributors.
 ;;;
-;;; Copyright (C) 1990, 1991, 1992, 1993 Chris McConnell
-;;;               1993, 1994 Ivan Vasquez
-;;;               1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
-;;;               1996-2000 Marco Antoniotti and Rick Campbell
-;;;
-;;; Other authors' names for which this Copyright notice also holds
-;;; may appear later in this file.
-;;;
-;;; Send mail to 'majordomo@cons.org' to be included in the
-;;; ILISP mailing list. 'ilisp@cons.org' is the general ILISP
-;;; mailing list were bugs and improvements are discussed.
-;;;
-;;; ILISP is freely redistributable under the terms found in the file
-;;; COPYING.
-
-
-
-;;;
-;;; Todd Kaufmann    May 1990
-;;;
-;;; Make CMU CL run better within GNU inferior-lisp (by ccm).
-;;;
+;;; $Id$
 
 
 (in-package "ILISP")
 
 ;;;%% arglist - return arglist of function
 ;;;
-;;; 19991219 Marco Antoniotti
-;;; New version is patterned after DESCRIBE-FUNCTION in the
+;;; This function is patterned after DESCRIBE-FUNCTION in the
 ;;; 'describe.lisp' file of CMUCL.
 
 (defun arglist (symbol package)
    (let* ((package-name (if (packagep package)
 			    (package-name package)
 			    package))
-	  (x (ilisp-find-symbol symbol package-name))
-	  )
+	  (x (ilisp-find-symbol symbol package-name)))
      (flet ((massage-arglist (args)
 	      (typecase args
 		(string (if (or (null args) (string= args "()"))
 		 #.vm:function-header-type
 		 #.vm:closure-function-header-type)
 		(massage-arglist
-		 (funcall #+CMU17 #'lisp::%function-arglist
-			  #-CMU17 #'lisp::%function-header-arglist
-			  func)))
-
+                 (the-function-if-defined
+                  (#:%function-arglist :lisp #:%function-header-arglist :lisp)
+                  func)))
 	       (#.vm:funcallable-instance-header-type
 		(typecase func
 		  (kernel:byte-function
 		  (eval:interpreted-function
 		   (massage-arglist (eval::interpreted-function-arglist func)))
 		
-		  (t (print 99 *trace-output*) "No arglist available.")
-		  ))			; typecase
-	       (t "No arglist available.")) ; case
+		  (t (print 99 *trace-output*) "No arglist available.")))
+	       (t "No arglist available."))
 	     "Unknown function - no arglist available." ; For the time
 					; being I just
 					; return this
 					; be better.
 	     ))))))
 
-#| Original version.
-(defun arglist (symbol package)
-  (ilisp-errors
-   (let* ((package-name (if (packagep package)
-			    (package-name package)
-			    package))
-	  (x (ilisp-find-symbol symbol package-name))
-	  (fun (get-correct-fn-object x)))
-     (values
-      (cond ((eval:interpreted-function-p fun) 
-	     (eval:interpreted-function-arglist fun))
-	    ((= (lisp::get-type fun)
-		#.vm:funcallable-instance-header-type) 
-	     ;; generic function / method
-	     (pcl::generic-function-pretty-arglist fun))
-	    ((compiled-function-p fun)
-	     (let ((string-or-nil
-		    (funcall #+CMU17 #'lisp::%function-arglist
-			     #-CMU17 #'lisp::%function-header-arglist
-		     fun)))
-	       (if string-or-nil
-		   (read-from-string string-or-nil)
-		   "No argument info.")))
-	    (t (error "Unknown type of function")))))))
-|#
-
 
 ;;; source-file symbol package type --
 ;;; New version provided by Richard Harris <rharris@chestnut.com> with
    (let* ((x (ilisp-find-symbol symbol package))
 	  (fun (get-correct-fn-object x)))
      (when (and fun (not (eval:interpreted-function-p fun)))
-	   ;; The hack above is necessary because CMUCL does not
-	   ;; correctly record source file information when 'loading'
-	   ;; a non compiled file.
-	   ;; In this case we fall back on the TAGS machinery.
-	   ;; (At least as I underestand the code).
-	   ;; Marco Antoniotti 11/22/94.
-	   (cond (#+CMU17 (pcl::generic-function-p fun)
-			  #-CMU17
-			  (= (lisp::get-type fun)
-			     #.vm:funcallable-instance-header-type)
-			  (dolist (method (pcl::generic-function-methods fun))
-				  (print-simple-source-info
-				   (or #+CMU17
-				       (pcl::method-fast-function method)
-				       (pcl::method-function method))))
-			  t)
-		 (t (print-simple-source-info fun)))))))
-
-;;; Old version. Left here for the time being.
-;(defun source-file (symbol package type)
-;  (declare (ignore type))
-;  (ilisp-errors
-;   (let* ((x (ilisp-find-symbol symbol package))
-;	  (fun (get-correct-fn-object x)))
-;     (when fun
-;       (cond ((= (lisp::get-type fun)
-;		 #.vm:funcallable-instance-header-type)
-;	      ;; A PCL method! Uh boy!
-;	      (dolist (method (pcl::generic-function-methods fun))
-;		(print-simple-source-info
-;		 (lisp::%closure-function (pcl::method-function method))))
-;	      t)
-;	     (t (print-simple-source-info fun)))))))
-
+       ;; The hack above is necessary because CMUCL does not
+       ;; correctly record source file information when 'loading'
+       ;; a non compiled file.
+       ;; In this case we fall back on the TAGS machinery.
+       ;; (At least as I underestand the code).
+       ;; Marco Antoniotti 11/22/94.
+       (cond ((or (the-function-if-defined (#:generic-function-p :pcl) fun)
+                  (the-function-if-defined (#:get-type :lisp)
+                                           (= (funcall the-function fun)
+                                              #.vm:funcallable-instance-header-type)))
+               (dolist (method (pcl::generic-function-methods fun))
+                 (print-simple-source-info
+                  (the-function-if-defined
+                   (#:method-fast-function :pcl #:method-function :pcl)
+                   method)))
+               t)
+             (t (print-simple-source-info fun)))))))
 
 ;;; Patch suggested by Richard Harris <rharris@chestnut.com>
 
 function was defined in.  If it was not defined in some file, nil is
 returned."
   (flet ((frob (code)
-	       (let ((info #+CMU17 (kernel:%code-debug-info code)
-			   #-CMU17 (kernel:code-debug-info code)))
+	       (let ((info (the-function-if-defined
+                            (#:%code-debug-info :kernel #:code-debug-info :kernel)
+                            code)))
 		 (when info
 		       (let ((sources (c::debug-info-source info)))
 			 (when sources
 				       (c::debug-source-name source)))))))))
 	(typecase function
 		  (symbol (fun-defined-from-pathname (fdefinition function)))
-		  #+CMU17
-		  (kernel:byte-closure
-		   (fun-defined-from-pathname
-		    (kernel:byte-closure-function function)))
-		  #+CMU17
-		  (kernel:byte-function
+                  (#.(the-symbol-if-defined (#:byte-closure :kernel))
+                   (fun-defined-from-pathname
+                    (kernel:byte-closure-function function)))		  
+		  (#.(the-symbol-if-defined (#:byte-function :kernel))
 		   (frob (c::byte-function-component function)))
 		  (function
 		   (frob (kernel:function-code-header
       (print (namestring (truename path)))
       t)))
 
-
-;;; Old version (semi patched). Left here for the time being.
-;(defun print-simple-source-info (fun)
-;  (let ((info (#+CMU17
-;	       kernel:%code-debug-info
-;	       #-CMU17
-;	       kernel:code-debug-info       
-;	       (kernel:function-code-header fun))))
-;    (when info
-;	  (let ((sources (c::compiled-debug-info-source info)))
-;	    (when sources
-;		  (dolist (source sources)
-;			  (let ((name (c::debug-source-name source)))
-;			    (when (eq (c::debug-source-from source) :file)
-;				  ;; Patch suggested by
-;				  ;; hunter@work.nlm.nih.gov (Larry
-;				  ;; Hunter) 
-;				  ;; (print (namestring name)) ; old
-;				  (print (truename name))
-;				  )))
-;		  t)))))
-
-
 (defun cmulisp-trace (symbol package breakp)
   "Trace SYMBOL in PACKAGE."
   (ilisp-errors
 (defun comint-sender (process string)
   "Send to PROCESS STRING with newline if comint-send-newline."
   ;; (comint-send-string process string)
+  (comint-log process string)
   (process-send-string process string)
   (if comint-send-newline
       (progn
-;;; completer.el --- powerful completion mechanism
-
-;; Partial completion mechanism for XEmacs.  Version 3.04.
-;; Copyright (C) 1990, 1991, 1992 Chris McConnell <chrimc@microsoft.com>
-;; Copyright (C) 2000 Ben Wing.
-
-;; Author: Chris Mcconnell <chrimc@microsoft.com>
-;; Latest XEmacs Author: Ben Wing
-;; Maintainer: Ben Wing
-;; Keywords: minibuffer, completion
-
+;;; -*-Emacs-Lisp-*-
+;;;%Header
+;;;
+;;; Rcs_Info: completer.el,v 3.23 1993/09/03 02:05:07 ivan Rel $
+;;;
+;;; Partial completion mechanism for GNU Emacs.  Version 3.03
+;;; Copyright (C) 1990, 1991, 1992 Chris McConnell, ccm@cs.cmu.edu.
 ;;; Thanks to Bjorn Victor for suggestions, testing, and patches for
 ;;; file completion. 
 
-;;; This file is part of XEmacs.
+;;; This file is part of GNU Emacs.
 
-;;; XEmacs is distributed in the hope that it will be useful,
+;;; GNU Emacs is distributed in the hope that it will be useful,
 ;;; but WITHOUT ANY WARRANTY.  No author or distributor
 ;;; accepts responsibility to anyone for the consequences of using it
 ;;; or for whether it serves any particular purpose or works at all,
 ;;; unless he says so in writing.  Refer to the GNU Emacs General Public
 ;;; License for full details.
 ;;; Everyone is granted permission to copy, modify and redistribute
-;;; XEmacs, but only under the conditions described in the
+;;; GNU Emacs, but only under the conditions described in the
 ;;; GNU Emacs General Public License.   A copy of this license is
-;;; supposed to have been given to you along with XEmacs so you
+;;; supposed to have been given to you along with GNU Emacs so you
 ;;; can know your rights and responsibilities.  It should be in a
 ;;; file named COPYING.  Among other things, the copyright notice
 ;;; and this notice must be preserved on all copies.
 (defvar completer-path-cache nil
   "Cache of (path . choices) for completer.")
 
-(defvar completer-path-separator-string
-  (if (eq system-type 'windows-nt) "\\" "/"))
-
-(defvar completer-path-separator-regexp
-  (if (eq system-type 'windows-nt) "[/\\]" "/"))
-
-(defvar completer-path-delimiter-list
-  (if (eq system-type 'windows-nt) '(?\\ ?/) '(?/)))
-
-(defvar completer-path-separator-regexp-inside-brackets
-  (if (eq system-type 'windows-nt) "/\\" "/"))
-
-(defvar completer-dot-dot-list
-  (if (eq system-type 'windows-nt) '("../" "..\\") '("../")))
-
 (defvar completer-string nil "Last completer string.")
 (defvar completer-table nil "Last completer table.")
 (defvar completer-pred nil "Last completer pred.")
     (delete-region point end)
     (if (and quit-flag 
 	     ;;(not (eq 'lucid-19 ilisp-emacs-version-id))
-	     (not (string-match "XEmacs" emacs-version))
+	     (not (string-match "Lucid" emacs-version))
 	     )
 	(setq quit-flag nil
 	      unread-command-char 7))))
 
 ;;;
 (defun completer-deleter (regexp choices &optional keep)
-  "Destructively remove strings that match REGEXP in CHOICES and
-return the modified list.  If optional KEEP, then keep entries that
+  "Destructively remove strings that match REGEXP in CHOICES.
+Return the modified list.  If optional KEEP, then keep entries that
 match regexp."
   (let* ((choiceb choices)
 	 choicep)
 
 ;;;%%Regexp
 (defun completer-regexp (string delimiters any)
-  "Convert STRING into a regexp with words delimited by characters in
-DELIMITERS.  Any delimiter in STRING that is the same as ANY will
-match any delimiter."
+  "Convert STRING into a regexp with words delimited by chars in DELIMITERS.
+Any delimiter in STRING that is the same as ANY will match any delimiter."
   (let* ((delimiter-reg (concat "[" delimiters "]"))
 	 (limit (length string))
 	 (pos 0)
 
 ;;;%Matcher
 (defun completer-matches (string choices delimiters any)
-    "Return STRING's matches in CHOICES using DELIMITERS and wildcard
-ANY to segment the strings."
+    "Return STRING's matches in CHOICES.
+DELIMITERS and the wildcard ANY are used  to segment the strings."
     (let* ((regexp (concat "[" delimiters "]"))
 	   (from nil)
 	   (to 0)
 
 ;;;
 (defun completer-choice (string choices delimiters use-words)
-  "Return the best match of STRING in CHOICES with DELIMITERS between
-words and T if it is unique.  A match is unique if it is the only
+  "Return a list with best match of STRING in CHOICES and T if it is unique.
+DELIMITERS are used to separate words.  A match is unique if it is the only
 possibility or when USE-WORDS the only possibility with the same
 number of words.  The shortest string of multiple possibilities will be
 the best match."
 ;;;%Completer
 ;;;%%Utilities
 (defun completer-region (delimiters)
-  "Return the completion region bounded by characters in DELIMITERS
-for the current buffer assuming that point is in it."
+  "Return the completion region bounded by characters in DELIMITERS.
+The search is for the current buffer assuming that point is in it."
   (cons (save-excursion (skip-chars-backward delimiters) (point))
 	(save-excursion (skip-chars-forward delimiters) (point))))
 	 
   (let ((last (1- (length string)) )
 	(match 0)
 	(end 0))
-    (while (and (setq match (string-match completer-path-separator-regexp string end)) (< match last))
+    (while (and (setq match (string-match "/" string end)) (< match last))
       (setq end (1+ match)))
     end))
 
 ;;;
 (defun completer-match-record (string matches delimiters any dir mode)
-  "Return (match lcs choices unique) for STRING in MATCHES with
+  "Return (match lcs choices unique) for STRING in MATCHES.
 DELIMITERS or ANY wildcards and DIR if a filename when in MODE."
   (let ((pattern (if dir
 		     (substring string (completer-last-component string))
 
 ;;;%%Complete file
 (defun completer-extension-regexp (extensions)
-  "Return a regexp that matches to a string that ends with any string from EXTENSIONS list."
+  "Return a regexp that matches a string ending with any string in EXTENSIONS."
   (concat "\\(" (mapconcat 'regexp-quote extensions "\\|") "\\)\\'"))
 
 ;;;
 
 ;;;
 (defun completer-cache (path pred words any mode)
-  "Check to see if PATH is in path cache with PRED, WORDS, ANY and
-MODE."
+  "Check to see if PATH is in path cache with PRED, WORDS, ANY and MODE."
   (let* ((last nil)
 	 (ptr completer-path-cache)
 	 (size 0) 
 			   mode t)))
 	  (if (and (or (car (cdr (cdr (cdr choices))))
 		       (string= path (car choices)))
-		   (memq (elt (car choices) (1- (length (car choices))))
-			 completer-path-delimiter-list))
+		   (eq (elt (car choices) (1- (length (car choices)))) ?/))
 	      (progn 
 		(if (>= size completer-cache-size) (rplacd last nil))
 		(setq completer-path-cache 
 
 ;;;
 (defun completer-file (string pred words any mode)
-  "Return (match common-substring matches unique-p) for STRING using
-read-file-name-internal for choices that pass PRED using WORDS to
+  "Return (match common-substring matches unique-p) for STRING.
+It uses 'READ-FILE-NAME-INTERNAL' for choices that pass PRED using WORDS to
 delimit words.  Optional ANY is a delimiter that matches any of the
 delimiters in WORD.  If optional MODE is nil or 'help then possible
 matches will always be returned."
-  ;; canonicalize slashes under windows-nt for proper completion
-  (if (eq system-type 'windows-nt)
-      (setq string (replace-in-string string "/" "\\\\")))
   (let* ((case-fold-search completion-ignore-case)
 	 (last (and (eq mode 'exit-ok) (completer-last-component string)))
 	 (position
-	  ;; find beginning of first directory component.
-	  (cond
-	   ;; CMU RFS filenames like /../computername/foo/bar.c
-	   ((string-match "^/\\.\\./[^/]*/" string)
-	    (match-end 0))
-	   ;; windows-nt filenames like \\computername\foo\bar.c, or
-	   ;; cygwin filenames like //d/foo/bar.c
-	   ((and (memq system-type '(windows-nt cygwin32))
-		 (string-match "[/\\][/\\][^/\\]*[/\\]" string))
-	    (match-end 0))
-	   ;; windows-nt filenames like c:\foo\bar.c or c:bar.c
-	   ((and (eq system-type 'windows-nt)
-		 (string-match "[A-Za-z]:[/\\]?" string))
-	    (match-end 0))
-	   (t
-	    ;; normal absolute or relative names, or names beginning
-	    ;; with ~/
-	    (string-match
-	     (concat "[^~" completer-path-separator-regexp-inside-brackets
-		     "]") string))))
+	  ;; Special hack for CMU RFS filenames
+	  (if (string-match "^/\\.\\./[^/]*/" string)
+	      (match-end 0)
+	      (string-match "[^~/]" string)))
 	 (new (substring string 0 position))
 	 (user (if (string= new "~")
 		   (setq new (file-name-directory (expand-file-name new)))))
-	 (words (concat words completer-path-separator-regexp-inside-brackets))
+	 (words (concat words "/"))
 	 (len (length string))
 	 (choices nil)
 	 end
 	 (old-choices (list nil nil nil nil)))
     (while position
-      (let* ((begin (string-match completer-path-separator-regexp string
-				  position))
+      (let* ((begin (string-match "/" string position))
 	     (exact-p nil))
 	(setq end (if begin (match-end 0))
 	      choices
 		   (let* ((choices
 			   (all-completions new 'read-file-name-internal))
 			  (choicep choices))
-		     (if (member (car choicep) completer-dot-dot-list)
+		     (if (string= (car choicep) "../")
 			 (cdr (cdr choicep))
 			 (while (cdr choicep)
-			   (if (member (car (cdr choicep))
-				       completer-dot-dot-list)
+			   (if (string= (car (cdr choicep)) "../")
 			       (rplacd choicep nil))
 			   (setq choicep (cdr choicep)))
 			 choices))
 	    (setq old-choices
 		  (let* ((lcs (car (cdr choices)))
 			 (matches (car (cdr (cdr choices))))
-			 (slash
-			  (and lcs
-			       (string-match
-				(concat completer-path-separator-regexp "$")
-				lcs))))
+			 (slash (and lcs (string-match "/$" lcs))))
 		    (list nil
 			  (if slash (substring lcs 0 slash) lcs)
 			  (if (and (cdr matches) 
 ;;;%%Completer
 (defun completer (string table pred words
 			 &optional any mode file-p)
-  "Return (match common-substring matches unique-p) for STRING in
-TABLE for choices that pass PRED using WORDS to delimit words.  If the
-flag completer-complete-filenames is T and the table is
-read-file-name-internal or read-directory-name-internal, then filename
-components will be individually expanded.  Optional ANY is a delimiter
-that can match any delimiter in WORDS.  Optional MODE is nil for
-complete, 'help for help and 'exit for exit."
+  "Return (match common-substring matches unique-p) for STRING in TABLE.
+The choices must also pass PRED using WORDS to delimit words.  If the
+flag 'COMPLETER-COMPLETE-FILENAMES' is T and the table is
+'READ-FILE-NAME-INTERNAL', then filename components will be individually
+expanded.  Optional ANY is a delimiter that can match any delimiter in
+WORDS.  Optional MODE is nil for complete, 'help for help and 'exit
+for exit."
   (if (and (stringp completer-string) 
 	   (string= string completer-string)
 	   (eq table completer-table)
        completer-mode mode
        completer-result
        (if (and completer-complete-filenames
-		(not file-p) (memq table '(read-file-name-internal
-					   read-directory-name-internal)))
+		(not file-p) (eq table 'read-file-name-internal))
 	   (completer-file string pred words any mode)
-	   (let* ((file-p (or file-p 
-			      (memq table '(read-file-name-internal
-					    read-directory-name-internal))))
+	   (let* ((file-p (or file-p (eq table 'read-file-name-internal)))
 		  (case-fold-search completion-ignore-case)
 		  (pattern (concat "[" words "]"))
 		  (component (if file-p (completer-last-component string)))
 		 ;; Handle environment variables
 		 (let ((match
 			(getenv (substring string 1 
-					   (string-match completer-path-separator-regexp string)))))
-		   (if match
-		       (setq match
-			     (concat match
-				     completer-path-separator-string)))
+					   (string-match "/" string)))))
+		   (if match (setq match (concat match "/")))
 		   (list match match (list match) match))
 		 (let* ((choices
 			 (all-completions 
 ;;;%%Display choices
 (defun completer-display-choices (choices &optional match message end
 					  display)
-  "Display the list of possible CHOICES with optional MATCH, MESSAGE,
-END and DISPLAY.  If MATCH is non-nil, it will be flagged as the best
-guess.  If there are no choices, display MESSAGE.  END is where to put
-temporary messages.  If DISPLAY is present then it will be called on
-each possible completion and should return a string."
+  "Display the list of possible CHOICES.
+MATCH, MESSAGE, END and DISPLAY are used optionally.  If MATCH is
+non-nil, it will be flagged as the best guess.  If there are no
+choices, display MESSAGE.  END is where to put temporary messages.  If
+DISPLAY is present then it will be called on each possible completion
+and should return a string."
+
   (if choices
       (with-output-to-temp-buffer "*Completions*"
 	(if (cdr choices) 
 ;;;%%Goto
 (defun completer-goto (match lcs choices unique delimiters words 
 			     &optional mode display)
-  "MATCH is the best match, LCS is the longest common substring of all
+  "Go to the part of the string that disambiguates CHOICES.
+MATCH is the best match, LCS is the longest common substring of all
 of the matches.  CHOICES is a list of the possibilities, UNIQUE
 indicates if MATCH is unique.  DELIMITERS are possible bounding
 characters for the completion region.  WORDS are the characters that
 delimit the words for partial matches.  Replace the region bounded by
 delimiters with the match if unique and the lcs otherwise unless
 optional MODE is 'help.  Then go to the part of the string that
-disambiguates choices using WORDS to separate words and display the
+disambiguates CHOICES using WORDS to separate words and display the
 possibilities if the string was not extended.  If optional DISPLAY is
 present then it will be called on each possible completion and should
 return a string."
 	 (start (car region))
 	 (end (cdr region))
 	 (string (buffer-substring start end))
-	 (file-p (string-match (if (eq system-type 'windows-nt)
-				   "[^ ]*\\(~\\|/\\|\\\\\\|\\|$\\)"
-				 "[^ ]*\\(~\\|/\\|$\\)") string))
+	 (file-p (string-match "[^ ]*\\(~\\|/\\|$\\)" string))
 	 (no-insert (eq mode 'help))
 	 (message t)
 	 (new (not (string= (buffer-substring start (point)) lcs))))
 	;;Not unique
 	(if lcs
 	    (let* ((regexp 
-		    (concat "[" words (if file-p completer-path-separator-regexp-inside-brackets) "]"))
+		    (concat "[" words (if file-p "/") "]"))
 		   (words (completer-words regexp lcs))
 		   point)
 	      ;; Go to where its ambiguous
 	    (if file-p 
 		(progn 
 		  (if (not (= (point) end)) (forward-char 1))
-		  (if (not (save-excursion (re-search-forward completer-path-separator-regexp end t)))
+		  (if (not (save-excursion (re-search-forward "/" end t)))
 		      (goto-char end))))
 	    (if message
 		(progn
 
 ;;;%%Undo
 (defun completer-insert (match delimiters &optional buffer undo)
-  "Replace the region bounded with characters in DELIMITERS by MATCH
-and save it so that it can be restored by completer-undo."
+  "Replace the region bounded with characters in DELIMITERS by MATCH.
+Then save it so that it can be restored by completer-undo."
   (let* ((region (completer-region delimiters))
 	 (start (car region))
 	 (end (cdr region)))
 ;;;%Minibuffer specific code
 ;;;%%Utilities
 (defun completer-minibuf-string ()
-  "Remove dead filename specs from the minibuffer as delimited by //
-or ~ or $ and return the resulting string."
+  "Remove dead filename specs from the minibuffer.
+Dead filename should be delimited by // or ~ or $ and return the
+resulting string."
   (save-excursion
     (goto-char (point-max))
-    (if (and (memq minibuffer-completion-table
-		   '(read-file-name-internal
-		     read-directory-name-internal))
-	     (re-search-backward
-	      (if (memq system-type '(windows-nt cygwin32))
-		  ; // is meaningful
-		  "/~\\|.\\$" "//\\|/~\\|.\\$") nil t))
+    (if (and (eq minibuffer-completion-table 'read-file-name-internal)
+	     (re-search-backward "//\\|/~\\|.\\$" nil t))
 	(delete-region (point-min) (1+ (point))))
     (buffer-substring (point-min) (point-max))))
 
 	  (let ((string (completer-minibuf-string)))
 	    (or
 	     (not (string-match
-		   (concat "[" completer-words
-			   completer-path-separator-regexp-inside-brackets "~]")
+		   (concat "[" completer-words "/~]")
 		   string))
 	      (condition-case ()
 		  (let ((completion
 			 (try-completion string
 					 minibuffer-completion-table
 					 minibuffer-completion-predicate)))
-		    (if (memq minibuffer-completion-table
-			      '(read-file-name-internal
-				read-directory-name-internal))
+		    (if (eq minibuffer-completion-table
+			    'read-file-name-internal)
 			;; Directories complete as themselves
 			(and completion
 			     (or (not (string= string completion))
 
 ;;;
 (defun completer-minibuf (&optional mode)
-  "Partial completion of minibuffer expressions.  Optional MODE is
-'help for help and 'exit for exit.
+  "Partial completion of minibuffer expressions.
+Optional MODE is (quote help) for help and (quote exit) for exit.
 
 If what has been typed so far matches any possibility normal
 completion will be done.  Otherwise, the string is considered to be a
 Examples:
 a-f     auto-fill-mode
 r-e     rmail-expunge
-b--d    *beginning-of-defun or byte-recompile-directory
+b--d    *begining-of-defun or byte-recompile-directory
 by  d   *byte-recompile-directory if completer-any-delimiter is \" \"
 ~/i.e   *~/ilisp.el or ~/il-el.el or ~/ilisp.elc
 /u/mi/  /usr/misc/"
 (defvar completer-old-completer
   (lookup-key minibuffer-local-must-match-map "\t")
   "Old binding of TAB in minibuffer completion map.")
+
 (defun completer-complete ()
   "Partial completion minibuffer-complete.
 See completer-minibuf for more information."
 
 ;;;%lisp-complete-symbol
 (defun lisp-complete-symbol (&optional mode)
-  "Perform partial completion on Lisp symbol preceding point.  That
-symbol is compared against the symbols that exist and any additional
+  "Perform partial completion on Lisp symbol preceding point.
+That symbol is compared against the symbols that exist and any additional
 characters determined by what is there are inserted.  If the symbol
 starts just after an open-parenthesis, only symbols with function
 definitions are considered.  Otherwise, all symbols with function
 ;;;%Hooks
 (provide 'completer)
 (run-hooks 'completer-load-hook)
+
+;;; end of file -- completer.el --
 ;;; -*- Mode: Emacs-Lisp -*-
 
 ;;; custom-ilisp.el --
-
-;;; This file is part of ILISP.
-;;; Version: 5.10.1
-;;;
-;;; Copyright (C) 1990, 1991, 1992, 1993 Chris McConnell
-;;;               1993, 1994 Ivan Vasquez
-;;;               1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
-;;;               1996-2000 Marco Antoniotti and Rick Campbell
-;;;
-;;; Other authors' names for which this Copyright notice also holds
-;;; may appear later in this file.
-;;;
-;;; Send mail to 'majordomo@cons.org' to be included in the
-;;; ILISP mailing list. 'ilisp@cons.org' is the general ILISP
-;;; mailing list were bugs and improvements are discussed.
-;;;
-;;; ILISP is freely redistributable under the terms found in the file
-;;; COPYING.
-
 ;;; ILISP Customization.
-
 ;;; WARNING!  This file is not loaded yet.  Loading it may cause some
 ;;; problems.
-
+;;;
+;;; This file is part of ILISP.
+;;; Please refer to the file COPYING for copyrights and licensing
+;;; information.
+;;; Please refer to the file ACKNOWLEGDEMENTS for an (incomplete) list
+;;; of present and past contributors.
+;;;
+;;; $Id$
 
 (defgroup ILisp nil
   "The ILisp Inferior Lisp System."
-ILISP 5.9 DOC
-=============
+ILISP DOCUMENTATION
+===================
 
 ILISP is a powerful GNU Emacs interface to many dialects of Lisp.
 
-This is the 'doc' directory.
+This is the 'docs' directory.
 
 Using 'make' you can produce .dvi, .ps and .info files for ILISP,
 starting from the 'ilisp.texi' file.
 
-There is also the 'ilisp-refcard' packag which you may find useful
-(provided by Valentino Kyriakides).
+There is also the reference card 'ilisp-refcard.tex' which you may
+find useful (provided by Valentino Kyriakides).
 
-Enjoy
+Enjoy,
 
-19990820 The ILISP Maintainers
+
+The ILISP Maintainers

docs/doc-changes.txt

-Changes to the ILISP manual draft for version 5.9
--------------------------------------------------
+2000-04-21  Paolo Amoroso  <amoroso@mclink.it>
+
+        * doc/doc-changes.txt: Restored information lost in the move to
+          SourceForge.
+          WARNING: This file is now obsolete and it will no longer be
+          maintained. It may be removed in future releases. From now on all
+          changes will be logged through CVS. For a list of changes from
+          2000-02-15 to the ILISP 5.10.1 release see the HISTORY file which
+          comes with the 5.10.1 distribution.
+
+2000-02-15  Paolo Amoroso  <amoroso@mclink.it>
+
+	* doc/ilisp.texi: Added @key formatting to some index entries.
+
+2000-02-07  Paolo Amoroso  <amoroso@mclink.it>
+
+	* doc/ilisp.texi (Files of ILISP): added entry for ilisp-sbcl.el.
+
+	* INSTALLATION, doc/ilisp.texi (installation instructions):
+	replaced unnecessary references to explicit version numbers
+	in files (e.g. 5.9.4) with generic ones (i.e. x.y.z).
+
+2000-02-03  Karl Fogel  <kfogel@onshore.com>
+
+        * doc/ilisp.texi (Keybindings): new node, document the
+        FSF-compliant keybinding situation.
+        (Miscellany): removed mention of ] for `close-all-lisp' (see
+        change to `lisp-bindings' in ilisp-key.el, below).
+
+
+Changes to ilisp.texi (from the draft for version 5.9 to 5.9.4)
+---------------------------------------------------------------
 
 (lesson learned from maintaining this file: I should have sorted and
-grouped entries by date - Paolo ;-)
+grouped entries by date - Paolo Amoroso ;-)
 
 -- Updated version information about ILISP and the manual.
 

docs/ilisp-refcard.tex

+% Reference Card for the ilisp Interface, as reported in ilisp-5.8.
+% Last edited: Sat Sep 27 20:07:53 1997 by vkyr (Valentino Kyriakides)
+
+%**start of header
+\newcount\columnsperpage
+
+% This file can be printed with 1, 2, or 3 columns per page (see below).
+% Specify how many you want here.  Nothing else needs to be changed.
+
+\columnsperpage=3
+
+% Copyright (c) 1997 by no one.  e.g. distribute it at will, subject to
+% permissions below.
+%
+% Author: (e.g. please send obvious bugs to)
+%  Valentino Kyriakides
+%  Internet: kyriakides@lavielle.com
+%
+% Of course, no one makes any claims on this, nor do I promise to "support" it.
+% Thanks to Stephen Gildea, Paul Rubin, Bob Chassell, Len Tower,
+% and Richard Mlynarik for the excellent GNU Emacs reference card on which
+% this is based.
+%
+% The idea of this was to have a piece of paper that prods your memory if
+% you've forgotten the name of a function, a keybinding, etc.  It assumes
+% pretty serious familiarity with the ilisp manual, but hopefully saves the effort
+% (in conjunction with all the manuals) of lugging out a
+% printed copy in most cases.  It of course reflects my (the author's)
+% biases about what was likely to be interesting or used often.
+%
+% To view, do 'tex ilisp-refcard.tex'. 
+% To print if you use columnsperpage=3, you must use have a dvips-like
+% program that prints in landscape format!
+
+% This file is distributed in the hope that it will be useful, but WITHOUT
+% ANY WARRANTY.  No author or distributor accepts responsibility to anyone
+% for the consequences of using it or for whether it serves any particular
+% purpose or describes any piece of software unless they say so in writing.  
+%
+% Permission is granted to copy, modify and redistribute this source
+% file provided the permission notices are preserved on all copies.
+%
+% Permission is granted to process this file with TeX and print the results.
+
+% This file is intended to be processed by plain TeX (TeX82).
+%
+% The final reference card has six columns, three on each side.
+% This file can be used to produce it in any of three ways:
+% 1 column per page
+%    produces six separate pages, each of which needs to be reduced to 80%.
+%    This gives the best resolution.
+% 2 columns per page
+%    produces three already-reduced pages.
+%    You will still need to cut and paste.
+% 3 columns per page
+%    produces two pages which must be printed sideways to make a
+%    ready-to-use 8.5 x 11 inch reference card.
+%    For this you need a dvi device driver that can print sideways.
+% Which mode to use is controlled by setting \columnsperpage above.
+
+\def\versionnumber{1.0}
+\def\year{1997}
+\def\version{September \year\ v\versionnumber}
+
+\def\shortcopyrightnotice{\vskip 1ex plus 2 fill \centerline{\small September
+  \year by Valentino Kyriakides.  Permissions on back.  v\versionnumber}}
+
+\def\copyrightnotice{
+\vskip 1ex plus 2 fill\begingroup\small
+\centerline{Designed by Valentino Kyriakides (kyriakides@lavielle.com), 9/97.}
+\centerline{Permission is granted to make \& distribute copies}
+\centerline{of this card provided this permission notice is preserved.}
+\endgroup}
+
+% ===================================================================
+% Macros to define this "mode".
+% ===================================================================
+%
+% make \bye not \outer so that the \def\bye in the \else clause below
+% can be scanned without complaint.
+\def\bye{\par\vfill\supereject\end}
+
+\newdimen\intercolumnskip
+\newbox\columna
+\newbox\columnb
+
+\def\ncolumns{\the\columnsperpage}
+
+\message{[\ncolumns\space 
+  column\if 1\ncolumns\else s\fi\space per page]}
+
+\def\scaledmag#1{ scaled \magstep #1}
+
+% This multi-way format was designed by Stephen Gildea October 1986.
+\if 1\ncolumns
+  \hsize 4in
+  \vsize 10in
+  \voffset -.7in
+  \font\titlefont=\fontname\tenbf \scaledmag4
+  \font\secfont=\fontname\tenbf \scaledmag3
+  \font\subsecfont=\fontname\tenbf \scaledmag2
+  \font\smallfont=\fontname\sevenrm
+  \font\smallsy=\fontname\sevensy
+
+  \footline{\hss\folio}
+  \def\makefootline{\baselineskip10pt\hsize6.5in\line{\the\footline}}
+\else
+  \hsize 3.2in
+  \vsize 7.95in
+  \hoffset -.75in
+  \voffset -.745in
+  \font\titlefont=cmbx10 \scaledmag3
+  \font\secfont=cmbx10 \scaledmag2
+  \font\subsecfont=cmbx10 \scaledmag1
+  \font\smallfont=cmr6
+  \font\smallsy=cmsy6
+  \font\eightrm=cmr8
+  \font\eightbf=cmbx8
+  \font\eightit=cmti8
+  \font\eighttt=cmtt8
+  \font\eightsy=cmsy8
+  \textfont0=\eightrm
+  \textfont2=\eightsy
+  \def\rm{\eightrm}
+  \def\bf{\eightbf}
+  \def\it{\eightit}
+  \def\tt{\eighttt}
+  \normalbaselineskip=.8\normalbaselineskip
+  \normallineskip=.8\normallineskip
+  \normallineskiplimit=.8\normallineskiplimit
+  \normalbaselines\rm		%make definitions take effect
+
+  \if 2\ncolumns
+    \let\maxcolumn=b
+    \footline{\hss\rm\folio\hss}
+    \def\makefootline{\vskip 2in \hsize=6.86in\line{\the\footline}}
+  \else \if 3\ncolumns
+    \let\maxcolumn=c
+    \nopagenumbers
+  \else
+    \errhelp{You must set \columnsperpage equal to 1, 2, or 3.}
+    \errmessage{Illegal number of columns per page}
+  \fi\fi
+
+  \intercolumnskip=.46in
+  \def\abc{a}
+  \output={%
+      % This next line is useful when designing the layout.
+      %\immediate\write16{Column \folio\abc\space starts with \firstmark}
+      \if \maxcolumn\abc \multicolumnformat \global\def\abc{a}
+      \else\if a\abc
+	\global\setbox\columna\columnbox \global\def\abc{b}
+        %% in case we never use \columnb (two-column mode)
+        \global\setbox\columnb\hbox to -\intercolumnskip{}
+      \else
+	\global\setbox\columnb\columnbox \global\def\abc{c}\fi\fi}
+  \def\multicolumnformat{\shipout\vbox{\makeheadline
+      \hbox{\box\columna\hskip\intercolumnskip
+        \box\columnb\hskip\intercolumnskip\columnbox}
+      \makefootline}\advancepageno}
+  \def\columnbox{\leftline{\pagebody}}
+
+  \def\bye{\par\vfill\supereject
+    \if a\abc \else\null\vfill\eject\fi
+    \if a\abc \else\null\vfill\eject\fi
+    \end}  
+\fi
+
+% we won't be using math mode much, so redefine some of the characters
+% we might want to talk about
+\catcode`\^=12
+\catcode`\_=12
+
+\chardef\\=`\\
+\chardef\{=`\{
+\chardef\}=`\}
+
+\hyphenation{mini-buf-fer}
+
+\parindent 0pt
+\parskip 1ex plus .5ex minus .5ex
+
+\def\small{\smallfont\textfont2=\smallsy\baselineskip=.8\baselineskip}
+
+\outer\def\newcolumn{\vfill\eject}
+
+%\outer\def\title#1{{\titlefont\centerline{#1}}\vskip 1ex plus .5ex}
+
+%% KOT redefined a bit
+\outer\def\title#1#2{{\titlefont\centerline{#1}}{\titlefont\centerline{#2}}\vskip 1ex plus .5ex}
+
+%\outer\def\section#1{\par\filbreak
+%  \vskip 3ex plus 2ex minus 2ex {\subsecfont #1}\mark{#1}%
+%  \vskip 2ex plus 1ex minus 1.5ex}
+
+%% KOT redefined to cram more on
+\outer\def\section#1{\vfill\par\filbreak
+  \vskip 3.0ex plus 0.95ex minus 1.7ex {\secfont #1}\mark{#1}%
+  \vskip 1.8ex plus 0.9ex minus 1.15ex}
+
+\outer\def\subsection#1{\vfill\par\filbreak
+  \vskip 3.0ex plus 0.95ex minus 1.7ex {\subsecfont #1}\mark{#1}%
+  \vskip 1.8ex plus 0.9ex minus 1.15ex}
+
+\outer\def\shortsubsection#1{\vfill\par\filbreak
+  \vskip 1.0ex plus 0.95ex minus 1.7ex {\subsecfont #1}\mark{#1}%
+  \vskip 0.8ex plus 0.9ex minus 1.15ex}
+
+\newdimen\keyindent
+
+\def\beginindentedkeys{\keyindent=1em}
+\def\endindentedkeys{\keyindent=0em}
+\endindentedkeys
+
+\def\paralign{\vskip\parskip\halign}
+
+\def\<#1>{$\langle${\rm #1}$\rangle$}
+
+\def\kbd#1{{\tt#1}\null}	%\null so not an abbrev even if period follows
+
+\def\beginexample{\par\leavevmode\begingroup
+  \obeylines\obeyspaces\parskip0pt\tt}
+{\obeyspaces\global\let =\ }
+\def\endexample{\endgroup}
+
+\def\key#1#2{\leavevmode\hbox to \hsize{\vtop
+  {\hsize=.79\hsize\rightskip=1em
+  \hskip\keyindent\relax#1}\kbd{#2}\hfil}}
+
+\def\com#1#2{\leavevmode\hbox to \hsize{\vtop
+  {\hsize=.306\hsize\rightskip=1em
+  \hskip\keyindent\relax#1}\kbd{#2}\hfil}}
+
+\def\lcom#1#2{\leavevmode\hbox to \hsize{\vtop
+  {\hsize=.49\hsize\rightskip=1em
+  \hskip\keyindent\relax#1}\kbd{#2}\hfil}}
+
+
+\newbox\metaxbox
+\setbox\metaxbox\hbox{\kbd{M-x }}
+\newdimen\metaxwidth
+\metaxwidth=\wd\metaxbox
+
+\def\metax#1#2{\leavevmode\hbox to \hsize{\hbox to .75\hsize
+  {\hskip\keyindent\relax#1\hfil}%
+  \hskip -\metaxwidth minus 1fil
+  \kbd{#2}\hfil}}
+
+\def\threecol#1#2#3{\hskip\keyindent\relax#1\hfil&\kbd{#2}\quad
+  &\kbd{#3}\quad\cr}
+
+%**end of header
+
+% ===================================================================
+% Real refcard related things start here.
+% ===================================================================
+\title{ilisp/Emacs}{Interface Reference Card}
+
+\centerline{(for Gnu Emacs , Xemacs)}
+
+This reference card is a quick-and-dirty guide to those parts of the
+ilisp manual, which are likely to be used often.
+It includes most of the ilisp Interface to emacs, plus many of the
+extensions defined in the {\it ilisp online help}.  It is {\it not} a
+substitute for the ilisp online manual.
+
+\section{The ilisp/Emacs Interface }
+
+You can use the ilisp interface from either GNU Emacs or Xemacs.  
+Put these lines in your {\tt .emacs} file for clisp and allegro:
+
+\kbd{(setq load-path (cons (expand-file-name }
+
+\hskip 25pt \kbd{"/usr/local/lib/ilisp-5.8/") load-path))}
+	 
+\kbd{(require 'completer)}
+
+\kbd{(autoload 'clisp "ilisp" } 
+
+\hskip 25pt \kbd{"Inferior generic Common LISP." t)}
+
+\kbd{(setq clisp-program "/usr/local/bin/clisp -I")}
+
+\kbd{(autoload 'allegro "ilisp" }
+
+\hskip 25pt \kbd{ "Inferior Allegro Common LISP." t)}
+
+\kbd{(setq allegro-program "/usr/local/bin/cl")}
+
+Then invoke lisp with either \kbd{M-x clisp}, 
+or with \kbd{M-x allegro}.
+
+`C-z' is the prefix-key for most ILISP commands. This can be changed by 
+setting the variable `ilisp-prefix'.
+
+For online help with emacs, use \kbd{C-h f}, \kbd{describe-function}.
+
+\shortsubsection{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.
+
+\key{return-ilisp}{RET}
+\key{interrupt-subjob-ilisp}{C-c C-c}
+\key{abort-commands-lisp}{C-z g}
+\key{M-x panic-lisp}{}
+\key{reset-ilisp}{C-z z}
+\key{delete-char-or-pop-ilisp}{C-d}
+
+
+\subsection{Editing Lisp Forms (general)}
+
+Indentation, parenthesis balancing, and comment commands.
+
+\key{indent-line-ilisp}{TAB}
+\key{indent-sexp-ilisp}{M-C-q}
+\key{reindent-lisp}{M-q}
+\key{comment-region-lisp}{C-z ;}
+\key{find-unbalanced-lisp}{C-z )}
+\key{close-all-lisp}{]}
+
+
+\subsection{Eval and compile functions}
+
+Functions for eval/compile in code buffers.  
+
+\key{ilisp-prefix}{C-z} 
+\key{close-and-send-lisp}{C-]}
+\key{newline-and-indent-lisp}{LFD}
+\key{eval-defun-lisp}{C-z e}
+\key{eval-defun-lisp}{M-C-x}
+\key{eval-defun-and-go-lisp}{C-z C-e} 
+\key{eval-region-lisp}{C-z r}
+\key{eval-region-and-go-lisp}{C-z C-r} 
+\key{eval-next-sexp-lisp}{C-z n}
+\key{eval-next-sexp-and-go-lisp}{C-z C-n}
+\key{compile-defun-lisp}{C-z c}
+\key{compile-defun-lisp-and-go}{C-z C-c}
+\key{compile-region-lisp}{C-z w}
+\key{compile-region-and-go-lisp}{C-z C-w}
+
+
+\subsection{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.
+
+\key{arglist-lisp}{C-z a}
+\key{documentation-lisp}{C-z d}
+\key{describe-lisp}{C-z i}
+\key{inspect-lisp}{C-z I}
+
+
+\subsection{The Franz Online Manual}
+
+Invoke with \kbd{M-x fi:clman} or \kbd{C-z D}, these are used to view the 
+Franz online manual if available.  Packages
+nicknames limit search: cltl1, comp, composer, defsys, excl, ff, inspect,
+ipc, lisp, mp, prof, stream, sys, tpl, xcw, xref.  Note the useful about-*
+man pages (e.g. about-top-level).
+
+\key{fi:clman}{C-z D}
+\key{fi:clman-apropos}{C-z A}
+%\key{fi:clman-next-entry}{n}
+%\key{fi:clman-search-forward-see-alsos}{s}
+%\key{fi:clman-package-help}{p}
+%\key{fi:clman-flush-doc}{C-c C-c}
+
+\shortsubsection{Tracing functions}
+
+Function which 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.
+
+\key{trace-defun-lisp}{C-z t}
+
+\shortsubsection{Macroexpansion}
+
+ 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.
+
+\key{macroexpand-lisp}{C-z M}
+\key{macroexpand-1-lisp}{C-z m}
+
+
+\shortsubsection{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-package-regexp' to find a package sexp and then
+passing that sexp to the inferior LISP through `ilisp-package-command'.
+For the `clisp' dialect, this will find the first `(in-package
+PACKAGE)' form in the file.  A buffer's package will be displayed in
+the mode line.  If a buffer has no specification, forms will be
+evaluated in the current inferior LISP package.
+
+Buffer package caching can be turned off by setting the variable
+`lisp-dont-cache-package' to `T'. This will force ILISP to search for
+the closest previous `ilisp-package-regexp' in the buffer each time an
+inferior LISP mode command is executed.
+
+\key{package-lisp}{C-z p}
+\key{set-package-lisp}{C-z P}
+\key{M-x set-buffer-package-lisp}{}
+
+
+\shortsubsection{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.
+
+\key{find-file-lisp}{C-x C-f}
+\key{load-file-lisp}{C-z l}
+\key{compile-file-lisp}{C-z k}
+\key{default-directory-lisp}{C-z !}
+
+
+\shortsubsection{Completion}
+
+Commands to reduce number of keystrokes.
+
+\key{complete-lisp}{M-TAB}
+\key{complete}{M-RET}
+
+%\shortcopyrightnotice
+
+\subsection{Command history}
+
+ILISP mode is built on top of `comint-mode', the general command  
+interpreter 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.
+
+\key{comint-next-input}{M-n}
+\key{comint-previous-input}{M-p}
+\key{comint-previous-similar-input}{M-s}
+\key{comint-psearch-input}{M-N}
+\key{comint-msearch-input}{M-P}
+\key{comint-msearch-input-matching}{C-c R}
+
+
+\subsection{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.
+
+\shortsubsection{}
+
+`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.
+
+\shortsubsection{}
+
+`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).
+
+\shortsubsection{}
+
+`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'.
+
+\shortsubsection{}
+
+`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).
+
+\shortsubsection{}
+
+`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'.
+
+
+\key{M-x lisp-directory}{}
+\key{edit-definitions-lisp}{M-.}
+\key{next-definition-lisp}{M-,}
+\key{edit-callers-lisp}{C-z ^}
+\key{next-caller-lisp}{M-`}
+\key{M-x who-calls-lisp}{}
+\key{search-lisp}{M-?}
+\key{replace-lisp}{M-"}
+
+
+\subsection{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*'.
+
+\key{mark-change-lisp}{C-z SPC}
+\key{eval-changes-lisp}{C-z * e}
+\key{compile-changes-lisp}{C-z * c}
+\key{clear-changes-lisp}{C-z * 0}
+\key{list-changes-lisp}{C-z * l}
+
+\subsection{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:
+
+\kbd{(progn (format t "1
+
+\hskip 35pt \kbd{(print (read-char)) (format t "0
+
+\subsection{}
+
+\copyrightnotice
+
+\bye
+
-\input texinfo    @c -*-texinfo-*-         Last modified: January 13, 2000
+\input texinfo    @c -*-texinfo-*-         Last modified: June 6, 2001
 @setfilename ilisp.info
 @settitle The ILISP Inferior Lisp Interface
 
+@dircategory Lisp Programming
+@direntry
+* ILisp: (ilisp).       Inferior Lisp mode.
+@end direntry
+
 @iftex
 @finalout
 @end iftex
 @ifinfo
 This file documents ILISP.
 
-This is edition 0.16 of the ILISP manual
-for ILISP Version: 5.10.1.
+This is edition 0.21 of the ILISP manual
+for ILISP Version: 5.11.1
 
 @example
 Copyright (C) 1991,1992,1993 Todd Kaufmann
 @titlepage
 @title ILISP User Manual