anchor.diff:                If using a pipe, returns two values: process and stream
                 If not using a pipe, returns one values: the process result;
                 also, inherits the output stream."
  -             (let* ((command
  +             (let* ((wait (not pipe))
  +                    #-(and clisp os-windows)
  +                    (command
                        (etypecase command
                          #+os-unix (string `("/bin/sh" "-c" ,command))
                          #+os-unix (list command)
  
positive.code:              (system:call-system-showing-output
                command :show-cmd nil :prefix "" :output-stream nil))
             (use-run-program ()
               #-(or abcl cormanlisp gcl (and lispworks os-windows) xcl)
               (let ((pipe (and output-processor t)))
                 (multiple-value-bind (process stream)
                     (run-program command :pipe pipe)
                   (unwind-protect
                        (when output-processor
                          (funcall output-processor stream))
                     (when stream (close stream))
                     (check-result (if pipe
                                       (process-result process)
                                       process))))))
             (use-system ()
               (with-temporary-file (:pathname tmp)
                 (let* ((command-string
                         (format nil "~A > ~A"
                                 (etypecase command
                                   (string command)
                                   (list (escape-shell-command command)))
                                 tmp)))
                   (check-result (system command-string))
                   (when output-processor
                     (with-open-file (stream tmp
                                             :direction :input
                                             :if-does-not-exist :error
                                             :element-type element-type
                                             :external-format external-format)
                       (funcall output-processor stream)))))))
      (if (and (not force-shell)
               #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl xcl) nil)
          (use-run-program)
          (use-system))))
  
negative.code:                       (excl:run-shell-command
                         #+os-unix (coerce (cons (first command) command) 'vector)
                         #+os-windows command
                         :input nil :output (and pipe :stream) :wait wait
                         #+os-windows :show-window #+os-windows (and pipe :hide))
                        #+clisp
                        (etypecase command
                          #+os-windows
                          (string
                           (ext:run-shell-command
                            command
                            :input nil :wait wait :output (if pipe :stream :terminal)))
                          (list
                           (ext:run-program
                            (car command) :arguments (cdr command)
                            :input nil :wait wait :output (if pipe :stream :terminal))))
                        #+lispworks
                        (system:run-shell-command
                         (cons "/usr/bin/env" command) ; lispworks wants a full path.
                         :input nil :output (and pipe :stream)
                         :wait wait :save-exit-status (and pipe t))
                        #+(or clozure cmu ecl sbcl scl)
                        (#+(or cmu ecl scl) ext:run-program
                         #+clozure ccl:run-program
                         #+sbcl sb-ext:run-program
                         (car command) #+clisp :arguments (cdr command)
                         :input nil :wait wait
                         :output (if pipe :stream
                                     #+(or clozure cmu ecl sbcl scl) t
                                     #+clisp :terminal)
  