anchor.diff:  
   (defmacro formatting-cell ((&optional (stream t)
                               &key (align-x :left) (align-y :center) ; FIXME!!! It must be :baseline, but it is not yet implemented
  -                                 (min-width (coordinate 0)) ; ???
  -                                 (min-height (coordinate 0))
  +                                 min-width min-height
                                    (record-type 'standard-cell-output-record))
                              &body body)
  -  (declare (type symbol stream))
  +  (check-type stream symbol)
     (when (eq stream 't)
       (setq stream '*standard-output*))
  -  (let ((record (gensym))
  -        (parent (gensym)))
  +  (let ((record (gensym "RECORD"))
  +        (parent (gensym "PARENT")))
       `(progn
          (let ((,parent (stream-current-output-record ,stream)))
            (assert (or (row-output-record-p ,parent)
                        (column-output-record-p ,parent))))
          (with-new-output-record (,stream ,record-type ,record
                                   :align-x ,align-x :align-y ,align-y
  -                                :min-width ,min-width :min-height ,min-height)
  +                                :min-width (parse-space ,stream
  +                                                        (or ,min-width 0)
  +                                                        :horizontal)
  +                                :min-height (parse-space ,stream
  +                                                         (or ,min-height 0)
  +                                                         :vertical))
            (declare (ignore ,record))
            ,@body))))
   
  
positive.code:   "Returns a list of BLOCK-INFOs for blocks in TABLE."
    (let ((infos nil))
      (map-over-table-elements
       #'(lambda (block)
           (push (block-info block) infos))
       table
       :row-or-column)
      (nreverse infos)))
  
  (defmethod adjust-table-cells ((table-record standard-table-output-record)
                                 stream)
    (let* ((cell-spacing (table-cell-spacing table-record stream))
           (block-spacing (table-block-spacing table-record stream))
           (infos (collect-block-infos table-record))
           (max-block-length (loop :for info :in infos
                                :maximize (block-info-number-of-cells info)))
           (sizes (make-array (list max-block-length)
                              :element-type 'real
                              :initial-element (coordinate 0))))
      (loop :for info :in infos
         :for block-sizes = (block-info-cell-sizes info)
         :do (loop :for i = 0 :then (1+ i)
  
negative.code:        ,table)))
  
  ;;; Internal
  (defgeneric table-cell-spacing (table)
    (:documentation "Spacing between cells in blocks when the TABLE is
  to be displayed on the STREAM."))
  
  (defgeneric table-block-spacing (table)
    (:documentation "Spacing between blocks in the TABLE when it is to
  be displayed on the STREAM."))
  
  