code.delx.au - gnu-emacs/blob - lisp/ielm.el

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