Anonymous avatar Anonymous committed 606ea5d

ilisp 5.10.1

Comments (0)

Files changed (80)

 -------------------------------------------------------------------------------
 
 This file is part of ILISP.
-Version: 5.8
-Date:    15 July 1996
+Version: 5.10.1
+Date:    15 June 1999
 
 Copyright (C) 1990, 1991, 1992, 1993 Chris McConnell
               1993, 1994 Ivan Vasquez
               1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
-              1996 Marco Antoniotti and Rick Campbell
+              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 'ilisp-request@naggum.no' to be included in the
-ILISP mailing list. 'ilisp@naggum.no' is the general ILISP
+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.
 
 -------------------------------------------------------------------------------
+2000-07-13  Will Deakin <anisotropy9@users.sourceforge.net>
+
+        * sync with ilisp 5.10.1.
+
 2000-07-07  Ben Wing  <ben@xemacs.org>
 
 	* completer.el:
-FTP directions
-==============
+FTP and WWW directions
+======================
 
-You can get the distribution file, `ilisp-5.8.tar.gz' via anonymous
-FTP from `FTP.CS.CMU.EDU' (128.2.206.173) in
-`/afs/cs/user/campbell/http/ilisp/'.
+You can get the distribution file, `ilisp-5.9.tar.gz'
+(`ilisp-5.9.zip') via anonymous FTP or HTML at the following
+addresses:
 
-% ftp ftp.cs.cmu.edu
-Name (ftp.cs.cmu.edu:rickc): anonymous
-331 Guest login ok, send username@node as password.
-Password: YOUR-USER-ID@YOUR-HOSTNAME
-ftp> cd /afs/cs/user/campbell/http/ilisp
-250 Directory path set to /afs/cs/user/campbell/http/ilisp.
-ftp> type binary
-200 Type set to I.
-ftp> get ilisp-5.8.tar.gz
-200 PORT command successful.
-150 Opening data connection for ilisp-5.8.tar.gz.
-226 Transfer complete.
-local: ilisp-5.8.tar.gz remote: ilisp-5.8.tar.gz
-168801 bytes received.
-ftp> quit
-221 Goodbye.
+    ftp://ftp2.cons.org/pub/languages/lisp/ilisp/
+or
+    http://www2.cons.org:8000/ftp-area/ilisp/
 
-Or get whatever single files you need from the `untarred'
-subdirectory.
+If you use a tty ftp client, just log in as 'anonymous'.
 
-You can also get `ilisp-5.8.tar.gz' via anonymous FTP from
-`FTP.ICSI.BERKELEY.EDU' in either `/pub/software/elisp/' or
-`/pub/theory/marcoxa/elisp/'.
+Please report any problems to the mailing list 'ilisp@cons.org'.
 
+Enjoy
 
-
-
-WWW directions
-==============
-
-You can use the World Wide Web (WWW) to get the distribution file from
-the anonymous FTP locations using one of the following URLs:
-   * ftp://ftp.cs.cmu.edu/afs/cs/user/campbell/http/ilisp/ilisp-5.8.tar.gz
-
-   * ftp://ftp.icsi.berkeley.edu/pub/software/elisp/ilisp-5.8.tar.gz
-
-   * ftp://ftp.icsi.berkeley.edu/pub/theory/marcoxa/ilisp-5.8.tar.gz
-
-   You can also use the CMU Artificial Intelligence Repository:
-
-   http://www.cs.cmu.edu/Web/Groups/AI/html/repository.html
-
-From there follow: `LISP', `UTIL', `EMACS' and finally `ILISP'.  Use
-your browser capabilities to download what you need.
-
-The complete URL for the distribution file in the CMU AI Repository is
-http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/util/emacs/ilisp/v57/ilisp57.tgz
-
-Other URLs for the distribution file include:
-   * http://www.c2.net/~campbell/ilisp/ilisp-5.8.tar.gz
-
-   * http://www.cs.cmu.edu/~campbell/ilisp/ilisp-5.8.tar.gz
+The ILISP Maintainer
 # -*- Mode: Text -*-
 
 ILISP HISTORY
+===============================================================================
+Version: 5.10.1.
+
+ILISP is on SOURCEFORGE!
+
+Fixes and enhancements since 5.9.4.
+
+Many.
+
+-- More CLish conventions for naming variables.
+   Note that 'ilisp-refix' is now 'ilisp-*prefix*' . Check your ilisp
+   initializations in your .emacs or wherever you keep them.
+
+-- Better FSF compliance (see variable
+   'ilisp-*use-fsf-compliant-keybindings*')
+
+-- changed vars in ilisp-def:
+   ilisp-*prefix*
+   ilisp-*use-fsf-compliant-keybindings*
+   ilisp-*use-frame-for-output*
+   ilisp-*prefix-match*
+   ilisp-*version*
+   ilisp-*arglist-message-lisp-space-p*
+   ilisp-*use-frame-for-arglist-output-p*
+   ilisp-*enable-imenu-p*
+   ilisp-*enable-cl-easy-menu-p*
+   ilisp-*enable-scheme-easy-menu-p*
+   ilisp-*enable-ild-support-p*
+   ilisp-*use-hyperspec-interface-p*
+   ilisp-*use-fi-clman-interface-p*
+   ilisp-*directory*
+
+-- *.el: replaced vars.
+
+-- In ilisp-key: new custom: ilisp-bindings-*bind-space-p*:
+   if t bind #\SPACE to #'ilisp-arglist-message-lisp-space
+
+-- Changed vars in ilisp-out:
+   changed all sink's to ilisp-output-sink's
+   ilisp-*icon-file*   
+   ilisp-*last-ilisp-output-sink*
+
+-- doc/ilisp.texi: replaced found vars of above with their replacements.
+
+-- doc/ilisp.texi: documented the frame-p stuff, arglist-p stuff,
+   imenu-p stuff.
+
+-- doc/ilisp.texi: documented imenu.el, ilisp-imenu.el.
+
+-- ilisp-out.el & ilisp-chs.el: in ilisp-display-output-default: now
+   printing of error messages
+   in the lisp-listener should work!!
+   at least it works for clisp, as I found out.
+
+-- ilisp-def: new variable ilisp-*arglist-message-switch-back-p*
+
+-- ilisp-hi: in lisp-send-region: fixed a bug; we had multiple outputs despite
+   the fact that we should not have had that (eq switch 'result) => no display.
+
+-- sblisp.lisp: changed #'arglist; code is a adapted version of #'arglist in
+   cmulisp.lisp. did not work for (arglist 'make-array) for example.
+
+-- cl-ilisp: reformatting of last ) ) [oops! :)]
+             bugfix: special-operator-p replaced by special-form-p in
+             #'ilisp-print-info-message.
+             added support for ECL (ECLS).
+
+===============================================================================
+Version: 5.9.4.
+
+Fixes and enhancements since 5.9.3.
+
+-- Cleaned up CLisp support (a leftover glitch from a previous
+   'merge').
+
+-- Corrected a few typos here and there, especially in the
+   INSTALLATION file.
+
+-- the CL functions ILISP-DESCRIBE and ILISP-INSPECT try now to be a
+   little smarter regarding symbols.  The generic behavior implemented
+   in 'cl-ilisp.lisp' should be ok for many CL implementations (it
+   works beautifully with CMUCL), but it may need some tuning for
+   other ones.
+
+===============================================================================
+Version 5.9.3
+
+Fixes and enhancements since 5.9.1.
+
+-- Better treatment of CLisp.
+
+-- The #\Space (?Space) key is now bound to the
+   ILISP-ARGLIST-MESSAGE-LISP-SPACE function. In an ILISP buffer it
+   will give you the arglist associated with a function you are about
+   to type in.
+
+The main bug list of 5.9.1 is still in place.
+
+
+===============================================================================
+Version 5.9.2
+
+Fixes and enhancements since 5.9.1.
+
+5.9.2 is mainly a bug fix releases with some simple bugs fixed.  The
+main bug list of 5.9.1 is still in place.
+
+
+===============================================================================
+Version 5.9.1
+
+Fixes and enhancements since 5.9
+
+-- Documentation fixed.
+
+-- Wrong symlink in 'extra' directory fixed.
+
+-- Hopefully fixed most problems with 'ilisp-*-binary-extension's.
+   Not perfect, but it should work now thanks to Hannu Koivisto. See
+   file 'ilisp-cl.el'.
+
+-- README.CL-HS file removed from distribution.
+
+-- ild.mail file removed from distribution.
+
+-- Slightly changed 'Welcome' file.
+
+-- Many buglets fixed.
+
+Known Bugs
+
+-- When using different implementations within the same session of
+   (X)Emacs, it may happen that the by switching from one to the other
+   in sequence, some settings are not cleared correctly.
+   This bug has been reported by Hannu Koivisto using CLisp and CMUCL.
+
+-- Multiprocessing handling is not up to par to Franz ELI interface
+   when using Allegro.  Similar problems may appear in Harlequin
+   Lispworks and Liquid and in the experimental versions of CMUCL
+   floating around.
+
+===============================================================================
+Version 5.9
+
+The major change in this release concerns the new Home for ILISP at CONS.ORG.
+
+Fixes and enhancements since 5.8 alpha
+
+-- Changed behavior of package definitions in buffers thanks to Martin
+   Atzmueller.  Now (DEFPACKAGE "ZUT" ...) (IN-PACKAGE "ZUT") works as
+   expected/desired.
+
+-- New Menus (thanks to Martin Atzmueller).
+
+-- Major Change for toplevel dialect: it is now called 'common-lisp'
+   (it used to be 'clisp'). Note however, that for the time being, the
+   name of the CLISP dialect remains 'clisp-hs'.
+
+-- Many bug fixes to CLISP dialect.
+
+-- The 'hyperspec' package and new 'ilisp-easy-menus' are distributed
+   with ILISP.  They are not loaded by default.
+
+-- Fixed loading of compatibility files for Emacs 20.xx.
+
+-- Fixed compilation and loading of 'ilisp-chs'.
+
+-- Fixed missing EXCL::FN_SYMDEF in ACL 5.0 (Larry Hunter)
+
+-- ILD Debugger interface by J. M. Siskind has been integrated in the
+   dialect definitions.  Please report any problems you may have with
+   it.
+
+-- Changed default binding for 'clisp-hs-program' form "clisp" to "clisp -I"
+   to account for buffer flushing behavior of this implementation.
+
+-- Added several Scheme dialects (thanks to Christian Lynbech).
+
 
 ===============================================================================
 Version 5.8 alpha
 
 -- The file ILISP.prj (if present) can be safely ignored unless you
    want to use the PRCS project control system
