lisp/ielm.el

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