1 ;;; ielm.el --- interaction mode for Emacs Lisp
3 ;; Copyright (C) 1994 Free Software Foundation, Inc.
5 ;; Author: David Smith <maa036@lancaster.ac.uk>
7 ;; Created: 25 Feb 1994
10 ;; This file is part of GNU Emacs.
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)
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.
22 ;; You should have received a copy of the GNU General Public License
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.
29 ;; Provides a nice interface to evaluating Emacs Lisp expressions.
30 ;; Input is handled by the comint package, and output is passed
31 ;; through the pretty-printer.
33 ;; To install: copy this file to a directory in your load-path, and
34 ;; add the following line to your .emacs file:
36 ;; (autoload 'ielm "ielm" "Start an inferior Emacs Lisp session" t)
38 ;; For completion to work, the comint.el from FSF Emacs 19.23 is
39 ;; required. If you do not have it, or if you are running Lemacs,
40 ;; also add the following code to your .emacs:
42 ;; (setq ielm-mode-hook
44 ;; (define-key ielm-map "\t"
45 ;; '(lambda nil (interactive) (or (ielm-tab)
46 ;; (lisp-complete-symbol))))))
48 ;; To start: M-x ielm. Type C-h m in the *ielm* buffer for more info.
50 ;; The latest version is available by WWW from
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>
64 "Interaction mode for Emacs Lisp."
68 (defcustom ielm-noisy t
69 "*If non-nil, IELM will beep on error."
73 (defvar ielm-prompt
"ELISP> "
74 "Prompt used in IELM.")
76 (defcustom ielm-dynamic-return t
77 "*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behaviour in IELM.
78 If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
79 and indents for incomplete sexps. If nil, always inserts newlines."
83 (defcustom ielm-dynamic-multiline-inputs t
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
88 such as `edebug-defun' to work with such inputs."
92 (defcustom ielm-mode-hook nil
93 "*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
99 (defvar ielm-working-buffer nil
100 "Buffer in which IELM sexps will be evaluated.
101 This variable is buffer-local.")
105 "*** Welcome to IELM version "
106 (substring "$Revision: 1.12 $" 11 -
2)
107 " *** Type (describe-mode) for help.\n"
108 "IELM has ABSOLUTELY NO WARRANTY; type (describe-no-warranty) for details.\n")
109 "Message to display when IELM is started.")
111 (defvar ielm-map nil
)
113 (if (string-match "Lucid" emacs-version
)
116 (setq ielm-map
(make-sparse-keymap))
117 (set-keymap-parent ielm-map comint-mode-map
))
119 (setq ielm-map
(cons 'keymap comint-mode-map
)))
120 (define-key ielm-map
"\t" 'comint-dynamic-complete
)
121 (define-key ielm-map
"\C-m" 'ielm-return
)
122 (define-key ielm-map
"\C-j" 'ielm-send-input
)
123 (define-key ielm-map
"\e\C-x" 'eval-defun
) ; for consistency with
124 (define-key ielm-map
"\e\t" 'lisp-complete-symbol
) ; lisp-interaction-mode
125 ;; These bindings are from shared-lisp-mode-map -- can you inherit
126 ;; from more than one keymap??
127 (define-key ielm-map
"\e\C-q" 'indent-sexp
)
128 (define-key ielm-map
"\177" 'backward-delete-char-untabify
)
129 ;; Some convenience bindings for setting the working buffer
130 (define-key ielm-map
"\C-c\C-b" 'ielm-change-working-buffer
)
131 (define-key ielm-map
"\C-c\C-f" 'ielm-display-working-buffer
)
132 (define-key ielm-map
"\C-c\C-v" 'ielm-print-working-buffer
))
134 (defvar ielm-font-lock-keywords
136 (cons (concat "^" (regexp-quote ielm-prompt
)) 'font-lock-keyword-face
)
137 '("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)" (1 font-lock-comment-face
) (2 font-lock-reference-face
)))
138 "Additional expressions to highlight in ielm buffers.")
143 "Possibly indent the current line as lisp code."
145 (if (or (eq (preceding-char) ?
\n)
146 (eq (char-syntax (preceding-char)) ?
))
151 (defun ielm-complete-symbol nil
152 "Complete the lisp symbol before point."
153 ;; A wrapper for lisp-complete symbol that returns non-nil if
154 ;; completion has occurred
155 (let* ((btick (buffer-modified-tick))
156 (cbuffer (get-buffer "*Completions*"))
157 (ctick (and cbuffer
(buffer-modified-tick cbuffer
))))
158 (lisp-complete-symbol)
159 ;; completion has occurred if:
161 ;; the buffer has been modified
162 (not (= btick
(buffer-modified-tick)))
163 ;; a completions buffer has been modified or created
165 (not (= ctick
(buffer-modified-tick cbuffer
)))
166 (get-buffer "*Completions*")))))
168 (defun ielm-complete-filename nil
169 "Dynamically complete filename before point, if in a string."
170 (if (nth 3 (parse-partial-sexp comint-last-input-start
(point)))
171 (comint-dynamic-complete-filename)))
173 (defun ielm-indent-line nil
174 "Indent the current line as Lisp code if it is not a prompt line."
177 (looking-at comint-prompt-regexp
)) nil
180 ;;; Working buffer manipulation
182 (defun ielm-print-working-buffer nil
183 "Print the current IELM working buffer's name in the echo area."
185 (message "The current working buffer is: %s" (buffer-name ielm-working-buffer
)))
187 (defun ielm-display-working-buffer nil
188 "Display the current IELM working buffer.
189 Don't forget that selecting that buffer will change its value of `point'
190 to its value of `window-point'!"
192 (display-buffer ielm-working-buffer
)
193 (ielm-print-working-buffer))
195 (defun ielm-change-working-buffer (buf)
196 "Change the current IELM working buffer to BUF.
197 This is the buffer in which all sexps entered at the IELM prompt are
198 evaluated. You can achieve the same effect with a call to
199 `set-buffer' at the IELM prompt."
200 (interactive "bSet working buffer to: ")
201 (setq ielm-working-buffer
(or (get-buffer buf
) (error "No such buffer")))
202 (ielm-print-working-buffer))
206 (defun ielm-return nil
207 "Newline and indent, or evaluate the sexp before the prompt.
208 Complete sexps are evaluated; for incomplete sexps inserts a newline
209 and indents. If however `ielm-dynamic-return' is nil, this always
210 simply inserts a newline."
212 (if ielm-dynamic-return
216 (parse-partial-sexp (ielm-pm)
218 (if (and (< (car state
) 1) (not (nth 3 state
)))
220 (if (and ielm-dynamic-multiline-inputs
223 (looking-at comint-prompt-regexp
)))
225 (goto-char (ielm-pm))
227 (newline-and-indent)))
232 (defun ielm-input-sender (proc input
)
233 ;; Just sets the variable ielm-input, which is in the scope of
234 ;; `ielm-send-input's call.
235 (setq ielm-input input
))
237 (defun ielm-send-input nil
238 "Evaluate the Emacs Lisp expression after the prompt."
240 (let ((buf (current-buffer))
241 ielm-input
) ; set by ielm-input-sender
242 (comint-send-input) ; update history, markers etc.
243 (ielm-eval-input ielm-input
)))
245 ;;; Utility functions
247 (defun ielm-is-whitespace (string)
248 "Return non-nil if STRING is all whitespace."
249 (or (string= string
"") (string-match "\\`[ \t\n]+\\'" string
)))
251 (defun ielm-format-errors (errlist)
254 (setq result
(concat result
(prin1-to-string (car errlist
)) ", "))
255 (setq errlist
(cdr errlist
)))
256 (substring result
0 -
2)))
259 (defun ielm-format-error (err)
260 ;; Return a string form of the error ERR.
262 (or (get (car err
) 'error-message
) "Peculiar error")
264 (format ": %s" (ielm-format-errors (cdr err
)))
269 (defun ielm-eval-input (ielm-string)
270 "Evaluate the Lisp expression IELM-STRING, and pretty-print the result."
271 ;; This is the function that actually `sends' the input to the
272 ;; `inferior Lisp process'. All comint-send-input does is works out
273 ;; what that input is. What this function does is evaluates that
274 ;; input and produces `output' which gets inserted into the buffer,
275 ;; along with a new prompt. A better way of doing this might have
276 ;; been to actually send the output to the `cat' process, and write
277 ;; this as in output filter that converted sexps in the output
278 ;; stream to their evaluated value. But that would have involved
279 ;; more process coordination than I was happy to deal with.
281 ;; NOTE: all temporary variables in this function will be in scope
282 ;; during the eval, and so need to have non-clashing names.
283 (let (ielm-form ; form to evaluate
284 ielm-pos
; End posn of parse in string
285 ielm-result
; Result, or error message
286 ielm-error-type
; string, nil if no error
287 (ielm-output "") ; result to display
288 (ielm-wbuf ielm-working-buffer
) ; current buffer after evaluation
289 (ielm-pmark (ielm-pm)))
290 (if (not (ielm-is-whitespace ielm-string
))
294 (setq rout
(read-from-string ielm-string
))
295 (setq ielm-form
(car rout
))
296 (setq ielm-pos
(cdr rout
)))
297 (error (setq ielm-result
(ielm-format-error err
))
298 (setq ielm-error-type
"Read error")))
299 (if ielm-error-type nil
300 ;; Make sure working buffer has not been killed
301 (if (not (buffer-name ielm-working-buffer
))
302 (setq ielm-result
"Working buffer has been killed"
303 ielm-error-type
"IELM Error"
304 ielm-wbuf
(current-buffer))
305 (if (ielm-is-whitespace (substring ielm-string ielm-pos
))
306 ;; need this awful let convolution to work around
307 ;; an Emacs bug involving local vbls and let binding
312 (set-buffer ielm-working-buffer
)
317 (ielm-obuf (current-buffer)))
318 (setq ielm-result
(eval ielm-form
))
319 (setq ielm-wbuf
(current-buffer))
320 ;; The eval may have changed current-buffer;
321 ;; need to set it back here to avoid a bug
322 ;; in let. Don't want to use save-excursion
323 ;; because we want to allow changes in point.
324 (set-buffer ielm-obuf
))
325 (error (setq ielm-result
(ielm-format-error err
))
326 (setq ielm-error-type
"Eval error"))
327 (quit (setq ielm-result
"Quit during evaluation")
328 (setq ielm-error-type
"Eval error")))))
329 (setq ielm-error-type
"IELM error")
330 (setq ielm-result
"More than one sexp in input"))))
332 ;; If the eval changed the current buffer, mention it here
333 (if (eq ielm-wbuf ielm-working-buffer
) nil
334 (message "current buffer is now: %s" ielm-wbuf
)
335 (setq ielm-working-buffer ielm-wbuf
))
337 (goto-char ielm-pmark
)
338 (if (not ielm-error-type
)
340 ;; Self-referential objects cause loops in the printer, so
341 ;; trap quits here. May as well do errors, too
342 (setq ielm-output
(concat ielm-output
(pp-to-string ielm-result
)))
343 (error (setq ielm-error-type
"IELM Error")
344 (setq ielm-result
"Error during pretty-printing (bug in pp)"))
345 (quit (setq ielm-error-type
"IELM Error")
346 (setq ielm-result
"Quit during pretty-printing"))))
349 (if ielm-noisy
(ding))
350 (setq ielm-output
(concat ielm-output
"*** " ielm-error-type
" *** "))
351 (setq ielm-output
(concat ielm-output ielm-result
)))
352 ;; There was no error, so shift the ::: values
355 (setq : ielm-result
))
356 (setq ielm-output
(concat ielm-output
"\n"))))
357 (setq ielm-output
(concat ielm-output ielm-prompt
))
358 (comint-output-filter (ielm-process) ielm-output
)))
360 ;;; Process and marker utilities
362 (defun ielm-process nil
363 ;; Return the current buffer's process.
364 (get-buffer-process (current-buffer)))
367 ;; Return the process mark of the current buffer.
368 (process-mark (get-buffer-process (current-buffer))))
370 (defun ielm-set-pm (pos)
371 ;; Set the process mark in the current buffer to POS.
372 (set-marker (process-mark (get-buffer-process (current-buffer))) pos
))
376 (put 'inferior-emacs-lisp-mode
'mode-class
'special
)
378 (defun inferior-emacs-lisp-mode nil
379 "Major mode for interactively evaluating Emacs Lisp expressions.
380 Uses the interface provided by `comint-mode' (which see).
382 * \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
383 one top-level sexp per prompt.
385 * \\[ielm-return] inserts a newline and indents, or evaluates a
386 complete expression (but see variable `ielm-dynamic-return').
387 Inputs longer than one line are moved to the line following the
388 prompt (but see variable `ielm-dynamic-multiline-inputs').
390 * \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
391 or indents the line if there is nothing to complete.
393 During evaluations, the values of the variables `:', `::', and `:::'
394 are the results of the previous, second previous and third previous
395 evaluations respectively.
397 The current working buffer may be changed (with a call to
398 `set-buffer', or with \\[ielm-change-working-buffer]), and its value
399 is preserved between successive evaluations. In this way, expressions
400 may be evaluated in a different buffer than the *ielm* buffer.
401 Display the name of the working buffer with \\[ielm-print-working-buffer],
402 or the buffer itself with \\[ielm-display-working-buffer].
404 Expressions evaluated by IELM are not subject to `debug-on-quit' or
407 The behaviour of IELM may be customised with the following variables:
408 * To stop beeping on error, set `ielm-noisy' to nil
409 * If you don't like the prompt, you can change it by setting `ielm-prompt'.
410 * Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'
411 * Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
414 Customised bindings may be defined in `ielm-map', which currently contains:
418 (setq comint-prompt-regexp
(concat "^" (regexp-quote ielm-prompt
)))
419 (make-local-variable 'paragraph-start
)
420 (setq paragraph-start comint-prompt-regexp
)
421 (setq comint-input-sender
'ielm-input-sender
)
422 (setq comint-process-echoes nil
)
423 (setq comint-dynamic-complete-functions
424 '(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol
))
425 (setq comint-get-old-input
'ielm-get-old-input
)
426 (make-local-variable 'comint-completion-addsuffix
)
427 (setq comint-completion-addsuffix
428 (cons (char-to-string directory-sep-char
) ""))
430 (setq major-mode
'inferior-emacs-lisp-mode
)
431 (setq mode-name
"IELM")
432 (use-local-map ielm-map
)
433 (set-syntax-table emacs-lisp-mode-syntax-table
)
435 (make-local-variable 'indent-line-function
)
436 (make-local-variable 'ielm-working-buffer
)
437 (setq ielm-working-buffer
(current-buffer))
438 (setq indent-line-function
'ielm-indent-line
)
439 (make-local-variable 'fill-paragraph-function
)
440 (setq fill-paragraph-function
'lisp-fill-paragraph
)
444 (make-local-variable ':)
446 (make-local-variable '::)
448 (make-local-variable ':::)
451 (make-local-variable 'font-lock-defaults
)
452 (setq font-lock-defaults
453 '(ielm-font-lock-keywords nil nil
((?
: .
"w") (?- .
"w") (?
* .
"w"))))
455 ;; A dummy process to keep comint happy. It will never get any input
456 (if (comint-check-proc (current-buffer)) nil
457 (start-process "ielm" (current-buffer) "cat")
458 (process-kill-without-query (ielm-process))
459 (goto-char (point-max))
460 ;; Add a silly header
462 (ielm-set-pm (point-max))
463 (comint-output-filter (ielm-process) ielm-prompt
)
464 (set-marker comint-last-input-start
(ielm-pm))
465 (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter
))
466 (run-hooks 'ielm-mode-hook
))
468 (defun ielm-get-old-input nil
469 ;; Return the previous input surrounding point
472 (if (looking-at comint-prompt-regexp
) nil
473 (re-search-backward comint-prompt-regexp
))
475 (buffer-substring (point) (progn (forward-sexp 1) (point)))))
479 ;;;###autoload (add-hook 'same-window-buffer-names "*ielm*")
483 "Interactively evaluate Emacs Lisp expressions.
484 Switches to the buffer `*ielm*', or creates it if it does not exist."
486 (if (comint-check-proc "*ielm*")
489 (set-buffer (get-buffer-create "*ielm*"))
490 (inferior-emacs-lisp-mode)))
491 (pop-to-buffer "*ielm*"))
493 ;;; ielm.el ends here