anchor.diff:                  (setf last-result result)
                   (debug-log status "RESULT ~A" result))
               (skip ()))
  -          (display-prompt stream prompt-stream))
  +          (setf *fresh-prompt* t))
         (die () (exit 1)))
       last-result))
   
  
positive.code:     (when *enable-lisp-splice*
        (setf *shell-readtable* *splice-table*))
  
      (run-shell-commands-in-stream *standard-input* :prompt-stream *standard-output*)))
  
negative.code: 
  (defparameter *shell-readtable* +standard-shell-readtable+)
  
  (defparameter *fresh-prompt* t)
  
  (defun next-line ()
    (let ((prompt (if *fresh-prompt* "shcl> " "> ")))
      (setf *fresh-prompt* nil)
      (get-line prompt)))
  
  (defclass interactive-buffer (fundamental-character-input-stream)
    ((text
      :initform (fset:empty-seq))))
  
  (defun extend-interactive-buffer (stream)
    (with-slots (text) stream
      (unless (open-stream-p stream)
        (error "Stream is closed"))
      (unless (zerop (fset:size text))
        (error "Stream isn't empty yet"))
      (let ((next-line (next-line)))
        (cond
          (next-line
           (assert (plusp (length next-line)))
           (fset:appendf text next-line))
  
          (t
           (close stream)))
        (values))))
  
  (defun buffer-read-char (s hang-p)
    (with-slots (text) s
      (tagbody
       again
         (return-from buffer-read-char
           (cond
             ((plusp (fset:size text))
              (let ((result (fset:pop-first text)))
                result))
  
             ((not (open-stream-p s))
              :eof)
  
             (hang-p
              (extend-interactive-buffer s)
              (go again))
  
             (t
              nil))))))
  
  (defmethod stream-read-char ((s interactive-buffer))
    (let ((value (buffer-read-char s t)))
      (assert value)
      value))
  
  (defmethod stream-unread-char ((s interactive-buffer) char)
    (with-slots (text) s
      (fset:push-first text char)
      nil))
  
  (defmethod stream-read-char-no-hang ((s interactive-buffer))
    (buffer-read-char s nil))
  
  (defmethod stream-clear-input ((s interactive-buffer))
    (with-slots (text) s
      (setf text (fset:empty-seq))))
  
  (defclass echo (fundamental-character-output-stream)
      ())
  
  (defmethod stream-write-char ((s echo) char)
    (format *standard-output* "CHAR: ~W~%" char)
    char)
  
  