-   (http://http.cs.berkeley.edu/~jmacd/prcs-home.html)
+   (http://xcf.berkeley.edu/~jmacd/prcs.html)
 
 -- Changed 'comint-ipc' and 'bridge'. They now use
    'process-send-string' instead of defining specialized versions of
 
 WELCOME TO ILISP.
 
+
 FIRST INSTALLATION STEP: UNPACKING AND COMPILING.
 
+Copy the ILISP distribution archive, e.g. ilisp-5.9.4.tar.gz, to the
+location where you would like to install it. Next extract the archive (you
+may need root privileges to perform these operations):
+
+% gzip -dc ilisp-5.9.4.tar.gz | tar xf -
+
+or:
+
+% unzip ilisp-5.9.4.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
+the comment Various variables (you can safely ignore the variables for
+configuring packaging and distribution, which are intended for
+maintainers).
+
+First, set the EMACS variable to be the pathname of the Emacs you will be
+using ILISP with.  This is the Emacs that will be used to compile ILISP
+with.
+
+If your Emacs supports the `easymenu' package, it is possible to make ILISP
+add to Lisp mode buffers and buffers with inferior Lisp processes, or to
+Scheme mode buffers and buffers with inferior Scheme 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.
+
+See the next section for additional configuration options and known
+problems for specific Lisp dialects.
+
+Run `make' or `make compile' to build ILISP from source.  Ignore any
+compilation warnings unless they result in ILISP not compiling completely.
+
+For reducing the Emacs startup time you may run `make loadfile'. This
+concatenates all `.elc' (the compiled Emacs Lisp files) into an
+`ilisp-all.elc' file and removes the `*.elc' files.  So your Emacs can load
+one single compiled file faster than a bunch of smaller compiled files.
+
+To activate ILISP you should add appropriate Emacs Lisp forms to your
+`.emacs' or to the system-wide `default.el' file, depending on who will be
+using ILISP.  These forms take care of starting it whenever you access a
+Lisp file or run an inferior Lisp process.  You can copy relevant portions
+of the sample file `ilisp.emacs', which also shows how to customize some
+ILISP features.
+
+You should add the directory where all of the ILISP Emacs Lisp files reside
+to your load-path.  There is an example of this in `ilisp.emacs'.
+
+As an alternative you could set up a `.ilisp' which contains the
+appropriate portions of `ilisp.emacs', in order to avoid cluttering too
+much `.emacs' or `default.el'.
+
+The first time a dialect is started, the interface files will complain
+about not being compiled, just ignore the message.  Once a Lisp dialect is
+started up, you should execute the command ilisp-compile-inits which will
+compile the `*.lisp' files and write them to the same directory as the
+ilisp files.
+
+The binary files should have a unique extension for each different
+combination of architecture and Lisp dialect.  You will need to change
+ILISP-INIT-BINARY-EXTENSION and ILISP-INIT-BINARY-COMMAND to get additional
+extensions.  The binary for each different architecture should be
+different.  If you want to build the interface files into a Lisp world, you
+will also need to set ILISP-LOAD-INITS to NIL in the same place that you
+change ILISP-PROGRAM to load the Lisp world.
+
+There is an ILISP-SITE-HOOK for initializing site specific stuff like
+program locations when ILISP is first loaded.  You may want to define
+appropriate autoloads in your system Emacs start up file.
+
+Example site init:
+
+;;; CMU site
+(setq ilisp-site-hook
+      '(lambda ()
+        (setq ilisp-motd "CMU ILISP V%s")
+        (setq expand-symlinks-rfs-exists t)
+        (setq allegro-program "/usr/local/acl5/lisp")
+        (setq lucid-program "/usr/misc/.lucid/bin/lisp")))
+
+Kent Pitman and The Harlequin Group Ltd. have made publicly available on
+the Web the Common Lisp HyperSpec, an HTML version of the full text of the
+ANSI Common Lisp specification.  Daniel Barlow, Stephen Carney and Erik
+Naggum independently developed Emacs Lisp packages for looking up Lisp
+symbols in the HyperSpec and displaying the relevant sections with a Web
+browser.  ILISP includes all of them in the `extra' directory of the
+distribution tree. By default ILISP uses Naggum's package.  If you want to
+use one of the others, see the comments at the beginning of the
+corresponding files.
+
+The `ilisp.emacs' file provides sample instructions for making Naggum's
+package access a local copy of the HyperSpec. Since the package relies on
+the `browse-url' Emacs package, make sure that the latter is properly
+configured.
+
+Previous versions of ILISP provided commands for accessing the online
+Common Lisp documentation shipped with Franz Inc.'s Allegro CL product
+(`fi:clman' module). The public availability of the HyperSpec, and the
+inclusion since version 5.9 of ILISP of the `hyperspec' packages, make
+access to the Franz documentation no longer necessary. So by default ILISP
+does not load the `fi:clman' module, but if you still want to use its
+commands set the ILISP-USE-FI-CLMAN-INTERFACE-P to T in `ilisp-def.el'.
+
+The ILISP documentation consists of a user manual and a reference card.
+Both of them are in the `docs' directory of the distribution tree.
+
+The generation of GNU Info, DVI, PostScript and HTML versions of the manual
+from the Texinfo source is controlled by the `Makefile' in the `docs'
+directory.  Run `make docs' or just `make' to generate all of the formats.
+If you are interested in only some of them then issue the appropriate
+command: `make info' for GNU Info, `make dvi' for DVI, `make ps' for
+PostScript and `make html' for HTML.  To remove the intermediate files
+produced during the generation of DVI output you can run `make tmpclean'.
+
+The ILISP reference card is available in DVI and PostScript formats
+together with the TeX source.  Check the comments at the beginning of the
+TeX source if you need to generate a version with a different number of
+columns.
+
+
 SECOND INSTALLATION STEP: DIALECT REQUIREMENTS.
 
 ILISP assumes a minimum of CLtL2 compliance. This requirements
 implementations (we do not know whether there are problems with
 Scheme's - please let us know).
 
-o All dialects
+o All Common Lisp dialects
 
 	Be sure that the variables:
 
 
 	  You can find a DEFPACKAGE in the AI.Repository of CMU.
 
+	  If you do not want - for mysterious reasons - DEFPACKAGE in
+          your GCL, you can manually edit the files 'ilisp-pkg.lisp'
+          and 'cl-ilisp.lisp' at the DEFPACKAGE and EXPORT forms.
+
 	- LOOP
 	  Most likely the DEFPACKAGE will require a full fledged LOOP.
 	  The same instructions apply.
 
 o CMUCL
 
-	Try to set the variables:
+	If you are interested in maintaining CMU CL or compiling it from
+	source try to set the variables:
 
 	cmulisp-source-directory-regexp
 	cmulisp-local-source-directory
 
-	To sensible values.
+	to sensible values, e.g. set 'cmulisp-local-source-directory'
+	to "target:". Refer to CMUCL documentation for an explanation
+	of this setting.
 
 
 o Harlequin
 
 o CLISP
 
-	No known extra installation glitches
+        Unless you add the following form to your ~/.clisprc file:
 
+          (pushnew (pathname ".lisp") system::*source-file-types*)
 
+        the ILISP command `M-x ilisp-compile-inits' will not be able to
+        compile CLISP's initialization files.
+
+        (The list below was provided by Valentino Kyriakides)
+
+        The following lists some unusual ILISP behaviour related to CLISP.
+        Some of these are of general interest, and should hopefully be
+        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
+          another Lisp prompt. This is somehow confusing.
+
+        - While prompted, a user can backspace over the prompt, or can move
+          the cursor down to inexistent lines, thus making the buffer look
+          bad.
+
+        - The history mode is unfortunately circular, which means that
+          after M-p M-n you don't get back your original empty line. Also,
+          a two- character input like "()" doesn't appear in the history.
+
+        - CLISP does not know that once it received a form for evaluation
+          the cursor is in column 0. Therefore (format t "~&") will output
+          a blank line. This results in too many blank lines.
+
+        - The default completion character for clisp (Tab) does not work.
+          Instead there are two different completion characters, with two
+          other keybindings.
+
+        - The Lisp code invisibly loaded into clisp is interpreted. Since
+          it is not user-visible, it could as well be compiled, for speed.
+
+        - In a CLISP debugger loop typing "abort" often throws you into the
+          next deeper debugging level, instead of leaving the actual
+          one. So you often have to retype "abort" x-times to get it work.
+
+        - When the ILISP/CLISP interaction hangs (blocks), you have to type
+          C-g to abort your last command, in order get the minibuffer work
+          again. After this you have to do a "M-x panic-lisp" to reassign
+          the ILISP/CLISP interaction.
+
+
+Scheme->C
+
+        - To get Scheme->C to work under ILISP it may be necessary to
+          create a custom executable with the following C foreign function:
+
+            #include <stdio.h>
+            void nobuff(){setbuf(stdout, (char*)0);}
+
+            (define-c-external (nobuff) void "nobuff")
+            (nobuff)
 # Makefile for ILISP/Inferior Lisp code
+# 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
+#
+# Send mail to 'majordomo@cons.org' to be included in the
+# ILISP mailing list.
 
-# This file is part of XEmacs.
-
-# XEmacs is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by the
-# Free Software Foundation; either version 2, or (at your option) any
-# later version.
+# Note: this makefile assumes GNU make
 
 # XEmacs is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 # Boston, MA 02111-1307, USA.
 
 VERSION = 1.10
-AUTHOR_VERSION = 5.8
-MAINTAINER = XEmacs Development Team <xemacs-beta@xemacs.org>
+AUTHOR_VERSION = 5.10.1
+MAINTAINER = ILISP maintainers <ilisp@cons.org>
 PACKAGE = ilisp
 PKG_TYPE = regular
-REQUIRES = xemacs-base
+REQUIRES = xemacs-base mail-lib fsf-compat eterm
 CATEGORY = os
 
-ELCS = bridge.elc comint-ipc.elc comint-v18.elc completer.elc \
-	completer.new.elc completer.no-fun.elc ilcompat.elc ilfsf18.elc \
-	ilfsf19.elc ilisp-acl.elc ilisp-aut.elc ilisp-bat.elc ilisp-bug.elc \
-	ilisp-chs.elc ilisp-cl.elc ilisp-cmp.elc ilisp-cmt.elc ilisp-cmu.elc \
-	ilisp-cpat.elc ilisp-def.elc ilisp-dia.elc ilisp-doc.elc ilisp-el.elc \
-	ilisp-ext.elc ilisp-hi.elc ilisp-hlw.elc ilisp-hnd.elc ilisp-ind.elc \
-	ilisp-inp.elc ilisp-kcl.elc ilisp-key.elc ilisp-kil.elc ilisp-low.elc \
-	ilisp-luc.elc ilisp-mak.elc ilisp-menu.elc ilisp-mnb.elc \
-	ilisp-mod.elc ilisp-mov.elc ilisp-out.elc ilisp-prc.elc ilisp-prn.elc \
-	ilisp-rng.elc ilisp-s2c.elc ilisp-sch.elc ilisp-snd.elc ilisp-src.elc \
-	ilisp-sym.elc ilisp-utl.elc ilisp-val.elc ilisp-xfr.elc ilisp-xls.elc \
-	ilisp.elc illuc19.elc ilxemacs.elc
+ELCS =  bridge.elc comint-ipc.elc completer.elc custom-ilisp.elc \
+	ilisp-acl.elc ilisp-aut.elc ilisp-chs.elc ilisp-cl.elc \
+	ilisp-cmp.elc ilisp-cmt.elc ilisp-cmu.elc ilisp-def.elc \
+	ilisp-dia.elc ilisp-doc.elc ilisp-ext.elc ilisp-hi.elc \
+	ilisp-hlw.elc ilisp-hnd.elc ilisp-ind.elc ilisp-inp.elc \
+	ilisp-kcl.elc ilisp-key.elc ilisp-kil.elc ilisp-low.elc \
+	ilisp-luc.elc ilisp-mnb.elc ilisp-mod.elc ilisp-mov.elc \
+	ilisp-out.elc ilisp-prc.elc ilisp-prn.elc ilisp-rng.elc \
+	ilisp-sbcl.elc ilisp-sch.elc ilisp-snd.elc ilisp-sym.elc \
+	ilisp-utl.elc ilisp-val.elc ilisp-xfr.elc ilisp-xls.elc \
+	ilisp.elc
 
-INFO_FILES = $(PACKAGE).info*
-TEXI_FILES = $(PACKAGE).texi
+ELCS_1 = extra/hyperspec.elc
+ELCS_1_DEST = ilisp/extra/
+ELCS_1_FILES = extra/*
+
+INFO_FILES = docs/$(PACKAGE).info*
+TEXI_FILES = docs/$(PACKAGE).texi docs/README docs/doc-changes.txt \
+	docs/ilisp-refcard.tgz
 MANUAL = $(PACKAGE)
 
-EXTRA_SOURCES = *.lisp ACKNOWLEDGMENTS HISTORY README Welcome GETTING-ILISP \
-	scheme2c.mail ild.mail ilisp.emacs
+EXTRA_SOURCES = *.lisp COPYING INSTALLATION HISTORY README Welcome \
+	GETTING-ILISP ilisp.emacs Makefile comint-v18.el ilcompat.el \
+	ild.el ilfsf18.el ilfsf19.el ilfsf20.el ilisp-bat.el \
+	ilisp-bug.el ilisp-cl-easy-menu.el ilisp-imenu.el \
+	ilisp-mak.el ilisp-menu.el ilisp-s2c.el \
+	ilisp-scheme-easy-menu.el ilisp-src.el illuc19.el ilxemacs.el
+
+DATA_FILES = pictures/*
+DATA_DEST = ilisp/
 
 include ../../XEmacs.rules
 
 PRELOADS = -eval "(push (expand-file-name \".\") load-path)"
 endif
 
-all:: $(ELCS) auto-autoloads.elc ilisp.info
+all:: compile $(ELCS_1) auto-autoloads.elc docs/ilisp.info 
+
+compile:
+	$(XEMACS) -batch -l ilisp-mak.el
 
 srckit: srckit-std
 
 binkit: binkit-common
+
+clean::
+	rm -f $(ELCS) $(ELCS_1)
+	$(MAKE) $(MFLAGS) -C docs clean
 
 # Makefile --
 # This file is part of ILISP.
-# Version: 5.8
+# 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 Marco Antoniotti and Rick Campbell
+#               1996-2000 Marco Antoniotti and Rick Campbell
 #
-# Send mail to 'ilisp-request@naggum.no' to be included in the
+# Send mail to 'majordomo@cons.org' to be included in the
 # ILISP mailing list.
 
 # Note: this makefile assumes GNU make
 
-# Updated for XEmacs autoloads builds, but unused at present since no
-#  autoloads are generated, and this package hasn't been customized.
-
 #==============================================================================
 # Various Variables
 
-Version = 5.8
+Version = 5.10.1
 
 # Use whichever you like most
 #EMACS = xemacs
 EMACS = emacs
 
 # The SHELL variable is used only for making the distribution.
-#SHELL = /bin/csh
-# Tsk, tsk, Though shalt not use csh in distributed scripts.
-SHELL = /bin/sh
+SHELL = /bin/csh
+
+# The 'rm' command used (we redefine it mostly because it may be
+# aliased
+RM = /bin/rm -f
+
 
 # These are used mostly for packaging the distribution
 Ilisp_src_dir = $(shell pwd)
              GETTING-ILISP  \
              Welcome
 
-DocFiles = ilisp.texi
-
-LoadFiles = ilisp-def.elc ilisp-el.elc ilisp-sym.elc \
+LoadFiles = custom-ilisp.elc ilisp-def.elc ilisp-sym.elc \
  ilisp-inp.elc ilisp-ind.elc ilisp-prc.elc ilisp-val.elc ilisp-out.elc \
  ilisp-mov.elc ilisp-key.elc ilisp-prn.elc ilisp-low.elc ilisp-doc.elc \
  ilisp-ext.elc ilisp-mod.elc ilisp-dia.elc ilisp-cmt.elc ilisp-rng.elc \
  ilisp-hnd.elc ilisp-utl.elc ilisp-cmp.elc ilisp-kil.elc ilisp-snd.elc \
- ilisp-xfr.elc ilisp-hi.elc ilisp-aut.elc ilisp-cl.elc ilisp-cmu.elc \
+ ilisp-xfr.elc ilisp-hi.elc ilisp-aut.elc \
+ ilisp-cl.elc ilisp-cmu.elc ilisp-sbcl.elc \
  ilisp-acl.elc ilisp-kcl.elc ilisp-luc.elc ilisp-sch.elc ilisp-hlw.elc \
- ilisp-xls.elc
+ ilisp-xls.elc ilisp-chs.elc
 
 
+DocFiles = docs/Makefile \
+	   docs/README \
+	   docs/doc-changes.txt \
+           docs/ilisp-refcard.tgz \
+           docs/ilisp.texi
+
 #==============================================================================
 # Rules
 
 compile:
 	$(EMACS) -batch -l ilisp-mak.el
 
-elc: $(LoadFiles) $(XEmacsELC)
-
-$(LoadFiles) :
-	$(EMACS) -batch -l ilisp-mak.el
-
 tags:
 	etags *.el
 
+docs: FORCE
+	cd docs; $(MAKE)
+
 clean: 
-	$(RM) *.elc
+	-$(RM) *.elc *~ extra/*.elc extra/*~
+	(cd docs; $(MAKE) clean)
 
 loadfile:
 	touch ilisp-all.elc
 	cat $(LoadFiles) > ilisp-all.elc
-	rm $(LoadFiles)
+	$(RM) $(LoadFiles)
 # Note that the redirection is done by a Bourne Shell.
 
 compress:
-	gzip *.el $(OtherFiles) $(DocFiles)
+	gzip *.el $(OtherFiles)
+
+FORCE:
 
 #==============================================================================
 # The following targets are used only to create a distribution file.
 dist: tarring dist_compressing
 
 tarring:
+	@echo "ILISP dist: preparing tar file."
+	@echo "            source directory: " $(Ilisp_src_dir)
+	@echo "            tar directory:    " $(Ilisp_tar_dir)
 	(cd $(Ilisp_src_dir)/..;                                        \
          if ( $(notdir $(Ilisp_src_dir)) != $(Ilisp_tar_dir) )          \
             ln -s $(notdir $(Ilisp_src_dir)) $(Ilisp_tar_dir) ;         \
             $(Ilisp_tar_dir)/*.el                                       \
             $(Ilisp_tar_dir)/*.lisp                                     \
             $(patsubst %,$(Ilisp_tar_dir)/%,$(DocFiles))                \
-            $(Ilisp_tar_dir)/*.mail)
+            $(Ilisp_tar_dir)/extra/README                               \
+            $(Ilisp_tar_dir)/extra/hyperspec-*.el                       \
+            $(Ilisp_tar_dir)/extra/hyperspec.el                         \
+            $(Ilisp_tar_dir)/pictures/ilisp-icon.*                      \
+        )
 
 dist_compressing:
 	(cd $(Ilisp_src_dir)/.. ; gzip $(Ilisp_tar_dir).tar)
 	(cd $(Ilisp_src_dir)/.. ;                                           \
          uuencode $(Ilisp_tar_dir).tar.gz $(Ilisp_tar_dir).tar.gz > il.uue)
 
-#autoloads: auto-autoloads.el
-
-#custom-load.elc: custom-load.el
-#	$(EMACS) -batch -q -no-site-file -f batch-byte-compile $?
-
-#auto-autoloads.el: $(LoadFiles:.elc=.el)
-#	$(EMACS) -batch -q -no-site-file \
-#		-eval '(setq autoload-target-directory "'`pwd`'/")' \
-#		-l autoload \
-#		-f batch-update-autoloads $?
 
 # end of file -- Makefile --
+ILISP 5.9.x
+===========
+
 ILISP is a powerful GNU Emacs interface to many dialects of Lisp,
 including Lucid, Allegro, Harlequin LispWorks, GCL, KCL, AKCL, ECL, IBCL,
-and CMUCL.
+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@icsi.berkeley.edu> and
-Rick Campbell <campbell@c2.net>.
+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
 		dialect needs.
 
 Please send bug reports, questions, suggestions, etc. to:
-  ILISP Discussion <ilisp@naggum.no>
+
+  ILISP Discussion <ilisp@cons.org>
 
 Please address all list administration messages, such as requests to
-subscribe or unsubscribe from ilisp@naggum.no, to:
-  ILISP Administrivia <ilisp-request@naggum.no>
+subscribe or unsubscribe from ilisp@cons.org, to:
 
-See http://www.c2.net/~campbell/ilisp/ or
-http://www.cs.cmu.edu/~campbell/ilisp/ for more information.
+  ILISP Administrivia <majordomo@cons.org>
+
+
+See <http://ilisp.cons.org> for more information.
+
+Enjoy
+
+The ILISP Maintainers
-Welcome to the ILISP Discussion mailing list.
+Welcome to ILISP.
 
 ILISP is a GNU Emacs package for controlling an inferior process
-running a lisp dialect.  You can get ILISP by anonymous ftp at
-FTP.CS.CMU.EDU in the directory /afs/cs/user/campbell/http/ilisp/.
-Also you can find ILISP by getting to the AI.Repository via the WWW.
+running a lisp dialect.  You can get ILISP at
+<http://ilisp.cons.org>.
 
-http://www.cs.cmu.edu/Web/Groups/AI/html/repository.html
-
-From there follow: LISP, UTIL, EMACS and finally ILISP
-
-Other archive sites include:
- ftp://ftp.icsi.berkeley.edu/pub/software/elisp/
- http://www.c2.net/~campbell/ilisp/
- http://www.cs.cmu.edu/~campbell/ilisp/
 
 ILISP is currently being maintained by Marco Antoniotti
-<marcoxa@icsi.berkeley.edu> and Rick Campbell <campbell@c2.net>.
-The mailing list is maintained by Erik Naggum <erik@naggum.no>.
+<marcoxa@cons.org> and Rick Campbell <campbell@c2.net>.
 
+There is an ILISP mailing list managed by `majordomo'.
 Please address all list administration messages, such as requests to
 subscribe or unsubscribe, to:
 
- ILISP Administrivia <ilisp-request@naggum.no>
-
-Please allow a little time;
-there's no list server programming running, the list is maintained by
-hand.
+	  <majordomo@cons.org> ILISP Administrivia
 
 To send a message to everyone on the list, address it to:
 
- ILISP Discussion <ilisp@naggum.no>
+          <ilisp@cons.org> ILISP Discussion
 
 The list has had a very low volume lately, so you may not see messages
 for a while after subscribing.
 
-Please note that there is no "bug" list like ilisp-bugs@naggum.no.
+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.
+
+Enjoy
+
+The ILISP Maintainers
 ;;; allegro.lisp --
 
 ;;; This file is part of ILISP.
-;;; Version: 5.8
+;;; 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 Marco Antoniotti and Rick Campbell
+;;;               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 'ilisp-request@naggum.no' to be included in the
-;;; ILISP mailing list. 'ilisp@naggum.no' is the general ILISP
+;;; 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.
 
-;;;
 ;;; Allegro initializations
 ;;; Author: Chris McConnell, ccm@cs.cmu.edu
-;;;
+
 (in-package "ILISP")
 
+;;; 19990615 Patch suggested by Larry Hunter <hunter@nlm.nih.gov>
+;;; EXCL::FN_SYMDEF is no longer available by default.
+
+#+allegro-v5.0 (require :llstructs)
+
 ;;;
 (defun ilisp-callers (symbol package)
-  "Print a list of all of the functions that call FUNCTION and return
-T if successful." 
+  "Print a list of all of the functions that call FUNCTION.
+Returns T if successful."
   (ilisp-errors
    (let ((function (ilisp-find-symbol symbol package))
 	 (callers nil)
 
 ;;;
 (defun ilisp-source-files (symbol package type)
-  "Print each file for PACKAGE:SYMBOL's TYPE definition on a line and
-return T if successful."
+  "Print each file for PACKAGE:SYMBOL's TYPE definition on a line.
+Returns T if successful."
   (ilisp-errors
    (let* ((symbol (ilisp-find-symbol symbol package))
 	  (type (if (equal type "any") t (ilisp-find-symbol type "keyword")))
 	   t)
 	 nil))))
 
-;;;
-(dolist (symbol '(ilisp-callers ilisp-source-files))
-  (export symbol))
-(unless (compiled-function-p #'ilisp-callers)
-  (format t "\"ILISP: File is not compiled, use M-x ilisp-compile-inits\""))
+;;;===========================================================================
+;;; Epilogue
 
+(eval-when (load eval)
+  (unless (compiled-function-p #'ilisp-callers)
+    (ilisp-message t "File is not compiled, use M-x ilisp-compile-inits")))
+
+;;; end of file -- allegro.lisp --
 ;;; Bridge process filter, V1.0
 ;;; Copyright (C) 1991 Chris McConnell, ccm@cs.cmu.edu  
 ;;;
-;;; Send mail to ilisp@naggum.no if you have problems.
+;;; Send mail to ilisp@cons.org if you have problems.
 ;;;
-;;; Send mail to ilisp-request@naggum.no if you want to be on the
+;;; Send mail to majordomo@cons.org if you want to be on the
 ;;; ilisp mailing list.
 
 ;;; This file is part of GNU Emacs.
+;;; cl-chs-init.lisp --
+;;; Init file for CLisp H.S.
+;;;
+;;; 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).
+;;;
+;;; 1999-09-03; M. Atzmueller
+;;; removed obsolete stuff
+;;;
+;;; 1999-06-15: M. Atzmueller
+;;; removed command to load inspect1.fas
+;;; load any INSPECTOR yourself if there is no other inspect!
+;;; 
+;;; 1999-05-31: M. Atzmueller
+;;; ilisp-arglist => #+clisp arglist (...) modified definition
+;;; another option might be sys::arglist ...
+;;; added command to preload inspect1
+
+(in-package "ILISP")
+
+;;;
+(defun ilisp-inspect (sexp package)
+  "Inspect SEXP in PACKAGE."
+  (when (not (ignore-errors (functionp #'inspect)))
+    (cerror
+     "~% Try loading it yourself, or proceed without inspecting ... :-( !" 
+     "~% There seems to be no INSPECTOR present!"))
+
+  (ilisp-errors
+   (let ((*package* (ilisp-find-package package)))
+     (if (functionp #'inspect)
+	 (let ((item-to-be-described (read-from-string sexp)))
+	   (if (atom item-to-be-described)
+	       (inspect item-to-be-described)
+	     (inspect (eval item-to-be-described))))
+       (format t "Sorry -- can't inspect ~S as Clisp has no inspector!"
+		     sexp)))))
+
+(defun arglist (sym)
+  (when (fboundp sym)
+    (let* ((s (with-output-to-string (s) (describe (symbol-function sym) s)))
+	   (p (search "Argument list: " s)))
+      (if p
+	  (read-from-string (subseq s (+ 15 (search "Argument list: " s))))
+	'(???)))))
+
+;;; Epilogue
+
+(eval-when (:execute :load-toplevel)
+  (when (not (compiled-function-p #'ilisp-inspect))
+    (ilisp-message t "File is not compiled, use M-x ilisp-compile-inits"))
+
+  (when (boundp 'system::*source-file-types*)
+    (pushnew (pathname ".lisp") system::*source-file-types* :test #'equalp))
+  (sys::debug-unwind))
+
+
+;;; end of file -- cl-chs-init.lsp --
 ;;; cl-ilisp.lisp --
 
 ;;; This file is part of ILISP.
-;;; Version: 5.8
+;;; 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 Marco Antoniotti and Rick Campbell
+;;;               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 'ilisp-request@naggum.no' to be included in the
-;;; ILISP mailing list. 'ilisp@naggum.no' is the general ILISP
+;;; 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
 (in-package "ILISP")
 
 ;;;
-;;; GCL 2.2 doesn't have defpackage (yet) so we need to put the export
-;;; here. (toy@rtp.ericsson.se)
+;;; GCL 2.2 and GCL 2.3 do not have defpackage (yet) so we need to put
+;;; the export here. (toy@rtp.ericsson.se)
 ;;;
-;;; Please note that while the comment and the fix posted by Richard
-;;; Toy are correct, they are deprecated by at least one of the ILISP
+;;; Please note that while the comment and the fix posted by R. Toy
+;;; are correct, they are deprecated by at least one of the ILISP
 ;;; maintainers. :) By removing the 'nil' in the following #+, you
 ;;; will fix the problem but will not do a good service to the CL
 ;;; community.  The right thing to do is to install DEFPACKAGE in your
 ;;; GCL and to write the GCL maintainers and to ask them to
 ;;; incorporate DEFPACKAGE in their standard builds.
-;;; Marco Antoniotti <marcoxa@icsi.berkeley.edu> 19960715
-;;;
+;;; 19960715 Marco Antoniotti
+;;; 20000404 Martin Atzmueller: same for ecl/ecls
 
-#+(and nil gcl)
+#+(or (and nil gcl) (and nil ecl))
 (export '(ilisp-errors
 	  ilisp-save
 	  ilisp-restore
 	  ilisp-untrace
 	  ilisp-compile-file
 	  ilisp-casify
+          ilisp-print-info-message
 	  ilisp-matching-symbols))
 
 
 ;;;
 (defvar *ilisp-old-result* nil "Used for save/restore of top level values.")
 
+(defvar *ilisp-message-addon-string* "ILISP:")
+
+;;; 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!"
+
+(defun ilisp-message (format-output-stream format-control-string &rest args)
+  "ilisp-message provides an interface to create 'special' ILISP messages, i.e. \"ILISP: ... \" in an uniform way."
+  (let* ((format-string (apply #'format nil " ~@?" format-control-string args))
+         (concat-string (if (equal (char format-string 0) #\")
+                            ""
+                          (if format-output-stream
+                              "\""
+                            ""))))
+    (format format-output-stream
+            (concatenate 'string "~&" concat-string *ilisp-message-addon-string* format-string concat-string))))
+
+
 #+:ANSI-CL
 (defun special-form-p (symbol)
   "Backward compatibility for non ANSI CL's."
   (special-operator-p symbol))
 
+#+(and :CLTL2 (not :ANSI-CL))
+(defun special-form-p (symbol)
+  "For CLTL2 Lisp just use the old one."
+  (lisp:special-form-p symbol))
 ;;;
 (defmacro ilisp-handler-case (expression &rest handlers)
   "Evaluate EXPRESSION using HANDLERS to handle errors."
       #+lucid `(lucid::handler-case ,expression ,@handlers)
       #-(or allegro lucid) expression))
 
+
+;;; ilisp-readtable-case --
 ;;;
+;;; 19991218 Marco Antoniotti
+;;; READTABLE-CASE is ANSI.  However, I feel magnanimous today, so I
+;;; leave the check in to make it easier for non conforming
+;;; implementations.
+
 (defun ilisp-readtable-case (readtable)
   (if (fboundp 'readtable-case)
-      (funcall #'readtable-case readtable)
+      (readtable-case readtable)
       #+allegro (case excl:*current-case-mode*
 		  (:case-insensitive-upper :upcase)
 		  (:case-insensitive-lower :downcase)
 	 #+ecl
 	 (sys:*gc-verbose* nil) ; ecolisp also outputs "[GC ...]"
 	 )
-     (princ " ")			;Make sure we have output
+     (princ " ")			; Make sure we have output
+
+     ;; 19990912 Martin Atzmuller
+     ;; Gross CLisp HS hack so that the command-index stays the same
+     ;; after an ILISP-command that has to use the inferior lisp
+     ;;
+     ;; 19990912 Marco Antoniotti
+     ;; Put here since the change is very localized and not requiring
+     ;; a separate init file.
+     #+:clisp
+     (setq system::*command-index* (max 0 (- system::*command-index* 2)))
+
      (ilisp-handler-case
       ,form	
       (error (error)
-       (with-output-to-string (string)
-	 (format string "ILISP: ~A" error))))))
+             (ilisp-message nil "~A" error)))))
 
 
 ;;;
 ;;;
 (defun ilisp-restore ()
   "Restore the old result history."
-  (declare (special / // /// + ++ +++ * ** -))
+  (declare (special / // + ++ * ** -))
+    
   (setq // (pop *ilisp-old-result*)
 	** (first //)
 	/  (pop *ilisp-old-result*)
 	++  (pop *ilisp-old-result*)
 	+   (pop *ilisp-old-result*)
 	-   (pop *ilisp-old-result*))
-  (values-list (pop *ilisp-old-result*)))
+
+    ;; Martin Atzmueller 2000-01-26
+    (let ((new/ (pop *ilisp-old-result*)))
+      (if (some #'(lambda (new+)
+		    (and (stringp new+)
+			 (search *ilisp-message-addon-string* new+)))
+		new/)
+	  nil
+	(values-list new/))))
   
 ;;; ilisp-symbol-name --
 ;;;
     (:downcase (string-downcase symbol-name))
     (:capitalize (string-capitalize symbol-name))
     (:preserve symbol-name)))
-  
+
+
+;;; ilisp-find-package --
 ;;;
+;;; Notes:
+;;; 19990806 Unknown Author (blame Marco Antoniotti for this)
+;;; Added test for KEYWORD case.
+
 (defun ilisp-find-package (package-name)
   "Return package PACKAGE-NAME or the current package."
-  (if (string-equal package-name "nil")
-      *package*
-      (or (find-package (ilisp-symbol-name package-name))
-	  (error "Package ~A not found" package-name))))
+  (cond ((string-equal package-name "nil") *package*)
+	((string-equal package-name "") (find-package "KEYWORD"))
+	(t (or (find-package (ilisp-symbol-name package-name))
+	       (error "Package ~A not found" package-name)))))
 
 ;;;
 (defun ilisp-find-symbol (symbol-name package-name)
-  "Return the symbol associated with SYMBOL-NAME in PACKAGE-NAME trying to
-handle case issues intelligently."
+  "Return the symbol associated with SYMBOL-NAME in PACKAGE-NAME.
+The trick is to try to handle print case issues intelligently."
   (find-symbol (ilisp-symbol-name symbol-name)
 	       (ilisp-find-package package-name)))
 
   "Describe SEXP in PACKAGE."
   (ilisp-errors
    (let ((*package* (ilisp-find-package package)))
-     (describe (eval (read-from-string sexp))))))
+     (let ((item-to-be-described (read-from-string sexp)))
+       (if (atom item-to-be-described)
+	   (describe item-to-be-described)
+	   (describe (eval item-to-be-described)))))))
 
 ;;;
 (defun ilisp-inspect (sexp package)
   "Inspect SEXP in PACKAGE."
   (ilisp-errors
    (let ((*package* (ilisp-find-package package)))
-     (inspect (eval (read-from-string sexp))))))
+    (let ((item-to-be-described (read-from-string sexp)))
+       (if (atom item-to-be-described)
+	   (inspect item-to-be-described)
+	   (inspect (eval item-to-be-described)))))))
 
 ;;;
 (defun ilisp-arglist (symbol package)
+  "Returns the argument list of SYMBOL from PACKAGE."
   (ilisp-errors
     (let ((fn (ilisp-find-symbol symbol package))
 	  (*print-length* nil)
   (values))
 
 
+;;; print-function-arglist --
+;;; This function is really invoked only by the #\Space binding of
+;;; ILISP-PRINT-INFO-MESSAGE.
+
+;;; 19991218 Marco Antoniotti
+;;; Unfortunately the function GET-FUNCTION-ARGLIST may default to
+;;; DOCUMENTATION, which returns a string.  Hence the change.
+;;;
+;;; 19991218 Marco Antoniotti
+;;; Using the arglist command bound to #\Space would probably be
+;;; better.  Anyway...
+
+(defun print-function-arglist (fn)
+  "Pretty arglist printer"
+  (let* ((arglist-doc (get-function-arglist fn))
+	 (desc (ilisp-function-short-description fn)))
+    (format t "~&~s~a" fn (or desc ""))
+    (write-string ": ")
+    (typecase arglist-doc
+      (string (write-string arglist-doc))
+      (list (let ((arglist (ldiff arglist-doc
+				  (member '&aux arglist-doc))))
+	      (if arglist
+		  (write arglist :case :downcase :escape nil)
+		  (write-string "()"))))
+      (t (error (ilisp-message nil
+			       "arglist doc very messed up [~S]."
+			       arglist-doc))))
+    (terpri)
+    (values)))
+
+#| Original version
 (defun print-function-arglist (fn)
   "Pretty arglist printer"
   (let* ((a (get-function-arglist fn))
-	 (arglist (ldiff a (member '&aux a)))
+ 	 (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)))
+    (terpri)
+    (values)))
+|#
 
 
 
 	   
 	   #+lispworks
 	   (system::function-lambda-list symbol)
+
+	   #+clisp
+	   (arglist symbol)
+
+	   #+cmu
+	   (arglist symbol (symbol-package symbol))
 	   
-	   #-(or allegro lucid kcl ibcl ecl)
+	   #+:sbcl
+	   (arglist symbol (symbol-package symbol))
+	   
+	   #-(or allegro lucid kcl ibcl ecl clisp cmu :sbcl)
 	   (documentation symbol 'function)))))
 
+
+(defun ilisp-print-info-message (symbol package)
+  "Returns the argument list or the value of SYMBOL from PACKAGE.
+Error messages are generated appropriately."
+  (ilisp-errors
+   (let ((real-symbol (ilisp-find-symbol symbol package))
+	 (*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)
+	    (values))
+	   ((special-form-p real-symbol)
+	    (format t "~S: special-operator." real-symbol)
+	    (values))
+	   ((fboundp real-symbol)
+	    (print-function-arglist real-symbol))
+	   ((ignore-errors (boundp real-symbol))
+	    (format t "~S is bound to ~S."
+		    real-symbol (symbol-value real-symbol))
+	    (values))
+	   (t
+	    (format t "Symbol ~S is unbound." real-symbol)
+	    (values))))))
+
+
 ;;;
 (defun ilisp-documentation (symbol package type)
-  "Return the TYPE documentation for SYMBOL in PACKAGE.  If TYPE is
-\(qualifiers* (class ...)), the appropriate method will be found."
+  "Return the TYPE documentation for SYMBOL in PACKAGE.
+If TYPE is \(qualifiers* (class ...)), the appropriate method will be found."
   (ilisp-errors
    (let* ((real-symbol (ilisp-find-symbol symbol package))
 	  (type (if (and (not (zerop (length type)))
 
 ;;;
 (defun ilisp-macroexpand (expression package)
-  "Macroexpand EXPRESSION as long as the top level function is still a
-macro." 
+  "Macroexpand EXPRESSION as long as the top level function is still a macro." 
   (ilisp-errors
    (let ((*print-length* nil)
 	 (*print-level* nil)
 	 (*package* (ilisp-find-package package)))
      (pprint (macroexpand-1 (read-from-string expression))))))
 
-;;;
-#-lispworks
+
 (defun ilisp-trace (symbol package breakp)
   "Trace SYMBOL in PACKAGE."
   (declare (ignore breakp)) ; No way to do this in CL.
    (let ((real-symbol (ilisp-find-symbol symbol package)))
      (when real-symbol (eval `(trace ,real-symbol))))))
 
-;;; Jason Trenouth: SEP 6 94 -- LispWorks can trace-break
-#+lispworks
-(defun ilisp-trace (symbol package breakp)
-  "Trace SYMBOL in PACKAGE."
-  (ilisp-errors
-   (let ((real-symbol (ilisp-find-symbol symbol package)))
-     breakp ;; idiom for (declare (ignorable breakp))
-     (when real-symbol (eval `(trace (,real-symbol :break breakp)))))))
-
-
 
 (defun ilisp-untrace (symbol package)
   "Untrace SYMBOL in PACKAGE."
   (ilisp-errors
    (let ((real-symbol (ilisp-find-symbol symbol package)))
      (when real-symbol (eval `(untrace ,real-symbol))))))
+
+
+;;; ilisp-compile-file-extension --
+;;;
+;;; 19990806 Marco Antoniotti
+
+(defun ilisp-compile-file-extension ()
+  (pathname-type (compile-file-pathname "ilisp-foo")))
+
    
 ;;;
 (defun ilisp-compile-file (file extension)
 
 ;;;
 (defun ilisp-casify (pattern string lower-p upper-p)
-  "Return STRING with its characters converted to the case of PATTERN,
-continuing with the last case beyond the end."
+  "Return STRING with its characters converted to the case of PATTERN.
+It continues with the 'last case' beyond the end."
   (cond (lower-p (string-downcase string))
 	(upper-p (string-upcase string))
 	(t
 
 ;;;
 (defun ilisp-words (string)
-  "Return STRING broken up into words.  Each word is (start end
-delimiter)."
+  "Return STRING broken up into words.
+Each word is (start end delimiter)."
   (do* ((length (length string))
 	(start 0)
 	(end t)
     (when start2 (incf start2))))
 
 ;;;
-(defun ilisp-matching-symbols (string package &optional (function-p nil)
+(defun ilisp-matching-symbols (string package
+				      &optional
+				      (function-p nil)
 				      (external-p nil)
 				      (prefix-p nil))
-  "Return a list of the symbols that have STRING as a prefix in
-PACKAGE. FUNCTION-P indicates that only symbols with a function value
+  "Return a list of the symbols that have STRING as a prefix in PACKAGE.
+FUNCTION-P indicates that only symbols with a function value
 should be considered.  EXTERNAL-P indicates that only external symbols
 should be considered.  PREFIX-P means that partial matches should not
 be considered.  The returned strings have the same case as the
 		     (check-symbol2 symbol symbol-string words)))
 		 (do-symbols (symbol *package*)
 		   (check-symbol2 symbol symbol-string words))))))
-       (prin1 results)
+       ;; 19990806 Unknown Author (blame Marco Antoniotti for this)
+       ;; () doesn't depend on *PACKAGE*
+       ;;
+       ;; (prin1 results)
+       (if results (prin1 results) (princ "()"))
        nil))))
 
 
 (eval-when (load eval)
   (when
-      #+cmu (eval:interpreted-function-p #'ilisp-matching-symbols)
-      #-cmu (not (compiled-function-p #'ilisp-matching-symbols))
-      (format *standard-output*
-	      "\"ILISP: File is not compiled, use M-x ilisp-compile-inits\"")))
+      #+(and :CMU :CMU17)
+      (eval:interpreted-function-p #'ilisp-matching-symbols)
+      #-(and :CMU :CMU17)
+      (not (compiled-function-p #'ilisp-matching-symbols))
+      (ilisp-message *standard-output*
+		     "File is not compiled, use M-x ilisp-compile-inits")))
+
 
 ;;; end of file -- cl-ilisp.lisp --
 ;;; cmulisp.lisp --
 
 ;;; This file is part of ILISP.
-;;; Version: 5.8
+;;; 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 Marco Antoniotti and Rick Campbell
+;;;               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 'ilisp-request@naggum.no' to be included in the
-;;; ILISP mailing list. 'ilisp@naggum.no' is the general ILISP
+;;; 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
 ;;; Normally, errors which occur while in the debugger are just ignored, unless
 ;;; the user issues the "flush" command, which toggles this behavior.
 ;;;
-(setq debug:*flush-debug-errors* nil)  ;; allow multiple error levels.
+(setq debug:*flush-debug-errors* nil)  ; allow multiple error levels.
 
 ;;; This implementation of "POP" simply looks for the first restart that says
 ;;; "Return to debug level n" or "Return to top level." and executes it.
 ;;;
 (debug::def-debug-command "POP" #+:new-compiler ()
-    ;; find the first "Return to ..." restart
-    (if (not (boundp 'debug::*debug-restarts*))
-	(error "You're not in the debugger; how can you call this!?")
-	(labels ((find-return-to (restart-list num)
+  ;; find the first "Return to ..." restart
+  (if (not (boundp 'debug::*debug-restarts*))
+      (error "You're not in the debugger; how can you call this!?")
+      (labels ((find-return-to (restart-list num)
 		 (let ((first
 			(member-if
 			 #'(lambda (restart)
-			     (string= (funcall
-				       (conditions::restart-report-function restart)
-				       nil)
-				      "Return to " :end1 10))
-			  restart-list)))
+			     (string=
+			      (funcall
+			       (conditions::restart-report-function restart)
+			       nil)
+			      "Return to " :end1 10))
+			 restart-list)))
 		   (cond ((zerop num) (car first))
-			 ((cdr first) (find-return-to (cdr first) (1- num)))))))
+			 ((cdr first)
+			  (find-return-to (cdr first) (1- num)))))))
 	(let* ((level (debug::read-if-available 1))
 	       (first-return-to (find-return-to 
 				 debug::*debug-restarts* (1- level))))
   "Deduce how to get the \"right\" function object and return it."
   (let ((fun (or (macro-function sym)
 		 (and (fboundp sym) (symbol-function sym)))))
-    (cond (fun
-	   (when (and (= (lisp::get-type fun) #.vm:closure-header-type)
-		      (not (eval:interpreted-function-p fun)))
-	     (setq fun (lisp::%closure-function fun)))
-	   fun)
-	  (t
-	   (error "Unknown function ~a.  Check package." sym)
-	   nil))))
+    (unless fun
+      (error "Unknown function ~a.  Check package." sym))
 
+    (if (and (= (lisp::get-type fun) #.vm:closure-header-type)
+	     (not (eval:interpreted-function-p fun)))
+	(lisp::%closure-function fun)
+	fun)))
 
+(defun extract-function-info-from-name (sym)
+  (let ((mf (macro-function sym)))
+    (if mf
+	(values mf :macro)
+	(if (fboundp sym)
+	    (values (symbol-function sym) :function)
+	    (values nil nil)))))
 
 (export '(arglist source-file cmulisp-trace))
 
 ;;;%% arglist - return arglist of function
+;;;
+;;; 19991219 Marco Antoniotti
+;;; New version is patterned after DESCRIBE-FUNCTION in the
+;;; 'describe.lisp' file of CMUCL.
 
 (defun arglist (symbol package)
   (ilisp-errors
-   (let* ((x (ilisp-find-symbol symbol package))
+   (let* ((package-name (if (packagep package)
+			    (package-name package)
+			    package))
+	  (x (ilisp-find-symbol symbol package-name))
+	  )
+     (flet ((massage-arglist (args)
+	      (typecase args
+		(string (if (or (null args) (string= args "()"))
+			    ""
+			    args))
+		(list (format nil "~S" args))
+		(t ""))))
+
+       (multiple-value-bind (func kind)
+	   (extract-function-info-from-name x)
+	 ;; (print func *trace-output*)
+	 ;; (print kind *trace-output*)
+	 (if (and func kind)
+	     (case (lisp::get-type func)
+	       ((#.vm:closure-header-type
+		 #.vm:function-header-type
+		 #.vm:closure-function-header-type)
+		(massage-arglist
+		 (funcall #+CMU17 #'lisp::%function-arglist
+			  #-CMU17 #'lisp::%function-header-arglist
+			  func)))
+
+	       (#.vm:funcallable-instance-header-type
+		(typecase func
+		  (kernel:byte-function
+		   "Byte compiled function or macro, no arglist available.")
+		  (kernel:byte-closure
+		   "Byte compiled closure, no arglist available.")
+		  ((or generic-function pcl:generic-function)
+		   (pcl::generic-function-pretty-arglist func))
+		  (eval:interpreted-function
+		   (massage-arglist (eval::interpreted-function-arglist func)))
+		
+		  (t (print 99 *trace-output*) "No arglist available.")
+		  ))			; typecase
+	       (t "No arglist available.")) ; case
+	     "Unknown function - no arglist available." ; For the time
+					; being I just
+					; return this
+					; value. Maybe
+					; an error would
+					; 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) 
 	     (pcl::generic-function-pretty-arglist fun))
 	    ((compiled-function-p fun)
 	     (let ((string-or-nil
-		    (#+CMU17 lisp::%function-arglist
-		     #-CMU17 lisp::%function-header-arglist
+		    (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 --
    (let ((real-symbol (ilisp-find-symbol symbol package)))
      (setq breakp (read-from-string breakp))
      (when real-symbol (eval `(trace ,real-symbol :break ,breakp))))))
+
+;;; end of file -- cmulisp.lisp --
 ;;; IPC extensions for comint
 ;;; Copyright (C) 1990 Chris McConnell, ccm@cs.cmu.edu.
 ;;;
-;;; Send mail to ilisp@naggum.no if you have problems.
+;;; Send mail to ilisp@cons.org if you have problems.
 ;;;
-;;; Send mail to ilisp-request@naggum.no if you want to be on the
+;;; Send mail to majordomo@cons.org if you want to be on the
 ;;; ilisp mailing list.
 
 ;;; This file is part of GNU Emacs.
 
 ;;;%Parameters
 (defvar comint-log nil
-  "If T, then record all process input and output in a buffer called
-process name.")
+  "If T, then record all process input and output in a buffer.
+The name of the buffer is the process name.")
 
 (defvar comint-send-newline t 
   "If T then add a newline to string in comint-default-send.")
 			       (string-match comint-error-regexp
 					     comint-output))))
 		(unwind-protect
-		     ;; (if handler
-		     ;;	    (setq handler
-		     ;;		 (funcall handler comint-errorp wait-p
-		     ;;		          message output last)))
+		    ;; (if handler
+		    ;;	    (setq handler
+		    ;;		 (funcall handler comint-errorp wait-p
+		    ;;		          message output last)))
 
-		     ;; v5.7b Patch suggested by fujieda@jaist.ac.jp
-		     ;; (Kazuhiro Fujieda). Here is his comment.
+		    ;; v5.7b Patch suggested by fujieda@jaist.ac.jp
+		    ;; (Kazuhiro Fujieda). Here is his comment.
 
-		     ;; "When the 'handler' is called, the current
-		     ;; buffer may be changed. 'comint-process-filter'
-		     ;; accesses some buffer-local variables, for
-		     ;; example 'comint-send-queue' and
-		     ;; 'comint-end-queue'.  If the current buffer is
-		     ;; changed in the 'handler', the entities of
-		     ;; these buffer-local variables is replaced, and
-		     ;; corrupt successive behaviors."
+		    ;; "When the 'handler' is called, the current
+		    ;; buffer may be changed. 'comint-process-filter'
+		    ;; accesses some buffer-local variables, for
+		    ;; example 'comint-send-queue' and
+		    ;; 'comint-end-queue'.  If the current buffer is
+		    ;; changed in the 'handler', the entities of
+		    ;; these buffer-local variables is replaced, and
+		    ;; corrupt successive behaviors."
 
-		     ;; The code hereafter fixes the problem.
-
-		     (if handler
-			 (save-excursion
-			   (setq handler
-				 (funcall handler comint-errorp wait-p
-					  message output last))))
+		    ;; The code hereafter fixes the problem.
+		    
+		    (if handler
+			(save-excursion
+			  (setq handler
+				(funcall handler comint-errorp wait-p
+					 message output last))))
 
 		  (if (and error handler no-insert comint-fix-error)
 		      (setq comint-send-queue 
 			      (rplaca messagep "Done")
 			      (rplaca running nil)
 			      (comint-dispatch-send process))))
-		      ;; Not waiting
-		      (rplaca messagep "Done")
-		      (rplaca running nil)
-		      (comint-dispatch-send process))))
-	      (rplacd result nil))))
+		    ;; Not waiting
+		    (rplaca messagep "Done")
+		    (rplaca running nil)
+		    (comint-dispatch-send process))))
+	    (rplacd result nil))))
     (store-match-data match-data)
     (if (or (get-buffer-window comint-original-buffer)
 	    (eq (window-buffer (minibuffer-window)) comint-original-buffer))
-;;; 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, then filename components will be individually
+  "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."
 		 ;; 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 (eq minibuffer-completion-table 'read-file-name-internal)
-	     (re-search-backward
-	      (if (memq system-type '(windows-nt cygwin32))
-		  ; // is meaningful
-		  "/~\\|.\\$" "//\\|/~\\|.\\$") nil t))
+	     (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
 
 ;;;
 (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
 (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 --

completer.new.el

-;;; -*-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 GNU Emacs.
-
-;;; 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
-;;; 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 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.
-
<