anchor.diff:    (defmacro formatting-row ((&optional (stream t)
                                          &rest more
                                          &key (record-type ''standard-row-output-record))
  -                             &body body)
  +                            &body body)
       (setf stream (stream-designator-symbol stream '*standard-output*))
       (with-gensyms (record)
         (with-keywords-removed (more (:record-type))
  
positive.code:     ;; Since we have :baseline vertical alignment (and no :char
      ;; horizontal alignment like in HTML), we always work from rows.
      (multiple-value-bind (rows nrows ncols)
  	(make-table-array table-record)
        (unless rows
  	(return-from adjust-table-cells nil))
  
        (let ((widthen  (make-array ncols :initial-element 0))
  	    (heights  (make-array nrows :initial-element 0))
  	    (ascents  (make-array nrows :initial-element 0))
  	    (descents (make-array nrows :initial-element 0)))
  	;; collect widthen, heights
  	(loop for row across rows
  	   for i from 0 do
  	   (loop for cell across row
  	      for j from 0 do
  	      ;; we have cell at row i col j at hand.
  	      ;; width:
  	      (multiple-value-bind (x1 y1 x2 y2) (bounding-rectangle* cell)
  		(maxf (aref widthen j)
  		      (max (- x2 x1) (cell-min-width cell)))
  		(maxf (aref heights i)
  		      (max (- y2 y1) (cell-min-height cell)))
  		(when (eq (cell-align-y cell) :baseline)
  		  (multiple-value-bind (baseline) (output-record-baseline cell)
  		    (maxf (aref ascents i) baseline)
  		    (maxf (aref descents i) (- y2 y1 baseline)))))))
  
  	;; baseline aligned cells can force the row to be taller.
  	(loop for i from 0 below nrows do
  	     (maxf (aref heights i) (+ (aref ascents i) (aref descents i))))
  
  	(when (slot-value table-record 'equalize-column-widths)
  	  (setf widthen (make-array ncols :initial-element (reduce #'max widthen :initial-value 0))))
  
  	(setf (slot-value table-record 'widths) widthen
  	      (slot-value table-record 'heights) heights
  	      (slot-value table-record 'rows) rows)
            
  	;; Finally just put the cells where they belong.
  
  	(multiple-value-bind (cx cy) (stream-cursor-position stream)
  	  (loop for row across rows
  	     for y = cy then (+ y h y-spacing)
  	     for h across heights
  	     for ascent across ascents
  	     do
  	     (loop for cell across row
  		for x = cx then (+ x w x-spacing) 
  		for w across widthen do
  		(adjust-cell* cell x y w h ascent))))))))
  
  (defmethod adjust-multiple-columns ((table standard-table-output-record) stream)
    (with-slots (widths heights rows
                 multiple-columns multiple-columns-x-spacing x-spacing y-spacing)
        table
      (let* ((mcolumn-width
              ;; total width of a column of the "meta" table.
  
negative.code:                                          equalize-column-widths (move-cursor t)
                                           (record-type ''standard-table-output-record)
                                           &allow-other-keys)
                                &body body)
      (declare (ignore x-spacing y-spacing multiple-columns
                       multiple-columns-x-spacing
                       equalize-column-widths move-cursor record-type))
  