(diff-apply-hunk): Function basically rewritten. Now understands

  non-unified diffs.  Some functionality moved into `diff-hunk-text' and
  `diff-find-text'.  Add OTHER-FILE, DRY-RUN, POPUP, and NOERROR
  arguments.  If DRY-RUN is true, don't actually modify anything.  Only
  reposition point in the patched file if the patch succeeds.  Only pop
  up another window if POPUP is true.  Emit a message describing what
  happened if successful, and at what line-offset.  Automatically detect
  reversed hunks and do something appropriate.
(diff-hunk-text, diff-find-text): New functions.
(diff-filter-lines): Function removed.
(diff-test-hunk): New function.
(diff-goto-source): Rewritten in terms of diff-apply-hunk.

1 files changed, 210 insertions, 59 deletions

diff --git a/lisp/diff-mode.el b/lisp/diff-mode.el
index b737754f3db..5e5d4d7e625 100644
--- a/lisp/diff-mode.el
+++ b/lisp/diff-mode.el
@@ -4,7 +4,7 @@
 
 ;; Author: Stefan Monnier <monnier@cs.yale.edu>
 ;; Keywords: patch diff
-;; Revision: $Id: diff-mode.el,v 1.9 2000/08/16 19:56:10 monnier Exp $
+;; Revision: $Id: diff-mode.el,v 1.11 2000/09/07 20:14:27 fx Exp $
 
 ;; This file is part of GNU Emacs.
 
@@ -42,7 +42,6 @@
 
 ;; - Reverse doesn't work with normal diffs.
 ;; - (nitpick) The mark is not always quite right in diff-goto-source.
-;; - diff-apply-hunk only works on unified diffs.
 
 ;; Todo:
 
@@ -471,21 +470,6 @@ Non-nil OLD means that we want the old file."
       (if (null file) (error "Can't find the file")
         (list file line span)))))
 
-(defun diff-goto-source (&optional other-file)
-  "Jump to the corresponding source line.
-`diff-jump-to-old-file-flag' (or its opposite if the OTHER-FILE prefix arg
-is give) determines whether to jump to the old or the new file.
-If the prefix arg is bigger than 8 (for example with \\[universal-argument] \\[universal-argument])
-  then `diff-jump-to-old-file-flag' is also set, for the next invocations."
-  (interactive "P")
-  (save-excursion
-    (let ((loc (diff-find-source-location other-file)))
-      (pop-to-buffer (find-file-noselect (car loc)))
-      (ignore-errors
-        (goto-line (+ (cadr loc) (caddr loc)))
-        (push-mark (point) t t)
-        (goto-line (cadr loc))))))
-
 (defun diff-mouse-goto-source (event)
   "Run `diff-goto-source' for the diff at a mouse click."
   (interactive "e")
@@ -896,57 +880,224 @@ Only works for unified diffs."
                               nil t)
            (equal (match-string 1) (match-string 2)))))
 
