lisp/ielm.el

   1 ;;; ielm.el --- interaction mode for Emacs Lisp
   2 ;; Copyright (C) 1994 Free Software Foundation, Inc.
   3
   4 ;; Author: David Smith <maa036@lancaster.ac.uk>
   5 ;; Created: 25 Feb 1994
   6 ;; Keywords: lisp
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to
  22 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24 ;;; Commentary:
  25
  26 ;; Provides a nice interface to evaluating Emacs Lisp expressions.
  27 ;; Input is handled by the comint package, and output is passed
  28 ;; through the pretty-printer.
  29
  30 ;; To install: copy this file to a directory in your load-path, and
  31 ;; add the following line to your .emacs file:
  32 ;;
  33 ;;   (autoload 'ielm "ielm" "Start an inferior Emacs Lisp session" t)
  34 ;;
  35 ;; For completion to work, the comint.el from FSF Emacs 19.23 is
  36 ;; required.  If you do not have it, or if you are running Lemacs,
  37 ;; also add the following code to your .emacs:
  38 ;;
  39 ;;    (setq ielm-mode-hook
  40 ;;          '(lambda nil
  41 ;;               (define-key ielm-map "\t"
  42 ;;                  '(lambda nil (interactive) (or (ielm-tab)
  43 ;;                                                 (lisp-complete-symbol))))))
  44
  45 ;; To start: M-x ielm.  Type C-h m in the *ielm* buffer for more info.
  46
  47 ;; The latest version is available by WWW from
  48 ;;      http://mathssun5.lancs.ac.uk:2080/~maa036/elisp/dir.html
  49 ;; or by anonymous FTP from
  50 ;;      /anonymous@wingra.stat.wisc.edu:pub/src/emacs-lisp/ielm.el.gz
  51 ;; or from the author: David M. Smith <maa036@lancaster.ac.uk>
  52
  53 ;;; Code:
  54
  55 (require 'comint)
  56 (require 'pp)
  57
  58 ;;; User variables
  59
  60 (defvar ielm-noisy t
  61   "*If non-nil, IELM will beep on error.")
  62
  63 (defvar ielm-prompt "ELISP> "
  64   "Prompt used in IELM.")
  65
  66 (defvar ielm-dynamic-return t
  67   "*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behaviour in IELM.
  68 If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
  69 and indents for incomplete sexps.  If nil, always inserts newlines.")
  70
  71 (defvar ielm-dynamic-multiline-inputs t
  72   "*Force multiline inputs to start from column zero?
  73 If non-nil, after entering the first line of an incomplete sexp, a newline
  74 will be inserted after the prompt, moving the input to the next line.
  75 This gives more frame width for large indented sexps, and allows functions
  76 such as `edebug-defun' to work with such inputs.")
  77
  78 (defvar ielm-mode-hook nil
  79   "*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started.")
  80
  81 ;;; System variables
  82
  83 (defvar ielm-working-buffer nil
  84   "Buffer in which IELM sexps will be evaluated.
  85 This variable is buffer-local.")
  86
  87 (defvar ielm-header
  88   (concat
  89    "*** Welcome to IELM version "
  90    (substring "$Revision: 1.4 $" 11 -2)
  91    " ***  Type (describe-mode) for help.\n"
  92    "IELM has ABSOLUTELY NO WARRANTY; type (describe-no-warranty) for details.\n")
  93   "Message to display when IELM is started.")
  94
  95 (defvar ielm-map nil)
  96 (if ielm-map nil
  97   (if (string-match "Lucid" emacs-version)
  98       ;; Lemacs
  99       (progn
 100         (setq ielm-map (make-sparse-keymap))
 101         (set-keymap-parent ielm-map comint-mode-map))
 102     ;; FSF
 103     (setq ielm-map (cons 'keymap comint-mode-map)))
 104   (define-key ielm-map "\t" 'comint-dynamic-complete)
 105   (define-key ielm-map "\C-m" 'ielm-return)
 106   (define-key ielm-map "\C-j" 'ielm-send-input)
 107   (define-key ielm-map "\e\C-x" 'eval-defun)         ; for consistency with
 108   (define-key ielm-map "\e\t" 'lisp-complete-symbol) ; lisp-interaction-mode
 109   ;; These bindings are from shared-lisp-mode-map -- can you inherit
 110   ;; from more than one keymap??
 111   (define-key ielm-map "\e\C-q" 'indent-sexp)
 112   (define-key ielm-map "\eq" 'lisp-fill-paragraph)
 113   (define-key ielm-map "\177" 'backward-delete-char-untabify)
 114   ;; Some convenience bindings for setting the working buffer
 115   (define-key ielm-map "\C-c\C-b" 'ielm-change-working-buffer)
 116   (define-key ielm-map "\C-c\C-f" 'ielm-display-working-buffer)
 117   (define-key ielm-map "\C-c\C-v" 'ielm-print-working-buffer))
 118
 119 (defvar ielm-font-lock-keywords
 120   (list
 121    (cons (concat "^" (regexp-quote ielm-prompt)) 'font-lock-keyword-face)
 122    '("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)" (1 font-lock-comment-face) (2 font-lock-reference-face)))
 123   "Additional expressions to highlight in ielm buffers.")
 124
 125 ;;; Completion stuff
 126
 127 (defun ielm-tab nil
 128   "Possibly indent the current line as lisp code."
 129   (interactive)
 130   (if (or (eq (preceding-char) ?\n)
 131           (eq (char-syntax (preceding-char)) ? ))
 132       (progn
 133         (ielm-indent-line)
 134         t)))
 135
 136 (defun ielm-complete-symbol nil
 137   "Complete the lisp symbol before point."
 138   ;; A wrapper for lisp-complete symbol that returns non-nil if
 139   ;; completion has occurred
 140   (let* ((btick (buffer-modified-tick))
 141          (cbuffer (get-buffer "*Completions*"))
 142          (ctick (and cbuffer (buffer-modified-tick cbuffer))))
 143     (lisp-complete-symbol)
 144      ;; completion has occurred if:
 145     (or
 146      ;; the buffer has been modified
 147      (not (= btick (buffer-modified-tick)))
 148      ;; a completions buffer has been modifed or created
 149      (if cbuffer
 150          (not (= ctick (buffer-modified-tick cbuffer)))
 151        (get-buffer "*Completions*")))))
 152
 153 (defun ielm-complete-filename nil
 154   "Dynamically complete filename before point, if in a string."
 155   (if (nth 3 (parse-partial-sexp comint-last-input-start (point)))
 156       (comint-dynamic-complete-filename)))
 157
 158 (defun ielm-indent-line nil
 159   "Indent the current line as Lisp code if it is not a prompt line."
 160   (if (save-excursion
 161         (beginning-of-line)
 162         (looking-at comint-prompt-regexp)) nil
 163     (lisp-indent-line)))
 164
 165 ;;; Working buffer manipulation
 166
 167 (defun ielm-print-working-buffer nil
 168   "Print the current IELM working buffer's name in the echo area."
 169   (interactive)
 170   (message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
 171
 172 (defun ielm-display-working-buffer nil
 173   "Display the current IELM working buffer.
 174 Don't forget that selecting that buffer will change its value of `point'
 175 to its value of `window-point'!"
 176   (interactive)
 177   (display-buffer ielm-working-buffer)
 178   (ielm-print-working-buffer))
 179
 180 (defun ielm-change-working-buffer (buf)
 181   "Change the current IELM working buffer to BUF.
 182 This is the buffer in which all sexps entered at the IELM prompt are
 183 evaluated.  You can achieve the same effect with a call to
 184 `set-buffer' at the IELM prompt."
 185   (interactive "bSet working buffer to: ")
 186   (setq ielm-working-buffer (or (get-buffer buf) (error "No such buffer")))
 187   (ielm-print-working-buffer))
 188
 189 ;;; Other bindings
 190
 191 (defun ielm-return nil
 192   "Newline and indent, or evaluate the sexp before the prompt.
 193 Complete sexps are evaluated; for incomplete sexps inserts a newline
 194 and indents.  If however `ielm-dynamic-return' is nil, this always
 195 simply inserts a newline."
 196   (interactive)
 197   (if ielm-dynamic-return
 198       (let ((state
 199              (save-excursion
 200                (end-of-line)
 201                (parse-partial-sexp (ielm-pm)
 202                                    (point)))))
 203         (if (and (< (car state) 1) (not (nth 3 state)))
 204             (ielm-send-input)
 205           (if (and ielm-dynamic-multiline-inputs
 206                    (save-excursion
 207                      (beginning-of-line)
 208                      (looking-at comint-prompt-regexp)))
 209               (save-excursion
 210                 (goto-char (ielm-pm))
 211                 (newline 1)))
 212           (newline-and-indent)))
 213     (newline)))
 214
 215 (defun ielm-input-sender (proc input)
 216   ;; Just sets the variable ielm-input, which is in the scope of
 217   ;; `ielm-send-input's call.
 218   (setq ielm-input input))
 219
 220 (defun ielm-send-input nil
 221   "Evaluate the Emacs Lisp expression after the prompt."
 222   (interactive)
 223   (let ((buf (current-buffer))
 224         ielm-input)                     ; set by ielm-input-sender
 225     (comint-send-input)                 ; update history, markers etc.
 226     (ielm-eval-input ielm-input)))
 227
 228 ;;; Utility functions
 229
 230 (defun ielm-is-whitespace (string)
 231   "Return non-nil if STRING is all whitespace."
 232   (or (string= string "") (string-match "\\`[ \t\n]+\\'" string)))
 233
 234 (defun ielm-format-errors (errlist)
 235   (let ((result ""))
 236     (while errlist
 237       (setq result (concat result (prin1-to-string (car errlist)) ", "))
 238       (setq errlist (cdr errlist)))
 239     (substring result 0 -2)))
 240
 241
 242 (defun ielm-format-error (err)
 243   ;; Return a string form of the error ERR.
 244   (format "%s%s"
 245           (or (get (car err) 'error-message) "Peculiar error")
 246           (if (cdr err)
 247               (format ": %s" (ielm-format-errors (cdr err)))
 248             "")))
 249
 250 ;;; Evaluation
 251
 252 (defun ielm-eval-input (ielm-string)
 253   "Evaluate the Lisp expression IELM-STRING, and pretty-print the result."
 254   ;; This is the function that actually `sends' the input to the
 255   ;; `inferior Lisp process'. All comint-send-input does is works out
 256   ;; what that input is.  What this function does is evaluates that
 257   ;; input and produces `output' which gets inserted into the buffer,
 258   ;; along with a new prompt.  A better way of doing this might have
 259   ;; been to actually send the output to the `cat' process, and write
 260   ;; this as in output filter that converted sexps in the output
 261   ;; stream to their evaluated value.  But that would have involved
 262   ;; more process coordination than I was happy to deal with.
 263   ;;
 264   ;; NOTE: all temporary variables in this function will be in scope
 265   ;; during the eval, and so need to have non-clashing names.
 266   (let (ielm-form                       ; form to evaluate
 267         ielm-pos                        ; End posn of parse in string
 268         ielm-result                     ; Result, or error message
 269         ielm-error-type                 ; string, nil if no error
 270         (ielm-output    "")             ; result to display
 271         (ielm-wbuf ielm-working-buffer) ; current buffer after evaluation
 272         (ielm-pmark (ielm-pm)))
 273     (if (not (ielm-is-whitespace ielm-string))
 274         (progn
 275           (condition-case err
 276               (let (rout)
 277                 (setq rout (read-from-string ielm-string))
 278                 (setq ielm-form (car rout))
 279                 (setq ielm-pos (cdr rout)))
 280             (error (setq ielm-result (ielm-format-error err))
 281                    (setq ielm-error-type "Read error")))
 282           (if ielm-error-type nil
 283             ;; Make sure working buffer has not been killed
 284             (if (not (buffer-name ielm-working-buffer))
 285                 (setq ielm-result "Working buffer has been killed"
 286                       ielm-error-type "IELM Error"
 287                       ielm-wbuf (current-buffer))
 288               (if (ielm-is-whitespace (substring ielm-string ielm-pos))
 289                   ;; need this awful let convolution to work around
 290                   ;; an Emacs bug involving local vbls and let binding
 291                   (let ((:save :)
 292                         (::save ::)
 293                         (:::save :::))
 294                     (save-excursion
 295                       (set-buffer ielm-working-buffer)
 296                       (condition-case err
 297                           (let ((: :save)
 298                                 (:: ::save)
 299                                 (::: :::save)
 300                                 (ielm-obuf (current-buffer)))
 301                             (setq ielm-result (eval ielm-form))
 302                             (setq ielm-wbuf (current-buffer))
 303                             ;; The eval may have changed current-buffer;
 304                             ;; need to set it back here to avoid a bug
 305                             ;; in let.  Don't want to use save-excursion
 306                             ;; because we want to allow changes in point.
 307                             (set-buffer ielm-obuf))
 308                         (error (setq ielm-result (ielm-format-error err))
 309                                (setq ielm-error-type "Eval error"))
 310                         (quit (setq ielm-result "Quit during evaluation")
 311                               (setq ielm-error-type "Eval error")))))
 312                 (setq ielm-error-type "IELM error")
 313                 (setq ielm-result "More than one sexp in input"))))
 314
 315           ;; If the eval changed the current buffer, mention it here
 316           (if (eq ielm-wbuf ielm-working-buffer) nil
 317             (message "current buffer is now: %s" ielm-wbuf)
 318             (setq ielm-working-buffer ielm-wbuf))
 319
 320           (goto-char ielm-pmark)
 321           (if (not ielm-error-type)
 322               (condition-case err
 323                   ;; Self-referential objects cause loops in the printer, so
 324                   ;; trap quits here. May as well do errors, too
 325                   (setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
 326                 (error (setq ielm-error-type "IELM Error")
 327                        (setq ielm-result  "Error during pretty-printing (bug in pp)"))
 328                 (quit  (setq ielm-error-type "IELM Error")
 329                        (setq ielm-result "Quit during pretty-printing"))))
 330           (if ielm-error-type
 331               (progn
 332                 (if ielm-noisy (ding))
 333                 (setq ielm-output (concat ielm-output "*** " ielm-error-type " ***  "))
 334                 (setq ielm-output (concat ielm-output ielm-result)))
 335             ;; There was no error, so shift the ::: values
 336             (setq ::: ::)
 337             (setq :: :)
 338             (setq : ielm-result))
 339           (setq ielm-output (concat ielm-output "\n"))))
 340     (setq ielm-output (concat ielm-output ielm-prompt))
 341     (comint-output-filter (ielm-process) ielm-output)))
 342
 343 ;;; Process and marker utilities
 344
 345 (defun ielm-process nil
 346   ;; Return the current buffer's process.
 347   (get-buffer-process (current-buffer)))
 348
 349 (defun ielm-pm nil
 350   ;; Return the process mark of the current buffer.
 351   (process-mark (get-buffer-process (current-buffer))))
 352
 353 (defun ielm-set-pm (pos)
 354   ;; Set the process mark in the current buffer to POS.
 355   (set-marker (process-mark (get-buffer-process (current-buffer))) pos))
 356
 357 ;;; Major mode
 358
 359 (defun inferior-emacs-lisp-mode nil
 360   "Major mode for interactively evaluating Emacs Lisp expressions.
 361 Uses the interface provided by `comint-mode' (which see).
 362
 363 * \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
 364   one top-level sexp per prompt.
 365
 366 * \\[ielm-return] inserts a newline and indents, or evaluates a
 367   complete expression (but see variable `ielm-dynamic-return').
 368   Inputs longer than one line are moved to the line following the
 369   prompt (but see variable `ielm-dynamic-multiline-inputs').
 370
 371 * \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
 372   or indents the line if there is nothing to complete.
 373
 374 During evaluations, the values of the variables `:', `::', and `:::'
 375 are the results of the previous, second previous and third previous
 376 evaluations respectively.
 377
 378 The current working buffer may be changed (with a call to
 379 `set-buffer', or with \\[ielm-change-working-buffer]), and its value
 380 is preserved between successive evaluations.  In this way, expressions
 381 may be evaluated in a different buffer than the *ielm* buffer.
 382 Display the name of the working buffer with \\[ielm-print-working-buffer],
 383 or the buffer itself with \\[ielm-display-working-buffer].
 384
 385 Expressions evaluated by IELM are not subject to `debug-on-quit' or
 386 `debug-on-error'.
 387
 388 The behaviour of IELM may be customised with the following variables:
 389 * To stop beeping on error, set `ielm-noisy' to nil
 390 * If you don't like the prompt, you can change it by setting `ielm-prompt'.
 391 * Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'
 392 * Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
 393  (in that order).
 394
 395 Customised bindings may be defined in `ielm-map', which currently contains:
 396 \\{ielm-map}"
 397   (interactive)
 398   (comint-mode)
 399   (setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
 400   (make-local-variable 'paragraph-start)
 401   (setq paragraph-start comint-prompt-regexp)
 402   (setq comint-input-sender 'ielm-input-sender)
 403   (setq comint-process-echoes nil)
 404   (setq comint-dynamic-complete-functions
 405         '(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol))
 406   (setq comint-get-old-input 'ielm-get-old-input)
 407
 408   (setq major-mode 'inferior-emacs-lisp-mode)
 409   (setq mode-name "IELM")
 410   (use-local-map ielm-map)
 411   (set-syntax-table emacs-lisp-mode-syntax-table)
 412
 413   (make-local-variable 'indent-line-function)
 414   (make-local-variable 'ielm-working-buffer)
 415   (setq ielm-working-buffer (current-buffer))
 416   (setq indent-line-function 'ielm-indent-line)
 417
 418   ;; Value holders
 419   (setq : nil)
 420   (make-local-variable ':)
 421   (setq :: nil)
 422   (make-local-variable '::)
 423   (setq ::: nil)
 424   (make-local-variable ':::)
 425
 426   ;; font-lock support
 427   (make-local-variable 'font-lock-defaults)
 428   (setq font-lock-defaults
 429         '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
 430
 431   ;; A dummy process to keep comint happy. It will never get any input
 432   (if (comint-check-proc (current-buffer)) nil
 433     (start-process "ielm" (current-buffer) "cat")
 434     (process-kill-without-query (ielm-process))
 435     (goto-char (point-max))
 436     ;; Add a silly header
 437     (insert ielm-header)
 438     (ielm-set-pm (point-max))
 439     (comint-output-filter (ielm-process) ielm-prompt)
 440     (set-marker comint-last-input-start (ielm-pm))
 441     (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
 442   (run-hooks 'ielm-mode-hook))
 443
 444 (defun ielm-get-old-input nil
 445   ;; Return the previous input surrounding point
 446   (save-excursion
 447     (beginning-of-line)
 448     (if (looking-at comint-prompt-regexp) nil
 449       (re-search-backward comint-prompt-regexp))
 450     (comint-skip-prompt)
 451     (buffer-substring (point) (progn (forward-sexp 1) (point)))))
 452
 453 ;;; User command
 454
 455 ;;;###autoload (add-hook 'same-window-buffer-names "*ielm*")
 456
 457 ;;;###autoload
 458 (defun ielm nil
 459   "Interactively evaluate Emacs Lisp expressions.
 460 Switches to the buffer `*ielm*', or creates it if it does not exist."
 461   (interactive)
 462   (if (comint-check-proc "*ielm*")
 463       nil
 464     (save-excursion
 465       (set-buffer (get-buffer-create "*ielm*"))
 466       (inferior-emacs-lisp-mode)))
 467   (pop-to-buffer "*ielm*"))
 468
 469 ;;; ielm.el ends here