anchor.diff:      (setf (buffer-mark-col buffer) 0)
       (setf (buffer-nlines buffer) 1)
       (setf (buffer-undo-size buffer) 0)
  -    (setf (buffer-undo-stack buffer) (make-tlist))
  +    (setf (buffer-undo-stack buffer) nil)
       (setf (buffer-redo-stack buffer) nil)
       (push buffer *buffer-list*)
       buffer))
  
positive.code:      nil)))
  
  (defun buffer-undo-1 (buffer)
    (let ((tlist (buffer-undo-stack buffer)))
      (unless (tlist-empty-p tlist)
        (decf (buffer-undo-size buffer))
        (let ((elt (tlist-right tlist))
              (*use-redo-stack* t))
          (setf (car tlist) (butlast (car tlist)))
          (tlist-update tlist)
          (unless (eq elt :undo-separator)
            (funcall elt))))))
  
  (defun buffer-undo (buffer)
    (do ((res #1=(buffer-undo-1 buffer) #1#)
         (pres nil res))
        ((not res) pres)))
  
  (defun buffer-redo (buffer)
    (let ((f (pop (buffer-redo-stack buffer))))
      (when f
        (let ((*use-undo-stack* t))
          (funcall f)))))
  
  (defclass buffer-output-stream (sb-gray:fundamental-output-stream)
    ((buffer
  
negative.code: 
  (defun push-undo-stack (buffer elt)
    (cond ((<= *undo-limit* (buffer-undo-size buffer))
           )
          (t
           (incf (buffer-undo-size buffer))))
    (when-interrupted-flag 
     undo
     (push :undo-separator (buffer-undo-stack buffer)))
    (push elt (buffer-undo-stack buffer)))
  
  (defun push-redo-stack (buffer elt)
    (push elt (buffer-redo-stack buffer)))
  