anchor.diff:        (seen-escape
          (intern token))
         ;; Attempt to parse a number.
  -      (t (or (maybe-parse-number token)
  -             (parse-ratio token)
  +      (t (or (read-integer token)
  +             (read-float token)
  +             (read-ratio token)
                (intern token))))))
   
  -(defun parse-ratio (string)
  +(defun read-ratio (string)
     ;; ratio = sign? digits+ slash digits+
     (let ((numerator nil)
           (denominator nil)
  
positive.code:       (#\+ (incf start)))
      ;; Ensure at least one numerator digit.
      (when (>= start len)
        (return-from parse-ratio))
      (setf numerator (digit-char-p (char string start) *read-base*))
      (when (not numerator)
        (return-from parse-ratio))
      (loop
         (incf start)
         (when (>= start len)
           (return-from parse-ratio))
         (let ((ch (char string start)))
           ;; Numerator is terminated by a slash.
           (when (eql ch #\/)
             (return))
           (let ((weight (digit-char-p ch *read-base*)))
             (when (not weight)
               (return-from parse-ratio))
             (setf numerator (+ (* numerator *read-base*)
                                weight)))))
      ;; Skip over the slash.
      (incf start)
      ;; Ensure at least one denominator digit.
      (when (>= start len)
        (return-from parse-ratio))
      (setf denominator (digit-char-p (char string start) *read-base*))
      (when (not denominator)
        (return-from parse-ratio))
      (loop
         (incf start)
         (when (>= start len)
           (return))
         (let ((weight (digit-char-p (char string start) *read-base*)))
           (when (not weight)
             (return-from parse-ratio))
           (setf denominator (+ (* denominator *read-base*)
                                weight))))
      (/ numerator denominator)))
  
  (defun parse-float (string)
    (let ((integer-part 0)
          (decimal-part 0.0)
          (negativep nil)
          (start 0))
      ;; Check for a leading sign.
      (case (char string 0)
        (#\- (incf start)
             (setf negativep t))
        (#\+ (incf start)))
      ;; Parse the integer portion.
      (loop
         (when (or (>= start (length string))
                   (eql (char string start) #\.))
           (return))
         (setf integer-part (+ (* integer-part 10)
                               (digit-char-p (char string start))))
         (incf start))
      ;; Parse the decimal portion.
      (when (eql (char string start) #\.)
        (let ((end (length string)))
          (loop
             (decf end)
             (when (<= end start) (return))
             (incf decimal-part (digit-char-p (char string end)))
             (setf decimal-part (/ decimal-part 10)))))
      ;; Mash together and apply the sign.
      (* (+ integer-part decimal-part)
         (if negativep -1 1))))
  
  (defun maybe-parse-number (token)
    "Attempt to parse TOKEN as a number, if it can't be parsed as a number,
  then return NIL."
    ;; integer = sign? decimal-digit+ decimal-point
    ;;         = sign? digit+
    ;; float   = sign? decimal-digit+ decimal-point decimal-digit+
    (let ((read-base *read-base*)
  	(negative nil)
  	(saw-sign nil)
  	(saw-point nil)
  	(number 0)
  	(start 0)
  	(end (length token)))
      ;; Check for a trailing decimal point, identifying a decimal integer
      (when (decimal-point-p (char token (1- (length token))))
        (setf read-base 10
  	    saw-point t
  	    end (1- end)))
      ;; Check for a leading sign.
      (when (or (plus-sign-p (char token 0))
  
negative.code:       (setf saw-sign t
  	    negative (minus-sign-p (char token 0))
  	    start (1+ start)))
      ;; If the token is empty, aside from the sign, then it isn't a number.
      (when (not (= (- end start) 0))
        ;; Main digit-reading loop for integers.
        (do ((offset start (1+ offset)))
            ((>= offset end)
             ;; Successfully parsed an integer!
             (if negative
                 (- number)
                 number))
          (let ((weight (digit-char-p (char token offset) read-base)))
            (when (not weight)
              ;; This character is not a digit in the current base.
              (return))
            (setf number (+ (* number read-base) weight)))))))
  
  (defun read-maybe-nothing (stream char)
    (let ((retval (multiple-value-list
  