anchor.diff:        (ecase type
           (:characters ; Stupid: if no type is specified, it's a string...
            (multiple-value-prog1
  -           (or (decode-object :lazy-string source)
  -               ;; ...but some impls insist on indenting the
  -               ;; contents of <values>:
  -               (multiple-value-prog1 (decode-object
  -                                      (type-tag-for (nth-value 2 (klacks:peek source)))
  -                                      source)
  -                                     (skip-characters source)))))
  +           (multiple-value-bind (value type) (decode-object :lazy-string source)
  +             ;; ...but some impls insist on indenting the contents of
  +             ;; <values>:
  +             (if value
  +                 (values value type)
  +                 (multiple-value-prog1
  +                   (decode-object
  +                    (type-tag-for (nth-value 2 (klacks:peek source)))
  +                    source)
  +                   (skip-characters source))))))
           (:start-element
            (multiple-value-prog1 (decode-object (type-tag-for val2) source)
                                  (skip-characters source)))))))
   
  -(defvar *xml-rpc-type-alist* '(("dateTime.iso8601" . :date-time)
  +(defvar *xml-rpc-type-alist* '(("dateTime.iso8601" . :time)
                                  ("string" . :string)
                                  ("i4" . :integer)
                                  ("int" . :integer)
  
positive.code:                                  :start (1+ point-posn))
              (error 'malformed-value-content :type "double" :content chars))
            (setf after-point (parse-integer chars :start (1+ point-posn))))
          (read-from-string (format nil "~D.~D"
                                    (parse-integer chars :end (or point-posn
                                                                  (length chars)))
                                    after-point)))))
    (:method (type source)
      (error 'bad-type-specifier
             :element (nth-value 2 (klacks:peek source))
  
negative.code:                    string))
  
  (defun decode-time (string)
    (let ((year (subseq string 0 4))
          (month (subseq string 4 6))
          (date (subseq string 6 8))
          (utc-marker (subseq string 8 9))
          (hour (subseq string 9 11))
          (minute (subseq string 12 14))
          (second (subseq string 15 17)))
      (apply #'encode-universal-time
             (mapcar #'parse-integer
                     `(,second ,minute ,hour ,date ,month ,year
                               ,@(when (equal utc-marker "Z")
                                   (list "0")))))))
  
  (defgeneric decode-object (type source)
    (:method ((type (eql :lazy-string)) source)
      (let ((string (nth-value 1 (klacks:skip source :characters))))
        (when (eql :end-element (klacks:peek source))
          (values string :string))))
    (:method ((type (eql :string)) source)
      (expecting-element/characters (source "string" chars)
        (values chars :string)))
    (:method ((type (eql :time)) source)
      (expecting-element/characters (source "dateTime.iso8601" chars)
        (values (decode-time chars) :time)))
    (:method ((type (eql :integer)) source)
      (let ((integer-spec (nth-value 2 (klacks:peek source))))
        (expecting-element/characters (source integer-spec chars)
  