;;; ielm.el --- interaction mode for Emacs Lisp
+
;; Copyright (C) 1994 Free Software Foundation, Inc.
;; Author: David Smith <maa036@lancaster.ac.uk>
+;; Maintainer: FSF
;; Created: 25 Feb 1994
;; Keywords: lisp
;; 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.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
-;; Provides a nice interface to evaluating Emacs-Lisp expressions.
+;; Provides a nice interface to evaluating Emacs Lisp expressions.
;; Input is handled by the comint package, and output is passed
;; through the pretty-printer.
;; To install: copy this file to a directory in your load-path, and
-;; add the line
+;; add the following line to your .emacs file:
;;
-;; (autoload 'ielm "ielm" "Start an inferior emacs-lisp session" t)
+;; (autoload 'ielm "ielm" "Start an inferior Emacs Lisp session" t)
;;
-;; For completion to work, the comint.el from FSF Emacs 19.23 is
+;; For completion to work, the comint.el from Emacs 19.23 is
;; required. If you do not have it, or if you are running Lemacs,
;; also add the following code to your .emacs:
;;
;; (setq ielm-mode-hook
;; '(lambda nil
;; (define-key ielm-map "\t"
-;; '(lambda nil (interactive) (or (ielm-tab)
+;; '(lambda nil (interactive) (or (ielm-tab)
;; (lisp-complete-symbol))))))
;; To start: M-x ielm. Type C-h m in the *ielm* buffer for more info.
-;; The latest version is available by WWW from
+;; The latest version is available by WWW from
;; http://mathssun5.lancs.ac.uk:2080/~maa036/elisp/dir.html
;; or by anonymous FTP from
;; /anonymous@wingra.stat.wisc.edu:pub/src/emacs-lisp/ielm.el.gz
;;; User variables
-(defvar ielm-noisy t
- "*If non-nil, beep on error")
+(defgroup ielm nil
+ "Interaction mode for Emacs Lisp."
+ :group 'lisp)
+
+
+(defcustom ielm-noisy t
+ "*If non-nil, IELM will beep on error."
+ :type 'boolean
+ :group 'ielm)
+
+(defvar ielm-prompt "ELISP> "
+ "Prompt used in IELM.")
+
+(defcustom ielm-dynamic-return t
+ "*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behaviour in IELM.
+If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
+and indents for incomplete sexps. If nil, always inserts newlines."
+ :type 'boolean
+ :group 'ielm)
+
+(defcustom ielm-dynamic-multiline-inputs t
+ "*Force multiline inputs to start from column zero?
+If non-nil, after entering the first line of an incomplete sexp, a newline
+will be inserted after the prompt, moving the input to the next line.
+This gives more frame width for large indented sexps, and allows functions
+such as `edebug-defun' to work with such inputs."
+ :type 'boolean
+ :group 'ielm)
-(defvar ielm-prompt "ELISP> ")
+(defcustom ielm-mode-hook nil
+ "*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
+ :type 'hook
+ :group 'ielm)
-(defvar ielm-dynamic-return t
- "*If non-nil, RET either evaluates input or inserts a newline,
-depending on context")
+(defvar * nil
+ "Most recent value evaluated in IELM.")
-(defvar ielm-mode-hook nil
- "*Hooks to be run when the inferior-emacs-lisp-mode is started")
+(defvar ** nil
+ "Second-most-recent value evaluated in IELM.")
+
+(defvar *** nil
+ "Third-most-recent value evaluated in IELM.")
;;; System variables
(defvar ielm-working-buffer nil
- "Buffer, if any, to use in ielm. Usually buffer-local")
+ "Buffer in which IELM sexps will be evaluated.
+This variable is buffer-local.")
-(defvar ielm-header
- (concat
- "*** Welcome to IELM mode version "
- (substring "$Revision: 1.15 $" 11 -2)
- " *** Type (describe-mode) for help.\n"
- "IELM has ABSOLUTELY NO WARRANTY; type (describe-no-warranty) for details\n"))
+(defvar ielm-header
+ "*** Welcome to IELM *** Type (describe-mode) for help.\n"
+ "Message to display when IELM is started.")
(defvar ielm-map nil)
(if ielm-map nil
(setq ielm-map (cons 'keymap comint-mode-map)))
(define-key ielm-map "\t" 'comint-dynamic-complete)
(define-key ielm-map "\C-m" 'ielm-return)
- (define-key ielm-map "\C-j" 'ielm-send-input))
+ (define-key ielm-map "\C-j" 'ielm-send-input)
+ (define-key ielm-map "\e\C-x" 'eval-defun) ; for consistency with
+ (define-key ielm-map "\e\t" 'lisp-complete-symbol) ; lisp-interaction-mode
+ ;; These bindings are from `lisp-mode-shared-map' -- can you inherit
+ ;; from more than one keymap??
+ (define-key ielm-map "\e\C-q" 'indent-sexp)
+ (define-key ielm-map "\177" 'backward-delete-char-untabify)
+ ;; Some convenience bindings for setting the working buffer
+ (define-key ielm-map "\C-c\C-b" 'ielm-change-working-buffer)
+ (define-key ielm-map "\C-c\C-f" 'ielm-display-working-buffer)
+ (define-key ielm-map "\C-c\C-v" 'ielm-print-working-buffer))
+
+(defvar ielm-font-lock-keywords
+ (list
+ (cons (concat "^" (regexp-quote ielm-prompt)) 'font-lock-keyword-face)
+ '("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)"
+ (1 font-lock-comment-face)
+ (2 font-lock-constant-face)))
+ "Additional expressions to highlight in ielm buffers.")
;;; Completion stuff
(defun ielm-tab nil
- "Possibly indent the current line as lisp code"
+ "Possibly indent the current line as lisp code."
(interactive)
(if (or (eq (preceding-char) ?\n)
(eq (char-syntax (preceding-char)) ? ))
(progn
(ielm-indent-line)
t)))
-
+
(defun ielm-complete-symbol nil
- "Just like lisp-complete-symbol"
- ;; except that it returns non-nil if completion has occurred
+ "Complete the lisp symbol before point."
+ ;; A wrapper for lisp-complete symbol that returns non-nil if
+ ;; completion has occurred
(let* ((btick (buffer-modified-tick))
- (cbuffer (get-buffer " *Completions*"))
+ (cbuffer (get-buffer "*Completions*"))
(ctick (and cbuffer (buffer-modified-tick cbuffer))))
(lisp-complete-symbol)
;; completion has occurred if:
- (or
+ (or
;; the buffer has been modified
- (not (= btick (buffer-modified-tick)))
- ;; a completions buffer has been modifed or created
+ (not (= btick (buffer-modified-tick)))
+ ;; a completions buffer has been modified or created
(if cbuffer
(not (= ctick (buffer-modified-tick cbuffer)))
- (get-buffer " *Completions*")))))
+ (get-buffer "*Completions*")))))
(defun ielm-complete-filename nil
- ;; Completes filenames if in a string
+ "Dynamically complete filename before point, if in a string."
(if (nth 3 (parse-partial-sexp comint-last-input-start (point)))
(comint-dynamic-complete-filename)))
-
+
(defun ielm-indent-line nil
- "Indent the current line as lisp code if it is not a prompt line"
- (if (save-excursion
- (beginning-of-line)
- (looking-at comint-prompt-regexp)) nil
+ "Indent the current line as Lisp code if it is not a prompt line."
+ (when (save-excursion (comint-bol) (bolp))
(lisp-indent-line)))
+;;; Working buffer manipulation
+
+(defun ielm-print-working-buffer nil
+ "Print the current IELM working buffer's name in the echo area."
+ (interactive)
+ (message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
+
+(defun ielm-display-working-buffer nil
+ "Display the current IELM working buffer.
+Don't forget that selecting that buffer will change its value of `point'
+to its value of `window-point'!"
+ (interactive)
+ (display-buffer ielm-working-buffer)
+ (ielm-print-working-buffer))
+
+(defun ielm-change-working-buffer (buf)
+ "Change the current IELM working buffer to BUF.
+This is the buffer in which all sexps entered at the IELM prompt are
+evaluated. You can achieve the same effect with a call to
+`set-buffer' at the IELM prompt."
+ (interactive "bSet working buffer to: ")
+ (setq ielm-working-buffer (or (get-buffer buf) (error "No such buffer")))
+ (ielm-print-working-buffer))
+
;;; Other bindings
(defun ielm-return nil
- "Evaluate the sexp at the prompt if it is complete, otherwise newline
-and indent. If ielm-dynamic-return is nil, just insert a newline."
+ "Newline and indent, or evaluate the sexp before the prompt.
+Complete sexps are evaluated; for incomplete sexps inserts a newline
+and indents. If however `ielm-dynamic-return' is nil, this always
+simply inserts a newline."
(interactive)
- (if ielm-dynamic-return
- (let ((state
+ (if ielm-dynamic-return
+ (let ((state
(save-excursion
(end-of-line)
(parse-partial-sexp (ielm-pm)
(point)))))
(if (and (< (car state) 1) (not (nth 3 state)))
(ielm-send-input)
+ (if (and ielm-dynamic-multiline-inputs
+ (save-excursion
+ (beginning-of-line)
+ (looking-at comint-prompt-regexp)))
+ (save-excursion
+ (goto-char (ielm-pm))
+ (newline 1)))
(newline-and-indent)))
(newline)))
+(defvar ielm-input)
+
(defun ielm-input-sender (proc input)
+ ;; Just sets the variable ielm-input, which is in the scope of
+ ;; `ielm-send-input's call.
(setq ielm-input input))
(defun ielm-send-input nil
- "Evaluate the Emacs Lisp expression after the prompt"
+ "Evaluate the Emacs Lisp expression after the prompt."
(interactive)
(let ((buf (current-buffer))
ielm-input) ; set by ielm-input-sender
;;; Utility functions
(defun ielm-is-whitespace (string)
- "Return non-nil if STRING is all whitespace"
+ "Return non-nil if STRING is all whitespace."
(or (string= string "") (string-match "\\`[ \t\n]+\\'" string)))
(defun ielm-format-errors (errlist)
(defun ielm-format-error (err)
- "Return a string form of the error ERR"
+ ;; Return a string form of the error ERR.
(format "%s%s"
(or (get (car err) 'error-message) "Peculiar error")
(if (cdr err)
;;; Evaluation
-(defun ielm-eval-input (string)
- "Evaluate the lisp expression STRING, and pretty-print the result"
+(defun ielm-eval-input (ielm-string)
+ "Evaluate the Lisp expression IELM-STRING, and pretty-print the result."
;; This is the function that actually `sends' the input to the
- ;; `inferior lisp process'. All comint-send-input does is works out
+ ;; `inferior Lisp process'. All comint-send-input does is works out
;; what that input is. What this function does is evaluates that
;; input and produces `output' which gets inserted into the buffer,
;; along with a new prompt. A better way of doing this might have
;; this as in output filter that converted sexps in the output
;; stream to their evaluated value. But that would have involved
;; more process coordination than I was happy to deal with.
- (let (form ; form to evaluate
- pos ; End posn of parse in string
- result ; Result, or error message
- error-type ; string, nil if no error
- (output "") ; result to display
- (wbuf ielm-working-buffer) ; current buffer after evaluation
- (pmark (ielm-pm)))
- (if (not (ielm-is-whitespace string))
+ ;;
+ ;; NOTE: all temporary variables in this function will be in scope
+ ;; during the eval, and so need to have non-clashing names.
+ (let (ielm-form ; form to evaluate
+ ielm-pos ; End posn of parse in string
+ ielm-result ; Result, or error message
+ ielm-error-type ; string, nil if no error
+ (ielm-output "") ; result to display
+ (ielm-wbuf ielm-working-buffer) ; current buffer after evaluation
+ (ielm-pmark (ielm-pm)))
+ (if (not (ielm-is-whitespace ielm-string))
(progn
(condition-case err
(let (rout)
- (setq rout (read-from-string string))
- (setq form (car rout))
- (setq pos (cdr rout)))
- (error (setq result (ielm-format-error err))
- (setq error-type "Read error")))
- (if error-type nil
- (if (ielm-is-whitespace (substring string pos))
- ;; need this awful let convolution to work around
- ;; an Emacs bug involving local vbls and let binding
- (let ((:save :)
- (::save ::)
- (:::save :::))
- (save-excursion
- (set-buffer ielm-working-buffer)
- (condition-case err
- (let ((: :save)
- (:: ::save)
- (::: :::save))
- (save-excursion
- (setq result (eval form))
- (setq wbuf (current-buffer))))
- (error (setq result (ielm-format-error err))
- (setq error-type "Eval error"))
- (quit (setq result "Quit during evaluation")
- (setq error-type "Eval error")))))
- (setq error-type "IELM error")
- (setq result "More than one sexp in input")))
+ (setq rout (read-from-string ielm-string))
+ (setq ielm-form (car rout))
+ (setq ielm-pos (cdr rout)))
+ (error (setq ielm-result (ielm-format-error err))
+ (setq ielm-error-type "Read error")))
+ (if ielm-error-type nil
+ ;; Make sure working buffer has not been killed
+ (if (not (buffer-name ielm-working-buffer))
+ (setq ielm-result "Working buffer has been killed"
+ ielm-error-type "IELM Error"
+ ielm-wbuf (current-buffer))
+ (if (ielm-is-whitespace (substring ielm-string ielm-pos))
+ ;; need this awful let convolution to work around
+ ;; an Emacs bug involving local vbls and let binding
+ (let ((*save *)
+ (**save **)
+ (***save ***))
+ (save-excursion
+ (set-buffer ielm-working-buffer)
+ (condition-case err
+ (let ((* *save)
+ (** **save)
+ (*** ***save)
+ (ielm-obuf (current-buffer)))
+ (setq ielm-result (eval ielm-form))
+ (setq ielm-wbuf (current-buffer))
+ ;; The eval may have changed current-buffer;
+ ;; need to set it back here to avoid a bug
+ ;; in let. Don't want to use save-excursion
+ ;; because we want to allow changes in point.
+ (set-buffer ielm-obuf))
+ (error (setq ielm-result (ielm-format-error err))
+ (setq ielm-error-type "Eval error"))
+ (quit (setq ielm-result "Quit during evaluation")
+ (setq ielm-error-type "Eval error")))))
+ (setq ielm-error-type "IELM error")
+ (setq ielm-result "More than one sexp in input"))))
;; If the eval changed the current buffer, mention it here
- (if (eq wbuf ielm-working-buffer) nil
- (message "current buffer is now: %s" wbuf)
- (setq ielm-working-buffer wbuf))
+ (if (eq ielm-wbuf ielm-working-buffer) nil
+ (message "current buffer is now: %s" ielm-wbuf)
+ (setq ielm-working-buffer ielm-wbuf))
- (goto-char pmark)
- (if (not error-type)
+ (goto-char ielm-pmark)
+ (if (not ielm-error-type)
(condition-case err
;; Self-referential objects cause loops in the printer, so
;; trap quits here. May as well do errors, too
- (setq output (concat output (pp-to-string result)))
- (error (setq error-type "IELM Error")
- (setq result "Error during pretty-printing (bug in pp)"))
- (quit (setq error-type "IELM Error")
- (setq result "Quit during pretty-printing"))))
- (if error-type
+ (setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
+ (error (setq ielm-error-type "IELM Error")
+ (setq ielm-result "Error during pretty-printing (bug in pp)"))
+ (quit (setq ielm-error-type "IELM Error")
+ (setq ielm-result "Quit during pretty-printing"))))
+ (if ielm-error-type
(progn
(if ielm-noisy (ding))
- (setq output (concat output "*** " error-type " *** "))
- (setq output (concat output result)))
- ;; There was no error, so shift the ::: values
- (setq ::: ::)
- (setq :: :)
- (setq : result))
- (setq output (concat output "\n"))))
- (setq output (concat output ielm-prompt))
- (comint-output-filter (ielm-process) output)))
+ (setq ielm-output (concat ielm-output "*** " ielm-error-type " *** "))
+ (setq ielm-output (concat ielm-output ielm-result)))
+ ;; There was no error, so shift the *** values
+ (setq *** **)
+ (setq ** *)
+ (setq * ielm-result))
+ (setq ielm-output (concat ielm-output "\n"))))
+ (setq ielm-output (concat ielm-output ielm-prompt))
+ (comint-output-filter (ielm-process) ielm-output)))
;;; Process and marker utilities
(defun ielm-process nil
- "Return the current buffer's process"
+ ;; Return the current buffer's process.
(get-buffer-process (current-buffer)))
(defun ielm-pm nil
- "Return the process mark of the current buffer"
+ ;; Return the process mark of the current buffer.
(process-mark (get-buffer-process (current-buffer))))
(defun ielm-set-pm (pos)
- "Set the process mark in the current buffer to POS"
+ ;; Set the process mark in the current buffer to POS.
(set-marker (process-mark (get-buffer-process (current-buffer))) pos))
;;; Major mode
+(put 'inferior-emacs-lisp-mode 'mode-class 'special)
+
(defun inferior-emacs-lisp-mode nil
- "Major mode for interactively evaluating Emacs-Lisp expressions
-Uses the interface provided by `comint-mode' (q.v.)
-
-\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
-one top-level sexp per prompt.
-\\[ielm-return] inserts a newline and indents. However, if the variable
-ielm-dynamic-return is non-nil (the default) then it will also evaluate
-a complete expression.
-\\[comint-dynamic-complete] completes lisp symbols (or filenames, within strings),
-or indents the line if there is nothing to complete.
-
-During evaluations, the values of the variables `:', `::', and `:::'
+ "Major mode for interactively evaluating Emacs Lisp expressions.
+Uses the interface provided by `comint-mode' (which see).
+
+* \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
+ one top-level sexp per prompt.
+
+* \\[ielm-return] inserts a newline and indents, or evaluates a
+ complete expression (but see variable `ielm-dynamic-return').
+ Inputs longer than one line are moved to the line following the
+ prompt (but see variable `ielm-dynamic-multiline-inputs').
+
+* \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
+ or indents the line if there is nothing to complete.
+
+During evaluations, the values of the variables `*', `**', and `***'
are the results of the previous, second previous and third previous
evaluations respectively.
-The current buffer may be changed, and its value is preserved between
-successive evaluations. In this way, expressions may be evaluated in
-a different buffer than the *ielm* buffer.
+The current working buffer may be changed (with a call to
+`set-buffer', or with \\[ielm-change-working-buffer]), and its value
+is preserved between successive evaluations. In this way, expressions
+may be evaluated in a different buffer than the *ielm* buffer.
+Display the name of the working buffer with \\[ielm-print-working-buffer],
+or the buffer itself with \\[ielm-display-working-buffer].
-Expressions evaluated by IELM are not subject to debug-on-quit or
-debug-on-error.
+Expressions evaluated by IELM are not subject to `debug-on-quit' or
+`debug-on-error'.
The behaviour of IELM may be customised with the following variables:
* To stop beeping on error, set `ielm-noisy' to nil
(setq paragraph-start comint-prompt-regexp)
(setq comint-input-sender 'ielm-input-sender)
(setq comint-process-echoes nil)
- (setq comint-dynamic-complete-functions
+ (setq comint-dynamic-complete-functions
'(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol))
+ (setq comint-get-old-input 'ielm-get-old-input)
+ (make-local-variable 'comint-completion-addsuffix)
+ (setq comint-completion-addsuffix
+ (cons (char-to-string directory-sep-char) ""))
(setq major-mode 'inferior-emacs-lisp-mode)
(setq mode-name "IELM")
(make-local-variable 'ielm-working-buffer)
(setq ielm-working-buffer (current-buffer))
(setq indent-line-function 'ielm-indent-line)
-
- ;;; Value holders
- (setq : nil)
- (make-local-variable ':)
- (setq :: nil)
- (make-local-variable '::)
- (setq ::: nil)
- (make-local-variable ':::)
+ (make-local-variable 'fill-paragraph-function)
+ (setq fill-paragraph-function 'lisp-fill-paragraph)
+
+ ;; Value holders
+ (setq * nil)
+ (make-local-variable '*)
+ (setq ** nil)
+ (make-local-variable '**)
+ (setq *** nil)
+ (make-local-variable '***)
+
+ ;; font-lock support
+ (make-local-variable 'font-lock-defaults)
+ (setq font-lock-defaults
+ '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
;; A dummy process to keep comint happy. It will never get any input
(if (comint-check-proc (current-buffer)) nil
(set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
(run-hooks 'ielm-mode-hook))
+(defun ielm-get-old-input nil
+ ;; Return the previous input surrounding point
+ (save-excursion
+ (beginning-of-line)
+ (if (looking-at comint-prompt-regexp) nil
+ (re-search-backward comint-prompt-regexp))
+ (comint-skip-prompt)
+ (buffer-substring (point) (progn (forward-sexp 1) (point)))))
+
;;; User command
+;;;###autoload (add-hook 'same-window-buffer-names "*ielm*")
+
+;;;###autoload
(defun ielm nil
- "Switch to or create the buffer *ielm* for evaluating emacs-lisp expressions"
+ "Interactively evaluate Emacs Lisp expressions.
+Switches to the buffer `*ielm*', or creates it if it does not exist."
(interactive)
- (if (comint-check-proc "*ielm*") nil
- (progn
+ (if (comint-check-proc "*ielm*")
+ nil
+ (save-excursion
(set-buffer (get-buffer-create "*ielm*"))
(inferior-emacs-lisp-mode)))
- (switch-to-buffer "*ielm*"))
+ (pop-to-buffer "*ielm*"))
+
+(provide 'ielm)
-;; ielm.el ends here
+;;; ielm.el ends here