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