lisp/ielm.el

   1 ;;; ielm.el --- interaction mode for Emacs Lisp
   2
   3 ;; Copyright (C) 1994, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 ;; Author: David Smith <maa036@lancaster.ac.uk>
   6 ;; Maintainer: FSF
   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
  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.
  26
  27 ;;; Commentary:
  28
  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.
  32
  33 ;; To start: M-x ielm.  Type C-h m in the *ielm* buffer for more info.
  34
  35 ;;; Code:
  36
  37 (require 'comint)
  38 (require 'pp)
  39
  40 ;;; User variables
  41
  42 (defgroup ielm nil
  43   "Interaction mode for Emacs Lisp."
  44   :group 'lisp)
  45
  46
  47 (defcustom ielm-noisy t
  48   "*If non-nil, IELM will beep on error."
  49   :type 'boolean
  50   :group 'ielm)
  51
  52 (defcustom ielm-prompt-read-only t
  53   "If non-nil, the IELM prompt is read only.
  54 Setting this variable does not affect existing IELM runs.
  55
  56 You can give the IELM prompt more highly customized read-only
  57 type properties, by setting this option to nil, and then setting
  58 `ielm-prompt', outside of Custom, to a string with the desired
  59 text properties.
  60
  61 Interrupting the IELM process with \\<ielm-map>\\[comint-interrupt-subjob],
  62 and then restarting it using \\[ielm], makes the then current
  63 default value affect _new_ prompts.  However, executing \\[ielm]
  64 does not have this effect on *ielm* buffers with a running process.
  65 For IELM buffers that are not called `*ielm*', you can execute
  66 \\[inferior-emacs-lisp-mode] in that IELM buffer to update the value,
  67 for new prompts.  This works even if the buffer has a running process."
  68   :type 'boolean
  69   :group 'ielm
  70   :version "21.4")
  71
  72 (defcustom ielm-prompt "ELISP> "
  73   "Prompt used in IELM.
  74 Setting the default value does not affect existing IELM runs.
  75 `inferior-emacs-lisp-mode' converts this into a buffer-local
  76 variable in IELM buffers.  The buffer-local value is meant for
  77 internal use by IELM.  Do not try to set the buffer-local value
  78 yourself in any way, unless you really know what you are doing.
  79
  80 Interrupting the IELM process with \\<ielm-map>\\[comint-interrupt-subjob],
  81 and then restarting it using \\[ielm], makes the then current
  82 _default_ value affect _new_ prompts.  Unless the new prompt
  83 differs only in text properties from the old one, IELM will no
  84 longer recognize the old prompts.  However, executing \\[ielm]
  85 does not update the prompt of an *ielm* buffer with a running process.
  86 For IELM buffers that are not called `*ielm*', you can execute
  87 \\[inferior-emacs-lisp-mode] in that IELM buffer to update the value,
  88 for new prompts.  This works even if the buffer has a running process."
  89   :type 'string
  90   :group 'ielm)
  91
  92 (defcustom ielm-dynamic-return t
  93   "*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behaviour in IELM.
  94 If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
  95 and indents for incomplete sexps.  If nil, always inserts newlines."
  96   :type 'boolean
  97   :group 'ielm)
  98
  99 (defcustom ielm-dynamic-multiline-inputs t
 100   "*Force multiline inputs to start from column zero?
 101 If non-nil, after entering the first line of an incomplete sexp, a newline
 102 will be inserted after the prompt, moving the input to the next line.
 103 This gives more frame width for large indented sexps, and allows functions
 104 such as `edebug-defun' to work with such inputs."
 105   :type 'boolean
 106   :group 'ielm)
 107
 108 (defcustom ielm-mode-hook nil
 109   "*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
 110   :options '(turn-on-eldoc-mode)
 111   :type 'hook
 112   :group 'ielm)
 113
 114 (defvar * nil
 115   "Most recent value evaluated in IELM.")
 116
 117 (defvar ** nil
 118   "Second-most-recent value evaluated in IELM.")
 119
 120 (defvar *** nil
 121   "Third-most-recent value evaluated in IELM.")
 122
 123 (defvar ielm-match-data nil
 124   "Match data saved at the end of last command.")
 125
 126 (defvar *1 nil
 127   "During IELM evaluation, most recent value evaluated in IELM.
 128 Normally identical to `*'.  However, if the working buffer is an IELM
 129 buffer, distinct from the process buffer, then `*' gives the value in
 130 the working buffer, `*1' the value in the process buffer.
 131 The intended value is only accessible during IELM evaluation.")
 132
 133 (defvar *2 nil
 134   "During IELM evaluation, second-most-recent value evaluated in IELM.
 135 Normally identical to `**'.  However, if the working buffer is an IELM
 136 buffer, distinct from the process buffer, then `**' gives the value in
 137 the working buffer, `*2' the value in the process buffer.
 138 The intended value is only accessible during IELM evaluation.")
 139
 140 (defvar *3 nil
 141   "During IELM evaluation, third-most-recent value evaluated in IELM.
 142 Normally identical to `***'.  However, if the working buffer is an IELM
 143 buffer, distinct from the process buffer, then `***' gives the value in
 144 the working buffer, `*3' the value in the process buffer.
 145 The intended value is only accessible during IELM evaluation.")
 146
 147 ;;; System variables
 148
 149 (defvar ielm-working-buffer nil
 150   "Buffer in which IELM sexps will be evaluated.
 151 This variable is buffer-local.")
 152
 153 (defvar ielm-header
 154   "*** Welcome to IELM ***  Type (describe-mode) for help.\n"
 155   "Message to display when IELM is started.")
 156
 157 (defvar ielm-map nil)
 158 (if ielm-map nil
 159   (if (string-match "Lucid" emacs-version)
 160       ;; Lemacs
 161       (progn
 162         (setq ielm-map (make-sparse-keymap))
 163         (set-keymap-parent ielm-map comint-mode-map))
 164     ;; FSF
 165     (setq ielm-map (cons 'keymap comint-mode-map)))
 166   (define-key ielm-map "\t" 'comint-dynamic-complete)
 167   (define-key ielm-map "\C-m" 'ielm-return)
 168   (define-key ielm-map "\C-j" 'ielm-send-input)
 169   (define-key ielm-map "\e\C-x" 'eval-defun)         ; for consistency with
 170   (define-key ielm-map "\e\t" 'lisp-complete-symbol) ; lisp-interaction-mode
 171   ;; These bindings are from `lisp-mode-shared-map' -- can you inherit
 172   ;; from more than one keymap??
 173   (define-key ielm-map "\e\C-q" 'indent-sexp)
 174   (define-key ielm-map "\177" 'backward-delete-char-untabify)
 175   ;; Some convenience bindings for setting the working buffer
 176   (define-key ielm-map "\C-c\C-b" 'ielm-change-working-buffer)
 177   (define-key ielm-map "\C-c\C-f" 'ielm-display-working-buffer)
 178   (define-key ielm-map "\C-c\C-v" 'ielm-print-working-buffer))
 179
 180 (defvar ielm-font-lock-keywords
 181   (list
 182    (cons (concat "^" (regexp-quote ielm-prompt)) 'font-lock-keyword-face)
 183    '("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)"
 184      (1 font-lock-comment-face)
 185      (2 font-lock-constant-face)))
 186   "Additional expressions to highlight in ielm buffers.")
 187
 188 ;;; Completion stuff
 189
 190 (defun ielm-tab nil
 191   "Possibly indent the current line as lisp code."
 192   (interactive)
 193   (if (or (eq (preceding-char) ?\n)
 194           (eq (char-syntax (preceding-char)) ? ))
 195       (progn
 196         (ielm-indent-line)
 197         t)))
 198
 199 (defun ielm-complete-symbol nil
 200   "Complete the lisp symbol before point."
 201   ;; A wrapper for lisp-complete symbol that returns non-nil if
 202   ;; completion has occurred
 203   (let* ((btick (buffer-modified-tick))
 204          (cbuffer (get-buffer "*Completions*"))
 205          (ctick (and cbuffer (buffer-modified-tick cbuffer))))
 206     (lisp-complete-symbol)
 207      ;; completion has occurred if:
 208     (or
 209      ;; the buffer has been modified
 210      (not (= btick (buffer-modified-tick)))
 211      ;; a completions buffer has been modified or created
 212      (if cbuffer
 213          (not (= ctick (buffer-modified-tick cbuffer)))
 214        (get-buffer "*Completions*")))))
 215
 216 (defun ielm-complete-filename nil
 217   "Dynamically complete filename before point, if in a string."
 218   (if (nth 3 (parse-partial-sexp comint-last-input-start (point)))
 219       (comint-dynamic-complete-filename)))
 220
 221 (defun ielm-indent-line nil
 222   "Indent the current line as Lisp code if it is not a prompt line."
 223   (when (save-excursion (comint-bol) (bolp))
 224     (lisp-indent-line)))
 225
 226 ;;; Working buffer manipulation
 227
 228 (defun ielm-print-working-buffer nil
 229   "Print the current IELM working buffer's name in the echo area."
 230   (interactive)
 231   (message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
 232
 233 (defun ielm-display-working-buffer nil
 234   "Display the current IELM working buffer.
 235 Don't forget that selecting that buffer will change its value of `point'
 236 to its value of `window-point'!"
 237   (interactive)
 238   (display-buffer ielm-working-buffer)
 239   (ielm-print-working-buffer))
 240
 241 (defun ielm-change-working-buffer (buf)
 242   "Change the current IELM working buffer to BUF.
 243 This is the buffer in which all sexps entered at the IELM prompt are
 244 evaluated.  You can achieve the same effect with a call to
 245 `set-buffer' at the IELM prompt."
 246   (interactive "bSet working buffer to: ")
 247   (setq ielm-working-buffer (or (get-buffer buf) (error "No such buffer")))
 248   (ielm-print-working-buffer))
 249
 250 ;;; Other bindings
 251
 252 (defun ielm-return nil
 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)
 266           (if (and ielm-dynamic-multiline-inputs
 267                    (save-excursion
 268                      (beginning-of-line)
 269                      (looking-at comint-prompt-regexp)))
 270               (save-excursion
 271                 (goto-char (ielm-pm))
 272                 (newline 1)))
 273           (newline-and-indent)))
 274     (newline)))
 275
 276 (defvar ielm-input)
 277
 278 (defun ielm-input-sender (proc input)
 279   ;; Just sets the variable ielm-input, which is in the scope of
 280   ;; `ielm-send-input's call.
 281   (setq ielm-input input))
 282
 283 (defun ielm-send-input nil
 284   "Evaluate the Emacs Lisp expression after the prompt."
 285   (interactive)
 286   (let ((buf (current-buffer))
 287         ielm-input)                     ; set by ielm-input-sender
 288     (comint-send-input)                 ; update history, markers etc.
 289     (ielm-eval-input ielm-input)))
 290
 291 ;;; Utility functions
 292
 293 (defun ielm-is-whitespace (string)
 294   "Return non-nil if STRING is all whitespace."
 295   (or (string= string "") (string-match "\\`[ \t\n]+\\'" string)))
 296
 297 ;;; Evaluation
 298
 299 (defun ielm-eval-input (ielm-string)
 300   "Evaluate the Lisp expression IELM-STRING, and pretty-print the result."
 301   ;; This is the function that actually `sends' the input to the
 302   ;; `inferior Lisp process'. All comint-send-input does is works out
 303   ;; what that input is.  What this function does is evaluates that
 304   ;; input and produces `output' which gets inserted into the buffer,
 305   ;; along with a new prompt.  A better way of doing this might have
 306   ;; been to actually send the output to the `cat' process, and write
 307   ;; this as in output filter that converted sexps in the output
 308   ;; stream to their evaluated value.  But that would have involved
 309   ;; more process coordination than I was happy to deal with.
 310   ;;
 311   ;; NOTE: all temporary variables in this function will be in scope
 312   ;; during the eval, and so need to have non-clashing names.
 313   (let (ielm-form                       ; form to evaluate
 314         ielm-pos                        ; End posn of parse in string
 315         ielm-result                     ; Result, or error message
 316         ielm-error-type                 ; string, nil if no error
 317         (ielm-output    "")             ; result to display
 318         (ielm-wbuf ielm-working-buffer) ; current buffer after evaluation
 319         (ielm-pmark (ielm-pm)))
 320     (if (not (ielm-is-whitespace ielm-string))
 321         (progn
 322           (condition-case err
 323               (let (rout)
 324                 (setq rout (read-from-string ielm-string))
 325                 (setq ielm-form (car rout))
 326                 (setq ielm-pos (cdr rout)))
 327             (error (setq ielm-result (error-message-string err))
 328                    (setq ielm-error-type "Read error")))
 329           (if ielm-error-type nil
 330             ;; Make sure working buffer has not been killed
 331             (if (not (buffer-name ielm-working-buffer))
 332                 (setq ielm-result "Working buffer has been killed"
 333                       ielm-error-type "IELM Error"
 334                       ielm-wbuf (current-buffer))
 335               (if (ielm-is-whitespace (substring ielm-string ielm-pos))
 336                   ;; To correctly handle the ielm-local variables *,
 337                   ;; ** and ***, we need a temporary buffer to be
 338                   ;; current at entry to the inner of the next two let
 339                   ;; forms.  We need another temporary buffer to exit
 340                   ;; that same let.  To avoid problems, neither of
 341                   ;; these buffers should be alive during the
 342                   ;; evaluation of ielm-form.
 343                   (let ((*1 *)
 344                         (*2 **)
 345                         (*3 ***)
 346                         ielm-temp-buffer)
 347                     (set-match-data ielm-match-data)
 348                     (save-excursion
 349                       (with-temp-buffer
 350                         (condition-case err
 351                             (unwind-protect
 352                                 ;; The next let form creates default
 353                                 ;; bindings for *, ** and ***.  But
 354                                 ;; these default bindings are
 355                                 ;; identical to the ielm-local
 356                                 ;; bindings.  Hence, during the
 357                                 ;; evaluation of ielm-form, the
 358                                 ;; ielm-local values are going to be
 359                                 ;; used in all buffers except for
 360                                 ;; other ielm buffers, which override
 361                                 ;; them.  Normally, the variables *1,
 362                                 ;; *2 and *3 also have default
 363                                 ;; bindings, which are not overridden.
 364                                 (let ((* *1)
 365                                       (** *2)
 366                                       (*** *3))
 367                                   (kill-buffer (current-buffer))
 368                                   (set-buffer ielm-wbuf)
 369                                   (setq ielm-result (eval ielm-form))
 370                                   (setq ielm-wbuf (current-buffer))
 371                                   (setq
 372                                    ielm-temp-buffer
 373                                    (generate-new-buffer " *ielm-temp*"))
 374                                   (set-buffer ielm-temp-buffer))
 375                               (when ielm-temp-buffer
 376                                 (kill-buffer ielm-temp-buffer)))
 377                           (error (setq ielm-result (error-message-string err))
 378                                  (setq ielm-error-type "Eval error"))
 379                           (quit (setq ielm-result "Quit during evaluation")
 380                                 (setq ielm-error-type "Eval error")))))
 381                     (setq ielm-match-data (match-data)))
 382                 (setq ielm-error-type "IELM error")
 383                 (setq ielm-result "More than one sexp in input"))))
 384
 385           ;; If the eval changed the current buffer, mention it here
 386           (if (eq ielm-wbuf ielm-working-buffer) nil
 387             (message "current buffer is now: %s" ielm-wbuf)
 388             (setq ielm-working-buffer ielm-wbuf))
 389
 390           (goto-char ielm-pmark)
 391           (if (not ielm-error-type)
 392               (condition-case err
 393                   ;; Self-referential objects cause loops in the printer, so
 394                   ;; trap quits here. May as well do errors, too
 395                   (setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
 396                 (error (setq ielm-error-type "IELM Error")
 397                        (setq ielm-result  "Error during pretty-printing (bug in pp)"))
 398                 (quit  (setq ielm-error-type "IELM Error")
 399                        (setq ielm-result "Quit during pretty-printing"))))
 400           (if ielm-error-type
 401               (progn
 402                 (if ielm-noisy (ding))
 403                 (setq ielm-output (concat ielm-output "*** " ielm-error-type " ***  "))
 404                 (setq ielm-output (concat ielm-output ielm-result)))
 405             ;; There was no error, so shift the *** values
 406             (setq *** **)
 407             (setq ** *)
 408             (setq * ielm-result))
 409           (setq ielm-output (concat ielm-output "\n"))))
 410     (setq ielm-output (concat ielm-output ielm-prompt))
 411     (comint-output-filter (ielm-process) ielm-output)))
 412
 413 ;;; Process and marker utilities
 414
 415 (defun ielm-process nil
 416   ;; Return the current buffer's process.
 417   (get-buffer-process (current-buffer)))
 418
 419 (defun ielm-pm nil
 420   ;; Return the process mark of the current buffer.
 421   (process-mark (get-buffer-process (current-buffer))))
 422
 423 (defun ielm-set-pm (pos)
 424   ;; Set the process mark in the current buffer to POS.
 425   (set-marker (process-mark (get-buffer-process (current-buffer))) pos))
 426
 427 ;;; Major mode
 428
 429 (put 'inferior-emacs-lisp-mode 'mode-class 'special)
 430
 431 (defun inferior-emacs-lisp-mode nil
 432   "Major mode for interactively evaluating Emacs Lisp expressions.
 433 Uses the interface provided by `comint-mode' (which see).
 434
 435 * \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt.  There must be at most
 436   one top level sexp per prompt.
 437
 438 * \\[ielm-return] inserts a newline and indents, or evaluates a
 439   complete expression (but see variable `ielm-dynamic-return').
 440   Inputs longer than one line are moved to the line following the
 441   prompt (but see variable `ielm-dynamic-multiline-inputs').
 442
 443 * \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
 444   or indents the line if there is nothing to complete.
 445
 446 The current working buffer may be changed (with a call to
 447 `set-buffer', or with \\[ielm-change-working-buffer]), and its value
 448 is preserved between successive evaluations.  In this way, expressions
 449 may be evaluated in a different buffer than the *ielm* buffer.
 450 By default, its name is shown on the mode line; you can always display
 451 it with \\[ielm-print-working-buffer], or the buffer itself with \\[ielm-display-working-buffer].
 452
 453 During evaluations, the values of the variables `*', `**', and `***'
 454 are the results of the previous, second previous and third previous
 455 evaluations respectively.  If the working buffer is another IELM
 456 buffer, then the values in the working buffer are used.  The variables
 457 `*1', `*2' and `*3', yield the process buffer values.
 458
 459 Expressions evaluated by IELM are not subject to `debug-on-quit' or
 460 `debug-on-error'.
 461
 462 The behaviour of IELM may be customized with the following variables:
 463 * To stop beeping on error, set `ielm-noisy' to nil.
 464 * If you don't like the prompt, you can change it by setting `ielm-prompt'.
 465 * If you do not like that the prompt is (by default) read-only, set
 466   `ielm-prompt-read-only' to nil.
 467 * Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'.
 468 * Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
 469  (in that order).
 470
 471 Customized bindings may be defined in `ielm-map', which currently contains:
 472 \\{ielm-map}"
 473   (interactive)
 474   (comint-mode)
 475   (setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
 476   (make-local-variable 'paragraph-start)
 477   (setq paragraph-start comint-prompt-regexp)
 478   (setq comint-input-sender 'ielm-input-sender)
 479   (setq comint-process-echoes nil)
 480   (make-local-variable 'comint-dynamic-complete-functions)
 481   (set (make-local-variable 'ielm-prompt)
 482        (if ielm-prompt-read-only
 483            (propertize ielm-prompt
 484                        'read-only t
 485                        'rear-nonsticky t
 486                        'front-sticky '(read-only))
 487          ielm-prompt))
 488   (setq comint-dynamic-complete-functions
 489         '(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol))
 490   (setq comint-get-old-input 'ielm-get-old-input)
 491   (make-local-variable 'comint-completion-addsuffix)
 492   (setq comint-completion-addsuffix
 493         (cons (char-to-string directory-sep-char) ""))
 494
 495   (setq major-mode 'inferior-emacs-lisp-mode)
 496   (setq mode-name "IELM")
 497   (setq mode-line-process '(":%s on " (:eval (buffer-name ielm-working-buffer))))
 498   (use-local-map ielm-map)
 499   (set-syntax-table emacs-lisp-mode-syntax-table)
 500
 501   (make-local-variable 'indent-line-function)
 502   (make-local-variable 'ielm-working-buffer)
 503   (setq ielm-working-buffer (current-buffer))
 504   (setq indent-line-function 'ielm-indent-line)
 505   (make-local-variable 'fill-paragraph-function)
 506   (setq fill-paragraph-function 'lisp-fill-paragraph)
 507
 508   ;; Value holders
 509   (make-local-variable '*)
 510   (setq * nil)
 511   (make-local-variable '**)
 512   (setq ** nil)
 513   (make-local-variable '***)
 514   (setq *** nil)
 515   (set (make-local-variable 'ielm-match-data) nil)
 516
 517   ;; font-lock support
 518   (make-local-variable 'font-lock-defaults)
 519   (setq font-lock-defaults
 520         '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
 521
 522   ;; A dummy process to keep comint happy. It will never get any input
 523   (unless (comint-check-proc (current-buffer))
 524     ;; Was cat, but on non-Unix platforms that might not exist, so
 525     ;; use hexl instead, which is part of the Emacs distribution.
 526     (condition-case nil
 527         (start-process "ielm" (current-buffer) "hexl")
 528       (file-error (start-process "ielm" (current-buffer) "cat")))
 529     (process-kill-without-query (ielm-process))
 530     (goto-char (point-max))
 531
 532     ;; Lisp output can include raw characters that confuse comint's
 533     ;; carriage control code.
 534     (set (make-local-variable 'comint-inhibit-carriage-motion) t)
 535
 536     ;; Add a silly header
 537     (insert ielm-header)
 538     (ielm-set-pm (point-max))
 539     (unless comint-use-prompt-regexp-instead-of-fields
 540       (let ((inhibit-read-only t))
 541         (add-text-properties
 542          (point-min) (point-max)
 543          '(rear-nonsticky t field output inhibit-line-move-field-capture t))))
 544     (comint-output-filter (ielm-process) ielm-prompt)
 545     (set-marker comint-last-input-start (ielm-pm))
 546     (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
 547
 548   (run-hooks 'ielm-mode-hook))
 549
 550 (defun ielm-get-old-input nil
 551   ;; Return the previous input surrounding point
 552   (save-excursion
 553     (beginning-of-line)
 554     (if (looking-at comint-prompt-regexp) nil
 555       (re-search-backward comint-prompt-regexp))
 556     (comint-skip-prompt)
 557     (buffer-substring (point) (progn (forward-sexp 1) (point)))))
 558
 559 ;;; User command
 560
 561 ;;;###autoload (add-hook 'same-window-buffer-names "*ielm*")
 562
 563 ;;;###autoload
 564 (defun ielm nil
 565   "Interactively evaluate Emacs Lisp expressions.
 566 Switches to the buffer `*ielm*', or creates it if it does not exist."
 567   (interactive)
 568   (let (old-point)
 569     (unless (comint-check-proc "*ielm*")
 570       (with-current-buffer (get-buffer-create "*ielm*")
 571         (unless (eq (buffer-size) 0) (setq old-point (point)))
 572         (inferior-emacs-lisp-mode)))
 573     (pop-to-buffer "*ielm*")
 574     (when old-point (push-mark old-point))))
 575
 576 (provide 'ielm)
 577
 578 ;;; arch-tag: ef60e4c0-9c4f-4bdb-8402-271313329790
 579 ;;; ielm.el ends here