anchor.diff:                                        (multiple-value-list (eval x))
                                       (lem::editor-abort () :report "Abort.")))
                               (when update-point-p
  -                              (lem::move-point marker cur-marker)))
  +                              (lem::move-point point cur-point)))
                              ((condition)
                               (setq error-p t)
                               (setq results (list condition))))
           (values results error-p)))))
   
  -(defun %lisp-eval (x marker
  +(defun %lisp-eval (x point
                        &optional update-point-p)
     (lem::call-with-allow-interrupt
      t
      (lambda ()
        (multiple-value-bind (results error-p)
            (%lisp-eval-internal x
  -                              marker
  +                              point
                                 update-point-p)
          (values results error-p)))))
   
  -(defun %lisp-eval-string (string marker
  +(defun %lisp-eval-string (string point
                                    &optional
                                    update-point-p (package "COMMON-LISP-USER"))
     (%lisp-eval `(cl:progn ,@(%string-to-exps string package))
  -              marker
  +              point
                 update-point-p))
   
   (define-key *global-keymap* (kbd "M-:") 'lisp-eval-string)
  
positive.code:                  (loop :for (file jump-fun) :in defs
                         :do (lem.sourcelist:append-sourcelist
                              sourcelist
                              (lambda (cur-marker)
                                (lem::insert-string-at cur-marker file))
                              jump-fun)))))))))
  
  (define-key *lisp-mode-keymap* (kbd "M-,") 'lisp-pop-find-definition-stack)
  (define-command lisp-pop-find-definition-stack () ()
    (let ((cur-marker (pop *lisp-find-definition-stack*)))
      (unless cur-marker
        (return-from lisp-pop-find-definition-stack nil))
      (switch-to-buffer (point-buffer cur-marker))
      (lem::move-point (current-point) cur-marker)))
  
  (defun analyze-symbol (str)
    (let (package
  
negative.code:                             (stop-timer *lisp-timer*)))))
  
  (defun lisp-print-values (values)
    (lem::with-point ((point (current-point) :left-inserting))
      (with-open-stream (out (make-buffer-output-stream point))
        (let ((*package* (lisp-current-package)))
          (dolist (v values)
            (pprint v out))))
      (lem::move-point (current-point) point)))
  
  (define-key *lisp-mode-keymap* (kbd "C-c C-j") 'lisp-eval-print-last-sexp)
  (define-command lisp-eval-print-last-sexp () ()
  