anchor.diff:    ;; We can be reasonably sure that nothing but well-formed (both in
     ;; JSON and Lisp sense) number literals get to this point.
     (handler-case (read-from-string token)
  -    ((or reader-error #+ecl arithmetic-error) (err)
  +    ((or reader-error #+ecl arithmetic-error #+allegro error) (err)
         ;; Typically, this happens when the exponent is too large for
         ;; the number to be represented as a float -- a concealed (or,
         ;; exceptionally in ECL, manifest) FLOATING-POINT-OVERFLOW.  At
  
positive.code:       ;; either this causes the overflow error to be explicitly
        ;; signaled, or else we might get some more or less
        ;; non-nonsensical value.
        (let ((f-marker (position #\. token :test #'char-equal))
              (e-marker (position #\e token :test #'char-equal)))
          (if (or e-marker f-marker)
              (let* ((int-part
  
negative.code:                    (frac-part
                      (if f-marker
                          (subseq token (1+ f-marker) e-marker)
                          "0"))
                     (significand
                      (+ (read-from-string int-part)
                         (* (read-from-string frac-part)
  