anchor.diff:  (defvar *debug-p* nil)
   (defvar *in-the-editor* nil)
   
  +(defparameter +bailout-tag+ (make-symbol "BAILOUT"))
  +
   (defun pop-up-backtrace (condition)
     (let ((buffer (get-buffer-create "*EDITOR ERROR*")))
       (erase-buffer buffer)
  
positive.code: (defun lem (&rest args)
    (if *in-the-editor*
        (mapc 'find-file args)
        (let ((report (with-editor ()
                        (mapc 'find-file args)
                        (lem-internal))))
          (when report
            (format t "~&~A~%" report)))))
  
negative.code:     (stop-idle-timers)))
  
  (defun toplevel-editor-loop ()
    (do-commandloop (:toplevel t)
      (with-error-handler ()
        (when (= 0 (event-queue-length)) (redraw-display))
        (handler-case
            (handler-bind ((editor-condition
                            (lambda (c)
                              (declare (ignore c))
                              (stop-record-key))))
              (let ((cmd (read-key-command-with-idle-timers)))
                (message nil)
                (cmd-call cmd nil)))
          (editor-abort ()
                        (buffer-mark-cancel (current-buffer))
                        (message "Quit"))
          (editor-condition (c)
                            (message "~A" c))))))
  
  (defun lem-internal ()
    (let* ((main-thread (bt:current-thread))
           (editor-thread (bt:make-thread
                           (lambda ()
                             (let ((*in-the-editor* t))
                               (let ((report (with-catch-bailout
                                               (toplevel-editor-loop))))
                                 (bt:interrupt-thread
                                  main-thread
                                  (lambda ()
                                    (error 'exit-editor :value report))))))
                           :name "editor")))
      (handler-case
          (loop
  