-
-(defun diff-filter-lines (char)
+(defun diff-hunk-text (hunk dest)
+  "Returns the literal source text from HUNK, if DEST is nil, otherwise
+the destination text."
+  (with-current-buffer "foo"
+    (erase-buffer)
+    (insert hunk)
+    (goto-char (point-min))
+    (let ((src nil)
+          (dst nil)
+          (divider nil)
+          (num-pfx-chars 2))
+      (cond ((looking-at "^@@")
+             ;; unified diff
+             (setq num-pfx-chars 1)
+             (forward-line 1)
+             (setq src (point) dst (point)))
+            ((looking-at "^\\*\\*")
+             ;; context diff
+             (forward-line 2)
+             (setq src (point))
+             (re-search-forward "^--- " nil t)
+             (forward-line 0)
+             (setq divider (point))
+             (forward-line 1)
+             (setq dst (point)))
+            ((looking-at "^[0-9]+a[0-9,]+$")
+             ;; normal diff, insert
+             (forward-line 1)
+             (setq dst (point)))
+            ((looking-at "^[0-9,]+d[0-9]+$")
+             ;; normal diff, delete
+             (forward-line 1)
+             (setq src (point)))
+            ((looking-at "^[0-9,]+c[0-9,]+$")
+             ;; normal diff, change
+             (forward-line 1)
+             (setq src (point))
+             (re-search-forward "^---$" nil t)
+             (forward-line 0)
+             (setq divider (point))
+             (forward-line 1)
+             (setq dst (point)))
+            (t
+             (error "Unknown diff hunk type")))
+
+      (if (if dest (null dst) (null src))
+          ;; Implied empty text
+          ""
+
+        ;; Explicit text
+
+        ;; Delete unused text region
+        (let ((keep (if dest dst src))
+              (kill (or divider (if dest src dst))))
+          (when (and kill (> kill keep))
+            (delete-region kill (point-max)))
+          (delete-region (point-min) keep))
+
+        ;; Remove line-prefix characters, and unneeded lines (for
+        ;; unified diffs).
+        (let ((kill-char (if dest ?- ?+)))
   (goto-char (point-min))
   (while (not (eobp))
-    (if (eq (char-after) char)
+            (if (eq (char-after) kill-char)
         (delete-region (point) (progn (forward-line 1) (point)))
-      (delete-char 1)
+              (delete-char num-pfx-chars)
       (forward-line 1))))
 
-(defun diff-apply-hunk (&optional reverse)
-  "Apply the current hunk.
-With a prefix argument, REVERSE the hunk.
-FIXME: Only works for unified diffs."
-  (interactive "P")
-  (save-excursion
-    (let ((loc (diff-find-source-location nil)))
-      (diff-beginning-of-hunk)
-      (unless (looking-at diff-hunk-header-re) (error "Help! Mom!"))
-      (goto-char (1+ (match-end 0)))
-      ;; Extract the SRC and DEST strings.
-      (let ((text (buffer-substring (point) (progn (diff-end-of-hunk) (point))))
-            src dest)
-        (with-temp-buffer
-          (insert text)
-          (diff-filter-lines ?+)
-          (setq src (buffer-string))
-          (erase-buffer)
-          (insert text)
-          (diff-filter-lines ?-)
-          (setq dest (buffer-string)))
-        ;; Exchange the two strings if we're reversing the patch.
-        (if reverse (let ((tmp src)) (setq src dest) (setq dest tmp)))
-        ;; Look for SRC in the file.
-        (pop-to-buffer (find-file-noselect (car loc)))
-        (goto-line (cadr loc))
-        (let* ((pos (point))
-               (forw (and (search-forward src nil t)
+        (buffer-substring-no-properties (point-min) (point-max))))))
+
+(defun diff-find-text (text line)
+  "Return the buffer position of the nearest occurance of TEXT to line LINE.
+If TEXT isn't found, nil is returned."
+  (goto-line line)
+  (let* ((orig (point))
+         (forw (and (search-forward text nil t)
                           (match-beginning 0)))
-               (back (and (goto-char (+ pos (length src)))
-                          (search-backward src nil t)
+         (back (and (goto-char (+ orig (length text)))
+                    (search-backward text nil t)
                           (match-beginning 0))))
           ;; Choose the closest match.
-          (setq pos (if (and forw back)
-                        (if (> (- forw pos) (- pos back)) back forw)
-                      (or back forw)))
-          (unless pos (error "Can't find the text to patch"))
-          ;; Do it!
-          (goto-char pos)
-          (delete-char (length src))
-          (insert dest))))))
+    (if (and forw back)
+        (if (> (- forw orig) (- orig back)) back forw)
+      (or back forw))))
+
+(defun diff-apply-hunk (&optional reverse other-file dry-run popup noerror)
+  "Apply the current hunk to the source file.
+By default, the new source file is patched, but if the variable
+`diff-jump-to-old-file-flag' is non-nil, then the old source file is
+patched instead (some commands, such as `diff-goto-source' can change
+the value of this variable when given an appropriate prefix argument).
+
+With a prefix argument, REVERSE the hunk.
+If OTHER-FILE is non-nil, patch the old file by default, and reverse the
+  sense of `diff-jump-to-old-file-flag'.
+If DRY-RUN is non-nil, don't actually modify anything, just see whether
+  it's possible to do so.
+If POPUP is non-nil, pop up the patched file in another window; if POPUP
+  is `select' then select the new window too.
+If NOERROR is non-nil, then no error is signaled in the case where the hunk
+  cannot be found in the source file (other errors may still be signaled).
+
+Return values are `t' if the hunk was sucessfully applied (or could be
+applied, in the case where DRY-RUN was non-nil), `reversed' if the hunk
+was applied backwards, or nil if the hunk couldn't be found and NOERROR
+was non-nil."
+  (interactive (list current-prefix-arg nil nil t))
+
+  (when other-file
+    ;; OTHER-FILE inverts the sense of the hunk
+    (setq reverse (not reverse)))
+  (when diff-jump-to-old-file-flag
+    ;; The global variable `diff-jump-to-old-file-flag' inverts the
+    ;; sense of OTHER-FILE (in `diff-find-source-location')
+    (setq reverse (not reverse)))
+
+  (let* ((loc (diff-find-source-location other-file))
+         (buf (find-file-noselect (car loc)))
+         (patch-line (cadr loc))
+         (hunk
+          (save-excursion
+            (diff-beginning-of-hunk)
+            (unless (looking-at diff-hunk-header-re)
+              (error "Malformed hunk"))
+            (buffer-substring (point) (progn (diff-end-of-hunk) (point)))))
+         (src (diff-hunk-text hunk reverse))
+         (dst (diff-hunk-text hunk (not reverse)))
+         (pos
+          (with-current-buffer buf (diff-find-text src patch-line)))
+         (reversed-pos
+          (and (null pos)
+               (with-current-buffer buf (diff-find-text dst patch-line)))))
+
+    (when (and reversed-pos popup)
+      ;; A reversed patch was detected, perhaps apply it in reverse
+      ;; (this is only done in `interactive' mode, when POPUP is non-nil).
+      (if (or dry-run
+              (save-window-excursion
+                (pop-to-buffer buf)
+                (goto-char reversed-pos)
+                (if reverse
+                    (y-or-n-p
+                     "Hunk hasn't been applied yet, so can't reverse it; apply it now? ")
+                  (y-or-n-p "Hunk has already been applied; undo it? "))))
+
+          ;; Set up things to reverse the diff
+          (let ((swap dst))
+            (setq pos reversed-pos)
+            (setq src dst)
+            (setq dst swap))
+
+        ;; The user has chosen not to apply the reversed hunk, but we
+        ;; don't want to given an error message, so set things up so
+        ;; nothing else gets done down below
+        (message "(Nothing done)")
+        (setq noerror t)))
+
+    (if (null pos)
+        ;; POS is nil, so we couldn't find the source text.
+        (unless noerror
+          (error "Can't find the text to patch"))
+
+      (let ((reversed (if reversed-pos (not reverse) reverse)))
+        (unless dry-run
+          ;; Apply the hunk
+          (with-current-buffer buf
+            (goto-char pos)
+            (delete-char (length src))
+            (insert dst)))
+
+        (when popup
+          ;; Show a message describing what was done
+          (let ((real-line
+                 (1+ (with-current-buffer buf (count-lines (point-min) pos))))
+                (msg 
+                 (if dry-run
+                     (if reversed "already applied" "not yet applied")
+                   (if reversed "undone" "applied"))))
+            (cond ((= real-line patch-line)
+                   (message "Hunk %s" msg))
+                  ((= real-line (1+ patch-line))
+                   (message "Hunk %s at offset 1 line" msg))
+                  (t
+                   (message "Hunk %s at offset %d lines"
+                            msg
+                            (- real-line patch-line)))))
+
+          ;; Display BUF in a window, and maybe select it
+          (cond ((eq popup 'select)
+                 (pop-to-buffer buf)
+                 (goto-char pos))
+                (t
+                 (set-window-point (display-buffer buf) pos))))
+
+        ;; Return an appropriate indicator of success
+        (if reversed 'reversed t)))))
+      
       
+(defun diff-test-hunk (&optional reverse)
+  "See whether it's possible to apply the current hunk.
+With a prefix argument, REVERSE the hunk."
+  (interactive "P")
+  (diff-apply-hunk reverse nil t t))
+
+(defun diff-goto-source (&optional other-file)
+  "Jump to the corresponding source line.
+`diff-jump-to-old-file-flag' (or its opposite if the OTHER-FILE prefix arg
+is give) determines whether to jump to the old or the new file.
+If the prefix arg is bigger than 8 (for example with \\[universal-argument] \\[universal-argument])
+  then `diff-jump-to-old-file-flag' is also set, for the next invocations."
+  (interactive "P")
+  (or (diff-apply-hunk nil other-file t 'select t)
+      ;; couldn't actually find the hunk, just obey the hunk line number
+      (let ((loc (diff-find-source-location other-file)))
+        (find-file-other-window (car loc))
+        (goto-line (cadr loc))
+        (error "Hunk text not found"))))
+
 
 ;; provide the package
 (provide 'diff-mode)