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