anchor.diff:                              (stop-timer *lisp-timer*)))))
   
   (defun lisp-print-values (values)
  -  (lem::with-point ((marker (current-point) :left-inserting))
  -    (with-open-stream (out (make-buffer-output-stream marker))
  +  (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) marker)))
  +    (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 () ()
  
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:     (syntax-add-match
       table
       (make-syntax-test "#[+-]" :regex-p t)
       :move-action (lambda (cur-point)
                      (ignore-errors
                       (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-point)))
                                    positivep
                                    (not positivep))
                                nil)
                               (t
                                (lem::form-offset cur-point 1))))))))
       :attribute *feature-attribute*)
  
      table))
  