anchor.diff:  (in-package #:ql-minitar)
   
  +(defconstant +block-size+ 512)
  +(defconstant +space-code+ 32)
  +(defconstant +newline-code+ 10)
  +(defconstant +equals-code+ 61)
  +
   (defun make-block-buffer ()
  -  (make-array 512 :element-type '(unsigned-byte 8) :initial-element 0))
  +  (make-array +block-size+ :element-type '(unsigned-byte 8) :initial-element 0))
   
   (defun skip-n-blocks (n stream)
     (let ((block (make-block-buffer)))
       (dotimes (i n)
         (read-sequence block stream))))
  +
  +(defun read-octet-vector (length stream)
  +  (let ((block (make-block-buffer))
  +        (vector (make-array length :element-type '(unsigned-byte 8)))
  +        (offset 0)
  +        (block-count (ceiling length +block-size+)))
  +    (dotimes (i block-count)
  +        (read-sequence block stream)
  +        (replace vector block :start1 offset)
  +        (incf offset +block-size+))
  +    vector))
  +
  +
  +(defun decode-pax-header-record (vector offset)
  +  "Decode VECTOR as pax extended header data. Returns the keyword and
  +value it specifies as multiple values."
  +  ;; Vector format is: "%d %s=%s\n", <length>, <keyword>, <value>
  +  ;; See http://pubs.opengroup.org/onlinepubs/009695399/utilities/pax.html
  +  (let* ((length-start offset)
  +         (length-end (position +space-code+ vector :start length-start))
  +         (length-string (ascii-subseq vector length-start length-end))
  +         (length (parse-integer length-string))
  +         (keyword-start (1+ length-end))
  +         (keyword-end (position +equals-code+ vector :start keyword-start))
  +         (keyword (ascii-subseq vector keyword-start keyword-end))
  +         (value-start (1+ keyword-end))
  +         (value-end (1- (+ offset length)))
  +         (value (ascii-subseq vector value-start value-end)))
  +    (values keyword value (+ offset length))))
  +
  +(defun decode-pax-header (vector)
  +  "Decode VECTOR as a pax header and return it as an alist."
  +  (let ((header nil)
  +        (offset 0)
  +        (length (length vector)))
  +    (loop
  +      (when (<= length offset)
  +        (return header))
  +      (multiple-value-bind (keyword value new-offset)
  +          (decode-pax-header-record vector offset)
  +        (setf header (acons keyword value header))
  +        (setf offset new-offset)))))
  +
  +(defun pax-header-path (vector)
  +  "Decode VECTOR as a pax header and return its 'path' value, if
  +  any."
  +  (let ((header-alist (decode-pax-header vector)))
  +    (cdr (assoc "path" header-alist :test 'equal))))
   
   (defun ascii-subseq (vector start end)
     (let ((string (make-string (- end start))))
  
positive.code:            ((:symlink :long-name :global-header)
              ;; These block types aren't required for Quicklisp archives
              (skip-n-blocks block-count stream))
             (t
              (warn "Unknown tar block payload code -- ~D" payload-code)
              (skip-n-blocks block-count stream)))))))))
  
negative.code:         (let ((size (read-sequence block stream)))
            (when (zerop size)
              (return (nreverse result)))
            (unless (= size +block-size+)
              (error "Bad size on tarfile"))
            (when (every #'zerop block)
              (return (nreverse result)))
            (let* ((payload-type (payload-type (aref block 156)))
                   (tar-path (full-path block))
                   (payload-size (payload-size block)))
              (skip-n-blocks (ceiling payload-size +block-size+) stream)
              (case payload-type
                (:file
                 (push tar-path result))
  