lisp/ielm.el

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