2 files changed, 215 insertions, 143 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index a01d1d58765..bfbe5b49eb8 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,19 @@
+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.
diff --git a/lisp/ielm.el b/lisp/ielm.el
index 4280a49af6e..fb1f9774237 100644
--- a/lisp/ielm.el
+++ b/lisp/ielm.el
@@ -1,3 +1,4 @@
+;;; -*- 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))))