lisp/ielm.el

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