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