anchor.diff:              (if indent
                   (format stream "~&~V,0T\"~A\": " (+ indent 2) name)
                   (format stream "\"~A\":" name))
  -            (if (eq (proto-label field) :repeated)
  -                (let ((repeated-printed))
  +            (if (not (eq (proto-label field) :repeated))
  +                (print-field-to-json value type (and indent (+ indent 2))
  +                                     stream camel-case-p numeric-enums-p)
  +                (let (repeated-printed)
                     (format stream "[")
                     (doseq (v value)
  -                         (if repeated-printed
  -                             (format stream ",")
  -                             (setf repeated-printed t))
  -                         (when indent (format stream "~&~V,0T" (+ indent 4)))
  -                         (print-field-to-json v type (and indent (+ indent 4))
  -                                              stream camel-case-p numeric-enums-p))
  +                    (if repeated-printed
  +                        (format stream ",")
  +                        (setf repeated-printed t))
  +                    (when indent (format stream "~&~V,0T" (+ indent 4)))
  +                    (print-field-to-json v type (and indent (+ indent 4))
  +                                         stream camel-case-p numeric-enums-p))
                     (if indent
                         (format stream "~&~V,0T]" (+ indent 2))
  -                      (format stream "]")))
  -                (print-field-to-json value type (and indent (+ indent 2))
  -                                     stream camel-case-p numeric-enums-p)))))
  -    (dolist (oneof (proto-oneofs message))
  -      (let* ((oneof-data (slot-value object (oneof-descriptor-internal-name oneof)))
  -             (set-field (oneof-set-field oneof-data)))
  -        (when set-field
  -          (let* ((field-desc (aref (oneof-descriptor-fields oneof) set-field))
  -                 (type (proto-class field-desc))
  -                 (value (oneof-value oneof-data))
  -                 (name (if camel-case-p
  -                           (proto-json-name field-desc)
  -                           (proto-name field-desc))))
  -            (if field-printed
  -                (format stream ",")
  -                (setf field-printed t))
  -             (if indent
  -                (format stream "~&~V,0T\"~A\": " (+ indent 2) name)
  -                (format stream "\"~A\":" name))
  -            (print-field-to-json value type (and indent (+ indent 2))
  -                                 stream camel-case-p numeric-enums-p)))))
  +                      (format stream "]")))))))
  +      (dolist (oneof (proto-oneofs message))
  +        (let* ((oneof-data (slot-value object (oneof-descriptor-internal-name oneof)))
  +               (set-field (oneof-set-field oneof-data)))
  +          (when set-field
  +            (let* ((field-desc (aref (oneof-descriptor-fields oneof) set-field))
  +                   (type (proto-class field-desc))
  +                   (value (oneof-value oneof-data))
  +                   (name (if camel-case-p
  +                             (proto-json-name field-desc)
  +                             (proto-name field-desc))))
  +              (if field-printed
  +                  (format stream ",")
  +                  (setf field-printed t))
  +              (if indent
  +                  (format stream "~&~V,0T\"~A\": " (+ indent 2) name)
  +                  (format stream "\"~A\":" name))
  +              (print-field-to-json value type (and indent (+ indent 2))
  +                                   stream camel-case-p numeric-enums-p))))))
       (if indent
           (format stream "~&~V,0T}" indent)
  -        (format stream "}")))))
  +        (format stream "}"))))
   
   (defun print-field-to-json (value type indent stream camel-case-p numeric-enums-p)
     "Print a field to JSON format.
  
positive.code:                     ((#\n)
                       (let ((tok (parse-token stream)))
                         (unless (string= tok "null")
                           (setf error-p t)))))
                    (multiple-value-setq (val error-p)
                      (parse-value-from-json type :stream stream)))
                (cond
                  (error-p
                   (undefined-field-type "While parsing ~S from JSON format,"
  
negative.code:         (if (null field)
              (skip-json-value stream)
              (let (val error-p)
                (if (not (eq (proto-label field) :repeated))
                    (multiple-value-setq (val error-p)
                      (parse-value-from-json type :stream stream))
                    (case (peek-char nil stream nil)
                      ;; Repeated field is in list format
                      ((#\[)
  