anchor.diff:        ,@(when element-type `(:element-type ,element-type))
         ,@(when external-format `(:external-format external-format)))))
   
  -(defun escape-shell-command (command &optional stream)
  -  "Escape a command for the current operating system's shell"
  -  (#+os-unix escape-sh-command
  -   #+os-windows escape-windows-command
  -   command stream))
  -
   ;;; Simple variant of run-program with no input, and capturing output
   ;;; On some implementations, may output to a temporary file...
   (defun run-program/process-output-stream (command output-processor
  
positive.code:                                           (external-format :default)
                                            &allow-other-keys)
    "Run program specified by COMMAND (either list of strings specifying
  a program and list of arguments, or a string specifying shell command),
  and have its output processed by the OUTPUT-PROCESSOR function (or
  merely output to the inherited standard output if it's NIL).
  Always call a shell (rather than directly execute the command)
  if FORCE-SHELL is specified.
  Issue an error if the process wasn't successful unless IGNORE-ERROR-STATUS
  is specified.
  Use ELEMENT-TYPE and EXTERNAL-FORMAT for the stream passed to OUTPUT-PROCESSOR."
    (declare (ignorable ignore-error-status element-type external-format))
    (let ((s (find-symbol* 'run-program/process-output-stream :quux-iolib nil)))
  
negative.code:                      #+(or allegro lispworks ecl) (third process*)
                       #-(or allegro lispworks ecl) (first process*))
                      (stream
                       (when pipe
                         #+(or allegro lispworks ecl) (first process*)
                         #+clisp (first process*)
                         #+clozure (ccl::external-process-output process)
                         #+(or cmu scl) (ext:process-output process)
                         #+sbcl (sb-ext:process-output process))))
                 (values process stream)))
             #+(or allegro clisp clozure cmu ecl
                   (and lispworks os-unix) sbcl scl)
             (process-result (process)
               ;; 1- wait
               #+(and clozure os-unix) (ccl::external-process-wait process)
               #+(or cmu scl) (ext:process-wait process)
  