anchor.diff:  
   ;;;; Readtables Iterators
   
  +(defmacro with-readtable-iterator ((name readtable) &body body)
  +  (let ((it (gensym)))
  +    `(let ((,it (%make-readtable-iterator ,readtable)))
  +       (macrolet ((,name () `(funcall ,',it)))
  +         ,@body))))
  +
   #+sbcl
   (defun %make-readtable-iterator (readtable)
     (let ((char-macro-array (sb-impl::character-macro-array readtable))
  
positive.code: (eval-when (:compile-toplevel :execute)
    #+sbcl (when (find-symbol "ASSERT-NOT-STANDARD-READTABLE"
                              (find-package "SB-IMPL"))
             (push :sbcl+safe-standard-readtable *features*)))
  
  
  ;;;;; Implementation-dependent cruft
  
negative.code:                 (values t char defn nil nil)))
            (values nil nil nil nil nil)))))
  
  #-(or sbcl clozure)
  (eval-when (:compile-toplevel)
    (simple-style-warn
     "~A hasn't been ported to ~A. ~
      We fall back to a portable implementation of readtable iterators. ~
      This implementation has to grovel through all available characters. ~
      On Unicode-aware implementations this comes with some costs." 
     (package-name *package*) (lisp-implementation-type)))
  
  #-(or sbcl clozure)
  (defun %make-readtable-iterator (readtable)
    (check-type readtable readtable)
    (let ((char-code 0))
      #'(lambda ()
          (prog ()
             :GROVEL
             (when (< char-code char-code-limit)
               (let* ((char (code-char char-code))
                      (fn   (get-macro-character char readtable)))
                 (incf char-code)
                 (when (not fn) (go :GROVEL))
                 (multiple-value-bind (disp? alist)
                     (handler-case ; grovel dispatch macro characters.
                         (values t (loop for code from 0 below char-code-limit
                                         for subchar = (code-char code)
                                         for disp-fn = (get-dispatch-macro-character
                                                        char subchar readtable)
                                         when disp-fn
                                         collect (cons subchar disp-fn)))
                       (error () nil))
                   (return (values t char fn disp? alist)))))))))
  