Display SVG images in external <object> files
[emacs.git] / lisp / ielm.el
blob37e66ccc61133638f3d652065869528420fb64af
1 ;;; -*- lexical-binding: t -*-
2 ;;; ielm.el --- interaction mode for Emacs Lisp
4 ;; Copyright (C) 1994, 2001-2014 Free Software Foundation, Inc.
6 ;; Author: David Smith <maa036@lancaster.ac.uk>
7 ;; Maintainer: emacs-devel@gnu.org
8 ;; Created: 25 Feb 1994
9 ;; Keywords: lisp
11 ;; This file is part of GNU Emacs.
13 ;; GNU Emacs is free software: you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation, either version 3 of the License, or
16 ;; (at your option) any later version.
18 ;; GNU Emacs is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ;; GNU General Public License for more details.
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
26 ;;; Commentary:
28 ;; Provides a nice interface to evaluating Emacs Lisp expressions.
29 ;; Input is handled by the comint package, and output is passed
30 ;; through the pretty-printer.
32 ;; To start: M-x ielm. Type C-h m in the *ielm* buffer for more info.
34 ;;; Code:
36 (require 'comint)
37 (require 'pp)
39 ;;; User variables
41 (defgroup ielm nil
42 "Interaction mode for Emacs Lisp."
43 :group 'lisp)
46 (defcustom ielm-noisy t
47 "If non-nil, IELM will beep on error."
48 :type 'boolean
49 :group 'ielm)
51 (defcustom ielm-prompt-read-only t
52 "If non-nil, the IELM prompt is read only.
53 The read only region includes the newline before the prompt.
54 Setting this variable does not affect existing IELM runs.
55 This works by setting the buffer-local value of `comint-prompt-read-only'.
56 Setting that value directly affects new prompts in the current buffer.
58 If this option is enabled, then the safe way to temporarily
59 override the read-only-ness of IELM prompts is to call
60 `comint-kill-whole-line' or `comint-kill-region' with no
61 narrowing in effect. This way you will be certain that none of
62 the remaining prompts will be accidentally messed up. You may
63 wish to put something like the following in your init file:
65 \(add-hook 'ielm-mode-hook
66 (lambda ()
67 (define-key ielm-map \"\\C-w\" 'comint-kill-region)
68 (define-key ielm-map [C-S-backspace]
69 'comint-kill-whole-line)))
71 If you set `comint-prompt-read-only' to t, you might wish to use
72 `comint-mode-hook' and `comint-mode-map' instead of
73 `ielm-mode-hook' and `ielm-map'. That will affect all comint
74 buffers, including IELM buffers. If you sometimes use IELM on
75 text-only terminals or with `emacs -nw', you might wish to use
76 another binding for `comint-kill-whole-line'."
77 :type 'boolean
78 :group 'ielm
79 :version "22.1")
81 (defcustom ielm-prompt "ELISP> "
82 "Prompt used in IELM.
83 Setting this variable does not affect existing IELM runs.
85 Interrupting the IELM process with \\<ielm-map>\\[comint-interrupt-subjob],
86 and then restarting it using \\[ielm], makes the then current
87 default value affect _new_ prompts. Unless the new prompt
88 differs only in text properties from the old one, IELM will no
89 longer recognize the old prompts. However, executing \\[ielm]
90 does not update the prompt of an *ielm* buffer with a running process.
91 For IELM buffers that are not called `*ielm*', you can execute
92 \\[inferior-emacs-lisp-mode] in that IELM buffer to update the value,
93 for new prompts. This works even if the buffer has a running process."
94 :type 'string
95 :group 'ielm)
97 (defvar ielm-prompt-internal "ELISP> "
98 "Stored value of `ielm-prompt' in the current IELM buffer.
99 This is an internal variable used by IELM. Its purpose is to
100 prevent a running IELM process from being messed up when the user
101 customizes `ielm-prompt'.")
103 (defcustom ielm-dynamic-return t
104 "Controls whether \\<ielm-map>\\[ielm-return] has intelligent behavior in IELM.
105 If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
106 and indents for incomplete sexps. If nil, always inserts newlines."
107 :type 'boolean
108 :group 'ielm)
110 (defcustom ielm-dynamic-multiline-inputs t
111 "Force multiline inputs to start from column zero?
112 If non-nil, after entering the first line of an incomplete sexp, a newline
113 will be inserted after the prompt, moving the input to the next line.
114 This gives more frame width for large indented sexps, and allows functions
115 such as `edebug-defun' to work with such inputs."
116 :type 'boolean
117 :group 'ielm)
119 (defcustom ielm-mode-hook nil
120 "Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
121 :options '(eldoc-mode)
122 :type 'hook
123 :group 'ielm)
124 (defvaralias 'inferior-emacs-lisp-mode-hook 'ielm-mode-hook)
126 (defvar * nil
127 "Most recent value evaluated in IELM.")
129 (defvar ** nil
130 "Second-most-recent value evaluated in IELM.")
132 (defvar *** nil
133 "Third-most-recent value evaluated in IELM.")
135 (defvar ielm-match-data nil
136 "Match data saved at the end of last command.")
138 (defvar *1 nil
139 "During IELM evaluation, most recent value evaluated in IELM.
140 Normally identical to `*'. However, if the working buffer is an IELM
141 buffer, distinct from the process buffer, then `*' gives the value in
142 the working buffer, `*1' the value in the process buffer.
143 The intended value is only accessible during IELM evaluation.")
145 (defvar *2 nil
146 "During IELM evaluation, second-most-recent value evaluated in IELM.
147 Normally identical to `**'. However, if the working buffer is an IELM
148 buffer, distinct from the process buffer, then `**' gives the value in
149 the working buffer, `*2' the value in the process buffer.
150 The intended value is only accessible during IELM evaluation.")
152 (defvar *3 nil
153 "During IELM evaluation, third-most-recent value evaluated in IELM.
154 Normally identical to `***'. However, if the working buffer is an IELM
155 buffer, distinct from the process buffer, then `***' gives the value in
156 the working buffer, `*3' the value in the process buffer.
157 The intended value is only accessible during IELM evaluation.")
159 ;;; System variables
161 (defvar ielm-working-buffer nil
162 "Buffer in which IELM sexps will be evaluated.
163 This variable is buffer-local.")
165 (defvar ielm-header
166 "*** Welcome to IELM *** Type (describe-mode) for help.\n"
167 "Message to display when IELM is started.")
169 (defvar ielm-map
170 (let ((map (make-sparse-keymap)))
171 (define-key map "\t" 'ielm-tab)
172 (define-key map "\C-m" 'ielm-return)
173 (define-key map "\e\C-m" 'ielm-return-for-effect)
174 (define-key map "\C-j" 'ielm-send-input)
175 (define-key map "\e\C-x" 'eval-defun) ; for consistency with
176 (define-key map "\e\t" 'completion-at-point) ; lisp-interaction-mode
177 ;; These bindings are from `lisp-mode-shared-map' -- can you inherit
178 ;; from more than one keymap??
179 (define-key map "\e\C-q" 'indent-sexp)
180 (define-key map "\177" 'backward-delete-char-untabify)
181 ;; Some convenience bindings for setting the working buffer
182 (define-key map "\C-c\C-b" 'ielm-change-working-buffer)
183 (define-key map "\C-c\C-f" 'ielm-display-working-buffer)
184 (define-key map "\C-c\C-v" 'ielm-print-working-buffer)
185 map)
186 "Keymap for IELM mode.")
187 (defvaralias 'inferior-emacs-lisp-mode-map 'ielm-map)
189 (easy-menu-define ielm-menu ielm-map
190 "IELM mode menu."
191 '("IELM"
192 ["Change Working Buffer" ielm-change-working-buffer t]
193 ["Display Working Buffer" ielm-display-working-buffer t]
194 ["Print Working Buffer" ielm-print-working-buffer t]))
196 (defvar ielm-font-lock-keywords
197 '(("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)"
198 (1 font-lock-comment-face)
199 (2 font-lock-constant-face)))
200 "Additional expressions to highlight in IELM buffers.")
202 ;;; Completion stuff
204 (defun ielm-tab ()
205 "Indent or complete."
206 (interactive)
207 (if (or (eq (preceding-char) ?\n)
208 (eq (char-syntax (preceding-char)) ?\s))
209 (ielm-indent-line)
210 (completion-at-point)))
213 (defun ielm-complete-filename nil
214 "Dynamically complete filename before point, if in a string."
215 (when (nth 3 (parse-partial-sexp comint-last-input-start (point)))
216 (comint-filename-completion)))
218 (defun ielm-indent-line nil
219 "Indent the current line as Lisp code if it is not a prompt line."
220 (when (save-excursion (comint-bol) (bolp))
221 (lisp-indent-line)))
223 ;;; Working buffer manipulation
225 (defun ielm-print-working-buffer nil
226 "Print the current IELM working buffer's name in the echo area."
227 (interactive)
228 (message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
230 (defun ielm-display-working-buffer nil
231 "Display the current IELM working buffer.
232 Don't forget that selecting that buffer will change its value of `point'
233 to its value of `window-point'!"
234 (interactive)
235 (display-buffer ielm-working-buffer)
236 (ielm-print-working-buffer))
238 (defun ielm-change-working-buffer (buf)
239 "Change the current IELM working buffer to BUF.
240 This is the buffer in which all sexps entered at the IELM prompt are
241 evaluated. You can achieve the same effect with a call to
242 `set-buffer' at the IELM prompt."
243 (interactive "bSet working buffer to: ")
244 (let ((buffer (get-buffer buf)))
245 (if (and buffer (buffer-live-p buffer))
246 (setq ielm-working-buffer buffer)
247 (error "No such buffer: %S" buf)))
248 (ielm-print-working-buffer))
250 ;;; Other bindings
252 (defun ielm-return (&optional for-effect)
253 "Newline and indent, or evaluate the sexp before the prompt.
254 Complete sexps are evaluated; for incomplete sexps inserts a newline
255 and indents. If however `ielm-dynamic-return' is nil, this always
256 simply inserts a newline."
257 (interactive)
258 (if ielm-dynamic-return
259 (let ((state
260 (save-excursion
261 (end-of-line)
262 (parse-partial-sexp (ielm-pm)
263 (point)))))
264 (if (and (< (car state) 1) (not (nth 3 state)))
265 (ielm-send-input for-effect)
266 (when (and ielm-dynamic-multiline-inputs
267 (save-excursion
268 (beginning-of-line)
269 (looking-at-p comint-prompt-regexp)))
270 (save-excursion
271 (goto-char (ielm-pm))
272 (newline 1)))
273 (newline-and-indent)))
274 (newline)))
276 (defun ielm-return-for-effect ()
277 "Like `ielm-return', but do not print the result."
278 (interactive)
279 (ielm-return t))
281 (defvar ielm-input)
283 (defun ielm-input-sender (_proc input)
284 ;; Just sets the variable ielm-input, which is in the scope of
285 ;; `ielm-send-input's call.
286 (setq ielm-input input))
288 (defun ielm-send-input (&optional for-effect)
289 "Evaluate the Emacs Lisp expression after the prompt."
290 (interactive)
291 (let (ielm-input) ; set by ielm-input-sender
292 (comint-send-input) ; update history, markers etc.
293 (ielm-eval-input ielm-input for-effect)))
295 ;;; Utility functions
297 (defun ielm-is-whitespace-or-comment (string)
298 "Return non-nil if STRING is all whitespace or a comment."
299 (or (string= string "")
300 (string-match-p "\\`[ \t\n]*\\(?:;.*\\)*\\'" string)))
302 ;;; Evaluation
304 (defun ielm-standard-output-impl (process)
305 "Return a function to use for `standard-output' while in ielm eval.
306 The returned function takes one character as input. Passing nil
307 to this function instead of a character flushes the output
308 buffer. Passing t appends a terminating newline if the buffer is
309 nonempty, then flushes the buffer."
310 ;; Use an intermediate output buffer because doing redisplay for
311 ;; each character we output is too expensive. Set up a flush timer
312 ;; so that users don't have to wait for whole lines to appear before
313 ;; seeing output.
314 (let* ((output-buffer nil)
315 (flush-timer nil)
316 (flush-buffer
317 (lambda ()
318 (comint-output-filter
319 process
320 (apply #'string (nreverse output-buffer)))
321 (redisplay)
322 (setf output-buffer nil)
323 (when flush-timer
324 (cancel-timer flush-timer)
325 (setf flush-timer nil)))))
326 (lambda (char)
327 (let (flush-now)
328 (cond ((and (eq char t) output-buffer)
329 (push ?\n output-buffer)
330 (setf flush-now t))
331 ((characterp char)
332 (push char output-buffer)))
333 (if flush-now
334 (funcall flush-buffer)
335 (unless flush-timer
336 (setf flush-timer (run-with-timer 0.1 nil flush-buffer))))))))
338 (defun ielm-eval-input (input-string &optional for-effect)
339 "Evaluate the Lisp expression INPUT-STRING, and pretty-print the result."
340 ;; This is the function that actually `sends' the input to the
341 ;; `inferior Lisp process'. All comint-send-input does is works out
342 ;; what that input is. What this function does is evaluates that
343 ;; input and produces `output' which gets inserted into the buffer,
344 ;; along with a new prompt. A better way of doing this might have
345 ;; been to actually send the output to the `cat' process, and write
346 ;; this as in output filter that converted sexps in the output
347 ;; stream to their evaluated value. But that would have involved
348 ;; more process coordination than I was happy to deal with.
349 (let ((string input-string) ; input expression, as a string
350 form ; form to evaluate
351 pos ; End posn of parse in string
352 result ; Result, or error message
353 error-type ; string, nil if no error
354 (output "") ; result to display
355 (wbuf ielm-working-buffer) ; current buffer after evaluation
356 (pmark (ielm-pm)))
357 (unless (ielm-is-whitespace-or-comment string)
358 (condition-case err
359 (let ((rout (read-from-string string)))
360 (setq form (car rout)
361 pos (cdr rout)))
362 (error (setq result (error-message-string err))
363 (setq error-type "Read error")))
364 (unless error-type
365 ;; Make sure working buffer has not been killed
366 (if (not (buffer-name ielm-working-buffer))
367 (setq result "Working buffer has been killed"
368 error-type "IELM Error"
369 wbuf (current-buffer))
370 (if (ielm-is-whitespace-or-comment (substring string pos))
371 ;; To correctly handle the ielm-local variables *,
372 ;; ** and ***, we need a temporary buffer to be
373 ;; current at entry to the inner of the next two let
374 ;; forms. We need another temporary buffer to exit
375 ;; that same let. To avoid problems, neither of
376 ;; these buffers should be alive during the
377 ;; evaluation of form.
378 (let* ((*1 *)
379 (*2 **)
380 (*3 ***)
381 (active-process (ielm-process))
382 (old-standard-output standard-output)
383 new-standard-output
384 ielm-temp-buffer)
385 (set-match-data ielm-match-data)
386 (save-excursion
387 (with-temp-buffer
388 (condition-case err
389 (unwind-protect
390 ;; The next let form creates default
391 ;; bindings for *, ** and ***. But
392 ;; these default bindings are
393 ;; identical to the ielm-local
394 ;; bindings. Hence, during the
395 ;; evaluation of form, the
396 ;; ielm-local values are going to be
397 ;; used in all buffers except for
398 ;; other ielm buffers, which override
399 ;; them. Normally, the variables *1,
400 ;; *2 and *3 also have default
401 ;; bindings, which are not overridden.
402 (let ((* *1)
403 (** *2)
404 (*** *3))
405 (when (eq standard-output t)
406 (setf new-standard-output
407 (ielm-standard-output-impl
408 active-process))
409 (setf standard-output new-standard-output))
410 (kill-buffer (current-buffer))
411 (set-buffer wbuf)
412 (setq result
413 (eval form lexical-binding))
414 (setq wbuf (current-buffer))
415 (setq
416 ielm-temp-buffer
417 (generate-new-buffer " *ielm-temp*"))
418 (set-buffer ielm-temp-buffer))
419 (when ielm-temp-buffer
420 (kill-buffer ielm-temp-buffer))
421 (when (eq new-standard-output standard-output)
422 (ignore-errors
423 (funcall standard-output t))
424 (setf standard-output old-standard-output)))
425 (error (setq result (error-message-string err))
426 (setq error-type "Eval error"))
427 (quit (setq result "Quit during evaluation")
428 (setq error-type "Eval error")))))
429 (setq ielm-match-data (match-data)))
430 (setq error-type "IELM error")
431 (setq result "More than one sexp in input"))))
433 ;; If the eval changed the current buffer, mention it here
434 (unless (eq wbuf ielm-working-buffer)
435 (message "current buffer is now: %s" wbuf)
436 (setq ielm-working-buffer wbuf))
438 (goto-char pmark)
439 (unless error-type
440 (condition-case nil
441 ;; Self-referential objects cause loops in the printer, so
442 ;; trap quits here. May as well do errors, too
443 (unless for-effect
444 (setq output (concat output (pp-to-string result)
445 (let ((str (eval-expression-print-format result)))
446 (if str (propertize str 'font-lock-face 'shadow))))))
447 (error (setq error-type "IELM Error")
448 (setq result "Error during pretty-printing (bug in pp)"))
449 (quit (setq error-type "IELM Error")
450 (setq result "Quit during pretty-printing"))))
451 (if error-type
452 (progn
453 (when ielm-noisy (ding))
454 (setq output (concat output "*** " error-type " *** "))
455 (setq output (concat output result)))
456 ;; There was no error, so shift the *** values
457 (setq *** **)
458 (setq ** *)
459 (setq * result))
460 (when (or (not for-effect) (not (equal output "")))
461 (setq output (concat output "\n"))))
462 (setq output (concat output ielm-prompt-internal))
463 (comint-output-filter (ielm-process) output)))
465 ;;; Process and marker utilities
467 (defun ielm-process nil
468 ;; Return the current buffer's process.
469 (get-buffer-process (current-buffer)))
471 (defun ielm-pm nil
472 ;; Return the process mark of the current buffer.
473 (process-mark (get-buffer-process (current-buffer))))
475 (defun ielm-set-pm (pos)
476 ;; Set the process mark in the current buffer to POS.
477 (set-marker (process-mark (get-buffer-process (current-buffer))) pos))
479 ;;; Major mode
481 (define-derived-mode inferior-emacs-lisp-mode comint-mode "IELM"
482 "Major mode for interactively evaluating Emacs Lisp expressions.
483 Uses the interface provided by `comint-mode' (which see).
485 * \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
486 one top level sexp per prompt.
488 * \\[ielm-return] inserts a newline and indents, or evaluates a
489 complete expression (but see variable `ielm-dynamic-return').
490 Inputs longer than one line are moved to the line following the
491 prompt (but see variable `ielm-dynamic-multiline-inputs').
493 * \\[ielm-return-for-effect] works like `ielm-return', except
494 that it doesn't print the result of evaluating the input. This
495 functionality is useful when forms would generate voluminous
496 output.
498 * \\[completion-at-point] completes Lisp symbols (or filenames, within strings),
499 or indents the line if there is nothing to complete.
501 The current working buffer may be changed (with a call to `set-buffer',
502 or with \\[ielm-change-working-buffer]), and its value is preserved between successive
503 evaluations. In this way, expressions may be evaluated in a different
504 buffer than the *ielm* buffer. By default, its name is shown on the
505 mode line; you can always display it with \\[ielm-print-working-buffer], or the buffer itself
506 with \\[ielm-display-working-buffer].
508 During evaluations, the values of the variables `*', `**', and `***'
509 are the results of the previous, second previous and third previous
510 evaluations respectively. If the working buffer is another IELM
511 buffer, then the values in the working buffer are used. The variables
512 `*1', `*2' and `*3', yield the process buffer values.
514 If, at the start of evaluation, `standard-output' is `t' (the
515 default), `standard-output' is set to a special function that
516 causes output to be directed to the ielm buffer.
517 `standard-output' is restored after evaluation unless explicitly
518 set to a different value during evaluation. You can use (princ
519 VALUE) or (pp VALUE) to write to the ielm buffer.
521 Expressions evaluated by IELM are not subject to `debug-on-quit' or
522 `debug-on-error'.
524 The behavior of IELM may be customized with the following variables:
525 * To stop beeping on error, set `ielm-noisy' to nil.
526 * If you don't like the prompt, you can change it by setting `ielm-prompt'.
527 * If you do not like that the prompt is (by default) read-only, set
528 `ielm-prompt-read-only' to nil.
529 * Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'.
530 * Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
531 (in that order).
533 Customized bindings may be defined in `ielm-map', which currently contains:
534 \\{ielm-map}"
535 :syntax-table emacs-lisp-mode-syntax-table
537 (setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
538 (set (make-local-variable 'paragraph-separate) "\\'")
539 (set (make-local-variable 'paragraph-start) comint-prompt-regexp)
540 (setq comint-input-sender 'ielm-input-sender)
541 (setq comint-process-echoes nil)
542 (set (make-local-variable 'completion-at-point-functions)
543 '(comint-replace-by-expanded-history
544 ielm-complete-filename elisp-completion-at-point))
545 (setq-local eldoc-documentation-function
546 #'elisp-eldoc-documentation-function)
547 (set (make-local-variable 'ielm-prompt-internal) ielm-prompt)
548 (set (make-local-variable 'comint-prompt-read-only) ielm-prompt-read-only)
549 (setq comint-get-old-input 'ielm-get-old-input)
550 (set (make-local-variable 'comint-completion-addsuffix) '("/" . ""))
551 (setq mode-line-process '(":%s on " (:eval (buffer-name ielm-working-buffer))))
552 ;; Useful for `hs-minor-mode'.
553 (setq-local comment-start ";")
554 (setq-local comment-use-syntax t)
556 (set (make-local-variable 'indent-line-function) 'ielm-indent-line)
557 (set (make-local-variable 'ielm-working-buffer) (current-buffer))
558 (set (make-local-variable 'fill-paragraph-function) 'lisp-fill-paragraph)
560 ;; Value holders
561 (set (make-local-variable '*) nil)
562 (set (make-local-variable '**) nil)
563 (set (make-local-variable '***) nil)
564 (set (make-local-variable 'ielm-match-data) nil)
566 ;; font-lock support
567 (set (make-local-variable 'font-lock-defaults)
568 '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
570 ;; A dummy process to keep comint happy. It will never get any input
571 (unless (comint-check-proc (current-buffer))
572 ;; Was cat, but on non-Unix platforms that might not exist, so
573 ;; use hexl instead, which is part of the Emacs distribution.
574 (condition-case nil
575 (start-process "ielm" (current-buffer) "hexl")
576 (file-error (start-process "ielm" (current-buffer) "cat")))
577 (set-process-query-on-exit-flag (ielm-process) nil)
578 (goto-char (point-max))
580 ;; Lisp output can include raw characters that confuse comint's
581 ;; carriage control code.
582 (set (make-local-variable 'comint-inhibit-carriage-motion) t)
584 ;; Add a silly header
585 (insert ielm-header)
586 (ielm-set-pm (point-max))
587 (unless comint-use-prompt-regexp
588 (let ((inhibit-read-only t))
589 (add-text-properties
590 (point-min) (point-max)
591 '(rear-nonsticky t field output inhibit-line-move-field-capture t))))
592 (comint-output-filter (ielm-process) ielm-prompt-internal)
593 (set-marker comint-last-input-start (ielm-pm))
594 (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter)))
596 (defun ielm-get-old-input nil
597 ;; Return the previous input surrounding point
598 (save-excursion
599 (beginning-of-line)
600 (unless (looking-at-p comint-prompt-regexp)
601 (re-search-backward comint-prompt-regexp))
602 (comint-skip-prompt)
603 (buffer-substring (point) (progn (forward-sexp 1) (point)))))
605 ;;; User command
607 ;;;###autoload
608 (defun ielm nil
609 "Interactively evaluate Emacs Lisp expressions.
610 Switches to the buffer `*ielm*', or creates it if it does not exist.
611 See `inferior-emacs-lisp-mode' for details."
612 (interactive)
613 (let (old-point)
614 (unless (comint-check-proc "*ielm*")
615 (with-current-buffer (get-buffer-create "*ielm*")
616 (unless (zerop (buffer-size)) (setq old-point (point)))
617 (inferior-emacs-lisp-mode)))
618 (switch-to-buffer "*ielm*")
619 (when old-point (push-mark old-point))))
621 (provide 'ielm)
623 ;;; ielm.el ends here