anchor.diff:               (write-value 'general-string out val
                             :length (length val)
                             :type (ucs-2-char-type #xfffe)))))
  +
  +(define-binary-type ucs-2-terminated-string (terminator)
  +  (:reader (in)
  +           (let ((byte-order-mark (read-value 'u2 in)))
  +             (read-value
  +              'general-terminate-string in
  +              :terminator terminator
  +              :type (ucs-2-char-type byte-order-mark))))
  +  (:writer (out string)
  +           (write-value 'u2 out #xfeff)
  +           (write-value
  +            'general-terminate-string out string
  +            :terminator terminator
  +            :type (ucs-2-char-type #xfeff))))
  +
  +(define-binary-type iso-8859-1-terminated-string (terminator)
  +  (general-terminate-string :terminator terminator :type 'iso-8859-1))
   
   (define-binary-type iso-8859-1-string (length)
     (:reader (in)
  
positive.code:                (signal 'in-padding))
               (let ((rest (read-value 'iso-8859-1-string in
                                       :length (1- length))))
                 (concatenate 'string first-byte rest))))
    (:writer (out val)
             (write-value 'iso-8859-1-string out val)))
  
  (defun read-frame (in)
    (handler-case (read-value 'frame in)
      (in-padding () nil)))
  
  (define-binary-class id3-v2.2-tag (id3-tag)
    ((frames id3-frames :size size :frame-type 'id3-v2.2-tag)))
  
  (define-binary-type optional (type if)
    (:reader (in)
  
negative.code:            (loop for i from 0 below length
                do (write-value type out (char value i)))))
  
  (define-binary-type general-terminate-string (terminator type)
    (:reader (in)
             (with-output-to-string (str)
               (loop for char = (code-char (read-byte in))
                  until (char= char terminator)
                  do (write-char char str))))
    (:writer (out val)
             (with-input-from-string (str val)
               (loop for char = (read-char str)
                  until (char= char terminator)
                  do (write-byte (char-code char) out)
                  finally (write-byte (char-code terminator) out)))))
  
  (define-binary-type iso-8859-1 ()
    (:reader (in)
  