Go to the previous, next section.

How to install ILISP

If ILISP has already been installed at your location, you can probably skip ahead to "Autoloading."

Note that jwz's byte-compiler is required when compiling ILISP. If you don't have it, get it from archive.cis.ohio-state.edu:/pub/gnu/emacs/elisp-archive/bytecomp2.tar.Z

You don't need it if you are running emacs version 19 as both the Fsf and Lucid releases include this in their distributions.

• Makefile configuration
• Files of ILISP
• Autoloading: How to define autoload entries.

Makefile configuration

Some configuration needs to be done before compiling the emacs-lisp files that comprise ILISP. This should be done in the Makefile-ilisp file in the section of the file marked CONFIGURATION SECTION.

First, set the YOUR_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 you don't have jwz's byte compiler in your standard load path then you will have to uncomment the BYTECOMP line and set it to point to the correct location of the bytecomp files.

If you do not have comint already in your emacs ( both Fsf 19 and Lucid 19 do ) then uncomment the USE_BUNDLED_COMINT line. This will cause the copy of comint.el to be moved from the Extras directory into the main ILISP directory.

The advice section is left uncommented out in the distributed Makefile-ilisp because most people will not have advice.elc in their load path. Only Lucid emacs 19.8 will have this in the standard distribution. If you do have it in your load path, then to avoid having two copies in your load-path and avoiding future confusion then comment out both the ADVICE and USE_BUNDLED_ADVICE lines.

You can then compile everything with the shell command

make -f Makefile-ilisp <your target here>'

Where the possible targets are emacs_18, emacs_18_epoch, emacs_18_menu, and emacs_19.

Ignore any compilation warnings unless they result in ILISP not compiling completely.

You should then copy relevant sections of ilisp.emacs to your .emacs or to the system-wide default.el file, depending on who will be using ILISP.

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

The first time a dialect is started, the interface files will complain about not being compiled, just hit i to 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/misc/.allegro/bin/cl")
        (setq lucid-program "/usr/misc/.lucid/bin/lisp")))

Files of ILISP

`ilisp.emacs'

File with sample `.emacs' code for ILISP.

`symlink-fix.el'

Expand pathnames resolving links.

`completer.el'

Partial completion code.

`bridge.el'

Process to process communication.

`comint.el'

The basic comint abstraction. You only need this if running emacs-18.

`comint-ipc.el'

Extensions for sending commands and getting results.

`ilisp-ext.el'

Standalone lisp-mode extensions.

`ilisp-bug.el'

ILISP bug submittal code.

`compat.el'

Compatibility code between fsf-18, fsf-19 and lemacs-19.

`ilisp-inp.el'

Buffer input module.

`ilisp-def.el'

Variable definitions.

`ilisp-ind.el'

Indentation code.

`ilisp-mov.el'

Buffer-point movement code.

`ilisp-key.el'

Keymap setups, including ilisp-lispm-bindings.

`ilisp-doc.el'

ILISP mode documenation.

`ilisp-mod.el'

ILISP mode definition.

`ilisp-prn.el'

Parenthesis handling.

`ilisp-el.el'

Emacs-lisp additions.

`ilisp-sym.el'

ILISP symbol handling.

`ilisp-low.el'

Low level interface code.

`ilisp-hi.el'

High level interface code.

`ilisp-out.el'

Output handling, include typeout window (a popper replacement).

`ilisp-prc.el'

Process handling code.

`ilisp-val.el'

Buffer value interface.

`ilisp-rng.el'

Match ring code.

`ilisp-utl.el'

Misc. utilities.

`ilisp-hnd.el'

Error handling.

`ilisp-kil.el'

Interface to reset/kill/abort inferior lisp.

`ilisp-snd.el'

ilisp-send definitions and associated code.

`ilisp-cmt.el'

Comint related code/setup.

`ilisp-cmp.el'

ILISP completer related code.

`ilisp-xfr.el'

Transfer between lisp <-> emacs code.

`ilisp-cl.el'

