anchor.diff:                                        :ignore-error-status t)))
                   (alexandria:curry #'grep-with-string
                                     "*grep*"
  +                                  directory
                                     #'f))))
         (f))))
   
  
positive.code:     (delete-between-points start end)
      (insert-string point string)))
  
  (defun next-replace-region (point)
    (unless (or (text-property-at point 'match-string)
                (next-single-property-change point 'match-string))
      (return-from next-replace-region))
    (with-point ((start point)
                 (end point))
      (line-end end)
      (values start end)))
  
  (defun replace-diff-with-current-line (point new-string)
    (alexandria:when-let (fn (text-property-at point 'jump-fn))
      (let* ((buffer (funcall fn))
             (point (buffer-point buffer)))
        (replace-line point new-string))))
  
  (defun replace-diff (p)
    (multiple-value-bind (start end)
        (next-replace-region p)
      (unless start (return-from replace-diff nil))
      (let ((old-string (text-property-at start 'match-string))
            (new-string (points-to-string start end)))
        (unless (string= old-string new-string)
          (replace-diff-with-current-line p new-string)))
      (move-point p end)
      t))
  
  (defun replace-all (buffer)
    (with-point ((p (buffer-point buffer)))
  
negative.code:   #+sbcl
    (:lock t))
  (in-package :lem.grep)
  
  (defvar *syntax-table*
    (let ((table (make-syntax-table))
          (tmlanguage (make-tmlanguage
                       :patterns (make-tm-patterns
                                  (make-tm-match "^(.*?):(\\d+):(\\d+):(?:.*)"
                                                 :captures (vector nil
                                                                   (make-tm-name 'lem.sourcelist:title-attribute)
                                                                   (make-tm-name 'lem.sourcelist:position-attribute)
                                                                   (make-tm-name 'lem.sourcelist:position-attribute)))
                                  (make-tm-match "^(.*?):(\\d+):(?:.*)"
                                                 :captures (vector nil
                                                                   (make-tm-name 'lem.sourcelist:title-attribute)
                                                                   (make-tm-name 'lem.sourcelist:position-attribute)))))))
      (set-syntax-parser table tmlanguage)
      table))
  
  (define-major-mode grep-mode nil
      (:name "grep"
       :keymap *grep-mode-keymap*
       :syntax-table *syntax-table*)
    (setf (variable-value 'enable-syntax-highlight) t)
    (setf (variable-value 'truncate-lines) nil))
  
  (define-key *grep-mode-keymap* "Return" 'grep-jump)
  (define-key *grep-mode-keymap* "q" 'quit-window)
  
  (defun grep-parse-line (line)
    (ignore-errors
  