lisp/ielm.el

   1 ;;; -*- lexical-binding: t -*-
   2 ;;; ielm.el --- interaction mode for Emacs Lisp
   3
   4 ;; Copyright (C) 1994, 2001-2015 Free Software Foundation, Inc.
   5
   6 ;; Author: David Smith <maa036@lancaster.ac.uk>
   7 ;; Maintainer: emacs-devel@gnu.org
   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 init 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 '(eldoc-mode)
 122   :type 'hook
 123   :group 'ielm)
 124 (defvaralias 'inferior-emacs-lisp-mode-hook 'ielm-mode-hook)
 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
 170   (let ((map (make-sparse-keymap)))
 171     (define-key map "\t" 'ielm-tab)
 172     (define-key map "\C-m" 'ielm-return)
 173     (define-key map "\e\C-m" 'ielm-return-for-effect)
 174     (define-key map "\C-j" 'ielm-send-input)
 175     (define-key map "\e\C-x" 'eval-defun)         ; for consistency with
 176     (define-key map "\e\t" 'completion-at-point)  ; lisp-interaction-mode
 177     ;; These bindings are from `lisp-mode-shared-map' -- can you inherit
 178     ;; from more than one keymap??
 179     (define-key map "\e\C-q" 'indent-sexp)
 180     (define-key map "\177" 'backward-delete-char-untabify)
 181     ;; Some convenience bindings for setting the working buffer
 182     (define-key map "\C-c\C-b" 'ielm-change-working-buffer)
 183     (define-key map "\C-c\C-f" 'ielm-display-working-buffer)
 184     (define-key map "\C-c\C-v" 'ielm-print-working-buffer)
 185     map)
 186   "Keymap for IELM mode.")
 187 (defvaralias 'inferior-emacs-lisp-mode-map 'ielm-map)
 188
 189 (easy-menu-define ielm-menu ielm-map
 190   "IELM mode menu."
 191   '("IELM"
 192     ["Change Working Buffer" ielm-change-working-buffer t]
 193     ["Display Working Buffer" ielm-display-working-buffer t]
 194     ["Print Working Buffer" ielm-print-working-buffer t]))
 195
 196 (defvar ielm-font-lock-keywords
 197   '(("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)"
 198      (1 font-lock-comment-face)
 199      (2 font-lock-constant-face)))
 200   "Additional expressions to highlight in IELM buffers.")
 201
 202 ;;; Completion stuff
 203
 204 (defun ielm-tab ()
 205   "Indent or complete."
 206   (interactive)
 207   (if (or (eq (preceding-char) ?\n)
 208           (eq (char-syntax (preceding-char)) ?\s))
 209       (ielm-indent-line)
 210     (completion-at-point)))
 211
 212
 213 (defun ielm-complete-filename nil
 214   "Dynamically complete filename before point, if in a string."
 215   (when (nth 3 (parse-partial-sexp comint-last-input-start (point)))
 216     (comint-filename-completion)))
 217
 218 (defun ielm-indent-line nil
 219   "Indent the current line as Lisp code if it is not a prompt line."
 220   (when (save-excursion (comint-bol) (bolp))
 221     (lisp-indent-line)))
 222
 223 ;;; Working buffer manipulation
 224
 225 (defun ielm-print-working-buffer nil
 226   "Print the current IELM working buffer's name in the echo area."
 227   (interactive)
 228   (message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
 229
 230 (defun ielm-display-working-buffer nil
 231   "Display the current IELM working buffer.
 232 Don't forget that selecting that buffer will change its value of `point'
 233 to its value of `window-point'!"
 234   (interactive)
 235   (display-buffer ielm-working-buffer)
 236   (ielm-print-working-buffer))
 237
 238 (defun ielm-change-working-buffer (buf)
 239   "Change the current IELM working buffer to BUF.
 240 This is the buffer in which all sexps entered at the IELM prompt are
 241 evaluated.  You can achieve the same effect with a call to
 242 `set-buffer' at the IELM prompt."
 243   (interactive "bSet working buffer to: ")
 244   (let ((buffer (get-buffer buf)))
 245     (if (and buffer (buffer-live-p buffer))
 246         (setq ielm-working-buffer buffer)
 247       (error "No such buffer: %S" buf)))
 248   (ielm-print-working-buffer))
 249
 250 ;;; Other bindings
 251
 252 (defun ielm-return (&optional for-effect)
 253   "Newline and indent, or evaluate the sexp before the prompt.
 254 Complete sexps are evaluated; for incomplete sexps inserts a newline
 255 and indents.  If however `ielm-dynamic-return' is nil, this always
 256 simply inserts a newline."
 257   (interactive)
 258   (if ielm-dynamic-return
 259       (let ((state
 260              (save-excursion
 261                (end-of-line)
 262                (parse-partial-sexp (ielm-pm)
 263                                    (point)))))
 264         (if (and (< (car state) 1) (not (nth 3 state)))
 265             (ielm-send-input for-effect)
 266           (when (and ielm-dynamic-multiline-inputs
 267                      (save-excursion
 268                        (beginning-of-line)
 269                        (looking-at-p comint-prompt-regexp)))
 270             (save-excursion
 271               (goto-char (ielm-pm))
 272               (newline 1)))
 273           (newline-and-indent)))
 274     (newline)))
 275
 276 (defun ielm-return-for-effect ()
 277   "Like `ielm-return', but do not print the result."
 278   (interactive)
 279   (ielm-return t))
 280
 281 (defvar ielm-input)
 282
 283 (defun ielm-input-sender (_proc input)
 284   ;; Just sets the variable ielm-input, which is in the scope of
 285   ;; `ielm-send-input's call.
 286   (setq ielm-input input))
 287
 288 (defun ielm-send-input (&optional for-effect)
 289   "Evaluate the Emacs Lisp expression after the prompt."
 290   (interactive)
 291   (let (ielm-input)                     ; set by ielm-input-sender
 292     (comint-send-input)                 ; update history, markers etc.
 293     (ielm-eval-input ielm-input for-effect)))
 294
 295 ;;; Utility functions
 296
 297 (defun ielm-is-whitespace-or-comment (string)
 298   "Return non-nil if STRING is all whitespace or a comment."
 299   (or (string= string "")
 300       (string-match-p "\\`[ \t\n]*\\(?:;.*\\)*\\'" string)))
 301
 302 ;;; Evaluation
 303
 304 (defun ielm-standard-output-impl (process)
 305   "Return a function to use for `standard-output' while in ielm eval.
 306 The returned function takes one character as input.  Passing nil
 307 to this function instead of a character flushes the output
 308 buffer.  Passing t appends a terminating newline if the buffer is
 309 nonempty, then flushes the buffer."
 310   ;; Use an intermediate output buffer because doing redisplay for
 311   ;; each character we output is too expensive.  Set up a flush timer
 312   ;; so that users don't have to wait for whole lines to appear before
 313   ;; seeing output.
 314   (let* ((output-buffer nil)
 315          (flush-timer nil)
 316          (flush-buffer
 317           (lambda ()
 318             (comint-output-filter
 319              process
 320              (apply #'string (nreverse output-buffer)))
 321             (redisplay)
 322             (setf output-buffer nil)
 323             (when flush-timer
 324               (cancel-timer flush-timer)
 325               (setf flush-timer nil)))))
 326     (lambda (char)
 327       (let (flush-now)
 328         (cond ((and (eq char t) output-buffer)
 329                (push ?\n output-buffer)
 330                (setf flush-now t))
 331               ((characterp char)
 332                (push char output-buffer)))
 333         (if flush-now
 334             (funcall flush-buffer)
 335           (unless flush-timer
 336             (setf flush-timer (run-with-timer 0.1 nil flush-buffer))))))))
 337
 338 (defun ielm-eval-input (input-string &optional for-effect)
 339   "Evaluate the Lisp expression INPUT-STRING, and pretty-print the result."
 340   ;; This is the function that actually `sends' the input to the
 341   ;; `inferior Lisp process'. All comint-send-input does is works out
 342   ;; what that input is.  What this function does is evaluates that
 343   ;; input and produces `output' which gets inserted into the buffer,
 344   ;; along with a new prompt.  A better way of doing this might have
 345   ;; been to actually send the output to the `cat' process, and write
 346   ;; this as in output filter that converted sexps in the output
 347   ;; stream to their evaluated value.  But that would have involved
 348   ;; more process coordination than I was happy to deal with.
 349   (let ((string input-string)        ; input expression, as a string
 350         form                         ; form to evaluate
 351         pos                          ; End posn of parse in string
 352         result                       ; Result, or error message
 353         error-type                   ; string, nil if no error
 354         (output "")                  ; result to display
 355         (wbuf ielm-working-buffer)   ; current buffer after evaluation
 356         (pmark (ielm-pm)))
 357     (unless (ielm-is-whitespace-or-comment string)
 358       (condition-case err
 359           (let ((rout (read-from-string string)))
 360             (setq form (car rout)
 361                   pos (cdr rout)))
 362         (error (setq result (error-message-string err))
 363                (setq error-type "Read error")))
 364       (unless error-type
 365         ;; Make sure working buffer has not been killed
 366         (if (not (buffer-name ielm-working-buffer))
 367             (setq result "Working buffer has been killed"
 368                   error-type "IELM Error"
 369                   wbuf (current-buffer))
 370           (if (ielm-is-whitespace-or-comment (substring string pos))
 371               ;; To correctly handle the ielm-local variables *,
 372               ;; ** and ***, we need a temporary buffer to be
 373               ;; current at entry to the inner of the next two let
 374               ;; forms.  We need another temporary buffer to exit
 375               ;; that same let.  To avoid problems, neither of
 376               ;; these buffers should be alive during the
 377               ;; evaluation of form.
 378               (let* ((*1 *)
 379                      (*2 **)
 380                      (*3 ***)
 381                      (active-process (ielm-process))
 382                      (old-standard-output standard-output)
 383                      new-standard-output
 384                      ielm-temp-buffer)
 385                 (set-match-data ielm-match-data)
 386                 (save-excursion
 387                   (with-temp-buffer
 388                     (condition-case err
 389                         (unwind-protect
 390                             ;; The next let form creates default
 391                             ;; bindings for *, ** and ***.  But
 392                             ;; these default bindings are
 393                             ;; identical to the ielm-local
 394                             ;; bindings.  Hence, during the
 395                             ;; evaluation of form, the
 396                             ;; ielm-local values are going to be
 397                             ;; used in all buffers except for
 398                             ;; other ielm buffers, which override
 399                             ;; them.  Normally, the variables *1,
 400                             ;; *2 and *3 also have default
 401                             ;; bindings, which are not overridden.
 402                             (let ((* *1)
 403                                   (** *2)
 404                                   (*** *3))
 405                               (when (eq standard-output t)
 406                                 (setf new-standard-output
 407                                       (ielm-standard-output-impl
 408                                        active-process))
 409                                 (setf standard-output new-standard-output))
 410                               (kill-buffer (current-buffer))
 411                               (set-buffer wbuf)
 412                               (setq result
 413                                     (eval form lexical-binding))
 414                               (setq wbuf (current-buffer))
 415                               (setq
 416                                ielm-temp-buffer
 417                                (generate-new-buffer " *ielm-temp*"))
 418                               (set-buffer ielm-temp-buffer))
 419                           (when ielm-temp-buffer
 420                             (kill-buffer ielm-temp-buffer))
 421                           (when (eq new-standard-output standard-output)
 422                             (ignore-errors
 423                               (funcall standard-output t))
 424                             (setf standard-output old-standard-output)))
 425                       (error (setq result (error-message-string err))
 426                              (setq error-type "Eval error"))
 427                       (quit (setq result "Quit during evaluation")
 428                             (setq error-type "Eval error")))))
 429                 (setq ielm-match-data (match-data)))
 430             (setq error-type "IELM error")
 431             (setq result "More than one sexp in input"))))
 432
 433       ;; If the eval changed the current buffer, mention it here
 434       (unless (eq wbuf ielm-working-buffer)
 435         (message "current buffer is now: %s" wbuf)
 436         (setq ielm-working-buffer wbuf))
 437
 438       (goto-char pmark)
 439       (unless error-type
 440         (condition-case nil
 441             ;; Self-referential objects cause loops in the printer, so
 442             ;; trap quits here. May as well do errors, too
 443             (unless for-effect
 444               (setq output (concat output (pp-to-string result)
 445                                    (let ((str (eval-expression-print-format result)))
 446                                      (if str (propertize str 'font-lock-face 'shadow))))))
 447           (error (setq error-type "IELM Error")
 448                  (setq result "Error during pretty-printing (bug in pp)"))
 449           (quit  (setq error-type "IELM Error")
 450                  (setq result "Quit during pretty-printing"))))
 451       (if error-type
 452           (progn
 453             (when ielm-noisy (ding))
 454             (setq output (concat output "*** " error-type " ***  "))
 455             (setq output (concat output result)))
 456         ;; There was no error, so shift the *** values
 457         (setq *** **)
 458         (setq ** *)
 459         (setq * result))
 460       (when (or (not for-effect) (not (equal output "")))
 461         (setq output (concat output "\n"))))
 462     (setq output (concat output ielm-prompt-internal))
 463     (comint-output-filter (ielm-process) output)))
 464
 465 ;;; Process and marker utilities
 466
 467 (defun ielm-process nil
 468   ;; Return the current buffer's process.
 469   (get-buffer-process (current-buffer)))
 470
 471 (defun ielm-pm nil
 472   ;; Return the process mark of the current buffer.
 473   (process-mark (get-buffer-process (current-buffer))))
 474
 475 (defun ielm-set-pm (pos)
 476   ;; Set the process mark in the current buffer to POS.
 477   (set-marker (process-mark (get-buffer-process (current-buffer))) pos))
 478
 479 ;;; Major mode
 480
 481 (define-derived-mode inferior-emacs-lisp-mode comint-mode "IELM"
 482   "Major mode for interactively evaluating Emacs Lisp expressions.
 483 Uses the interface provided by `comint-mode' (which see).
 484
 485 * \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt.  There must be at most
 486   one top level sexp per prompt.
 487
 488 * \\[ielm-return] inserts a newline and indents, or evaluates a
 489   complete expression (but see variable `ielm-dynamic-return').
 490   Inputs longer than one line are moved to the line following the
 491   prompt (but see variable `ielm-dynamic-multiline-inputs').
 492
 493 * \\[ielm-return-for-effect] works like `ielm-return', except
 494   that it doesn't print the result of evaluating the input.  This
 495   functionality is useful when forms would generate voluminous
 496   output.
 497
 498 * \\[completion-at-point] completes Lisp symbols (or filenames, within strings),
 499   or indents the line if there is nothing to complete.
 500
 501 The current working buffer may be changed (with a call to `set-buffer',
 502 or with \\[ielm-change-working-buffer]), and its value is preserved between successive
 503 evaluations.  In this way, expressions may be evaluated in a different
 504 buffer than the *ielm* buffer.  By default, its name is shown on the
 505 mode line; you can always display it with \\[ielm-print-working-buffer], or the buffer itself
 506 with \\[ielm-display-working-buffer].
 507
 508 During evaluations, the values of the variables `*', `**', and `***'
 509 are the results of the previous, second previous and third previous
 510 evaluations respectively.  If the working buffer is another IELM
 511 buffer, then the values in the working buffer are used.  The variables
 512 `*1', `*2' and `*3', yield the process buffer values.
 513
 514 If, at the start of evaluation, `standard-output' is t (the
 515 default), `standard-output' is set to a special function that
 516 causes output to be directed to the ielm buffer.
 517 `standard-output' is restored after evaluation unless explicitly
 518 set to a different value during evaluation.  You can use (princ
 519 VALUE) or (pp VALUE) to write to the ielm buffer.
 520
 521 Expressions evaluated by IELM are not subject to `debug-on-quit' or
 522 `debug-on-error'.
 523
 524 The behavior of IELM may be customized with the following variables:
 525 * To stop beeping on error, set `ielm-noisy' to nil.
 526 * If you don't like the prompt, you can change it by setting `ielm-prompt'.
 527 * If you do not like that the prompt is (by default) read-only, set
 528   `ielm-prompt-read-only' to nil.
 529 * Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'.
 530 * Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
 531  (in that order).
 532
 533 Customized bindings may be defined in `ielm-map', which currently contains:
 534 \\{ielm-map}"
 535   :syntax-table emacs-lisp-mode-syntax-table
 536
 537   (setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
 538   (set (make-local-variable 'paragraph-separate) "\\'")
 539   (set (make-local-variable 'paragraph-start) comint-prompt-regexp)
 540   (setq comint-input-sender 'ielm-input-sender)
 541   (setq comint-process-echoes nil)
 542   (set (make-local-variable 'completion-at-point-functions)
 543        '(comint-replace-by-expanded-history
 544          ielm-complete-filename elisp-completion-at-point))
 545   (add-function :before-until (local 'eldoc-documentation-function)
 546                 #'elisp-eldoc-documentation-function)
 547   (set (make-local-variable 'ielm-prompt-internal) ielm-prompt)
 548   (set (make-local-variable 'comint-prompt-read-only) ielm-prompt-read-only)
 549   (setq comint-get-old-input 'ielm-get-old-input)
 550   (set (make-local-variable 'comint-completion-addsuffix) '("/" . ""))
 551   (setq mode-line-process '(":%s on " (:eval (buffer-name ielm-working-buffer))))
 552   ;; Useful for `hs-minor-mode'.
 553   (setq-local comment-start ";")
 554   (setq-local comment-use-syntax t)
 555
 556   (set (make-local-variable 'indent-line-function) 'ielm-indent-line)
 557   (set (make-local-variable 'ielm-working-buffer) (current-buffer))
 558   (set (make-local-variable 'fill-paragraph-function) 'lisp-fill-paragraph)
 559
 560   ;; Value holders
 561   (set (make-local-variable '*) nil)
 562   (set (make-local-variable '**) nil)
 563   (set (make-local-variable '***) nil)
 564   (set (make-local-variable 'ielm-match-data) nil)
 565
 566   ;; font-lock support
 567   (set (make-local-variable 'font-lock-defaults)
 568        '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
 569
 570   ;; A dummy process to keep comint happy. It will never get any input
 571   (unless (comint-check-proc (current-buffer))
 572     ;; Was cat, but on non-Unix platforms that might not exist, so
 573     ;; use hexl instead, which is part of the Emacs distribution.
 574     (condition-case nil
 575         (start-process "ielm" (current-buffer) "hexl")
 576       (file-error (start-process "ielm" (current-buffer) "cat")))
 577     (set-process-query-on-exit-flag (ielm-process) nil)
 578     (goto-char (point-max))
 579
 580     ;; Lisp output can include raw characters that confuse comint's
 581     ;; carriage control code.
 582     (set (make-local-variable 'comint-inhibit-carriage-motion) t)
 583
 584     ;; Add a silly header
 585     (insert ielm-header)
 586     (ielm-set-pm (point-max))
 587     (unless comint-use-prompt-regexp
 588       (let ((inhibit-read-only t))
 589         (add-text-properties
 590          (point-min) (point-max)
 591          '(rear-nonsticky t field output inhibit-line-move-field-capture t))))
 592     (comint-output-filter (ielm-process) ielm-prompt-internal)
 593     (set-marker comint-last-input-start (ielm-pm))
 594     (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter)))
 595
 596 (defun ielm-get-old-input nil
 597   ;; Return the previous input surrounding point
 598   (save-excursion
 599     (beginning-of-line)
 600     (unless (looking-at-p comint-prompt-regexp)
 601       (re-search-backward comint-prompt-regexp))
 602     (comint-skip-prompt)
 603     (buffer-substring (point) (progn (forward-sexp 1) (point)))))
 604
 605 ;;; User command
 606
 607 ;;;###autoload
 608 (defun ielm nil
 609   "Interactively evaluate Emacs Lisp expressions.
 610 Switches to the buffer `*ielm*', or creates it if it does not exist.
 611 See `inferior-emacs-lisp-mode' for details."
 612   (interactive)
 613   (let (old-point)
 614     (unless (comint-check-proc "*ielm*")
 615       (with-current-buffer (get-buffer-create "*ielm*")
 616         (unless (zerop (buffer-size)) (setq old-point (point)))
 617         (inferior-emacs-lisp-mode)))
 618     (switch-to-buffer "*ielm*")
 619     (when old-point (push-mark old-point))))
 620
 621 (provide 'ielm)
 622
 623 ;;; ielm.el ends here