lisp/ielm.el

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