anchor.diff:                                   :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)))))
  +        (values
  +         (read-from-string (format nil "~D.~D"
  +                                   (parse-integer chars
  +                                                  :end (or point-posn
  +                                                           (length chars)))
  +                                   after-point))
  +         :double))))
     (:method (type source)
       (error 'bad-type-specifier
              :element (nth-value 2 (klacks:peek source))
  
positive.code:       (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)))))
          (:start-element
           (multiple-value-prog1 (decode-object (type-tag-for val2) source)
                                 (skip-characters source)))))))
  
  (defvar *xml-rpc-type-alist* '(("dateTime.iso8601" . :date-time)
                                 ("string" . :string)
                                 ("i4" . :integer)
                                 ("int" . :integer)
  
negative.code:           (when (first-invalid-integer-position chars)
              (error 'malformed-value-content
                     :type integer-spec :content chars))
            (values value :integer)))))
    (:method ((type (eql :boolean)) source)
      (expecting-element/characters (source "boolean" chars)
        (values (cond ((string= chars "1") t)
                      ((string= chars "0") nil)
                      (t (error 'malformed-value-content
                                :type "boolean" :content chars)))
                :boolean)))
    (:method ((type (eql :array)) source)
      (expecting-element/consuming (source "array")
        (expecting-element/consuming (source "data")
          (values
           (loop while (eql :start-element (klacks:peek source))
                 for (value type) =  (multiple-value-list (decode-value source))
                 collect type
                 collect value
                 do (skip-characters source))
           :array))))
    (:method ((type (eql :struct)) source)
      (expecting-element/consuming (source "struct")
        (loop while (eql :start-element (klacks:peek source))
              collect (expecting-element/consuming (source "member")
                        (let ((name (decode-name source)))
                          (multiple-value-bind (value type)  (decode-value source)
                            (list name type value))))
              do (skip-characters source))))
    (:method ((type (eql :base64)) source)
      (expecting-element/characters (source "base64" chars)
        (values (cl-base64:base64-string-to-usb8-array chars) :base64)))
    (:method ((type (eql :double)) source)
      (expecting-element/characters (source "double" chars)
        (let ((point-posn (first-invalid-integer-position chars))
  