anchor.diff:  
   (defun formatter-fn (*string* *default-package*)
     (or (catch :format-compilation-error
  -        `(apply (function maybe-initiate-xp-printing)
  -                (function
  -                 (lambda (xp &rest args)
  +        `(apply #'maybe-initiate-xp-printing
  +                (lambda (xp &rest args)
                     ,@(bind-initial
                        `((block top
                            ,@(let ((*get-arg-carefully* nil)
                                    (*at-top* t)
                                    (*inner-end* 'top)
                                    (*outer-end* 'top))
  -                             (compile-format 0 (length *string*))))))
  -                  (if ,(args) (copy-list ,(args))))) ;needed by symbolics.
  +                                (compile-format 0 (length *string*))))))
  +                  ,(args))
                   s args))
  -      `(apply #'format s *string* args)))
  +      `(apply #'format s ,*string* args)))
   
   ;The business with the catch above allows many (formatter "...") errors to be
   ;reported in a file without stopping the compilation of the file.
  -
  -(defun maybe-compile-format-string (string force-fn?)
  -  (if (not (or force-fn? (fancy-directives-p string)))
  -      string
  -      (eval `(formatter ,string))))
  -
  -;COMPILE-FORMAT gets called to turn a bit of format control string into code.
   
   (defvar *testing-errors* nil "Used only when testing XP")
   
  
positive.code:              (return nil))
              ((char= c #\') (incf i))
              (T (return n))))))
  
  (defun compile-format (start end)
    (let ((result nil))
  
negative.code:         (T (if (eq stream T) (setf stream *standard-output*))
             (when (stringp string-or-fn)
               (setf string-or-fn (process-format-string string-or-fn nil)))
             (apply string-or-fn stream args)
             nil)))
  
  (defvar *format-string-cache* (make-hash-table :test #'equal))
  
  (defun compile-format-string (string)
    (eval `(formatter ,string)))
  
  (defun process-format-string (string-or-fn force-fn?)
    (cond ((not (stringp string-or-fn)) string-or-fn) ;called from ~? too.
          (T (let ((value (gethash string-or-fn *format-string-cache*)))
               (when (or (not value) (and force-fn? (stringp value)))
                 (setf value (compile-format-string string-or-fn))
                 (setf (gethash string-or-fn *format-string-cache*) value))
               value))))
  