anchor.diff:              `(let ,(mapcar #'list vars params)
                  (funcall (symbol-function ',fn) xp ,(get-arg) ,colon ,atsign ,@ vars)))))))
   
  +;; TODO: Process mincol,colinc,minpad,padchar.
  +(defun impl-A/S (start end escape-value)
  +  (declare (ignore end))
  +  (multiple-value-bind (colon atsign)
  +      (parse-params start nil)
  +    (declare (ignore atsign))
  +    (if colon
  +        `(let ((*print-escape* ,escape-value)
  +               (arg ,(get-arg)))
  +           (if arg
  +               (write+ arg XP)
  +               (write-string++ "()" XP 0 2)))
  +        `(let ((*print-escape* ,escape-value))
  +           (write+ ,(get-arg) XP)))))
  +
   (def-format-handler #\A (start end)
  -  (if (not (= end (1+ start))) (simple-directive start end)
  -      `(let ((*print-escape* nil))
  -         (write+ ,(get-arg) XP))))
  +  (impl-A/S start end nil))
   
   (def-format-handler #\S (start end)
  -  (if (not (= end (1+ start))) (simple-directive start end)
  -      `(let ((*print-escape* T))
  -         (write+ ,(get-arg) XP))))
  +  (impl-A/S start end t))
   
   ;The basic Format directives "DBOXRCFEG$".  The key thing about all of
   ;these directives is that they just get a single arg and print a chunk of
  
positive.code: 
  (defun formatter-fn (*string* *default-package*)
    (or (catch :format-compilation-error
          `(apply (function maybe-initiate-xp-printing)
                  (function
                   (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.
                  s 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")
  
  
negative.code: ;called is the internal routine that FORMAT uses to do the corresponding
  ;work.  However, this cannot be done in a portable way.
  
  (defun impl-integer (start end base)
    (declare (ignore end))
    (multiple-value-bind (colon atsign params)
        (parse-params start '(nil #\Space #\, 3))
      `(sys.format::format-integer ,(get-arg) ,base ',params ',atsign ',colon)))
  
  (def-format-handler #\D (start end) (impl-integer start end 10))
  (def-format-handler #\B (start end) (impl-integer start end 2))
  (def-format-handler #\O (start end) (impl-integer start end 8))
  (def-format-handler #\X (start end) (impl-integer start end 16))
  
  (def-format-handler #\R (start end)
    (declare (ignore end))
    (multiple-value-bind (colon atsign params)
        (parse-params start '(10 nil #\Space #\, 3))
      `(sys.format::format-radix ,(get-arg) ',params ',atsign ',colon)))
  
  (def-format-handler #\C (start end)
    (declare (ignore end))
    (multiple-value-bind (colon atsign)
        (parse-params start '())
      `(sys.format::format-character ,(get-arg) ',atsign ',colon)))
  
  ;; TODO.
  (def-format-handler #\F (start end) (impl-integer start end 10))
  (def-format-handler #\E (start end) (impl-integer start end 10))
  (def-format-handler #\G (start end) (impl-integer start end 10))
  (def-format-handler #\$ (start end) (impl-integer start end 10))
  
  ;Format directives that get open coded "P%&~|T*?^"
  
  