(require 'comint)
(require 'pp)
(defgroup ielm nil
"Interaction mode for Emacs Lisp."
:group 'lisp)
(defcustom ielm-noisy t
"*If non-nil, IELM will beep on error."
:type 'boolean
:group 'ielm)
(defvar ielm-prompt "ELISP> "
"Prompt used in IELM.")
(defcustom ielm-dynamic-return t
"*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behaviour in IELM.
If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
and indents for incomplete sexps. If nil, always inserts newlines."
:type 'boolean
:group 'ielm)
(defcustom ielm-dynamic-multiline-inputs t
"*Force multiline inputs to start from column zero?
If non-nil, after entering the first line of an incomplete sexp, a newline
will be inserted after the prompt, moving the input to the next line.
This gives more frame width for large indented sexps, and allows functions
such as `edebug-defun' to work with such inputs."
:type 'boolean
:group 'ielm)
(defcustom ielm-mode-hook nil
"*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
:type 'hook
:group 'ielm)
(defvar * nil
"Most recent value evaluated in IELM.")
(defvar ** nil
"Second-most-recent value evaluated in IELM.")
(defvar *** nil
"Third-most-recent value evaluated in IELM.")
(defvar ielm-working-buffer nil
"Buffer in which IELM sexps will be evaluated.
This variable is buffer-local.")
(defvar ielm-header
"*** Welcome to IELM *** Type (describe-mode) for help.\n"
"Message to display when IELM is started.")
(defvar ielm-map nil)
(if ielm-map nil
(if (string-match "Lucid" emacs-version)
(progn
(setq ielm-map (make-sparse-keymap))
(set-keymap-parent ielm-map comint-mode-map))
(setq ielm-map (cons 'keymap comint-mode-map)))
(define-key ielm-map "\t" 'comint-dynamic-complete)
(define-key ielm-map "\C-m" 'ielm-return)
(define-key ielm-map "\C-j" 'ielm-send-input)
(define-key ielm-map "\e\C-x" 'eval-defun) (define-key ielm-map "\e\t" 'lisp-complete-symbol) (define-key ielm-map "\e\C-q" 'indent-sexp)
(define-key ielm-map "\177" 'backward-delete-char-untabify)
(define-key ielm-map "\C-c\C-b" 'ielm-change-working-buffer)
(define-key ielm-map "\C-c\C-f" 'ielm-display-working-buffer)
(define-key ielm-map "\C-c\C-v" 'ielm-print-working-buffer))
(defvar ielm-font-lock-keywords
(list
(cons (concat "^" (regexp-quote ielm-prompt)) 'font-lock-keyword-face)
'("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)"
(1 font-lock-comment-face)
(2 font-lock-constant-face)))
"Additional expressions to highlight in ielm buffers.")
(defun ielm-tab nil
"Possibly indent the current line as lisp code."
(interactive)
(if (or (eq (preceding-char) ?\n)
(eq (char-syntax (preceding-char)) ? ))
(progn
(ielm-indent-line)
t)))
(defun ielm-complete-symbol nil
"Complete the lisp symbol before point."
(let* ((btick (buffer-modified-tick))
(cbuffer (get-buffer "*Completions*"))
(ctick (and cbuffer (buffer-modified-tick cbuffer))))
(lisp-complete-symbol)
(or
(not (= btick (buffer-modified-tick)))
(if cbuffer
(not (= ctick (buffer-modified-tick cbuffer)))
(get-buffer "*Completions*")))))
(defun ielm-complete-filename nil
"Dynamically complete filename before point, if in a string."
(if (nth 3 (parse-partial-sexp comint-last-input-start (point)))
(comint-dynamic-complete-filename)))
(defun ielm-indent-line nil
"Indent the current line as Lisp code if it is not a prompt line."
(when (save-excursion (comint-bol) (bolp))
(lisp-indent-line)))
(defun ielm-print-working-buffer nil
"Print the current IELM working buffer's name in the echo area."
(interactive)
(message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
(defun ielm-display-working-buffer nil
"Display the current IELM working buffer.
Don't forget that selecting that buffer will change its value of `point'
to its value of `window-point'!"
(interactive)
(display-buffer ielm-working-buffer)
(ielm-print-working-buffer))
(defun ielm-change-working-buffer (buf)
"Change the current IELM working buffer to BUF.
This is the buffer in which all sexps entered at the IELM prompt are
evaluated. You can achieve the same effect with a call to
`set-buffer' at the IELM prompt."
(interactive "bSet working buffer to: ")
(setq ielm-working-buffer (or (get-buffer buf) (error "No such buffer")))
(ielm-print-working-buffer))
(defun ielm-return nil
"Newline and indent, or evaluate the sexp before the prompt.
Complete sexps are evaluated; for incomplete sexps inserts a newline
and indents. If however `ielm-dynamic-return' is nil, this always
simply inserts a newline."
(interactive)
(if ielm-dynamic-return
(let ((state
(save-excursion
(end-of-line)
(parse-partial-sexp (ielm-pm)
(point)))))
(if (and (< (car state) 1) (not (nth 3 state)))
(ielm-send-input)
(if (and ielm-dynamic-multiline-inputs
(save-excursion
(beginning-of-line)
(looking-at comint-prompt-regexp)))
(save-excursion
(goto-char (ielm-pm))
(newline 1)))
(newline-and-indent)))
(newline)))
(defvar ielm-input)
(defun ielm-input-sender (proc input)
(setq ielm-input input))
(defun ielm-send-input nil
"Evaluate the Emacs Lisp expression after the prompt."
(interactive)
(let ((buf (current-buffer))
ielm-input) (comint-send-input) (ielm-eval-input ielm-input)))
(defun ielm-is-whitespace (string)
"Return non-nil if STRING is all whitespace."
(or (string= string "") (string-match "\\`[ \t\n]+\\'" string)))
(defun ielm-format-errors (errlist)
(let ((result ""))
(while errlist
(setq result (concat result (prin1-to-string (car errlist)) ", "))
(setq errlist (cdr errlist)))
(substring result 0 -2)))
(defun ielm-format-error (err)
(format "%s%s"
(or (get (car err) 'error-message) "Peculiar error")
(if (cdr err)
(format ": %s" (ielm-format-errors (cdr err)))
"")))
(defun ielm-eval-input (ielm-string)
"Evaluate the Lisp expression IELM-STRING, and pretty-print the result."
(let (ielm-form ielm-pos ielm-result ielm-error-type (ielm-output "") (ielm-wbuf ielm-working-buffer) (ielm-pmark (ielm-pm)))
(if (not (ielm-is-whitespace ielm-string))
(progn
(condition-case err
(let (rout)
(setq rout (read-from-string ielm-string))
(setq ielm-form (car rout))
(setq ielm-pos (cdr rout)))
(error (setq ielm-result (ielm-format-error err))
(setq ielm-error-type "Read error")))
(if ielm-error-type nil
(if (not (buffer-name ielm-working-buffer))
(setq ielm-result "Working buffer has been killed"
ielm-error-type "IELM Error"
ielm-wbuf (current-buffer))
(if (ielm-is-whitespace (substring ielm-string ielm-pos))
(let ((*save *)
(**save **)
(***save ***))
(save-excursion
(set-buffer ielm-working-buffer)
(condition-case err
(let ((* *save)
(** **save)
(*** ***save)
(ielm-obuf (current-buffer)))
(setq ielm-result (eval ielm-form))
(setq ielm-wbuf (current-buffer))
(set-buffer ielm-obuf))
(error (setq ielm-result (ielm-format-error err))
(setq ielm-error-type "Eval error"))
(quit (setq ielm-result "Quit during evaluation")
(setq ielm-error-type "Eval error")))))
(setq ielm-error-type "IELM error")
(setq ielm-result "More than one sexp in input"))))
(if (eq ielm-wbuf ielm-working-buffer) nil
(message "current buffer is now: %s" ielm-wbuf)
(setq ielm-working-buffer ielm-wbuf))
(goto-char ielm-pmark)
(if (not ielm-error-type)
(condition-case err
(setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
(error (setq ielm-error-type "IELM Error")
(setq ielm-result "Error during pretty-printing (bug in pp)"))
(quit (setq ielm-error-type "IELM Error")
(setq ielm-result "Quit during pretty-printing"))))
(if ielm-error-type
(progn
(if ielm-noisy (ding))
(setq ielm-output (concat ielm-output "*** " ielm-error-type " *** "))
(setq ielm-output (concat ielm-output ielm-result)))
(setq *** **)
(setq ** *)
(setq * ielm-result))
(setq ielm-output (concat ielm-output "\n"))))
(setq ielm-output (concat ielm-output ielm-prompt))
(comint-output-filter (ielm-process) ielm-output)))
(defun ielm-process nil
(get-buffer-process (current-buffer)))
(defun ielm-pm nil
(process-mark (get-buffer-process (current-buffer))))
(defun ielm-set-pm (pos)
(set-marker (process-mark (get-buffer-process (current-buffer))) pos))
(put 'inferior-emacs-lisp-mode 'mode-class 'special)
(defun inferior-emacs-lisp-mode nil
"Major mode for interactively evaluating Emacs Lisp expressions.
Uses the interface provided by `comint-mode' (which see).
* \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
one top-level sexp per prompt.
* \\[ielm-return] inserts a newline and indents, or evaluates a
complete expression (but see variable `ielm-dynamic-return').
Inputs longer than one line are moved to the line following the
prompt (but see variable `ielm-dynamic-multiline-inputs').
* \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
or indents the line if there is nothing to complete.
During evaluations, the values of the variables `*', `**', and `***'
are the results of the previous, second previous and third previous
evaluations respectively.
The current working buffer may be changed (with a call to
`set-buffer', or with \\[ielm-change-working-buffer]), and its value
is preserved between successive evaluations. In this way, expressions
may be evaluated in a different buffer than the *ielm* buffer.
Display the name of the working buffer with \\[ielm-print-working-buffer],
or the buffer itself with \\[ielm-display-working-buffer].
Expressions evaluated by IELM are not subject to `debug-on-quit' or
`debug-on-error'.
The behaviour of IELM may be customised with the following variables:
* To stop beeping on error, set `ielm-noisy' to nil
* If you don't like the prompt, you can change it by setting `ielm-prompt'.
* Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'
* Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
(in that order).
Customised bindings may be defined in `ielm-map', which currently contains:
\\{ielm-map}"
(interactive)
(comint-mode)
(setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
(make-local-variable 'paragraph-start)
(setq paragraph-start comint-prompt-regexp)
(setq comint-input-sender 'ielm-input-sender)
(setq comint-process-echoes nil)
(setq comint-dynamic-complete-functions
'(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol))
(setq comint-get-old-input 'ielm-get-old-input)
(make-local-variable 'comint-completion-addsuffix)
(setq comint-completion-addsuffix
(cons (char-to-string directory-sep-char) ""))
(setq major-mode 'inferior-emacs-lisp-mode)
(setq mode-name "IELM")
(use-local-map ielm-map)
(set-syntax-table emacs-lisp-mode-syntax-table)
(make-local-variable 'indent-line-function)
(make-local-variable 'ielm-working-buffer)
(setq ielm-working-buffer (current-buffer))
(setq indent-line-function 'ielm-indent-line)
(make-local-variable 'fill-paragraph-function)
(setq fill-paragraph-function 'lisp-fill-paragraph)
(setq * nil)
(make-local-variable '*)
(setq ** nil)
(make-local-variable '**)
(setq *** nil)
(make-local-variable '***)
(make-local-variable 'font-lock-defaults)
(setq font-lock-defaults
'(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
(if (comint-check-proc (current-buffer)) nil
(start-process "ielm" (current-buffer) "cat")
(process-kill-without-query (ielm-process))
(goto-char (point-max))
(insert ielm-header)
(ielm-set-pm (point-max))
(comint-output-filter (ielm-process) ielm-prompt)
(set-marker comint-last-input-start (ielm-pm))
(set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
(run-hooks 'ielm-mode-hook))
(defun ielm-get-old-input nil
(save-excursion
(beginning-of-line)
(if (looking-at comint-prompt-regexp) nil
(re-search-backward comint-prompt-regexp))
(comint-skip-prompt)
(buffer-substring (point) (progn (forward-sexp 1) (point)))))
(defun ielm nil
"Interactively evaluate Emacs Lisp expressions.
Switches to the buffer `*ielm*', or creates it if it does not exist."
(interactive)
(if (comint-check-proc "*ielm*")
nil
(save-excursion
(set-buffer (get-buffer-create "*ielm*"))
(inferior-emacs-lisp-mode)))
(pop-to-buffer "*ielm*"))
(provide 'ielm)