Commit 04a19a79 authored by Daniel Colascione's avatar Daniel Colascione
Browse files

IELM improvements.

parent 4c1f03ef
2013-10-18 Daniel Colascione <dancol@dancol.org>
When evaluating forms in ielm, direct standard output to ielm
buffer. Add new ielm-return-for-effect command. Remove trailing
whitespace throughout.
* ielm.el (ielm-map): Bind M-RET to ielm-return-for-effect.
(ielm-return-for-effect): New command.
(ielm-send-input): Accept optional `for-effect' parameter.
(ielm-eval-input): Accept optional `for-effect' parameter. Bind
`standard-output' to stream we create using
`ielm-standard-output-impl'. Suppress printing result when
`for-effect'.
(ielm-standard-output-impl): New function.
(inferior-emacs-lisp-mode): Explain new features in documentation.
2013-10-17 Michael Albinus <michael.albinus@gmx.de>
Code cleanup.
......
;;; -*- lexical-binding: t -*-
;;; ielm.el --- interaction mode for Emacs Lisp
;; Copyright (C) 1994, 2001-2013 Free Software Foundation, Inc.
......@@ -62,10 +63,10 @@ the remaining prompts will be accidentally messed up. You may
wish to put something like the following in your init file:
\(add-hook 'ielm-mode-hook
(lambda ()
(define-key ielm-map \"\\C-w\" 'comint-kill-region)
(define-key ielm-map [C-S-backspace]
'comint-kill-whole-line)))
(lambda ()
(define-key ielm-map \"\\C-w\" 'comint-kill-region)
(define-key ielm-map [C-S-backspace]
'comint-kill-whole-line)))
If you set `comint-prompt-read-only' to t, you might wish to use
`comint-mode-hook' and `comint-mode-map' instead of
......@@ -169,6 +170,7 @@ This variable is buffer-local.")
(let ((map (make-sparse-keymap)))
(define-key map "\t" 'completion-at-point)
(define-key map "\C-m" 'ielm-return)
(define-key map "\e\C-m" 'ielm-return-for-effect)
(define-key map "\C-j" 'ielm-send-input)
(define-key map "\e\C-x" 'eval-defun) ; for consistency with
(define-key map "\e\t" 'completion-at-point) ; lisp-interaction-mode
......@@ -203,7 +205,7 @@ This variable is buffer-local.")
"Possibly indent the current line as Lisp code."
(interactive)
(when (or (eq (preceding-char) ?\n)
(eq (char-syntax (preceding-char)) ?\s))
(eq (char-syntax (preceding-char)) ?\s))
(ielm-indent-line)
t))
......@@ -212,9 +214,9 @@ This variable is buffer-local.")
;; A wrapper for completion-at-point that returns non-nil if
;; completion has occurred
(let* ((btick (buffer-modified-tick))
(cbuffer (get-buffer "*Completions*"))
(ctick (and cbuffer (buffer-modified-tick cbuffer)))
(completion-at-point-functions '(lisp-completion-at-point)))
(cbuffer (get-buffer "*Completions*"))
(ctick (and cbuffer (buffer-modified-tick cbuffer)))
(completion-at-point-functions '(lisp-completion-at-point)))
(completion-at-point)
;; completion has occurred if:
(or
......@@ -222,7 +224,7 @@ This variable is buffer-local.")
(not (= btick (buffer-modified-tick)))
;; a completions buffer has been modified or created
(if cbuffer
(not (= ctick (buffer-modified-tick cbuffer)))
(not (= ctick (buffer-modified-tick cbuffer)))
(get-buffer "*Completions*")))))
(defun ielm-complete-filename nil
......@@ -258,13 +260,13 @@ evaluated. You can achieve the same effect with a call to
(interactive "bSet working buffer to: ")
(let ((buffer (get-buffer buf)))
(if (and buffer (buffer-live-p buffer))
(setq ielm-working-buffer buffer)
(setq ielm-working-buffer buffer)
(error "No such buffer: %S" buf)))
(ielm-print-working-buffer))
;;; Other bindings
(defun ielm-return nil
(defun ielm-return (&optional for-effect)
"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
......@@ -272,22 +274,27 @@ 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)
(when (and ielm-dynamic-multiline-inputs
(save-excursion
(beginning-of-line)
(looking-at-p comint-prompt-regexp)))
(save-excursion
(goto-char (ielm-pm))
(newline 1)))
(newline-and-indent)))
(save-excursion
(end-of-line)
(parse-partial-sexp (ielm-pm)
(point)))))
(if (and (< (car state) 1) (not (nth 3 state)))
(ielm-send-input for-effect)
(when (and ielm-dynamic-multiline-inputs
(save-excursion
(beginning-of-line)
(looking-at-p comint-prompt-regexp)))
(save-excursion
(goto-char (ielm-pm))
(newline 1)))
(newline-and-indent)))
(newline)))
(defun ielm-return-for-effect ()
"Like `ielm-return', but do not print the result."
(interactive)
(ielm-return t))
(defvar ielm-input)
(defun ielm-input-sender (_proc input)
......@@ -295,12 +302,12 @@ simply inserts a newline."
;; `ielm-send-input's call.
(setq ielm-input input))
(defun ielm-send-input nil
(defun ielm-send-input (&optional for-effect)
"Evaluate the Emacs Lisp expression after the prompt."
(interactive)
(let (ielm-input) ; set by ielm-input-sender
(comint-send-input) ; update history, markers etc.
(ielm-eval-input ielm-input)))
(let (ielm-input) ; set by ielm-input-sender
(comint-send-input) ; update history, markers etc.
(ielm-eval-input ielm-input for-effect)))
;;; Utility functions
......@@ -311,16 +318,41 @@ simply inserts a newline."
;;; Evaluation
(defvar ielm-string)
(defvar ielm-form)
(defvar ielm-pos)
(defvar ielm-result)
(defvar ielm-error-type)
(defvar ielm-output)
(defvar ielm-wbuf)
(defvar ielm-pmark)
(defun ielm-eval-input (input-string)
(defun ielm-standard-output-impl (process)
"Return a function to use for `standard-output' while in ielm eval.
The returned function takes one character as input. Passing nil
to this function instead of a character flushes the output
buffer. Passing t appends a terminating newline if the buffer is
nonempty, then flushes the buffer."
;; Use an intermediate output buffer because doing redisplay for
;; each character we output is too expensive. Set up a flush timer
;; so that users don't have to wait for whole lines to appear before
;; seeing output.
(let* ((output-buffer nil)
(flush-timer nil)
(flush-buffer
(lambda ()
(comint-output-filter
process
(apply #'string (nreverse output-buffer)))
(redisplay)
(setf output-buffer nil)
(when flush-timer
(cancel-timer flush-timer)
(setf flush-timer nil)))))
(lambda (char)
(let (flush-now)
(cond ((and (eq char t) output-buffer)
(push ?\n output-buffer)
(setf flush-now t))
((characterp char)
(push char output-buffer)))
(if flush-now
(funcall flush-buffer)
(unless flush-timer
(setf flush-timer (run-with-timer 0.1 nil flush-buffer))))))))
(defun ielm-eval-input (input-string &optional for-effect)
"Evaluate the Lisp expression INPUT-STRING, and pretty-print the result."
;; This is the function that actually `sends' the input to the
;; `inferior Lisp process'. All comint-send-input does is works out
......@@ -331,108 +363,119 @@ simply inserts a newline."
;; this as in output filter that converted sexps in the output
;; stream to their evaluated value. But that would have involved
;; more process coordination than I was happy to deal with.
;;
;; NOTE: all temporary variables in this function will be in scope
;; during the eval, and so need to have non-clashing names.
(let ((ielm-string input-string) ; input expression, as a string
ielm-form ; form to evaluate
ielm-pos ; End posn of parse in string
ielm-result ; Result, or error message
ielm-error-type ; string, nil if no error
(ielm-output "") ; result to display
(ielm-wbuf ielm-working-buffer) ; current buffer after evaluation
(ielm-pmark (ielm-pm)))
(unless (ielm-is-whitespace-or-comment ielm-string)
(let ((string input-string) ; input expression, as a string
form ; form to evaluate
pos ; End posn of parse in string
result ; Result, or error message
error-type ; string, nil if no error
(output "") ; result to display
(wbuf ielm-working-buffer) ; current buffer after evaluation
(pmark (ielm-pm)))
(unless (ielm-is-whitespace-or-comment string)
(condition-case err
(let ((rout (read-from-string ielm-string)))
(setq ielm-form (car rout)
ielm-pos (cdr rout)))
(error (setq ielm-result (error-message-string err))
(setq ielm-error-type "Read error")))
(unless ielm-error-type
;; Make sure working buffer has not been killed
(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-or-comment (substring ielm-string ielm-pos))
;; To correctly handle the ielm-local variables *,
;; ** and ***, we need a temporary buffer to be
;; current at entry to the inner of the next two let
;; forms. We need another temporary buffer to exit
;; that same let. To avoid problems, neither of
;; these buffers should be alive during the
;; evaluation of ielm-form.
(let ((*1 *)
(*2 **)
(*3 ***)
ielm-temp-buffer)
(set-match-data ielm-match-data)
(save-excursion
(with-temp-buffer
(condition-case err
(unwind-protect
;; The next let form creates default
;; bindings for *, ** and ***. But
;; these default bindings are
;; identical to the ielm-local
;; bindings. Hence, during the
;; evaluation of ielm-form, the
;; ielm-local values are going to be
;; used in all buffers except for
;; other ielm buffers, which override
;; them. Normally, the variables *1,
;; *2 and *3 also have default
;; bindings, which are not overridden.
(let ((* *1)
(** *2)
(*** *3))
(kill-buffer (current-buffer))
(set-buffer ielm-wbuf)
(setq ielm-result
(eval ielm-form lexical-binding))
(setq ielm-wbuf (current-buffer))
(setq
ielm-temp-buffer
(generate-new-buffer " *ielm-temp*"))
(set-buffer ielm-temp-buffer))
(when ielm-temp-buffer
(kill-buffer ielm-temp-buffer)))
(error (setq ielm-result (error-message-string err))
(setq ielm-error-type "Eval error"))
(quit (setq ielm-result "Quit during evaluation")
(setq ielm-error-type "Eval error")))))
(setq ielm-match-data (match-data)))
(setq ielm-error-type "IELM error")
(setq ielm-result "More than one sexp in input"))))
(let ((rout (read-from-string string)))
(setq form (car rout)
pos (cdr rout)))
(error (setq result (error-message-string err))
(setq error-type "Read error")))
(unless error-type
;; Make sure working buffer has not been killed
(if (not (buffer-name ielm-working-buffer))
(setq result "Working buffer has been killed"
error-type "IELM Error"
wbuf (current-buffer))
(if (ielm-is-whitespace-or-comment (substring string pos))
;; To correctly handle the ielm-local variables *,
;; ** and ***, we need a temporary buffer to be
;; current at entry to the inner of the next two let
;; forms. We need another temporary buffer to exit
;; that same let. To avoid problems, neither of
;; these buffers should be alive during the
;; evaluation of form.
(let* ((*1 *)
(*2 **)
(*3 ***)
(active-process (ielm-process))
(old-standard-output standard-output)
new-standard-output
ielm-temp-buffer)
(set-match-data ielm-match-data)
(save-excursion
(with-temp-buffer
(condition-case err
(unwind-protect
;; The next let form creates default
;; bindings for *, ** and ***. But
;; these default bindings are
;; identical to the ielm-local
;; bindings. Hence, during the
;; evaluation of form, the
;; ielm-local values are going to be
;; used in all buffers except for
;; other ielm buffers, which override
;; them. Normally, the variables *1,
;; *2 and *3 also have default
;; bindings, which are not overridden.
(let ((* *1)
(** *2)
(*** *3))
(when (eq standard-output t)
(setf new-standard-output
(ielm-standard-output-impl
active-process))
(setf standard-output new-standard-output))
(kill-buffer (current-buffer))
(set-buffer wbuf)
(setq result
(eval form lexical-binding))
(setq wbuf (current-buffer))
(setq
ielm-temp-buffer
(generate-new-buffer " *ielm-temp*"))
(set-buffer ielm-temp-buffer))
(when ielm-temp-buffer
(kill-buffer ielm-temp-buffer))
(when (eq new-standard-output standard-output)
(ignore-errors
(funcall standard-output t))
(setf standard-output old-standard-output)))
(error (setq result (error-message-string err))
(setq error-type "Eval error"))
(quit (setq result "Quit during evaluation")
(setq error-type "Eval error")))))
(setq ielm-match-data (match-data)))
(setq error-type "IELM error")
(setq result "More than one sexp in input"))))
;; If the eval changed the current buffer, mention it here
(unless (eq ielm-wbuf ielm-working-buffer)
(message "current buffer is now: %s" ielm-wbuf)
(setq ielm-working-buffer ielm-wbuf))
(goto-char ielm-pmark)
(unless ielm-error-type
(condition-case nil
;; Self-referential objects cause loops in the printer, so
;; trap quits here. May as well do errors, too
(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
(when ielm-noisy (ding))
(setq ielm-output (concat ielm-output "*** " ielm-error-type " *** "))
(setq ielm-output (concat ielm-output ielm-result)))
;; There was no error, so shift the *** values
(setq *** **)
(setq ** *)
(setq * ielm-result))
(setq ielm-output (concat ielm-output "\n")))
(setq ielm-output (concat ielm-output ielm-prompt-internal))
(comint-output-filter (ielm-process) ielm-output)))
(unless (eq wbuf ielm-working-buffer)
(message "current buffer is now: %s" wbuf)
(setq ielm-working-buffer wbuf))
(goto-char pmark)
(unless error-type
(condition-case nil
;; Self-referential objects cause loops in the printer, so
;; trap quits here. May as well do errors, too
(unless for-effect
(setq output (concat output (pp-to-string result))))
(error (setq error-type "IELM Error")
(setq result "Error during pretty-printing (bug in pp)"))
(quit (setq error-type "IELM Error")
(setq result "Quit during pretty-printing"))))
(if error-type
(progn
(when ielm-noisy (ding))
(setq output (concat output "*** " error-type " *** "))
(setq output (concat output result)))
;; There was no error, so shift the *** values
(setq *** **)
(setq ** *)
(setq * result))
(when (or (not for-effect) (not (equal output "")))
(setq output (concat output "\n"))))
(setq output (concat output ielm-prompt-internal))
(comint-output-filter (ielm-process) output)))
;;; Process and marker utilities
......@@ -462,6 +505,11 @@ Uses the interface provided by `comint-mode' (which see).
Inputs longer than one line are moved to the line following the
prompt (but see variable `ielm-dynamic-multiline-inputs').
* \\[ielm-return-for-effect] works like `ielm-return', except
that it doesn't print the result of evaluating the input. This
functionality is useful when forms would generate voluminous
output.
* \\[completion-at-point] completes Lisp symbols (or filenames, within strings),
or indents the line if there is nothing to complete.
......@@ -478,6 +526,13 @@ evaluations respectively. If the working buffer is another IELM
buffer, then the values in the working buffer are used. The variables
`*1', `*2' and `*3', yield the process buffer values.
If, at the start of evaluation, `standard-output' is `t' (the
default), `standard-output' is set to a special function that
causes output to be directed to the ielm buffer.
`standard-output' is restored after evaluation unless explicitly
set to a different value during evaluation. You can use (princ
VALUE) or (pp VALUE) to write to the ielm buffer.
Expressions evaluated by IELM are not subject to `debug-on-quit' or
`debug-on-error'.
......@@ -501,7 +556,7 @@ Customized bindings may be defined in `ielm-map', which currently contains:
(setq comint-process-echoes nil)
(set (make-local-variable 'completion-at-point-functions)
'(ielm-tab comint-replace-by-expanded-history
ielm-complete-filename ielm-complete-symbol))
ielm-complete-filename ielm-complete-symbol))
(set (make-local-variable 'ielm-prompt-internal) ielm-prompt)
(set (make-local-variable 'comint-prompt-read-only) ielm-prompt-read-only)
(setq comint-get-old-input 'ielm-get-old-input)
......@@ -530,7 +585,7 @@ Customized bindings may be defined in `ielm-map', which currently contains:
;; Was cat, but on non-Unix platforms that might not exist, so
;; use hexl instead, which is part of the Emacs distribution.
(condition-case nil
(start-process "ielm" (current-buffer) "hexl")
(start-process "ielm" (current-buffer) "hexl")
(file-error (start-process "ielm" (current-buffer) "cat")))
(set-process-query-on-exit-flag (ielm-process) nil)
(goto-char (point-max))
......@@ -565,13 +620,14 @@ Customized bindings may be defined in `ielm-map', which currently contains:
;;;###autoload
(defun ielm nil
"Interactively evaluate Emacs Lisp expressions.
Switches to the buffer `*ielm*', or creates it if it does not exist."
Switches to the buffer `*ielm*', or creates it if it does not exist.
See `inferior-emacs-lisp-mode' for details."
(interactive)
(let (old-point)
(unless (comint-check-proc "*ielm*")
(with-current-buffer (get-buffer-create "*ielm*")
(unless (zerop (buffer-size)) (setq old-point (point)))
(inferior-emacs-lisp-mode)))
(unless (zerop (buffer-size)) (setq old-point (point)))
(inferior-emacs-lisp-mode)))
(switch-to-buffer "*ielm*")
(when old-point (push-mark old-point))))
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment