anchor.diff:               #+sbcl (sb-ext:process-wait process)
                ;; 2- extract result
                #+allegro (sys:reap-os-subprocess :pid process :wait t)
  +             #+clisp process
                #+clozure (nth-value 1 (ccl:external-process-status process))
                #+(or cmu scl) (ext:process-exit-code process)
                #+ecl (nth-value 1 (ext:external-process-status process))
                #+lispworks (system:pid-exit-status process :wait t)
                #+sbcl (sb-ext:process-exit-code process))
  -           (check-result (return-code)
  +           (check-result (exit-code)
  +             #+clisp
  +             (setf exit-code
  +                   (typecase exit-code (integer exit-code) (null 0) (t -1)))
                (unless (or ignore-error-status
  -                         #+clisp t
  -                         (zerop return-code))
  -               (cerror "ignore error code~*~*"
  -                       "Process ~S exited with error code ~D"
  -                       command return-code)))
  +                         (equal exit-code 0))
  +               (error "Process ~S exited with error code ~D" command exit-code))
  +             exit-code)
              (system (command)
                #+(or abcl xcl) (ext:run-shell-command command)
                #+allegro
  
positive.code:       ,@(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
  
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)
  