anchor.diff:  (defparameter *cold-stream-buffers* '())
   (defparameter *cold-stream-lock* (mezzano.supervisor:make-mutex '*cold-stream-buffers*))
   
  +(defstruct cold-stream-buffer
  +  thread
  +  data
  +  column)
  +
   (defmacro with-cold-stream-buffer ((buffer) &body body)
     `(let ((buffer (get-cold-stream-buffer)))
        ,@body))
  
positive.code:          (prev nil))
          ((endp i)
           (when (not entry)
             (setf entry (cons (make-weak-pointer self)
                               (make-array 100
                                           :element-type 'character
                                           :fill-pointer 0
                                           :adjustable t
                                           :area :wired)))
             (push entry *cold-stream-buffers*))
           (cdr entry))
        (let ((thread (weak-pointer-value (car (first i)))))
          (when (eql thread self)
            (setf entry (first i)))
          (cond (thread
                 (setf prev i))
                (t
                 ;; Entry is dead, flush & remove it.
                 (when (not (zerop (length (cdr (first i)))))
                   (mezzano.supervisor::debug-write-string (cdr (first i))))
                 (if prev
                     (setf (rest prev) (rest i))
                     (setf *cold-stream-buffers* (rest i)))))
  
negative.code: (defmethod mezzano.gray:stream-clear-input ((stream cold-stream))
    (cold-clear-input stream))
  
  (defun cold-stream-buffer-flush (buffer)
    (let ((data (cold-stream-buffer-data buffer)))
      (mezzano.supervisor::debug-write-string data)
      (setf (fill-pointer data) 0)))
  
  (defmethod mezzano.gray:stream-write-char ((stream cold-stream) character)
    (cond (*cold-stream-is-line-buffered*
           (with-cold-stream-buffer (buffer)
             (vector-push-extend character (cold-stream-buffer-data buffer))
             (cond ((eql character #\Newline)
                    (setf (cold-stream-buffer-column buffer) 0)
                    (cold-stream-buffer-flush buffer))
                   (t
                    (incf (cold-stream-buffer-column buffer))))))
          (t
           (cold-write-char character stream))))
  
  (defmethod mezzano.gray:stream-start-line-p ((stream cold-stream))
    (cond (*cold-stream-is-line-buffered*
           (with-cold-stream-buffer (buffer)
             (zerop (cold-stream-buffer-column buffer))))
          (t
           (cold-start-line-p stream))))
  
  (defmethod mezzano.gray:stream-line-column ((stream cold-stream))
    (cond (*cold-stream-is-line-buffered*
           (with-cold-stream-buffer (buffer)
             (cold-stream-buffer-column buffer)))
          (t
           (cold-line-column stream))))
  
  (defmethod mezzano.gray:stream-finish-output ((stream cold-stream))
    (when *cold-stream-is-line-buffered*
      (with-cold-stream-buffer (buffer)
        (cold-stream-buffer-flush buffer))))
  
  (defmethod mezzano.gray:stream-force-output ((stream cold-stream))
    (finish-output stream))
  