[bpt/emacs.git] / lisp / ielm.el

;;; 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

;; 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, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;; 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 following line to your .emacs file:
;;
;;   (autoload 'ielm "ielm" "Start an inferior Emacs Lisp session" t)
;;
;; 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)
;;                                                 (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
;;      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
;; or from the author: David M. Smith <maa036@lancaster.ac.uk>

;;; Code:

(require 'comint)
(require 'pp)

;;; User variables

(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)

(defcustom ielm-mode-hook nil
  "*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
  :type 'hook
  :group 'ielm)

(defvar * nil
  "Most recent value evaluated in IELM.")

(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 in which IELM sexps will be evaluated.
This variable is buffer-local.")

(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
  (if (string-match "Lucid" emacs-version)
      ;; Lemacs
      (progn
	(setq ielm-map (make-sparse-keymap))
	(set-keymap-parent ielm-map comint-mode-map))
    ;; FSF
    (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 "\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."
  (interactive)
  (if (or (eq (preceding-char) ?\n)
	  (eq (char-syntax (preceding-char)) ? ))
      (progn
	(ielm-indent-line)
	t)))

(defun ielm-complete-symbol nil
  "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*"))
	 (ctick (and cbuffer (buffer-modified-tick cbuffer))))
    (lisp-complete-symbol)
     ;; completion has occurred if:
    (or
     ;; the buffer has been modified
     (not (= btick (buffer-modified-tick)))
     ;; a completions buffer has been modified or created
     (if cbuffer
	 (not (= ctick (buffer-modified-tick cbuffer)))
       (get-buffer "*Completions*")))))

(defun ielm-complete-filename nil
  "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."
  (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
  "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
	     (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."
  (interactive)
  (let ((buf (current-buffer))
	ielm-input)			; set by ielm-input-sender
    (comint-send-input)			; update history, markers etc.
    (ielm-eval-input ielm-input)))

;;; Utility functions

(defun ielm-is-whitespace (string)
  "Return non-nil if STRING is all whitespace."
  (or (string= string "") (string-match "\\`[ \t\n]+\\'" string)))

(defun ielm-format-errors (errlist)
  (let ((result ""))
    (while errlist
      (setq result (concat result (prin1-to-string (car errlist)) ", "))
      (setq errlist (cdr errlist)))
    (substring result 0 -2)))


(defun ielm-format-error (err)
  ;; Return a string form of the error ERR.
  (format "%s%s"
	  (or (get (car err) 'error-message) "Peculiar error")
	  (if (cdr err)
	      (format ": %s" (ielm-format-errors (cdr err)))
	    "")))

;;; Evaluation

(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
  ;; 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
  ;; been to actually send the output to the `cat' process, and write
  ;; 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.
  ;;
  ;; 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 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 ielm-wbuf ielm-working-buffer) nil
	    (message "current buffer is now: %s" ielm-wbuf)
	    (setq ielm-working-buffer ielm-wbuf))

	  (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 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 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.
  (get-buffer-process (current-buffer)))

(defun ielm-pm nil
  ;; 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-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' (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 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'.

The behaviour of IELM may be customised with the following variables:
* To stop beeping on error, set `ielm-noisy' to nil
* If you don't like the prompt, you can change it by setting `ielm-prompt'.
* Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'
* Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
 (in that order).

Customised bindings may be defined in `ielm-map', which currently contains:
\\{ielm-map}"
  (interactive)
  (comint-mode)
  (setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
  (make-local-variable 'paragraph-start)
  (setq paragraph-start comint-prompt-regexp)
  (setq comint-input-sender 'ielm-input-sender)
  (setq comint-process-echoes nil)
  (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")
  (use-local-map ielm-map)
  (set-syntax-table emacs-lisp-mode-syntax-table)

  (make-local-variable 'indent-line-function)
  (make-local-variable 'ielm-working-buffer)
  (setq ielm-working-buffer (current-buffer))
  (setq indent-line-function 'ielm-indent-line)
  (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
    (start-process "ielm" (current-buffer) "cat")
    (process-kill-without-query (ielm-process))
    (goto-char (point-max))
    ;; Add a silly header
    (insert ielm-header)
    (ielm-set-pm (point-max))
    (comint-output-filter (ielm-process) ielm-prompt)
    (set-marker comint-last-input-start (ielm-pm))
    (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
  "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
    (save-excursion
      (set-buffer (get-buffer-create "*ielm*"))
      (inferior-emacs-lisp-mode)))
  (pop-to-buffer "*ielm*"))

(provide 'ielm)

;;; ielm.el ends here
Commit	Line	Data
813f532d	1	;;; ielm.el --- interaction mode for Emacs Lisp
b578f267	2
813f532d RS	3	;; Copyright (C) 1994 Free Software Foundation, Inc.
	4
	5	;; Author: David Smith <maa036@lancaster.ac.uk>
4228277d	6	;; Maintainer: FSF
813f532d RS	7	;; Created: 25 Feb 1994
	8	;; Keywords: lisp
	9
	10	;; This file is part of GNU Emacs.
	11
	12	;; GNU Emacs is free software; you can redistribute it and/or modify
	13	;; it under the terms of the GNU General Public License as published by
	14	;; the Free Software Foundation; either version 2, or (at your option)
	15	;; any later version.
	16
	17	;; GNU Emacs is distributed in the hope that it will be useful,
	18	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	;; GNU General Public License for more details.
	21
	22	;; You should have received a copy of the GNU General Public License
b578f267 EN	23	;; along with GNU Emacs; see the file COPYING. If not, write to the
	24	;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	25	;; Boston, MA 02111-1307, USA.
813f532d RS	26
	27	;;; Commentary:
	28
e848854a	29	;; Provides a nice interface to evaluating Emacs Lisp expressions.
813f532d RS	30	;; Input is handled by the comint package, and output is passed
	31	;; through the pretty-printer.
	32
	33	;; To install: copy this file to a directory in your load-path, and
e848854a	34	;; add the following line to your .emacs file:
813f532d	35	;;
e848854a	36	;; (autoload 'ielm "ielm" "Start an inferior Emacs Lisp session" t)
813f532d	37	;;
326e87d2	38	;; For completion to work, the comint.el from Emacs 19.23 is
813f532d RS	39	;; required. If you do not have it, or if you are running Lemacs,
	40	;; also add the following code to your .emacs:
	41	;;
	42	;; (setq ielm-mode-hook
	43	;; '(lambda nil
	44	;; (define-key ielm-map "\t"
690ec649	45	;; '(lambda nil (interactive) (or (ielm-tab)
813f532d RS	46	;; (lisp-complete-symbol))))))
	47
	48	;; To start: M-x ielm. Type C-h m in the ielm buffer for more info.
	49
690ec649	50	;; The latest version is available by WWW from
813f532d RS	51	;; http://mathssun5.lancs.ac.uk:2080/~maa036/elisp/dir.html
	52	;; or by anonymous FTP from
	53	;; /anonymous@wingra.stat.wisc.edu:pub/src/emacs-lisp/ielm.el.gz
	54	;; or from the author: David M. Smith <maa036@lancaster.ac.uk>
	55
	56	;;; Code:
	57
	58	(require 'comint)
	59	(require 'pp)
	60
	61	;;; User variables
	62
94114394 RS	63	(defgroup ielm nil
	64	"Interaction mode for Emacs Lisp."
	65	:group 'lisp)
	66
	67
	68	(defcustom ielm-noisy t
	69	"*If non-nil, IELM will beep on error."
	70	:type 'boolean
	71	:group 'ielm)
813f532d	72
e848854a RS	73	(defvar ielm-prompt "ELISP> "
e848854a RS	74	"Prompt used in IELM.")
813f532d	75
94114394	76	(defcustom ielm-dynamic-return t
e848854a RS	77	"*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behaviour in IELM.
e848854a RS	78	If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
94114394 RS	79	and indents for incomplete sexps. If nil, always inserts newlines."
	80	:type 'boolean
	81	:group 'ielm)
e848854a	82
94114394	83	(defcustom ielm-dynamic-multiline-inputs t
e848854a RS	84	"*Force multiline inputs to start from column zero?
	85	If non-nil, after entering the first line of an incomplete sexp, a newline
	86	will be inserted after the prompt, moving the input to the next line.
	87	This gives more frame width for large indented sexps, and allows functions
94114394 RS	88	such as `edebug-defun' to work with such inputs."
	89	:type 'boolean
	90	:group 'ielm)
813f532d	91
94114394 RS	92	(defcustom ielm-mode-hook nil
	93	"*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
	94	:type 'hook
	95	:group 'ielm)
813f532d	96
d38e7d5f RS	97	(defvar * nil
	98	"Most recent value evaluated in IELM.")
	99
	100	(defvar ** nil
	101	"Second-most-recent value evaluated in IELM.")
	102
	103	(defvar *** nil
	104	"Third-most-recent value evaluated in IELM.")
690ec649	105
813f532d RS	106	;;; System variables
	107
	108	(defvar ielm-working-buffer nil
e848854a RS	109	"Buffer in which IELM sexps will be evaluated.
e848854a RS	110	This variable is buffer-local.")
813f532d	111
690ec649	112	(defvar ielm-header
0a13146e	113	"* Welcome to IELM * Type (describe-mode) for help.\n"
e848854a	114	"Message to display when IELM is started.")
813f532d RS	115
	116	(defvar ielm-map nil)
	117	(if ielm-map nil
	118	(if (string-match "Lucid" emacs-version)
	119	;; Lemacs
	120	(progn
	121	(setq ielm-map (make-sparse-keymap))
	122	(set-keymap-parent ielm-map comint-mode-map))
	123	;; FSF
	124	(setq ielm-map (cons 'keymap comint-mode-map)))
	125	(define-key ielm-map "\t" 'comint-dynamic-complete)
	126	(define-key ielm-map "\C-m" 'ielm-return)
e848854a RS	127	(define-key ielm-map "\C-j" 'ielm-send-input)
	128	(define-key ielm-map "\e\C-x" 'eval-defun) ; for consistency with
	129	(define-key ielm-map "\e\t" 'lisp-complete-symbol) ; lisp-interaction-mode
690ec649	130	;; These bindings are from `lisp-mode-shared-map' -- can you inherit
e848854a	131	;; from more than one keymap??
690ec649	132	(define-key ielm-map "\e\C-q" 'indent-sexp)
e848854a RS	133	(define-key ielm-map "\177" 'backward-delete-char-untabify)
	134	;; Some convenience bindings for setting the working buffer
	135	(define-key ielm-map "\C-c\C-b" 'ielm-change-working-buffer)
	136	(define-key ielm-map "\C-c\C-f" 'ielm-display-working-buffer)
	137	(define-key ielm-map "\C-c\C-v" 'ielm-print-working-buffer))
813f532d	138
9d42eea3	139	(defvar ielm-font-lock-keywords
690ec649	140	(list
9d42eea3	141	(cons (concat "^" (regexp-quote ielm-prompt)) 'font-lock-keyword-face)
883212ce SM	142	'("\\(^\\\\\\[^]+\\\\\\\\)\\(.$\\)"
	143	(1 font-lock-comment-face)
	144	(2 font-lock-constant-face)))
9d42eea3	145	"Additional expressions to highlight in ielm buffers.")
690ec649	146
813f532d RS	147	;;; Completion stuff
	148
	149	(defun ielm-tab nil
e848854a	150	"Possibly indent the current line as lisp code."
813f532d RS	151	(interactive)
	152	(if (or (eq (preceding-char) ?\n)
	153	(eq (char-syntax (preceding-char)) ? ))
	154	(progn
	155	(ielm-indent-line)
	156	t)))
690ec649	157
813f532d	158	(defun ielm-complete-symbol nil
e848854a RS	159	"Complete the lisp symbol before point."
	160	;; A wrapper for lisp-complete symbol that returns non-nil if
	161	;; completion has occurred
813f532d	162	(let* ((btick (buffer-modified-tick))
e58df0dc	163	(cbuffer (get-buffer "Completions"))
813f532d RS	164	(ctick (and cbuffer (buffer-modified-tick cbuffer))))
	165	(lisp-complete-symbol)
	166	;; completion has occurred if:
690ec649	167	(or
813f532d	168	;; the buffer has been modified
690ec649	169	(not (= btick (buffer-modified-tick)))
a7acbbe4	170	;; a completions buffer has been modified or created
813f532d RS	171	(if cbuffer
813f532d RS	172	(not (= ctick (buffer-modified-tick cbuffer)))
e58df0dc	173	(get-buffer "Completions")))))
813f532d RS	174
813f532d RS	175	(defun ielm-complete-filename nil
e848854a	176	"Dynamically complete filename before point, if in a string."
813f532d RS	177	(if (nth 3 (parse-partial-sexp comint-last-input-start (point)))
813f532d RS	178	(comint-dynamic-complete-filename)))
690ec649	179
813f532d	180	(defun ielm-indent-line nil
e848854a	181	"Indent the current line as Lisp code if it is not a prompt line."
3250010d	182	(when (save-excursion (comint-bol) (bolp))
813f532d RS	183	(lisp-indent-line)))
813f532d RS	184
e848854a RS	185	;;; Working buffer manipulation
	186
	187	(defun ielm-print-working-buffer nil
	188	"Print the current IELM working buffer's name in the echo area."
	189	(interactive)
	190	(message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
	191
	192	(defun ielm-display-working-buffer nil
	193	"Display the current IELM working buffer.
	194	Don't forget that selecting that buffer will change its value of `point'
	195	to its value of `window-point'!"
	196	(interactive)
	197	(display-buffer ielm-working-buffer)
	198	(ielm-print-working-buffer))
	199
	200	(defun ielm-change-working-buffer (buf)
	201	"Change the current IELM working buffer to BUF.
	202	This is the buffer in which all sexps entered at the IELM prompt are
	203	evaluated. You can achieve the same effect with a call to
	204	`set-buffer' at the IELM prompt."
	205	(interactive "bSet working buffer to: ")
	206	(setq ielm-working-buffer (or (get-buffer buf) (error "No such buffer")))
	207	(ielm-print-working-buffer))
	208
813f532d RS	209	;;; Other bindings
	210
	211	(defun ielm-return nil
e848854a RS	212	"Newline and indent, or evaluate the sexp before the prompt.
	213	Complete sexps are evaluated; for incomplete sexps inserts a newline
	214	and indents. If however `ielm-dynamic-return' is nil, this always
	215	simply inserts a newline."
813f532d	216	(interactive)
690ec649 SS	217	(if ielm-dynamic-return
690ec649 SS	218	(let ((state
813f532d RS	219	(save-excursion
	220	(end-of-line)
	221	(parse-partial-sexp (ielm-pm)
	222	(point)))))
	223	(if (and (< (car state) 1) (not (nth 3 state)))
	224	(ielm-send-input)
e848854a RS	225	(if (and ielm-dynamic-multiline-inputs
	226	(save-excursion
	227	(beginning-of-line)
	228	(looking-at comint-prompt-regexp)))
	229	(save-excursion
	230	(goto-char (ielm-pm))
	231	(newline 1)))
813f532d RS	232	(newline-and-indent)))
	233	(newline)))
	234
94aba130 RS	235	(defvar ielm-input)
94aba130 RS	236
813f532d	237	(defun ielm-input-sender (proc input)
690ec649	238	;; Just sets the variable ielm-input, which is in the scope of
e848854a	239	;; `ielm-send-input's call.
813f532d RS	240	(setq ielm-input input))
	241
	242	(defun ielm-send-input nil
e848854a	243	"Evaluate the Emacs Lisp expression after the prompt."
813f532d RS	244	(interactive)
	245	(let ((buf (current-buffer))
	246	ielm-input) ; set by ielm-input-sender
	247	(comint-send-input) ; update history, markers etc.
	248	(ielm-eval-input ielm-input)))
	249
	250	;;; Utility functions
	251
	252	(defun ielm-is-whitespace (string)
e848854a	253	"Return non-nil if STRING is all whitespace."
813f532d RS	254	(or (string= string "") (string-match "\\`[ \t\n]+\\'" string)))
	255
	256	(defun ielm-format-errors (errlist)
	257	(let ((result ""))
	258	(while errlist
	259	(setq result (concat result (prin1-to-string (car errlist)) ", "))
	260	(setq errlist (cdr errlist)))
	261	(substring result 0 -2)))
	262
	263
	264	(defun ielm-format-error (err)
e848854a	265	;; Return a string form of the error ERR.
813f532d RS	266	(format "%s%s"
	267	(or (get (car err) 'error-message) "Peculiar error")
	268	(if (cdr err)
	269	(format ": %s" (ielm-format-errors (cdr err)))
	270	"")))
	271
	272	;;; Evaluation
	273
e848854a RS	274	(defun ielm-eval-input (ielm-string)
e848854a RS	275	"Evaluate the Lisp expression IELM-STRING, and pretty-print the result."
813f532d	276	;; This is the function that actually `sends' the input to the
e848854a	277	;; `inferior Lisp process'. All comint-send-input does is works out
813f532d RS	278	;; what that input is. What this function does is evaluates that
	279	;; input and produces `output' which gets inserted into the buffer,
	280	;; along with a new prompt. A better way of doing this might have
	281	;; been to actually send the output to the `cat' process, and write
	282	;; this as in output filter that converted sexps in the output
	283	;; stream to their evaluated value. But that would have involved
	284	;; more process coordination than I was happy to deal with.
e848854a RS	285	;;
	286	;; NOTE: all temporary variables in this function will be in scope
	287	;; during the eval, and so need to have non-clashing names.
	288	(let (ielm-form ; form to evaluate
	289	ielm-pos ; End posn of parse in string
	290	ielm-result ; Result, or error message
	291	ielm-error-type ; string, nil if no error
	292	(ielm-output "") ; result to display
	293	(ielm-wbuf ielm-working-buffer) ; current buffer after evaluation
	294	(ielm-pmark (ielm-pm)))
	295	(if (not (ielm-is-whitespace ielm-string))
813f532d RS	296	(progn
	297	(condition-case err
	298	(let (rout)
e848854a RS	299	(setq rout (read-from-string ielm-string))
	300	(setq ielm-form (car rout))
	301	(setq ielm-pos (cdr rout)))
	302	(error (setq ielm-result (ielm-format-error err))
	303	(setq ielm-error-type "Read error")))
	304	(if ielm-error-type nil
	305	;; Make sure working buffer has not been killed
	306	(if (not (buffer-name ielm-working-buffer))
	307	(setq ielm-result "Working buffer has been killed"
	308	ielm-error-type "IELM Error"
	309	ielm-wbuf (current-buffer))
	310	(if (ielm-is-whitespace (substring ielm-string ielm-pos))
	311	;; need this awful let convolution to work around
	312	;; an Emacs bug involving local vbls and let binding
fed9da13 RS	313	(let ((save )
	314	(save )
	315	(*save *))
e848854a RS	316	(save-excursion
	317	(set-buffer ielm-working-buffer)
	318	(condition-case err
fed9da13 RS	319	(let ((* *save)
	320	( save)
	321	(* *save)
e848854a RS	322	(ielm-obuf (current-buffer)))
	323	(setq ielm-result (eval ielm-form))
	324	(setq ielm-wbuf (current-buffer))
	325	;; The eval may have changed current-buffer;
	326	;; need to set it back here to avoid a bug
	327	;; in let. Don't want to use save-excursion
	328	;; because we want to allow changes in point.
	329	(set-buffer ielm-obuf))
	330	(error (setq ielm-result (ielm-format-error err))
	331	(setq ielm-error-type "Eval error"))
	332	(quit (setq ielm-result "Quit during evaluation")
	333	(setq ielm-error-type "Eval error")))))
	334	(setq ielm-error-type "IELM error")
	335	(setq ielm-result "More than one sexp in input"))))
813f532d RS	336
813f532d RS	337	;; If the eval changed the current buffer, mention it here
e848854a RS	338	(if (eq ielm-wbuf ielm-working-buffer) nil
	339	(message "current buffer is now: %s" ielm-wbuf)
	340	(setq ielm-working-buffer ielm-wbuf))
813f532d	341
e848854a RS	342	(goto-char ielm-pmark)
e848854a RS	343	(if (not ielm-error-type)
813f532d RS	344	(condition-case err
	345	;; Self-referential objects cause loops in the printer, so
	346	;; trap quits here. May as well do errors, too
e848854a RS	347	(setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
	348	(error (setq ielm-error-type "IELM Error")
	349	(setq ielm-result "Error during pretty-printing (bug in pp)"))
	350	(quit (setq ielm-error-type "IELM Error")
	351	(setq ielm-result "Quit during pretty-printing"))))
	352	(if ielm-error-type
813f532d RS	353	(progn
813f532d RS	354	(if ielm-noisy (ding))
e848854a RS	355	(setq ielm-output (concat ielm-output "* " ielm-error-type " * "))
e848854a RS	356	(setq ielm-output (concat ielm-output ielm-result)))
d38e7d5f	357	;; There was no error, so shift the *** values
71d54f88 RS	358	(setq * )
	359	(setq ** *)
	360	(setq * ielm-result))
e848854a RS	361	(setq ielm-output (concat ielm-output "\n"))))
	362	(setq ielm-output (concat ielm-output ielm-prompt))
	363	(comint-output-filter (ielm-process) ielm-output)))
813f532d RS	364
	365	;;; Process and marker utilities
	366
	367	(defun ielm-process nil
e848854a	368	;; Return the current buffer's process.
813f532d RS	369	(get-buffer-process (current-buffer)))
	370
	371	(defun ielm-pm nil
e848854a	372	;; Return the process mark of the current buffer.
813f532d RS	373	(process-mark (get-buffer-process (current-buffer))))
	374
	375	(defun ielm-set-pm (pos)
e848854a	376	;; Set the process mark in the current buffer to POS.
813f532d RS	377	(set-marker (process-mark (get-buffer-process (current-buffer))) pos))
	378
	379	;;; Major mode
	380
95b20f3b RS	381	(put 'inferior-emacs-lisp-mode 'mode-class 'special)
95b20f3b RS	382
813f532d	383	(defun inferior-emacs-lisp-mode nil
e848854a RS	384	"Major mode for interactively evaluating Emacs Lisp expressions.
	385	Uses the interface provided by `comint-mode' (which see).
	386
	387	* \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
	388	one top-level sexp per prompt.
813f532d	389
e848854a RS	390	* \\[ielm-return] inserts a newline and indents, or evaluates a
	391	complete expression (but see variable `ielm-dynamic-return').
	392	Inputs longer than one line are moved to the line following the
	393	prompt (but see variable `ielm-dynamic-multiline-inputs').
	394
690ec649	395	* \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
e848854a	396	or indents the line if there is nothing to complete.
813f532d	397
fed9da13	398	During evaluations, the values of the variables `', `', and `**'
813f532d RS	399	are the results of the previous, second previous and third previous
	400	evaluations respectively.
	401
e848854a RS	402	The current working buffer may be changed (with a call to
	403	`set-buffer', or with \\[ielm-change-working-buffer]), and its value
	404	is preserved between successive evaluations. In this way, expressions
	405	may be evaluated in a different buffer than the ielm buffer.
	406	Display the name of the working buffer with \\[ielm-print-working-buffer],
	407	or the buffer itself with \\[ielm-display-working-buffer].
813f532d	408
e848854a RS	409	Expressions evaluated by IELM are not subject to `debug-on-quit' or
e848854a RS	410	`debug-on-error'.
813f532d RS	411
	412	The behaviour of IELM may be customised with the following variables:
	413	* To stop beeping on error, set `ielm-noisy' to nil
	414	* If you don't like the prompt, you can change it by setting `ielm-prompt'.
	415	* Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'
	416	* Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
	417	(in that order).
	418
	419	Customised bindings may be defined in `ielm-map', which currently contains:
	420	\\{ielm-map}"
	421	(interactive)
	422	(comint-mode)
	423	(setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
	424	(make-local-variable 'paragraph-start)
	425	(setq paragraph-start comint-prompt-regexp)
	426	(setq comint-input-sender 'ielm-input-sender)
	427	(setq comint-process-echoes nil)
690ec649	428	(setq comint-dynamic-complete-functions
813f532d	429	'(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol))
e848854a	430	(setq comint-get-old-input 'ielm-get-old-input)
34ce46c8 KH	431	(make-local-variable 'comint-completion-addsuffix)
	432	(setq comint-completion-addsuffix
	433	(cons (char-to-string directory-sep-char) ""))
813f532d RS	434
	435	(setq major-mode 'inferior-emacs-lisp-mode)
	436	(setq mode-name "IELM")
	437	(use-local-map ielm-map)
	438	(set-syntax-table emacs-lisp-mode-syntax-table)
	439
	440	(make-local-variable 'indent-line-function)
	441	(make-local-variable 'ielm-working-buffer)
	442	(setq ielm-working-buffer (current-buffer))
	443	(setq indent-line-function 'ielm-indent-line)
950086e6 KH	444	(make-local-variable 'fill-paragraph-function)
950086e6 KH	445	(setq fill-paragraph-function 'lisp-fill-paragraph)
813f532d	446
e848854a	447	;; Value holders
fed9da13 RS	448	(setq * nil)
	449	(make-local-variable '*)
	450	(setq ** nil)
	451	(make-local-variable '**)
	452	(setq *** nil)
	453	(make-local-variable '***)
813f532d	454
9d42eea3 RS	455	;; font-lock support
9d42eea3 RS	456	(make-local-variable 'font-lock-defaults)
690ec649	457	(setq font-lock-defaults
9d42eea3	458	'(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
690ec649	459
813f532d RS	460	;; A dummy process to keep comint happy. It will never get any input
	461	(if (comint-check-proc (current-buffer)) nil
	462	(start-process "ielm" (current-buffer) "cat")
	463	(process-kill-without-query (ielm-process))
	464	(goto-char (point-max))
	465	;; Add a silly header
	466	(insert ielm-header)
	467	(ielm-set-pm (point-max))
	468	(comint-output-filter (ielm-process) ielm-prompt)
	469	(set-marker comint-last-input-start (ielm-pm))
	470	(set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
	471	(run-hooks 'ielm-mode-hook))
	472
e848854a RS	473	(defun ielm-get-old-input nil
	474	;; Return the previous input surrounding point
	475	(save-excursion
	476	(beginning-of-line)
	477	(if (looking-at comint-prompt-regexp) nil
	478	(re-search-backward comint-prompt-regexp))
	479	(comint-skip-prompt)
	480	(buffer-substring (point) (progn (forward-sexp 1) (point)))))
	481
813f532d RS	482	;;; User command
813f532d RS	483
9e983c78 RS	484	;;;###autoload (add-hook 'same-window-buffer-names "ielm")
9e983c78 RS	485
e848854a	486	;;;###autoload
813f532d	487	(defun ielm nil
e848854a	488	"Interactively evaluate Emacs Lisp expressions.
9e983c78	489	Switches to the buffer `ielm', or creates it if it does not exist."
813f532d	490	(interactive)
9e983c78 RS	491	(if (comint-check-proc "ielm")
	492	nil
	493	(save-excursion
813f532d RS	494	(set-buffer (get-buffer-create "ielm"))
813f532d RS	495	(inferior-emacs-lisp-mode)))
9e983c78	496	(pop-to-buffer "ielm"))
813f532d	497
896546cd RS	498	(provide 'ielm)
896546cd RS	499
e848854a	500	;;; ielm.el ends here