(shell-command-on-region-default-error-buffer): New var.

(shell-command-on-region): Use that variable as interactive
value of ERROR-BUFFER argument.

1 files changed, 96 insertions, 86 deletions

diff --git a/lisp/simple.el b/lisp/simple.el
index 94cff99ee57..ab4fa875137 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -1173,6 +1173,12 @@ In either case, the output is inserted after point (leaving mark after it)."
                (car (cdr (cdr (process-command process))))
                (substring signal 0 -1))))
 
+(defvar shell-command-on-region-default-error-buffer nil
+  "*Name of buffer that `shell-command-on-region' uses for stderr.
+This buffer is used when `shell-command-on-region' is run interactively.
+A nil value for this variable means that output to stderr and stdout
+will be intermixed in the output stream.")
+
 (defun shell-command-on-region (start end command
                                       &optional output-buffer replace
                                       error-buffer)
@@ -1211,7 +1217,10 @@ around it.
 
 If optional sixth argument ERROR-BUFFER is non-nil, it is a buffer
 or buffer name to which to direct the command's standard error output.
-If it is nil, error output is mingled with regular output."
+If it is nil, error output is mingled with regular output.
+In an interactive call, the variable
+`shell-command-on-region-default-error-buffer' specifies the value
+of ERROR-BUFFER."
   (interactive (let ((string
                       ;; Do this before calling region-beginning
                       ;; and region-end, in case subprocess output
@@ -1224,96 +1233,97 @@ If it is nil, error output is mingled with regular output."
                  (list (region-beginning) (region-end)
                        string
                        current-prefix-arg
-                       current-prefix-arg)))
+                       current-prefix-arg
+                       shell-command-on-region-default-error-buffer)))
   (let ((error-file
          (if error-buffer 
              (concat (file-name-directory temp-file-name-pattern)
                      (make-temp-name "scor"))
            nil)))
-  (if (or replace
-          (and output-buffer
-               (not (or (bufferp output-buffer) (stringp output-buffer))))
-          (equal (buffer-name (current-buffer)) "*Shell Command Output*"))
-      ;; Replace specified region with output from command.
-      (let ((swap (and replace (< start end))))
-        ;; Don't muck with mark unless REPLACE says we should.
-        (goto-char start)
-        (and replace (push-mark))
-        (call-process-region start end shell-file-name t
-                             (if error-file
-                                 (list t error-file)
-                               t)
-                             nil shell-command-switch command)
-        (let ((shell-buffer (get-buffer "*Shell Command Output*")))
-          (and shell-buffer (not (eq shell-buffer (current-buffer)))
-               (kill-buffer shell-buffer)))
-        ;; Don't muck with mark unless REPLACE says we should.
-        (and replace swap (exchange-point-and-mark)))
-    ;; No prefix argument: put the output in a temp buffer,
-    ;; replacing its entire contents.
-    (let ((buffer (get-buffer-create
-                   (or output-buffer "*Shell Command Output*")))
-          (success nil)
-          (exit-status nil))
-      (unwind-protect
-          (if (eq buffer (current-buffer))
-              ;; If the input is the same buffer as the output,
-              ;; delete everything but the specified region,
-              ;; then replace that region with the output.
-              (progn (setq buffer-read-only nil)
-                     (delete-region (max start end) (point-max))
-                     (delete-region (point-min) (min start end))
-                     (setq exit-status
-                           (call-process-region (point-min) (point-max)
-                                                shell-file-name t 
-                                                (if error-file
-                                                    (list t error-file)
-                                                  t)
-                                                nil shell-command-switch command))
-                     (setq success t))
-            ;; Clear the output buffer, then run the command with output there.
-            (save-excursion
-              (set-buffer buffer)
-              (setq buffer-read-only nil)
-              (erase-buffer))
-            (setq exit-status
-                  (call-process-region start end shell-file-name nil
-                                       (if error-file
-                                           (list buffer error-file)
-                                         buffer)
-                                       nil shell-command-switch command))
-            (setq success t))
-        ;; Report the amount of output.
-        (let ((lines (save-excursion
-                       (set-buffer buffer)
-                       (if (= (buffer-size) 0)
-                           0
-                         (count-lines (point-min) (point-max))))))
-          (cond ((= lines 0)
-                 (if success
-                     (message "(Shell command %sed with no output)"
-                              (if (equal 0 exit-status)
-                                  "succeed"
-                                "fail")))
-                 (kill-buffer buffer))
-                ((and success (= lines 1))
-                 (message "%s"
-                          (save-excursion
-                            (set-buffer buffer)
-                            (goto-char (point-min))
-                            (buffer-substring (point)
-                                              (progn (end-of-line) (point))))))
-                (t 
-                 (save-excursion
-                   (set-buffer buffer)
-                   (goto-char (point-min)))
-                 (display-buffer buffer)))))))
-  (if (and error-file (file-exists-p error-file))
-      (save-excursion
-        (set-buffer (get-buffer-create error-buffer))
-        ;; Do no formatting while reading error file, for fear of looping.
-        (format-insert-file error-file nil)
-        (delete-file error-file)))))
+    (if (or replace
+            (and output-buffer
+                 (not (or (bufferp output-buffer) (stringp output-buffer))))
+            (equal (buffer-name (current-buffer)) "*Shell Command Output*"))
+        ;; Replace specified region with output from command.
+        (let ((swap (and replace (< start end))))
+          ;; Don't muck with mark unless REPLACE says we should.
+          (goto-char start)
+          (and replace (push-mark))
+          (call-process-region start end shell-file-name t
+                               (if error-file
+                                   (list t error-file)
+                                 t)
+                               nil shell-command-switch command)
+          (let ((shell-buffer (get-buffer "*Shell Command Output*")))
+            (and shell-buffer (not (eq shell-buffer (current-buffer)))
+                 (kill-buffer shell-buffer)))
+          ;; Don't muck with mark unless REPLACE says we should.
+          (and replace swap (exchange-point-and-mark)))
+      ;; No prefix argument: put the output in a temp buffer,
+      ;; replacing its entire contents.
+      (let ((buffer (get-buffer-create
+                     (or output-buffer "*Shell Command Output*")))
+            (success nil)
+            (exit-status nil))
+        (unwind-protect
+            (if (eq buffer (current-buffer))
+                ;; If the input is the same buffer as the output,
+                ;; delete everything but the specified region,
+                ;; then replace that region with the output.
+                (progn (setq buffer-read-only nil)
+                       (delete-region (max start end) (point-max))
+                       (delete-region (point-min) (min start end))
+                       (setq exit-status
+                             (call-process-region (point-min) (point-max)
+                                                  shell-file-name t 
+                                                  (if error-file
+                                                      (list t error-file)
+                                                    t)
+                                                  nil shell-command-switch command))
+                       (setq success t))
+              ;; Clear the output buffer, then run the command with output there.
+              (save-excursion
+                (set-buffer buffer)
+                (setq buffer-read-only nil)
+                (erase-buffer))
+              (setq exit-status
+                    (call-process-region start end shell-file-name nil
+                                         (if error-file
+                                             (list buffer error-file)
+                                           buffer)
+                                         nil shell-command-switch command))
+              (setq success t))
+          ;; Report the amount of output.
+          (let ((lines (save-excursion
+                         (set-buffer buffer)
+                         (if (= (buffer-size) 0)
+                             0
+                           (count-lines (point-min) (point-max))))))
+            (cond ((= lines 0)
+                   (if success
+                       (message "(Shell command %sed with no output)"
+                                (if (equal 0 exit-status)
+                                    "succeed"
+                                  "fail")))
+                   (kill-buffer buffer))
+                  ((and success (= lines 1))
+                   (message "%s"
+                            (save-excursion
+                              (set-buffer buffer)
+                              (goto-char (point-min))
+                              (buffer-substring (point)
+                                                (progn (end-of-line) (point))))))
+                  (t 
+                   (save-excursion
+                     (set-buffer buffer)
+                     (goto-char (point-min)))
+                   (display-buffer buffer)))))))
+    (if (and error-file (file-exists-p error-file))
+        (save-excursion
+          (set-buffer (get-buffer-create error-buffer))
+          ;; Do no formatting while reading error file, for fear of looping.
+          (format-insert-file error-file nil)
+          (delete-file error-file)))))
        
 (defun shell-command-to-string (command)
   "Execute shell command COMMAND and return its output as a string."