;;; inf-lisp.el --- an inferior-lisp mode
-;; Author: Olin Shivers <shivers@cs.cmu.edu>
-;; Last-Modified: 16 Jul 1992
-;; Keyword: processes, lisp
+;; Copyright (C) 1988, 1993, 1994, 2001, 2002, 2003, 2004, 2005
+;; Free Software Foundation, Inc.
-;;; Copyright Olin Shivers (1988).
+;; Author: Olin Shivers <shivers@cs.cmu.edu>
+;; Keywords: processes, lisp
-;;; This file is part of GNU Emacs.
+;; 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 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.
+;; 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.
+;; 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, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
-;;; Hacked from tea.el by Olin Shivers (shivers@cs.cmu.edu). 8/88
-
-;;; 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,
-;;; and a common set of bindings, with all modes derived from comint mode.
-;;; This makes these modes easier to use.
-
-;;; 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 inferior-lisp mode, see the comments below.
-
-;;; Needs fixin:
-;;; The load-file/compile-file default mechanism could be smarter -- it
-;;; doesn't know about the relationship between filename extensions and
-;;; whether the file is source or executable. If you compile foo.lisp
-;;; with compile-file, then the next load-file should use foo.bin for
-;;; the default, not foo.lisp. This is tricky to do right, particularly
-;;; because the extension for executable files varies so much (.o, .bin,
-;;; .lbin, .mo, .vo, .ao, ...).
-;;;
-;;; 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?
-;;;
-;;; When sending text from a source file to a subprocess, the process-mark can
-;;; move off the window, so you can lose sight of the process interactions.
-;;; Maybe I should ensure the process mark is in the window when I send
-;;; text to the process? Switch selectable?
-
-;; YOUR .EMACS FILE
-;;=============================================================================
-;; Some suggestions for your .emacs file.
+;; Hacked from tea.el by Olin Shivers (shivers@cs.cmu.edu). 8/88
+
+;; This file defines 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,
+;; and a common set of bindings, with all modes derived from comint mode.
+;; This makes these modes easier to use.
+
+;; 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 inferior-lisp mode, see the comments below.
+
+;; Needs fixin:
+;; The load-file/compile-file default mechanism could be smarter -- it
+;; doesn't know about the relationship between filename extensions and
+;; whether the file is source or executable. If you compile foo.lisp
+;; with compile-file, then the next load-file should use foo.bin for
+;; the default, not foo.lisp. This is tricky to do right, particularly
+;; because the extension for executable files varies so much (.o, .bin,
+;; .lbin, .mo, .vo, .ao, ...).
;;
-;; ; 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))
+;; 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?
;;
-;; ; 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 inferior-lisp mode:
-;; (setq inferior-lisp-load-hook
-;; '((lambda ()
-;; (define-key inferior-lisp-mode-map "\C-ct" 'favorite-cmd))))
-
-\f
-;;; Brief Command Documentation:
-;;;============================================================================
-;;; 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
-;;; m-c-r comint-previous-input-matching Search backwards in input history
-;;; return comint-send-input
-;;; c-a comint-bol Beginning of line; skip prompt.
-;;; c-d comint-delchar-or-maybe-eof Delete char unless at end of buff.
-;;; c-c c-u comint-kill-input ^u
-;;; c-c c-w backward-kill-word ^w
-;;; c-c c-c comint-interrupt-subjob ^c
-;;; c-c c-z comint-stop-subjob ^z
-;;; c-c c-\ comint-quit-subjob ^\
-;;; c-c c-o comint-kill-output Delete last batch of process output
-;;; c-c c-r comint-show-output Show last batch of process output
-;;; send-invisible Read line w/o echo & send to proc
-;;; comint-continue-subjob Useful if you accidentally suspend
-;;; top-level job.
-;;; comint-mode-hook is the comint mode hook.
-
-;;; 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.
-;;; Filename completion is available, of course.
-;;;
-;;; Additionally, these commands are added to the key bindings of Lisp mode:
-;;; c-m-x lisp-eval-defun This binding is a gnu convention.
-;;; c-c c-e lisp-eval-defun Send the current defun to Lisp process.
-;;; c-x c-e lisp-eval-last-sexp Send the previous sexp to Lisp process.
-;;; c-c c-r lisp-eval-region Send the current region to Lisp process.
-;;; c-c c-c lisp-compile-defun Compile the current defun in Lisp process.
-;;; c-c c-z switch-to-lisp Switch to the Lisp process buffer.
-;;; c-c c-l lisp-load-file (See above. In a Lisp file buffer, default
-;;; c-c c-k lisp-compile-file is to load/compile the current file.)
-;;; c-c c-d lisp-describe-sym Query Lisp for a symbol's description.
-;;; c-c c-a lisp-show-arglist Query Lisp for function's arglist.
-;;; 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.
-
-;;; inferior-lisp Fires up the Lisp process.
-;;; lisp-compile-region Compile all forms in the current region.
-;;;
-;;; 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
-;;; inferior-lisp-mode-hook
-;;; inferior-lisp-prompt Initialises comint-prompt-regexp.
-;;; Backwards compatibility.
-;;; lisp-source-modes Anything loaded into a buffer that's in
-;;; one of these modes is considered Lisp
-;;; source by lisp-load/compile-file.
-
-;;; Read the rest of this file for more information.
+;; When sending text from a source file to a subprocess, the process-mark can
+;; move off the window, so you can lose sight of the process interactions.
+;; Maybe I should ensure the process mark is in the window when I send
+;; text to the process? Switch selectable?
;;; Code:
(require 'comint)
+(require 'lisp-mode)
+
\f
-(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 inferior-lisp
-mode. Default is whitespace followed by 0 or 1 single-letter :keyword
-(as in :a, :c, etc.)")
+(defgroup inferior-lisp nil
+ "Run an outside Lisp in an Emacs buffer."
+ :group 'lisp
+ :version "22.1")
+
+;;;###autoload
+(defcustom 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 Inferior Lisp
+mode. Default is whitespace followed by 0 or 1 single-letter colon-keyword
+\(as in :a, :c, etc.)"
+ :type 'regexp
+ :group 'inferior-lisp)
(defvar inferior-lisp-mode-map nil)
-(cond ((not inferior-lisp-mode-map)
- (setq inferior-lisp-mode-map
- (full-copy-sparse-keymap comint-mode-map))
- (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)))
+(unless inferior-lisp-mode-map
+ (setq inferior-lisp-mode-map (copy-keymap comint-mode-map))
+ (set-keymap-parent inferior-lisp-mode-map lisp-mode-shared-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.
+;;; "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 inferior-lisp-load-hook:
+;;; (add-hook 'inferior-lisp-load-hook 'inferior-lisp-install-letter-bindings)
+;;;You can modify this function to install just the bindings you want."
(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 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 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-cv"
'lisp-show-variable-documentation))
+;;;###autoload
+(defcustom inferior-lisp-program "lisp"
+ "*Program name for invoking an inferior Lisp in Inferior Lisp mode."
+ :type 'string
+ :group 'inferior-lisp)
-(defvar inferior-lisp-program "lisp"
- "*Program name for invoking an inferior Lisp with `inferior-lisp'.")
-
-(defvar inferior-lisp-load-command "(load \"%s\")\n"
+;;;###autoload
+(defcustom inferior-lisp-load-command "(load \"%s\")\n"
"*Format-string for building a Lisp expression to load a file.
-This format string should use %s to substitute a file name
+This format string should use `%s' to substitute a file name
and should result in a Lisp expression that will command the inferior Lisp
to load that file. The default works acceptably on most Lisps.
-The string \"(progn (load \\\"%s\\\" :verbose nil :print t) (values))\\\n\"
+The string \"(progn (load \\\"%s\\\" :verbose nil :print t) (values))\\n\"
produces cosmetically superior output for this application,
-but it works only in Common Lisp.")
+but it works only in Common Lisp."
+ :type 'string
+ :group 'inferior-lisp)
-(defvar inferior-lisp-prompt "^[^> ]*>+:? *"
- "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
-inferior-lisp buffer.
+;;;###autoload
+(defcustom inferior-lisp-prompt "^[^> \n]*>+:? *"
+ "Regexp to recognize prompts in the Inferior Lisp mode.
+Defaults to \"^[^> \\n]*>+:? *\", which works pretty good for Lucid, kcl,
+and franz. This variable is used to initialize `comint-prompt-regexp' in the
+Inferior Lisp buffer.
+
+This variable is only used if the variable
+`comint-use-prompt-regexp' is non-nil.
More precise choices:
-Lucid Common Lisp: \"^\\(>\\|\\(->\\)+\\) *\"
-franz: \"^\\(->\\|<[0-9]*>:\\) *\"
+Lucid Common Lisp: \"^\\\\(>\\\\|\\\\(->\\\\)+\\\\) *\"
+franz: \"^\\\\(->\\\\|<[0-9]*>:\\\\) *\"
kcl: \"^>+ *\"
-This is a fine thing to set in your .emacs file.")
+This is a fine thing to set in your .emacs file or through Custom."
+ :type 'regexp
+ :group 'inferior-lisp)
+
+(defvar inferior-lisp-buffer nil "*The current inferior-lisp process buffer.
+
+MULTIPLE PROCESS SUPPORT
+===========================================================================
+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 `inferior-lisp-buffer'. Suppose you
+have three inferior Lisps running:
+ 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 *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 `inferior-lisp-buffer'.
+This process selection is performed by function `inferior-lisp-proc'.
+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 does the right thing. If you run multiple
+processes, you can change `inferior-lisp-buffer' to another process
+buffer with \\[set-variable].")
+
+;;;###autoload
(defvar inferior-lisp-mode-hook '()
- "*Hook for customising inferior-lisp mode")
+ "*Hook for customising Inferior Lisp mode.")
+
+(put 'inferior-lisp-mode 'mode-class 'special)
-(defun inferior-lisp-mode ()
- "Major mode for interacting with an inferior Lisp process.
+(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, inferior-lisp-filter-regexp and
-inferior-lisp-load-command can customize this mode for different Lisp
+Emacs buffer. Variable `inferior-lisp-program' controls which Lisp interpreter
+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 inferior-lisp-buffer.
+documentation for variable `inferior-lisp-buffer'.
\\{inferior-lisp-mode-map}
-Customisation: Entry to this mode runs the hooks on comint-mode-hook and
-inferior-lisp-mode-hook (in that order).
+Customisation: Entry to this mode runs the hooks on `comint-mode-hook' and
+`inferior-lisp-mode-hook' (in that order).
You can send text to the inferior Lisp process from other buffers containing
-Lisp source.
+Lisp source.
switch-to-lisp switches the current buffer to the Lisp process buffer.
lisp-eval-defun sends the current defun to the Lisp process.
lisp-compile-defun compiles the current defun.
the text.
Commands:
-Return after the end of the process' output sends the text from the
+Return after the end of the process' output sends the text from the
end of process to point.
Return before the end of the process' output copies the sexp ending at point
to the end of the process' output, and sends it.
If you accidentally suspend your process, use \\[comint-continue-subjob]
to continue it."
(interactive)
- (comint-mode)
+ (delay-mode-hooks
+ (comint-mode))
(setq comint-prompt-regexp inferior-lisp-prompt)
(setq major-mode 'inferior-lisp-mode)
(setq mode-name "Inferior Lisp")
- (setq mode-line-process '(": %s"))
+ (setq mode-line-process '(":%s"))
(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 'inferior-lisp-mode-hook))
+ (run-mode-hooks 'inferior-lisp-mode-hook))
(defun lisp-get-old-input ()
- "Snarf the sexp ending at point"
+ "Return a string containing the sexp ending at point."
(save-excursion
(let ((end (point)))
(backward-sexp)
(buffer-substring (point) end))))
(defun lisp-input-filter (str)
- "Don't save anything matching inferior-lisp-filter-regexp"
+ "t if STR does not match `inferior-lisp-filter-regexp'."
(not (string-match inferior-lisp-filter-regexp str)))
+;;;###autoload
(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
+ "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
-inferior-lisp-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 "*inferior-lisp*"))
- (let ((cmdlist (inferior-lisp-args-to-list cmd)))
+ (let ((cmdlist (split-string 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 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)
- (inferior-lisp-args-to-list (substring string (+ 1 where)
- (length string)))))
- (t (let ((pos (string-match "[^ \t]" string)))
- (if (null pos)
- nil
- (inferior-lisp-args-to-list (substring string pos
- (length string)))))))))
+ (pop-to-buffer "*inferior-lisp*"))
+;;;###autoload (add-hook 'same-window-buffer-names "*inferior-lisp*")
+
+;;;###autoload
+(defalias 'run-lisp 'inferior-lisp)
(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."
+Prefix argument means switch to the Lisp buffer afterwards."
(interactive "r\nP")
(comint-send-region (inferior-lisp-proc) start end)
(comint-send-string (inferior-lisp-proc) "\n")
(defun lisp-eval-defun (&optional and-go)
"Send the current defun to the inferior Lisp process.
-Prefix argument means switch-to-lisp afterwards."
+Prefix argument means switch to the Lisp buffer afterwards."
(interactive "P")
(save-excursion
(end-of-defun)
(defun lisp-eval-last-sexp (&optional and-go)
"Send the previous sexp to the inferior Lisp process.
-Prefix argument means switch-to-lisp afterwards."
+Prefix argument means switch to the Lisp buffer afterwards."
(interactive "P")
(lisp-eval-region (save-excursion (backward-sexp) (point)) (point) and-go))
-;;; Common Lisp COMPILE sux.
+;;; Common Lisp COMPILE sux.
(defun lisp-compile-region (start end &optional and-go)
"Compile the current region in the inferior Lisp process.
-Prefix argument means switch-to-lisp afterwards."
+Prefix argument means switch to the Lisp buffer afterwards."
(interactive "r\nP")
(comint-send-string
(inferior-lisp-proc)
(defun lisp-compile-defun (&optional and-go)
"Compile the current defun in the inferior Lisp process.
-Prefix argument means switch-to-lisp afterwards."
+Prefix argument means switch to the Lisp buffer afterwards."
(interactive "P")
(save-excursion
(end-of-defun)
"Switch to the inferior Lisp process buffer.
With argument, positions cursor at end of buffer."
(interactive "P")
- (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
+ (if (get-buffer-process inferior-lisp-buffer)
+ (let ((pop-up-frames
+ ;; Be willing to use another frame
+ ;; that already has the window in it.
+ (or pop-up-frames
+ (get-buffer-window inferior-lisp-buffer t))))
+ (pop-to-buffer inferior-lisp-buffer))
+ (run-lisp inferior-lisp-program))
+ (when eob-p
(push-mark)
- (goto-char (point-max)))))
+ (goto-char (point-max))))
;;; Now that lisp-compile/eval-defun/region takes an optional prefix arg,
;;; easier to type C-c e than C-u C-c C-e.
(defun lisp-eval-region-and-go (start end)
- "Send the current region to the inferior Lisp,
-and switch to the process buffer."
+ "Send the current region to the inferior Lisp, and switch to its buffer."
(interactive "r")
(lisp-eval-region start end t))
(defun lisp-eval-defun-and-go ()
- "Send the current defun to the inferior Lisp,
-and switch to the process buffer."
+ "Send the current defun to the inferior Lisp, and switch to its buffer."
(interactive)
(lisp-eval-defun t))
(defun lisp-compile-region-and-go (start end)
- "Compile the current region in the inferior Lisp,
-and switch to the process buffer."
+ "Compile the current region in the inferior Lisp, and switch to its buffer."
(interactive "r")
(lisp-compile-region start end t))
(defun lisp-compile-defun-and-go ()
- "Compile the current defun in the inferior Lisp,
-and switch to the process buffer."
+ "Compile the current defun in the inferior Lisp, and switch to its buffer."
(interactive)
(lisp-compile-defun t))
;;; (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."
;;; (setq s (point))
;;; (end-of-defun))
;;; (if (< s end) (lisp-compile-sexp s end)))))
-;;;
+;;;
;;; End of HS-style code
(defvar lisp-prev-l/c-dir/file nil
- "Saves the (directory . file) pair used in the last lisp-load-file or
-lisp-compile-file command. Used for determining the default in the
-next one.")
+ "Record last directory and file used in loading or compiling.
+This holds a cons cell of the form `(DIRECTORY . FILE)'
+describing the last `lisp-load-file' or `lisp-compile-file' command.")
-(defvar lisp-source-modes '(lisp-mode)
+(defcustom lisp-source-modes '(lisp-mode)
"*Used to determine if a buffer contains Lisp source code.
If it's loaded into a buffer that is in one of these major modes, it's
-considered a Lisp source file by lisp-load-file and lisp-compile-file.
-Used by these commands to determine defaults.")
+considered a Lisp source file by `lisp-load-file' and `lisp-compile-file'.
+Used by these commands to determine defaults."
+ :type '(repeat symbol)
+ :group 'inferior-lisp)
(defun lisp-load-file (file-name)
"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
+ lisp-source-modes nil)) ; nil because LOAD
; 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)
(defun lisp-compile-file (file-name)
"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
+ lisp-source-modes nil)) ; nil = don't need
; 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)
;;; Adapted from function-called-at-point in help.el.
(defun lisp-fn-called-at-pt ()
"Returns the name of the function called in the current call.
-Nil if it can't find one."
+The value is nil if it can't find one."
(condition-case nil
(save-excursion
(save-restriction
(defun lisp-show-function-documentation (fn)
"Send a command to the inferior Lisp to give documentation for function FN.
-See variable lisp-function-doc-command."
+See variable `lisp-function-doc-command'."
(interactive (lisp-symprompt "Function doc" (lisp-fn-called-at-pt)))
(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."
+See variable `lisp-var-doc-command'."
(interactive (lisp-symprompt "Variable doc" (lisp-var-at-pt)))
(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."
+ "Send a 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 (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."
+See variable `lisp-describe-sym-command'."
(interactive (lisp-symprompt "Describe" (lisp-var-at-pt)))
(comint-proc-query (inferior-lisp-proc)
(format lisp-describe-sym-command sym)))
\f
-(defvar inferior-lisp-buffer nil "*The current inferior-lisp process buffer.
-
-MULTIPLE PROCESS SUPPORT
-===========================================================================
-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 inferior-lisp-buffer. Suppose you
-have three inferior lisps running:
- 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 *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 inferior-lisp-buffer.
-This process selection is performed by function inferior-lisp-proc.
-
-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,
-you may wish to consider ilisp.el, a larger, more sophisticated package
-for running inferior Lisp processes. The approach taken here is for a
-minimal, simple implementation. Feel free to extend it.")
-
+;; "Returns the current inferior Lisp process.
+;; See variable `inferior-lisp-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)
inferior-lisp-buffer))))
(or proc
- (error "No current process. See variable inferior-lisp-buffer"))))
+ (error "No Lisp subprocess; see variable `inferior-lisp-buffer'"))))
;;; Do the user's customisation...
;;;===============================
(defvar inferior-lisp-load-hook nil
- "This hook is run when inferior-lisp is loaded in.
-This is a good place to put keybindings.")
+ "This hook is run when the library `inf-lisp' is loaded.")
(run-hooks 'inferior-lisp-load-hook)
;;; 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.
+;;; - 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.
;;; - Upgraded process sends to use comint-send-string instead of
;;; process-send-string.
;;; supposed to be reserved for the user to bind. This affected
;;; mainly the compile/eval-defun/region[-and-go] commands.
;;; This was painful, but necessary to adhere to the gnumacs standard.
-;;; For some backwards compatibility, see the
+;;; For some backwards compatibility, see the
;;; cmulisp-install-letter-bindings
;;; function.
;;;
(provide 'inf-lisp)
+;;; arch-tag: 5b74abc3-a085-4b91-8ab8-8da6899d3b92
;;; inf-lisp.el ends here