Commo-Lisp dialect definition.

`ilisp-src.el'

ILISP source code module.

`ilisp-bat.el'

ILISP batch code module.

`ilisp.el'

File to be loaded, loads in all necessary parts of ILISP.

`*.lisp'

ILISP support code. Each dialect will have one of these files.

`*.lcd'

Package descriptors for the Lisp Code Directory.

`ilisp.texi'

Texinfo file for ILISP.

How to define autoload entries

;;;
;;; This file shows examples of some of the things you might want to
;;; do to install or customize ILISP.  You may not want to include all
;;; of them in your .emacs.  For example, the default key binding
;;; prefix for ILISP is C-z and this file changes the default prefix to
;;; C-c.  For more information on things that can be changed, see the
;;; file ilisp.el. 
;;;

;;; If ilisp lives in some non-standard directory, you must tell emacs
;;; where to get it. This may or may not be necessary.
(setq load-path (cons (expand-file-name "~jones/emacs/ilisp/") load-path))

;;; If you always want partial minibuffer completion
(require 'completer)

;;; If want TMC completion then you will have to Ftp it yourself from think.com
;;; It's become to flaky for me to deal with. -- Ivan
;;;(load "completion")
;;;(initialize-completions)

;;; If you want to redefine typeout-window keys:
(add-hook 'ilisp-load-hook
      '(lambda ()
	(define-key global-map "\C-c1" 'ilisp-bury-output)
	(define-key global-map "\C-cv" 'ilisp-scroll-output)
	(define-key global-map "\C-cg" 'ilisp-grow-output)))


(autoload 'run-ilisp "ilisp" "Select a new inferior LISP." t)
;;; Autoload based on your LISP.  You only really need the one you use.
;;; If called with a prefix, you will be prompted for a buffer and
;;; program.
;;; 
;;; [Back to the old way now -- Ivan Mon Jun 28 23:30:51 1993]
;;;
(autoload 'clisp     "ilisp" "Inferior generic Common LISP." t)
(autoload 'allegro   "ilisp" "Inferior Allegro Common LISP." t)
(autoload 'lucid     "ilisp" "Inferior Lucid Common LISP." t)
(autoload 'cmulisp   "ilisp" "Inferior CMU Common LISP." t)
(autoload 'kcl       "ilisp" "Inferior Kyoto Common LISP." t)
(autoload 'akcl      "ilisp" "Inferior Austin Kyoto Common LISP." t)
(autoload 'ibcl      "ilisp" "Ibuki Common LISP." t)
(autoload 'scheme    "ilisp" "Inferior generic Scheme." t)
(autoload 'oaklisp   "ilisp" "Inferior Oaklisp Scheme." t)

;;; Define where LISP programs are found.  (This may already be done
;;; at your site.)
(setq allegro-program "/usr/misc/.allegro/bin/cl")
(setq lucid-program "/usr/misc/.lucid/bin/lisp")
(setq cmulisp-program "/usr/misc/.cmucl/bin/lisp")

;;; If you run cmu-cl then set this to where your source files are.
(setq cmulisp-local-source-directory 
      "/usr/local/utils/CMU-CL/")


;;; This makes reading a lisp file load in ilisp.
(set-default 'auto-mode-alist
	     (append '(("\\.lisp$" . lisp-mode)) auto-mode-alist))
(setq lisp-mode-hook '(lambda () (require 'ilisp)))

;;; Sample load hook
(add-hook 'ilisp-load-hook 
	  '(lambda ()
	    ;; Change default key prefix to C-c
	    (setq ilisp-prefix "\C-c")

	    ;; Define LispMachine-like key bindings, too.
	    (ilisp-lispm-bindings)

	    ;; Sample initialization hook.  Set the inferior LISP directory to
	    ;; the directory of the buffer that spawned it on the first prompt.
	    (setq ilisp-init-hook
	     '(lambda ()
	       (default-directory-lisp ilisp-last-buffer)))))

Go to the previous, next section.