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