anchor.diff:    (let ((point (point)))
       (when (backward-sexp)
         (mark-sexp)
  -      (let ((expr
  -             (read-from-string
  -              (region-string (region-beginning)
  -                             (region-end)))))
  +
  +      (let ((str (region-string (region-beginning)
  +                                (region-end))))
           (point-set point)
           (insert-newline 1)
  -        (insert-string (write-to-string (safe-eval expr)))
  +        (insert-string (write-to-string (safe-eval-from-string str)))
           (insert-newline 1)))))
  
positive.code:       (bt:destroy-thread mi-thread))
      val))
  
  (defun safe-eval (x)
    (let ((result
           (handler-case (safe-eval-1 x)
             #+sbcl
             (sb-thread:join-thread-error
              (cdt)
              (write-message "interrupt")
              nil))))
      result))
  
  (defun eval-string (str)
    (write-message
     (write-to-string
      (safe-eval (string-to-exps str)))))
  
  (define-command eval-region (&optional begin end) ("r")
    (unless (or begin end)
  
negative.code:         (setq str (subseq str i))))
      (cons 'progn (nreverse exps))))
  
  (defun eval-from-string (str)
    (eval (string-to-exps str)))
  
  (defun safe-eval-from-string-1 (str)
    (unless (get-buffer "*REPL*")
      (let ((*current-window* *current-window*))
        (inferior-lisp)))
    (let ((val))
      (let* ((eval-thread
              (bt:make-thread
               (lambda ()
                 (let ((out 
                        (let ((repl-buffer (get-buffer-create "*REPL*")))
                          (make-buffer-output-stream
                           repl-buffer
                           (make-point (buffer-nlines repl-buffer)
                                       0)))))
                   (let ((*error-output* (or out *error-output*))
                         (*standard-output* (or out *standard-output*)))
                     (handler-case
                         (prog1 (setq val (eval-from-string str))
                           (point-set (make-point
                                       (buffer-output-stream-linum out)
                                       (buffer-output-stream-column out))))
                       (error (cdt)
                              (let* ((buffer (get-buffer-create "*Error*"))
                                     (out (make-buffer-output-stream buffer)))
                                (popup buffer 
                                       (lambda ()
                                         (princ cdt out)))))))))))
             (mi-thread
              (bt:make-thread
               (lambda ()
  