anchor.diff:        ;; 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))
  +      (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
  
positive.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)
  
negative.code:          do (funcall *string-char-handler* c)
           finally (return (funcall *end-of-string-handler*))))))
  
  ;;; handling numerical read errors in ACL
  #+allegro
  (defun allegro-read-numerical-overflow-p (condition)
    (and (typep condition 'simple-error)
         (search "is too large to be converted"
                 (slot-value condition 'excl::format-control))))
  
  #+allegro
  (deftype allegro-reader-numerical-overflow ()
    `(and error (satisfies allegro-read-numerical-overflow-p)))
  
  
  ;;; The default semantics
  
  