anchor.diff:      (syntax-add-match
        table
        (make-syntax-test "#[+-]" :regex-p t)
  -     :move-action (lambda (cur-marker)
  +     :move-action (lambda (cur-point)
                       (ignore-errors
  -                     (let ((positivep (eql #\+ (lem::character-at cur-marker 1))))
  -                       (lem::character-offset cur-marker 2)
  -                       (lem::with-point ((prev cur-marker))
  -                         (when (lem::form-offset cur-marker 1)
  +                     (let ((positivep (eql #\+ (lem::character-at cur-point 1))))
  +                       (lem::character-offset cur-point 2)
  +                       (lem::with-point ((prev cur-point))
  +                         (when (lem::form-offset cur-point 1)
                              (cond
                                ((if (featurep (read-from-string
                                                (lem::points-to-string
  -                                              prev cur-marker)))
  +                                              prev cur-point)))
                                     positivep
                                     (not positivep))
                                 nil)
                                (t
  -                              (lem::form-offset cur-marker 1))))))))
  +                              (lem::form-offset cur-point 1))))))))
        :attribute *feature-attribute*)
   
       table))
  
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:                                       (multiple-value-list (eval x))
                                      (lem::editor-abort () :report "Abort.")))
                              (when update-point-p
                                (lem::move-point point cur-point)))
                             ((condition)
                              (setq error-p t)
                              (setq results (list condition))))
          (values results error-p)))))
  
  (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
                                point
                                update-point-p)
         (values results error-p)))))
  
  (defun %lisp-eval-string (string point
                                   &optional
                                   update-point-p (package "COMMON-LISP-USER"))
    (%lisp-eval `(cl:progn ,@(%string-to-exps string package))
                point
                update-point-p))
  
  (define-key *global-keymap* (kbd "M-:") 'lisp-eval-string)
  