anchor.diff:     :object-key #'accumulator-add-key
      :object-value #'accumulator-add-value
      :end-of-object #'accumulator-get
  -   :beginning-of-string #'init-vector-accumulator
  -   :string-char #'vector-accumulator-add
  -   :end-of-string #'vector-accumulator-get-string
  +   :beginning-of-string #'init-accumulator
  +   :string-char #'accumulator-add
  +   :end-of-string #'accumulator-get-string
      :aggregate-scope (union *aggregate-scope-variables*
                              '(*accumulator* *accumulator-last*))
      :internal-decoder #'decode-json))
  
positive.code:   "Read a JSON number token from the given STREAM, and return 2
  values: the token category (:INTEGER or :REAL) and the token itself,
  as a string."
    (let ((int (make-array 32 :adjustable t :fill-pointer 0
                           :element-type 'character))
          (frac (make-array 32 :adjustable t :fill-pointer 0
                            :element-type 'character))
          (exp (make-array 32 :adjustable t :fill-pointer 0
                           :element-type 'character))
          (type :integer)
          c)
      (flet ((safe-read-char (stream)
               (handler-case (read-char stream)
                 (end-of-file ()
                   (return-from read-json-number-token
                     (values type (concatenate 'string int frac exp)))))))
        (macrolet
            ((read-digits (part)
               (let ((error-fmt
                      (format nil "Invalid JSON number: no ~(~A~) digits"
                              part)))
                 `(loop while (char<= #\0 c #\9)
                     with count = 0
                     do (vector-push-extend c ,part 32)
                        (setq c (safe-read-char stream))
                        (incf count)
                     finally
                       (if (zerop count)
                           (json-syntax-error stream ,error-fmt))))))
          (setq c (read-char stream))
          (when (char= c #\-)
            (vector-push c int)
            (setq c (read-char stream)))
          (if (char= c #\0)
              (progn
                (vector-push c int)
                (setq c (safe-read-char stream)))
              (read-digits int))
          (when (char= c #\.)
            (vector-push c frac)
            (setq c (read-char stream)
                  type :real)
            (read-digits frac))
          (when (char-equal c #\e)
            (vector-push c exp)
            (setq c (read-char stream)
                  type :real)
            (when (or (char= c #\+) (char= c #\-))
              (vector-push c exp)
              (setq c (read-char stream)))
            (read-digits exp))
          (unread-char c stream)
          (values type (concatenate 'string int frac exp))))))
  
  (defun read-json-name-token (stream)
    "Read a JSON literal name token from the given STREAM, and return 2
  values: the token category (:BOOLEAN) and the token itself, as a
  string."
    (let ((symbol (make-array 8 :adjustable t :fill-pointer 0
                              :element-type 'character)))
      (loop for c = (read-char stream nil)
         while (and c (alpha-char-p c))
         do (vector-push-extend c symbol 32)
         finally (if c (unread-char c stream)))
      (setq symbol (coerce symbol 'string))
      (if (assoc symbol +json-lisp-symbol-tokens+ :test #'equal)
          (values :boolean symbol)
          (json-syntax-error stream "Invalid JSON literal name: ~A"
                             symbol))))
  
  (define-condition no-char-for-code (error)
    ((offending-code :initarg :code :reader offending-code))
  
negative.code: *JSON-ARRAY-TYPE*."
    (coerce (cdr *accumulator*) *json-array-type*))
  
  (defun accumulator-get-string ()
    "Return all values accumulated so far in the list accumulator as
  *JSON-ARRAY-TYPE*."
    (coerce (cdr *accumulator*) 'string))
  
  (defun accumulator-get ()
    "Return all values accumulated so far in the list accumulator as a
  list."
    (cdr *accumulator*))
  
  #| Invalidated.
  
  (defun init-vector-accumulator ()
    "Initialize a vector accumulator."
    (setq *accumulator*
  