-;;; cmulisp.el --- improved version of standard inferior-lisp mode
+;;; inf-lisp.el --- an inferior-lisp mode
;; Author: Olin Shivers <shivers@cs.cmu.edu>
-;; Last-Modified: 16 Jul 1993
+;; Last-Modified: 16 Jul 1992
;; Keyword: processes, lisp
;;; Copyright Olin Shivers (1988).
-;;; Please imagine a long, tedious, legalistic 5-page gnu-style copyright
-;;; notice appearing here to the effect that you may use this code any
-;;; way you like, as long as you don't charge money for it, remove this
-;;; notice, or hold me liable for its results.
+
+;;; This file is part of GNU Emacs.
+
+;;; GNU Emacs 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.
+
+;;; GNU Emacs is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;;; GNU General Public License for more details.
+
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Emacs; see the file COPYING. If not, write to
+;;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
;;; Commentary:
-;;; This replaces the standard inferior-lisp mode.
;;; Hacked from tea.el by Olin Shivers (shivers@cs.cmu.edu). 8/88
-;;; Please send me bug reports, bug fixes, and extensions, so that I can
-;;; merge them into the master source.
-;;;
-;;; Change log at end of file.
-;;; This file defines a a lisp-in-a-buffer package (cmulisp mode) built on top
-;;; of comint mode. Cmulisp mode is similar to, and intended to replace, its
-;;; counterpart in the standard gnu emacs release. This replacements is more
-;;; featureful, robust, and uniform than the released version. The key
-;;; bindings are also more compatible with the bindings of Hemlock and Zwei
-;;; (the Lisp Machine emacs).
+;;; This file defines a a lisp-in-a-buffer package (inferior-lisp
+;;; mode) built on top of comint mode. This version is more
+;;; featureful, robust, and uniform than the Emacs 18 version. The
+;;; key bindings are also more compatible with the bindings of Hemlock
+;;; and Zwei (the Lisp Machine emacs).
;;; Since this mode is built on top of the general command-interpreter-in-
;;; a-buffer mode (comint mode), it shares a common base functionality,
;;; For documentation on the functionality provided by comint mode, and
;;; the hooks available for customising it, see the file comint.el.
-;;; For further information on cmulisp mode, see the comments below.
+;;; For further information on inferior-lisp mode, see the comments below.
;;; Needs fixin:
;;; The load-file/compile-file default mechanism could be smarter -- it
;;; because the extension for executable files varies so much (.o, .bin,
;;; .lbin, .mo, .vo, .ao, ...).
;;;
-;;; It would be nice if cmulisp (and inferior scheme, T, ...) modes
+;;; It would be nice if inferior-lisp (and inferior scheme, T, ...) modes
;;; had a verbose minor mode wherein sending or compiling defuns, etc.
;;; would be reflected in the transcript with suitable comments, e.g.
;;; ";;; redefining fact". Several ways to do this. Which is right?
;;=============================================================================
;; Some suggestions for your .emacs file.
;;
-;; ; If cmulisp lives in some non-standard directory, you must tell emacs
+;; ; If inferior-lisp 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/lib/emacs") load-path))
;;
-;; ; Autoload cmulisp from file cmulisp.el
-;; (autoload 'cmulisp "cmulisp"
+;; ; Autoload inferior-lisp from file inf-lisp.el
+;; (autoload 'inferior-lisp "inferior-lisp"
;; "Run an inferior Lisp process."
;; t)
;;
-;; ; Define C-c t to run my favorite command in cmulisp mode:
-;; (setq cmulisp-load-hook
+;; ; Define C-c t to run my favorite command in inferior-lisp mode:
+;; (setq inferior-lisp-load-hook
;; '((lambda ()
-;; (define-key cmulisp-mode-map "\C-ct" 'favorite-cmd))))
+;; (define-key inferior-lisp-mode-map "\C-ct" 'favorite-cmd))))
\f
;;; Brief Command Documentation:
;;;============================================================================
-;;; Comint Mode Commands: (common to cmulisp and all comint-derived modes)
+;;; Comint Mode Commands: (common to inferior-lisp and all
+;;; comint-derived modes)
;;;
;;; m-p comint-previous-input Cycle backwards in input history
;;; m-n comint-next-input Cycle forwards
;;; top-level job.
;;; comint-mode-hook is the comint mode hook.
-;;; CMU Lisp Mode Commands:
+;;; Inferior Lisp Mode Commands:
;;; c-m-x lisp-send-defun This binding is a gnu convention.
;;; c-c c-l lisp-load-file Prompt for file name; tell Lisp to load it.
;;; c-c c-k lisp-compile-file Prompt for file name; tell Lisp to kompile it.
;;; c-c c-f lisp-show-function-documentation Query Lisp for a function's doc.
;;; c-c c-v lisp-show-variable-documentation Query Lisp for a variable's doc.
-;;; cmulisp Fires up the Lisp process.
+;;; inferior-lisp Fires up the Lisp process.
;;; lisp-compile-region Compile all forms in the current region.
;;;
-;;; CMU Lisp Mode Variables:
-;;; cmulisp-filter-regexp Match this => don't get saved on input hist
+;;; Inferior Lisp Mode Variables:
+;;; inferior-lisp-filter-regexp Match this => don't get saved on input hist
;;; inferior-lisp-program Name of Lisp program run-lisp executes
;;; inferior-lisp-load-command Customises lisp-load-file
-;;; cmulisp-mode-hook
+;;; inferior-lisp-mode-hook
;;; inferior-lisp-prompt Initialises comint-prompt-regexp.
;;; Backwards compatibility.
;;; lisp-source-modes Anything loaded into a buffer that's in
(require 'comint)
\f
-(defvar cmulisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'"
+(defvar inferior-lisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'"
"*What not to save on inferior Lisp's input history
-Input matching this regexp is not saved on the input history in cmulisp
+Input matching this regexp is not saved on the input history in inferior-lisp
mode. Default is whitespace followed by 0 or 1 single-letter :keyword
(as in :a, :c, etc.)")
-(defvar cmulisp-mode-map nil)
-(cond ((not cmulisp-mode-map)
- (setq cmulisp-mode-map
+(defvar inferior-lisp-mode-map nil)
+(cond ((not inferior-lisp-mode-map)
+ (setq inferior-lisp-mode-map
(full-copy-sparse-keymap comint-mode-map))
- (lisp-mode-commands cmulisp-mode-map)
- (define-key cmulisp-mode-map "\C-x\C-e" 'lisp-eval-last-sexp)
- (define-key cmulisp-mode-map "\C-c\C-l" 'lisp-load-file)
- (define-key cmulisp-mode-map "\C-c\C-k" 'lisp-compile-file)
- (define-key cmulisp-mode-map "\C-c\C-a" 'lisp-show-arglist)
- (define-key cmulisp-mode-map "\C-c\C-d" 'lisp-describe-sym)
- (define-key cmulisp-mode-map "\C-c\C-f" 'lisp-show-function-documentation)
- (define-key cmulisp-mode-map "\C-c\C-v" 'lisp-show-variable-documentation)))
+ (setq inferior-lisp-mode-map
+ (nconc inferior-lisp-mode-map shared-lisp-mode-map))
+ (define-key inferior-lisp-mode-map "\C-x\C-e" 'lisp-eval-last-sexp)
+ (define-key inferior-lisp-mode-map "\C-c\C-l" 'lisp-load-file)
+ (define-key inferior-lisp-mode-map "\C-c\C-k" 'lisp-compile-file)
+ (define-key inferior-lisp-mode-map "\C-c\C-a" 'lisp-show-arglist)
+ (define-key inferior-lisp-mode-map "\C-c\C-d" 'lisp-describe-sym)
+ (define-key inferior-lisp-mode-map "\C-c\C-f"
+ 'lisp-show-function-documentation)
+ (define-key inferior-lisp-mode-map "\C-c\C-v"
+ 'lisp-show-variable-documentation)))
;;; These commands augment Lisp mode, so you can process Lisp code in
;;; the source files.
;;; Previous versions of this package bound commands to C-c <letter>
;;; bindings, which is not allowed by the gnumacs standard.
-(defun cmulisp-install-letter-bindings ()
- "This function binds many cmulisp commands to C-c <letter> bindings,
+(defun inferior-lisp-install-letter-bindings ()
+ "This function binds many inferior-lisp commands to C-c <letter> bindings,
where they are more accessible. C-c <letter> bindings are reserved for the
user, so these bindings are non-standard. If you want them, you should
-have this function called by the cmulisp-load-hook:
- (setq cmulisp-load-hook '(cmulisp-install-letter-bindings))
+have this function called by the inferior-lisp-load-hook:
+ (setq inferior-lisp-load-hook '(inferior-lisp-install-letter-bindings))
You can modify this function to install just the bindings you want."
-
+
(define-key lisp-mode-map "\C-ce" 'lisp-eval-defun-and-go)
(define-key lisp-mode-map "\C-cr" 'lisp-eval-region-and-go)
(define-key lisp-mode-map "\C-cc" 'lisp-compile-defun-and-go)
(define-key lisp-mode-map "\C-cd" 'lisp-describe-sym)
(define-key lisp-mode-map "\C-cf" 'lisp-show-function-documentation)
(define-key lisp-mode-map "\C-cv" 'lisp-show-variable-documentation)
-
- (define-key cmulisp-mode-map "\C-cl" 'lisp-load-file)
- (define-key cmulisp-mode-map "\C-ck" 'lisp-compile-file)
- (define-key cmulisp-mode-map "\C-ca" 'lisp-show-arglist)
- (define-key cmulisp-mode-map "\C-cd" 'lisp-describe-sym)
- (define-key cmulisp-mode-map "\C-cf" 'lisp-show-function-documentation)
- (define-key cmulisp-mode-map "\C-cv" 'lisp-show-variable-documentation))
+
+ (define-key inferior-lisp-mode-map "\C-cl" 'lisp-load-file)
+ (define-key inferior-lisp-mode-map "\C-ck" 'lisp-compile-file)
+ (define-key inferior-lisp-mode-map "\C-ca" 'lisp-show-arglist)
+ (define-key inferior-lisp-mode-map "\C-cd" 'lisp-describe-sym)
+ (define-key inferior-lisp-mode-map "\C-cf" 'lisp-show-function-documentation)
+ (define-key inferior-lisp-mode-map "\C-cv"
+ 'lisp-show-variable-documentation))
(defvar inferior-lisp-program "lisp"
- "*Program name for invoking an inferior Lisp with `cmulisp'.")
+ "*Program name for invoking an inferior Lisp with `inferior-lisp'.")
(defvar inferior-lisp-load-command "(load \"%s\")\n"
"*Format-string for building a Lisp expression to load a file.
"Regexp to recognise prompts in the inferior Lisp.
Defaults to \"^[^> ]*>+:? *\", which works pretty good for Lucid, kcl,
and franz. This variable is used to initialise comint-prompt-regexp in the
-cmulisp buffer.
+inferior-lisp buffer.
More precise choices:
Lucid Common Lisp: \"^\\(>\\|\\(->\\)+\\) *\"
This is a fine thing to set in your .emacs file.")
-(defvar cmulisp-mode-hook '()
- "*Hook for customising cmulisp mode")
+(defvar inferior-lisp-mode-hook '()
+ "*Hook for customising inferior-lisp mode")
-(defun cmulisp-mode ()
+(defun inferior-lisp-mode ()
"Major mode for interacting with an inferior Lisp process.
Runs a Lisp interpreter as a subprocess of Emacs, with Lisp I/O through an
Emacs buffer. Variable inferior-lisp-program controls which Lisp interpreter
-is run. Variables inferior-lisp-prompt, cmulisp-filter-regexp and
+is run. Variables inferior-lisp-prompt, inferior-lisp-filter-regexp and
inferior-lisp-load-command can customize this mode for different Lisp
interpreters.
For information on running multiple processes in multiple buffers, see
-documentation for variable cmulisp-buffer.
+documentation for variable inferior-lisp-buffer.
-\\{cmulisp-mode-map}
+\\{inferior-lisp-mode-map}
Customisation: Entry to this mode runs the hooks on comint-mode-hook and
-cmulisp-mode-hook (in that order).
+inferior-lisp-mode-hook (in that order).
You can send text to the inferior Lisp process from other buffers containing
Lisp source.
(interactive)
(comint-mode)
(setq comint-prompt-regexp inferior-lisp-prompt)
- (setq major-mode 'cmulisp-mode)
- (setq mode-name "CMU Lisp")
+ (setq major-mode 'inferior-lisp-mode)
+ (setq mode-name "Inferior Lisp")
(setq mode-line-process '(": %s"))
- (if (string-match "^18.4" emacs-version) ; hack.
- (lisp-mode-variables) ; This is right for 18.49
- (lisp-mode-variables t)) ; This is right for 18.50
- (use-local-map cmulisp-mode-map) ;c-c c-k for "kompile" file
+ (lisp-mode-variables t)
+ (use-local-map inferior-lisp-mode-map) ;c-c c-k for "kompile" file
(setq comint-get-old-input (function lisp-get-old-input))
(setq comint-input-filter (function lisp-input-filter))
(setq comint-input-sentinel 'ignore)
- (run-hooks 'cmulisp-mode-hook))
+ (run-hooks 'inferior-lisp-mode-hook))
(defun lisp-get-old-input ()
"Snarf the sexp ending at point"
(buffer-substring (point) end))))
(defun lisp-input-filter (str)
- "Don't save anything matching cmulisp-filter-regexp"
- (not (string-match cmulisp-filter-regexp str)))
+ "Don't save anything matching inferior-lisp-filter-regexp"
+ (not (string-match inferior-lisp-filter-regexp str)))
-(defun cmulisp (cmd)
- "Run an inferior Lisp process, input and output via buffer *cmulisp*.
-If there is a process already running in *cmulisp*, just switch to that buffer.
+(defun inferior-lisp (cmd)
+ "Run an inferior Lisp process, input and output via buffer *inferior-lisp*.
+If there is a process already running in *inferior-lisp*, just switch
+to that buffer.
With argument, allows you to edit the command line (default is value
-of inferior-lisp-program). Runs the hooks from cmulisp-mode-hook (after the
-comint-mode-hook is run).
+of inferior-lisp-program). Runs the hooks from
+inferior-lisp-mode-hook (after the comint-mode-hook is run).
\(Type \\[describe-mode] in the process buffer for a list of commands.)"
(interactive (list (if current-prefix-arg
(read-string "Run lisp: " inferior-lisp-program)
- inferior-lisp-program)))
- (if (not (comint-check-proc "*cmulisp*"))
- (let ((cmdlist (cmulisp-args-to-list cmd)))
- (set-buffer (apply (function make-comint) "cmulisp" (car cmdlist) nil
- (cdr cmdlist)))
- (cmulisp-mode)))
- (setq cmulisp-buffer "*cmulisp*")
- (switch-to-buffer "*cmulisp*"))
+ inferior-lisp-program)))
+ (if (not (comint-check-proc "*inferior-lisp*"))
+ (let ((cmdlist (inferior-lisp-args-to-list cmd)))
+ (set-buffer (apply (function make-comint)
+ "inferior-lisp" (car cmdlist) nil (cdr cmdlist)))
+ (inferior-lisp-mode)))
+ (setq inferior-lisp-buffer "*inferior-lisp*")
+ (switch-to-buffer "*inferior-lisp*"))
+
+(fset 'run-lisp 'inferior-lisp)
;;; Break a string up into a list of arguments.
;;; This will break if you have an argument with whitespace, as in
;;; string = "-ab +c -x 'you lose'".
-(defun cmulisp-args-to-list (string)
+(defun inferior-lisp-args-to-list (string)
(let ((where (string-match "[ \t]" string)))
(cond ((null where) (list string))
((not (= where 0))
(cons (substring string 0 where)
- (tea-args-to-list (substring string (+ 1 where)
- (length string)))))
+ (inferior-lisp-args-to-list (substring string (+ 1 where)
+ (length string)))))
(t (let ((pos (string-match "[^ \t]" string)))
(if (null pos)
nil
- (cmulsip-args-to-list (substring string pos
- (length string)))))))))
+ (inferior-lisp-args-to-list (substring string pos
+ (length string)))))))))
(defun lisp-eval-region (start end &optional and-go)
"Send the current region to the inferior Lisp process.
Prefix argument means switch-to-lisp afterwards."
(interactive "r\nP")
- (comint-send-region (cmulisp-proc) start end)
- (comint-send-string (cmulisp-proc) "\n")
+ (comint-send-region (inferior-lisp-proc) start end)
+ (comint-send-string (inferior-lisp-proc) "\n")
(if and-go (switch-to-lisp t)))
(defun lisp-eval-defun (&optional and-go)
"Compile the current region in the inferior Lisp process.
Prefix argument means switch-to-lisp afterwards."
(interactive "r\nP")
- (comint-send-string (cmulisp-proc)
- (format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n"
- (buffer-substring start end)))
+ (comint-send-string
+ (inferior-lisp-proc)
+ (format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n"
+ (buffer-substring start end)))
(if and-go (switch-to-lisp t)))
-
+
(defun lisp-compile-defun (&optional and-go)
"Compile the current defun in the inferior Lisp process.
Prefix argument means switch-to-lisp afterwards."
"Switch to the inferior Lisp process buffer.
With argument, positions cursor at end of buffer."
(interactive "P")
- (if (get-buffer cmulisp-buffer)
- (pop-to-buffer cmulisp-buffer)
- (error "No current process buffer. See variable cmulisp-buffer."))
+ (if (get-buffer inferior-lisp-buffer)
+ (pop-to-buffer inferior-lisp-buffer)
+ (error "No current process buffer. See variable inferior-lisp-buffer."))
(cond (eob-p
(push-mark)
(goto-char (point-max)))))
(lisp-compile-defun t))
;;; A version of the form in H. Shevis' soar-mode.el package. Less robust.
-;(defun lisp-compile-sexp (start end)
-; "Compile the s-expression bounded by START and END in the inferior lisp.
-;If the sexp isn't a DEFUN form, it is evaluated instead."
-; (cond ((looking-at "(defun\\s +")
-; (goto-char (match-end 0))
-; (let ((name-start (point)))
-; (forward-sexp 1)
-; (process-send-string "cmulisp" (format "(compile '%s #'(lambda "
-; (buffer-substring name-start
-; (point)))))
-; (let ((body-start (point)))
-; (goto-char start) (forward-sexp 1) ; Can't use end-of-defun.
-; (process-send-region "cmulisp" (buffer-substring body-start (point))))
-; (process-send-string "cmulisp" ")\n"))
-; (t (lisp-eval-region start end)))))
-;
-;(defun lisp-compile-region (start end)
-; "Each s-expression in the current region is compiled (if a DEFUN)
-;or evaluated (if not) in the inferior lisp."
-; (interactive "r")
-; (save-excursion
-; (goto-char start) (end-of-defun) (beginning-of-defun) ; error check
-; (if (< (point) start) (error "region begins in middle of defun"))
-; (goto-char start)
-; (let ((s start))
-; (end-of-defun)
-; (while (<= (point) end) ; Zip through
-; (lisp-compile-sexp s (point)) ; compiling up defun-sized chunks.
-; (setq s (point))
-; (end-of-defun))
-; (if (< s end) (lisp-compile-sexp s end)))))
-;;;
+;;; (defun lisp-compile-sexp (start end)
+;;; "Compile the s-expression bounded by START and END in the inferior lisp.
+;;; If the sexp isn't a DEFUN form, it is evaluated instead."
+;;; (cond ((looking-at "(defun\\s +")
+;;; (goto-char (match-end 0))
+;;; (let ((name-start (point)))
+;;; (forward-sexp 1)
+;;; (process-send-string "inferior-lisp"
+;;; (format "(compile '%s #'(lambda "
+;;; (buffer-substring name-start
+;;; (point)))))
+;;; (let ((body-start (point)))
+;;; (goto-char start) (forward-sexp 1) ; Can't use end-of-defun.
+;;; (process-send-region "inferior-lisp"
+;;; (buffer-substring body-start (point))))
+;;; (process-send-string "inferior-lisp" ")\n"))
+;;; (t (lisp-eval-region start end)))))
+;;;
+;;; (defun lisp-compile-region (start end)
+;;; "Each s-expression in the current region is compiled (if a DEFUN)
+;;; or evaluated (if not) in the inferior lisp."
+;;; (interactive "r")
+;;; (save-excursion
+;;; (goto-char start) (end-of-defun) (beginning-of-defun) ; error check
+;;; (if (< (point) start) (error "region begins in middle of defun"))
+;;; (goto-char start)
+;;; (let ((s start))
+;;; (end-of-defun)
+;;; (while (<= (point) end) ; Zip through
+;;; (lisp-compile-sexp s (point)) ; compiling up defun-sized chunks.
+;;; (setq s (point))
+;;; (end-of-defun))
+;;; (if (< s end) (lisp-compile-sexp s end)))))
+;;;
;;; End of HS-style code
"Load a Lisp file into the inferior Lisp process."
(interactive (comint-get-source "Load Lisp file: " lisp-prev-l/c-dir/file
lisp-source-modes nil)) ; NIL because LOAD
- ; doesn't need an exact name
+ ; doesn't need an exact name
(comint-check-source file-name) ; Check to see if buffer needs saved.
(setq lisp-prev-l/c-dir/file (cons (file-name-directory file-name)
(file-name-nondirectory file-name)))
- (comint-send-string (cmulisp-proc)
+ (comint-send-string (inferior-lisp-proc)
(format inferior-lisp-load-command file-name))
(switch-to-lisp t))
"Compile a Lisp file in the inferior Lisp process."
(interactive (comint-get-source "Compile Lisp file: " lisp-prev-l/c-dir/file
lisp-source-modes nil)) ; NIL = don't need
- ; suffix .lisp
+ ; suffix .lisp
(comint-check-source file-name) ; Check to see if buffer needs saved.
(setq lisp-prev-l/c-dir/file (cons (file-name-directory file-name)
(file-name-nondirectory file-name)))
- (comint-send-string (cmulisp-proc) (concat "(compile-file \""
- file-name
- "\"\)\n"))
+ (comint-send-string (inferior-lisp-proc) (concat "(compile-file \""
+ file-name
+ "\"\)\n"))
(switch-to-lisp t))
(defun lisp-symprompt (prompt default)
(list (let* ((prompt (if default
(format "%s (default %s): " prompt default)
- (concat prompt ": ")))
+ (concat prompt ": ")))
(ans (read-string prompt)))
(if (zerop (length ans)) default ans))))
"Send a command to the inferior Lisp to give documentation for function FN.
See variable lisp-function-doc-command."
(interactive (lisp-symprompt "Function doc" (lisp-fn-called-at-pt)))
- (comint-proc-query (cmulisp-proc) (format lisp-function-doc-command fn)))
+ (comint-proc-query (inferior-lisp-proc)
+ (format lisp-function-doc-command fn)))
(defun lisp-show-variable-documentation (var)
"Send a command to the inferior Lisp to give documentation for function FN.
See variable lisp-var-doc-command."
(interactive (lisp-symprompt "Variable doc" (lisp-var-at-pt)))
- (comint-proc-query (cmulisp-proc) (format lisp-var-doc-command var)))
+ (comint-proc-query (inferior-lisp-proc) (format lisp-var-doc-command var)))
(defun lisp-show-arglist (fn)
"Sends an query to the inferior Lisp for the arglist for function FN.
See variable lisp-arglist-command."
(interactive (lisp-symprompt "Arglist" (lisp-fn-called-at-pt)))
- (comint-proc-query (cmulisp-proc) (format lisp-arglist-command fn)))
+ (comint-proc-query (inferior-lisp-proc) (format lisp-arglist-command fn)))
(defun lisp-describe-sym (sym)
"Send a command to the inferior Lisp to describe symbol SYM.
See variable lisp-describe-sym-command."
(interactive (lisp-symprompt "Describe" (lisp-var-at-pt)))
- (comint-proc-query (cmulisp-proc) (format lisp-describe-sym-command sym)))
+ (comint-proc-query (inferior-lisp-proc)
+ (format lisp-describe-sym-command sym)))
\f
-(defvar cmulisp-buffer nil "*The current cmulisp process buffer.
+(defvar inferior-lisp-buffer nil "*The current inferior-lisp process buffer.
MULTIPLE PROCESS SUPPORT
===========================================================================
-Cmulisp.el supports, in a fairly simple fashion, running multiple Lisp
-processes. To run multiple Lisp processes, you start the first up with
-\\[cmulisp]. It will be in a buffer named *cmulisp*. Rename this buffer
-with \\[rename-buffer]. You may now start up a new process with another
-\\[cmulisp]. It will be in a new buffer, named *cmulisp*. You can
-switch between the different process buffers with \\[switch-to-buffer].
+Inf-lisp.el supports, in a fairly simple fashion, running multiple
+Lisp processes. To run multiple Lisp processes, you start the first up
+with \\[inferior-lisp]. It will be in a buffer named *inferior-lisp*.
+Rename this buffer with \\[rename-buffer]. You may now start up a new
+process with another \\[inferior-lisp]. It will be in a new buffer,
+named *inferior-lisp*. You can switch between the different process
+buffers with \\[switch-to-buffer].
Commands that send text from source buffers to Lisp processes --
like lisp-eval-defun or lisp-show-arglist -- have to choose a process
to send to, when you have more than one Lisp process around. This
-is determined by the global variable cmulisp-buffer. Suppose you
+is determined by the global variable inferior-lisp-buffer. Suppose you
have three inferior lisps running:
- Buffer Process
- foo cmulisp
- bar cmulisp<2>
- *cmulisp* cmulisp<3>
+ Buffer Process
+ foo inferior-lisp
+ bar inferior-lisp<2>
+ *inferior-lisp* inferior-lisp<3>
If you do a \\[lisp-eval-defun] command on some Lisp source code,
what process do you send it to?
-- If you're in a process buffer (foo, bar, or *cmulisp*),
+- If you're in a process buffer (foo, bar, or *inferior-lisp*),
you send it to that process.
- If you're in some other buffer (e.g., a source file), you
- send it to the process attached to buffer cmulisp-buffer.
-This process selection is performed by function cmulisp-proc.
+ send it to the process attached to buffer inferior-lisp-buffer.
+This process selection is performed by function inferior-lisp-proc.
-Whenever \\[cmulisp] fires up a new process, it resets cmulisp-buffer
-to be the new process's buffer. If you only run one process, this will
-do the right thing. If you run multiple processes, you can change
-cmulisp-buffer to another process buffer with \\[set-variable].
+Whenever \\[inferior-lisp] fires up a new process, it resets
+inferior-lisp-buffer to be the new process's buffer. If you only run
+one process, this will do the right thing. If you run multiple
+processes, you can change inferior-lisp-buffer to another process
+buffer with \\[set-variable].
More sophisticated approaches are, of course, possible. If you find youself
needing to switch back and forth between multiple processes frequently,
for running inferior Lisp processes. The approach taken here is for a
minimal, simple implementation. Feel free to extend it.")
-(defun cmulisp-proc ()
- "Returns the current cmulisp process. See variable cmulisp-buffer."
+(defun inferior-lisp-proc ()
+ "Returns the current inferior-lisp process. See variable inferior-lisp-buffer."
(let ((proc (get-buffer-process (if (eq major-mode 'inferior-lisp-mode)
(current-buffer)
- cmulisp-buffer))))
+ inferior-lisp-buffer))))
(or proc
- (error "No current process. See variable cmulisp-buffer"))))
+ (error "No current process. See variable inferior-lisp-buffer"))))
;;; Do the user's customisation...
;;;===============================
-(defvar cmulisp-load-hook nil
- "This hook is run when cmulisp is loaded in.
+(defvar inferior-lisp-load-hook nil
+ "This hook is run when inferior-lisp is loaded in.
This is a good place to put keybindings.")
-
-(run-hooks 'cmulisp-load-hook)
+
+(run-hooks 'inferior-lisp-load-hook)
;;; CHANGE LOG
;;; ===========================================================================
+;;; 7/21/92 Jim Blandy
+;;; - Changed all uses of the cmulisp name or prefix to inferior-lisp;
+;;; this is now the official inferior lisp package. Use the global
+;;; ChangeLog from now on.
;;; 5/24/90 Olin
;;; - Split cmulisp and cmushell modes into separate files.
;;; Not only is this a good idea, it's apparently the way it'll be rel 19.
;;; - If M-x cmulisp is invoked with a prefix arg, it allows you to
;;; edit the command line.
-(provide 'cmulisp)
+(provide 'inf-lisp)
-;;; cmulisp.el ends here
+;;; inf-lisp.el ends here