1 files changed, 562 insertions, 0 deletions

diff --git a/lisp/ediff-ptch.el b/lisp/ediff-ptch.el
new file mode 100644
index 00000000000..401bfc1ef08
--- /dev/null
+++ b/lisp/ediff-ptch.el
@@ -0,0 +1,562 @@
+;;; ediff-ptch.el --- Ediff's  patch support
+
+;; Copyright (C) 1996 Free Software Foundation, Inc.
+
+;; Author: Michael Kifer <kifer@cs.sunysb.edu>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+
+;;; Code:
+
+(defvar ediff-last-dir-patch nil
+  "Last directory used by an Ediff command for file to patch.")
+
+(defvar ediff-backup-extension 
+  (if (memq system-type '(vax-vms axp-vms emx ms-dos windows-nt windows-95))
+      "_orig" ".orig")
+  "Default backup extension for the patch program.")
+
+(defvar ediff-patch-default-directory nil
+  "*Default directory to look for patches.")
+
+(defvar ediff-context-diff-label-regexp
+  (concat "\\("         ; context diff 2-liner
+          "^\\*\\*\\* \\([^ \t]+\\)[^*]+[\t ]*\n--- \\([^ \t]+\\)"
+          "\\|"         ; GNU unified format diff 2-liner
+          "^--- \\([^ \t]+\\)[^-]+[\t ]*\n\\+\\+\\+ \\([^ \t]+\\)"
+          "\\)")
+  "*Regexp matching filename 2-liners at the start of each context diff.")
+
+(defvar ediff-patch-program "patch"
+  "*Name of the program that applies patches.")
+(defvar ediff-patch-options ""
+  "*Options to pass to ediff-patch-program.")
+
+;; The buffer of the patch file. Local to control buffer.
+(ediff-defvar-local ediff-patchbufer nil "")
+
+;; The buffer where patch displays its diagnostics.
+(ediff-defvar-local ediff-patch-diagnostics nil "")
+
+;; Map of patch buffer. Has the form:
+;;    ((filename1 marker1 marker2) (filename2 marker1 marker2) ...)
+;; where filenames are files to which patch would have applied the patch;
+;; marker1 delimits the beginning of the corresponding patch and marker2 does
+;; it for the end.
+(ediff-defvar-local ediff-patch-map nil "")
+
+;; strip prefix from filename
+;; returns /dev/null, if can't strip prefix
+(defsubst ediff-file-name-sans-prefix (filename prefix)
+  (save-match-data
+    (if (string-match (concat "^" prefix) filename)
+        (substring filename (match-end 0))
+      (concat "/null/" filename))))
+
+
+
+;; no longer used
+;; return the number of matches of regexp in buf starting from the beginning
+(defun ediff-count-matches (regexp buf)
+  (ediff-eval-in-buffer buf
+    (let ((count 0) opoint)
+      (save-excursion
+        (goto-char (point-min))
+        (while (and (not (eobp))
+                    (progn (setq opoint (point))
+                           (re-search-forward regexp nil t)))
+          (if (= opoint (point))
+              (forward-char 1)
+            (setq count (1+ count)))))
+      count)))
+
+;; Scan BUF (which is supposed to contain a patch) and make a list of the form 
+;;    ((filename1 marker1 marker2) (filename2 marker1 marker2) ...)
+;; where filenames are files to which patch would have applied the patch;
+;; marker1 delimits the beginning of the corresponding patch and marker2 does
+;; it for the end. This list is then assigned to ediff-patch-map.
+;; Returns the number of elements in the list ediff-patch-map
+(defun ediff-map-patch-buffer (buf)
+  (ediff-eval-in-buffer buf
+    (let ((count 0)
+          (mark1 (move-marker (make-marker) (point-min)))
+          (mark1-end (point-min))
+          (possible-file-names '("/dev/null" . "/dev/null"))
+          mark2-end mark2 filenames
+          beg1 beg2 end1 end2
+          patch-map opoint)
+      (save-excursion
+        (goto-char (point-min))
+        (setq opoint (point))
+        (while (and (not (eobp))
+                    (re-search-forward ediff-context-diff-label-regexp nil t))
+          (if (= opoint (point))
+              (forward-char 1) ; ensure progress towards the end
+            (setq mark2 (move-marker (make-marker) (match-beginning 0))
+                  mark2-end (match-end 0)
+                  beg1 (match-beginning 2)
+                  end1 (match-end 2)
+                  beg2 (match-beginning 3)
+                  end2 (match-end 3))
+            ;; possible-file-names is holding the new file names until we
+            ;; insert the old file name in the patch map
+            ;; It is a pair (filename from 1st header line . fn from 2nd line)
+            (setq possible-file-names
+                  (cons (if (and beg1 end1)
+                            (buffer-substring beg1 end1)
+                          "/dev/null")
+                        (if (and beg2 end2)
+                            (buffer-substring beg2 end2)
+                          "/dev/null")))
+            ;; check for any `Index:' or `Prereq:' lines, but don't use them
+            (if (re-search-backward "^Index:" mark1-end 'noerror)
+                (move-marker mark2 (match-beginning 0)))
+            (if (re-search-backward "^Prereq:" mark1-end 'noerror)
+                (move-marker mark2 (match-beginning 0)))
+
+            (goto-char mark2-end)
+            
+            (if filenames
+                (setq patch-map (cons (list filenames mark1 mark2) patch-map)))
+            (setq mark1 mark2
+                  mark1-end mark2-end
+                  filenames possible-file-names))
+          (setq opoint (point)
+                count (1+ count))))
+      (setq mark2 (point-max-marker)
+            patch-map (cons (list possible-file-names mark1 mark2) patch-map))
+      (setq ediff-patch-map (nreverse patch-map))
+      count)))
+
+;; Fix up the file names in the list using the argument FILENAME
+;; Algorithm: find the first file's directory and cut it out from each file
+;; name in the patch. Prepend the directory of FILENAME to each file in the
+;; patch. In addition, the first file in the patch is replaced by FILENAME.
+;; Each file is actually a file-pair of files found in the context diff header
+;; In the end, for each pair, we select the shortest existing file.
+;; Note: Ediff doesn't recognize multi-file patches that are separated
+;; with the `Index:' line. It treats them as a single-file patch.
+;;
+;; Executes inside the patch buffer
+(defun ediff-fixup-patch-map (filename)
+  (setq filename (expand-file-name filename))
+  (let ((actual-dir (if (file-directory-p filename)
+                        ;; directory part of filename
+                        (file-name-as-directory filename)
+                      (file-name-directory filename)))
+        ;; directory part of the first file in the patch
+        (base-dir1 (file-name-directory (car (car (car ediff-patch-map)))))
+        (base-dir2 (file-name-directory (cdr (car (car ediff-patch-map)))))
+        )
+
+    ;; chop off base-dirs
+    (mapcar (function (lambda (triple)
+                        (or (string= (car (car triple)) "/dev/null")
+                            (setcar (car triple)
+                                    (ediff-file-name-sans-prefix
+                                     (car (car triple)) base-dir1)))
+                        (or (string= (cdr (car triple)) "/dev/null")
+                            (setcdr (car triple)
+                                    (ediff-file-name-sans-prefix
+                                     (cdr (car triple)) base-dir2)))
+                        ))
+            ediff-patch-map)
+
+    ;; take the given file name into account
+    (or (file-directory-p filename)
+        (string= "/dev/null" filename)
+        (progn
+          (setcar (car ediff-patch-map)
+                  (cons (file-name-nondirectory filename)
+                        (file-name-nondirectory filename)))))
+
+    ;; prepend actual-dir
+    (mapcar (function (lambda (triple)
+                         (if (and (string-match "^/null/" (car (car triple)))
+                                  (string-match "^/null/" (cdr (car triple))))
+                             ;; couldn't strip base-dir1 and base-dir2
+                             ;; hence, something wrong
+                             (progn
+                               (with-output-to-temp-buffer ediff-msg-buffer
+                                 (princ
+                                  (format "
+The patch file contains a context diff for
+        %s
+        %s
+
+However, Ediff cannot infer the name of the actual file
+to be patched on your system. If you know the correct file name,
+please enter it now.
+
+If you don't know and still would like to apply patches to
+other files, enter /dev/null
+"
+                                          (substring (car (car triple)) 6)
+                                          (substring (cdr (car triple)) 6))))
+                               (let ((directory t)
+                                     user-file)
+                                 (while directory
+                                   (setq user-file
+                                         (read-file-name
+                                          "Please enter file name: "
+                                          actual-dir actual-dir t))
+                                   (if (not (file-directory-p user-file))
+                                       (setq directory nil)
+                                     (setq directory t)
+                                     (beep)
+                                     (message "%s is a directory" user-file)
+                                     (sit-for 2)))
+                                 (setcar triple (cons user-file user-file))))
+                           (setcar (car triple)
+                                   (expand-file-name 
+                                    (concat actual-dir (car (car triple)))))
+                           (setcdr (car triple)
+                                   (expand-file-name 
+                                    (concat actual-dir (cdr (car triple))))))
+                         ))
+            ediff-patch-map)
+    ;; check for the shorter existing file in each pair and discard the other
+    ;; one
+    (mapcar (function (lambda (triple)
+                        (let* ((file1 (car (car triple)))
+                               (file2 (cdr (car triple)))
+                               (f1-exists (file-exists-p file1))
+                               (f2-exists (file-exists-p file2)))
+                          (cond
+                           ((and (< (length file2) (length file1))
+                                 f2-exists)
+                            (setcar triple file2))
+                           ((and (< (length file1) (length file2))
+                                 f1-exists)
+                            (setcar triple file1))
+                           ((and f1-exists f2-exists
+                                 (string= file1 file2))
+                            (setcar triple file1))
+                           ((and f1-exists f2-exists)
+                            (with-output-to-temp-buffer ediff-msg-buffer
+                              (princ (format "
+Ediff has inferred that
+        %s
+        %s
+are possible targets for applying the patch.
+Both files seem to be plausible alternatives.
+
+Please advice:
+    Type `y' to use %s as the target;
+    Type `n' to use %s as the target.
+"
+                                             file1 file2 file2 file1)))
+                            (setcar triple
+                                    (if (y-or-n-p (format "Use %s ? " file2))
+                                        file2 file1)))
+                           (f2-exists (setcar triple file2))
+                           (f1-exists (setcar triple file1))
+                           (t
+                            (with-output-to-temp-buffer ediff-msg-buffer
+                              (princ (format "
+Ediff inferred that 
+        %s
+        %s
+are possible alternative targets for this patch.
+
+However, these files do not exist.
+
+Please enter an alternative patch target ... 
+"
+                                             file1 file2)))
+                            (let ((directory t)
+                                  target)
+                              (while directory
+                                (setq target (read-file-name 
+                                              "Please enter a patch target: "
+                                              actual-dir actual-dir t))
+                                (if (not (file-directory-p target))
+                                    (setq directory nil)
+                                  (beep)
+                                  (message "%s is a directory" target)
+                                  (sit-for 2)))
+                              (setcar triple target)))))))
+            ediff-patch-map)
+    ))
+
+(defun ediff-show-patch-diagnostics ()
+  (interactive)
+  (cond ((window-live-p ediff-window-A)
+         (set-window-buffer ediff-window-A ediff-patch-diagnostics))
+        ((window-live-p ediff-window-B)
+         (set-window-buffer ediff-window-B ediff-patch-diagnostics))
+        (t (display-buffer ediff-patch-diagnostics 'not-this-window))))
+
+(defun ediff-get-patch-buffer ()
+  "Obtain patch buffer.  If patch is already in a buffer---use it.
+Else, read patch file into a new buffer."
+  (let ((dir (cond (ediff-patch-default-directory) ; try patch default dir
+                   (ediff-use-last-dir ediff-last-dir-patch)
+                   (t default-directory)))
+        patch-buf)
+    (if (y-or-n-p "Is the patch already in a buffer? ")
+        (setq patch-buf
+              (get-buffer
+               (read-buffer
+                "Which buffer contains the patch? "
+                (current-buffer) 'must-match)))
+      (setq patch-buf
+            (find-file-noselect
+             (read-file-name "Which file contains the patch? " dir))))
+    
+    (ediff-eval-in-buffer patch-buf
+      (goto-char (point-min))
+      (or (ediff-get-visible-buffer-window patch-buf)
+          (progn
+            (pop-to-buffer patch-buf 'other-window)
+            (select-window (previous-window)))))
+    (ediff-map-patch-buffer patch-buf)
+    patch-buf))
+
+;; Dispatch the right patch file function: regular or meta-level,
+;; depending on how many patches are in the patch file.
+;; At present, there is no support for meta-level patches.
+;; Should return either the ctl buffer or the meta-buffer
+(defun ediff-dispatch-file-patching-job (patch-buf filename
+                                                   &optional startup-hooks)
+  (ediff-eval-in-buffer patch-buf
+    ;; relativize names in the patch with respect to source-file
+    (ediff-fixup-patch-map filename)
+    (if (< (length ediff-patch-map) 2)
+        (ediff-patch-file-internal
+         patch-buf
+         (if (and (not (string-match "^/dev/null" (car (car ediff-patch-map))))
+                  (> (length (car (car ediff-patch-map))) 1))
+             (car (car ediff-patch-map))
+           filename)
+         startup-hooks)
+      (ediff-multi-patch-internal patch-buf startup-hooks))
+    ))
+
+
+(defun ediff-patch-buffer-internal (patch-buf buf-to-patch-name
+                                              &optional startup-hooks)
+  (let* ((buf-to-patch (get-buffer buf-to-patch-name))
+         (file-name-ok (if buf-to-patch (buffer-file-name  buf-to-patch)))
+         (buf-mod-status (buffer-modified-p buf-to-patch))
+         (multifile-patch-p (> (length (ediff-eval-in-buffer patch-buf
+                                         ediff-patch-map)) 1))
+         default-dir file-name ctl-buf)
+    (if file-name-ok
+        (setq file-name file-name-ok)
+      (if multifile-patch-p
+          (error
+           "Can't apply multi-file patches to buffers that visit no files"))
+      (ediff-eval-in-buffer buf-to-patch
+        (setq default-dir default-directory)
+        (setq file-name (ediff-make-temp-file buf-to-patch))
+        (set-visited-file-name file-name)
+        (setq buffer-auto-save-file-name nil) ; don't create auto-save file
+        ;;don't confuse the user with a new bufname
+        (rename-buffer buf-to-patch-name)
+        (set-buffer-modified-p nil)
+        (set-visited-file-modtime) ; sync buffer and temp file
+        (setq default-directory default-dir)
+        ))
+    
+    ;; dispatch a patch function
+    (setq ctl-buf (ediff-dispatch-file-patching-job
+                   patch-buf file-name startup-hooks))
+    
+    (if file-name-ok
+        ()
+      ;; buffer wasn't visiting any file,
+      ;; so we will not run meta-level ediff here
+      (ediff-eval-in-buffer ctl-buf
+        (delete-file (buffer-file-name ediff-buffer-A))
+        (delete-file (buffer-file-name ediff-buffer-B))
+        (ediff-eval-in-buffer ediff-buffer-A
+          (if default-dir (setq default-directory default-dir))
+          (set-visited-file-name nil)
+          (rename-buffer buf-to-patch-name)
+          (set-buffer-modified-p buf-mod-status))
+        (ediff-eval-in-buffer ediff-buffer-B
+          (setq buffer-auto-save-file-name nil) ; don't create auto-save file
+          (if default-dir (setq default-directory default-dir))
+          (set-visited-file-name nil)
+          (rename-buffer (ediff-unique-buffer-name 
+                          (concat buf-to-patch-name "_patched") ""))
+          (set-buffer-modified-p t))))
+    ))
+
+(defun ediff-patch-file-internal (patch-buf source-filename
+                                            &optional startup-hooks)
+  (setq source-filename (expand-file-name source-filename))
+  
+  (let* ((backup-extension 
+          ;; if the user specified a -b option, extract the backup
+          ;; extension from there; else use ediff-backup-extension
+          (substring ediff-patch-options
+                     (if (string-match "-b[ \t]+" ediff-patch-options)
+                         (match-end 0) 0)
+                     (if (string-match "-b[ \t]+[^ \t]+" ediff-patch-options)
+                         (match-end 0) 0)))
+         (shell-file-name ediff-shell)
+         (patch-diagnostics (get-buffer-create "*ediff patch diagnostics*"))
+         ;; ediff-find-file may use a temp file to do the patch
+         ;; so, we save source-filename and true-source-filename as a var
+         ;; that initially is source-filename but may be changed to a temp
+         ;; file for the purpose of patching.
+         (true-source-filename source-filename)
+         (target-filename source-filename)
+         target-buf buf-to-patch file-name-magic-p ctl-buf backup-style)
+          
+    ;; if the user didn't specify a backup extension, use
+    ;; ediff-backup-extension 
+    (if (string= backup-extension "")
+        (setq backup-extension ediff-backup-extension))
+    (if (string-match "-V" ediff-patch-options)
+        (error
+         "Ediff doesn't take the -V option in `ediff-patch-options'--sorry"))
+                                        
+    ;; Make a temp file, if source-filename has a magic file handler (or if
+    ;; it is handled via auto-mode-alist and similar magic).
+    ;; Check if there is a buffer visiting source-filename and if they are in
+    ;; sync; arrange for the deletion of temp file.
+    (ediff-find-file 'true-source-filename 'buf-to-patch
+                     'ediff-last-dir-patch 'startup-hooks)
+
+    ;; Check if source file name has triggered black magic, such as file name
+    ;; handlers or auto mode alist, and make a note of it.
+    ;; true-source-filename should be either the original name or a
+    ;; temporary file where we put the after-product of the file handler.
+    (setq file-name-magic-p (not (equal (file-truename true-source-filename)
+                                        (file-truename source-filename))))
+    
+    ;; Checkout orig file, if necessary, so that the patched file could be
+    ;; checked back in.
+    (if (ediff-file-checked-in-p (buffer-file-name buf-to-patch))
+        (ediff-toggle-read-only buf-to-patch))
+
+    (ediff-eval-in-buffer patch-diagnostics
+      (insert-buffer patch-buf)
+      (message "Applying patch ... ")
+      ;; fix environment for gnu patch, so it won't make numbered extensions
+      (setq backup-style (getenv "VERSION_CONTROL"))
+      (setenv "VERSION_CONTROL" nil)
+      ;; always pass patch the -f option, so it won't ask any questions
+      (shell-command-on-region 
+       (point-min) (point-max)
+       (format "%s -f %s -b %s %s"
+               ediff-patch-program ediff-patch-options
+               backup-extension
+               (expand-file-name true-source-filename))
+       t)
+      ;; restore environment for gnu patch
+      (setenv "VERSION_CONTROL" backup-style))
+
+    (message "Applying patch ... done")
+    (message "")
+
+    (switch-to-buffer patch-diagnostics)
+    (sit-for 0) ; synchronize - let the user see diagnostics
+    
+    (or (file-exists-p (concat true-source-filename backup-extension))
+        (error "Patch appears to have failed"))
+  
+    ;; If black magic is involved, apply patch to a temp copy of the
+    ;; file. Otherwise, apply patch to the orig copy.  If patch is applied
+    ;; to temp copy, we name the result old-name_patched for local files
+    ;; and temp-copy_patched for remote files. The orig file name isn't
+    ;; changed, and the temp copy of the original is later deleted.
+    ;; Without magic, the original file is renamed (usually into
+    ;; old-name_orig) and the result of patching will have the same name as
+    ;; the original.
+    (if (not file-name-magic-p)
+        (ediff-eval-in-buffer buf-to-patch
+          (set-visited-file-name (concat source-filename backup-extension))
+          (set-buffer-modified-p nil))
+      
+      ;; Black magic in effect.
+      ;; If orig file was remote, put the patched file in the temp directory.
+      ;; If orig file is local, put the patched file in the directory of
+      ;; the orig file.
+      (setq target-filename
+            (concat
+             (if (ediff-file-remote-p (file-truename source-filename))
+                 true-source-filename
+               source-filename)
+             "_patched"))
+      
+      (rename-file true-source-filename target-filename t)
+      
+      ;; arrange that the temp copy of orig will be deleted
+      (rename-file (concat true-source-filename backup-extension)
+                   true-source-filename t))
+    
+    ;; make orig buffer read-only
+    (setq startup-hooks
+          (cons 'ediff-set-read-only-in-buf-A startup-hooks))
+    
+    ;; set up a buf for the patched file
+    (setq target-buf (find-file-noselect target-filename))
+    
+    (setq ctl-buf
+          (ediff-buffers-internal
+           buf-to-patch target-buf nil
+           startup-hooks 'epatch))
+    (ediff-eval-in-buffer ctl-buf
+      (setq ediff-patchbufer patch-buf
+            ediff-patch-diagnostics patch-diagnostics))
+  
+    (bury-buffer patch-diagnostics)
+    (message "Type `P', if you need to see patch diagnostics")
+    ctl-buf))
+
+(defun ediff-multi-patch-internal (patch-buf &optional startup-hooks)
+  (let (meta-buf)
+    (setq startup-hooks
+          ;; this sets various vars in the meta buffer inside
+          ;; ediff-prepare-meta-buffer
+          (cons (` (lambda ()
+                     ;; tell what to do if the user clicks on a session record
+                     (setq ediff-session-action-function
+                           'ediff-patch-file-form-meta
+                           ediff-meta-patchbufer patch-buf)
+                     ))
+                startup-hooks))
+    (setq meta-buf (ediff-prepare-meta-buffer 
+                    'ediff-filegroup-action
+                    (ediff-eval-in-buffer patch-buf
+                      ;; nil replaces a regular expression
+                      (cons (list nil (format "%S" patch-buf))
+                            ediff-patch-map))
+                    "*Ediff Session Group Panel"
+                    'ediff-redraw-directory-group-buffer
+                    'ediff-multifile-patch
+                    startup-hooks))
+    (ediff-show-meta-buffer meta-buf)
+    ))
+
+  
+      
+
+;;; Local Variables:
+;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
+;;; eval: (put 'ediff-eval-in-buffer 'lisp-indent-hook 1)
+;;; End:
+
+(provide 'ediff-ptch)
+
+;;; ediff-ptch.el ends here