anchor.diff:    (check-connection)
     (let ((symbol-name
            (read-symbol-name "Describe symbol: "
  -                           (or (symbol-string-at-point (current-marker)) ""))))
  +                           (or (symbol-string-at-point (current-point)) ""))))
       (when (string= "" symbol-name)
         (editor-error "No symbol given"))
       (show-description (slime-eval-internal `(swank:describe-symbol ,symbol-name)))))
  
positive.code:                      (list :snippet _)))
           (push (list title file offset) found-list))))
      (when found-list
        (push (list (current-buffer) (current-point))
              *edit-definition-stack*)
        (if (null (rest found-list))
            (destructuring-bind (title file offset)
                (first found-list)
              (declare (ignore title))
              (find-file file)
              (goto-position offset))
            (let ((prev-file nil))
              (lem.sourcelist:with-sourcelist (sourcelist "*slime-definitions*")
                (dolist (elt found-list)
                  (destructuring-bind (title file offset) elt
                    (lem.sourcelist:append-sourcelist
                     sourcelist
                     (lambda (cur-marker)
                       (unless (and prev-file (string= prev-file file))
                         (lem::insert-string-at cur-marker
                                                (lem.text-property:make-text-property
                                                 file :attribute *headline-attribute*))
                         (lem::insert-char-at cur-marker #\newline))
                       (lem::insert-string-at cur-marker
                                              (lem.text-property:make-text-property
                                               (format nil "  ~A" title)
                                               :attribute *entry-attribute*)))
                     (lambda ()
                       (find-file file)
                       (goto-position offset)))
                    (setf prev-file file)))))))))
  
  (define-command slime-pop-find-definition-stack () ()
    (let ((elt (pop *edit-definition-stack*)))
      (when elt
        (destructuring-bind (buffer point) elt
          (select-buffer buffer)
          (point-set point)))))
  
  (define-command slime-edit-uses () ()
    (check-connection)
    (let* ((symbol (read-symbol-name "Edit uses of: " (or (symbol-string-at-point (current-marker)) "")))
           (result (slime-eval-internal `(swank:xrefs '(:calls :macroexpands :binds
                                                        :references :sets :specializes)
                                                      ,symbol)))
  
negative.code: (define-command slime-eval-last-expression () ()
    (check-connection)
    (refresh-output-buffer)
    (with-point ((start (current-point))
                 (end (current-point)))
      (scan-lists start -1 0)
      (interactive-eval (points-to-string start end))))
  
  (define-command slime-eval-defun () ()
    (check-connection)
    (with-point ((point (current-point)))
      (lem.lisp-mode::top-of-defun point)
      (with-point ((start point)
                   (end point))
        (scan-lists end 1 0)
        (let ((string (points-to-string start end)))
          (refresh-output-buffer)
          (if (ppcre:scan "^\\(defvar\\b" string)
              (re-eval-defvar string)
              (interactive-eval string))))))
  
  (define-command slime-eval-region (start end) ("r")
    (check-connection)
    (refresh-output-buffer)
    (interactive-eval (points-to-string start end)))
  
  (define-command slime-load-file (filename) ("fLoad File: ")
    (check-connection)
  