X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/aa228418e97d3b6aada0da50ee0419c5c23f726c..16e8b162565202f416f2141d75a3c8bd6f45b96f:/lisp/diff.el

diff --git a/lisp/diff.el b/lisp/diff.el
index 7b92c6a431..c985b66036 100644
--- a/lisp/diff.el
+++ b/lisp/diff.el
@@ -1,12 +1,15 @@
-;; "DIFF" mode for handling output from unix diff utility.
-;; Copyright (C) 1990 Free Software Foundation, Inc.
-;; Written fpb@ittc.wec.com 1/27/89
+;;; diff.el --- run `diff' in compilation-mode
+
+;; Copyright (C) 1992, 1994, 1996, 2001, 2004 Free Software Foundation, Inc.
+
+;; Maintainer: FSF
+;; Keywords: unix, tools
 
 ;; 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 1, or (at your option)
+;; 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,
@@ -15,257 +18,156 @@
 ;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; 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.
 
-;; todo: diff-switches flexibility:
-;; (defconst diff-switches-function
-;;   '(lambda (file)
-;;     (if (string-match "\\.el$" file)
-;; 	 "-c -F\"^(\""
-;;       "-p"))
-;;  "Function to return switches to pass to the `diff' utility, in \\[diff].
-;; This function is called with one arg, a file name, and returns a string
-;; containing 0 or more arguments which are passed on to `diff'.
-;; NOTE: This is not an ordinary hook; it may not be a list of functions.")
+;;; Commentary:
 
-;;  - fpb@ittc.wec.com - Sep 25, 1990
-;; Added code to support sccs diffing.
-;; also fixed one minor glitch in the
-;; search for the pattern.  If you only 1 addition you won't find the end
-;; of the pattern (minor)
+;; This package helps you explore differences between files, using the
+;; UNIX command diff(1).  The commands are `diff' and `diff-backup'.
+;; You can specify options with `diff-switches'.
 
-;;
-(defvar diff-switches nil
-  "*A list of switches to pass to the diff program.")
+;;; Code:
 
-(defvar diff-search-pattern "^\\([0-9]\\|\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\)"
-  "Regular expression that delineates difference regions in diffs.")
+(defgroup diff nil
+  "Comparing files with `diff'."
+  :group 'tools)
 
-(defvar diff-rcs-extension ",v"
-  "*Extension to find RCS file, some systems do not use ,v")
+;;;###autoload
+(defcustom diff-switches "-c"
+  "*A string or list of strings specifying switches to be passed to diff."
+  :type '(choice string (repeat string))
+  :group 'diff)
 
-;; Initialize the keymap if it isn't already
-(if (boundp 'diff-mode-map)
-    nil
-  (setq diff-mode-map (make-keymap))
-  (suppress-keymap diff-mode-map)
-  (define-key diff-mode-map "?" 'describe-mode)
-  (define-key diff-mode-map "." 'diff-beginning-of-diff)
-  (define-key diff-mode-map " " 'scroll-up)
-  (define-key diff-mode-map "\177" 'scroll-down)
-  (define-key diff-mode-map "n" 'diff-next-difference)
-  (define-key diff-mode-map "p" 'diff-previous-difference)
-  (define-key diff-mode-map "j" 'diff-show-difference))
+;;;###autoload
+(defcustom diff-command "diff"
+  "*The command to use to run diff."
+  :type 'string
+  :group 'diff)
+
+(defvar diff-old-temp-file nil
+  "This is the name of a temp file to be deleted after diff finishes.")
+(defvar diff-new-temp-file nil
+  "This is the name of a temp file to be deleted after diff finishes.")
+
+;; prompt if prefix arg present
+(defun diff-switches ()
+  (if current-prefix-arg
+      (read-string "Diff switches: "
+		   (if (stringp diff-switches)
+		       diff-switches
+		     (mapconcat 'identity diff-switches " ")))))
+
+(defun diff-sentinel (code)
+  "Code run when the diff process exits.
+CODE is the exit code of the process.  It should be 0 iff no diffs were found."
+  (if diff-old-temp-file (delete-file diff-old-temp-file))
+  (if diff-new-temp-file (delete-file diff-new-temp-file))
+  (save-excursion
+    (goto-char (point-max))
+    (insert (format "\nDiff finished%s.  %s\n"
+		    (if (equal 0 code) " (no differences)" "")
+		    (current-time-string)))))
 
 ;;;###autoload
-(defun diff (old new)
+(defun diff (old new &optional switches no-async)
   "Find and display the differences between OLD and NEW files.
-Interactively you are prompted with the current buffer's file name for NEW
-and what appears to be it's backup for OLD."
+Interactively the current buffer's file name is the default for NEW
+and a backup file for NEW is the default for OLD.
+If NO-ASYNC is non-nil, call diff synchronously.
+With prefix arg, prompt for diff switches."
   (interactive
    (let (oldf newf)
-     (reverse
-      (list
-       (setq newf (buffer-file-name)
-	     newf (if (and newf (file-exists-p newf))
-			  (read-file-name
-			   (concat "Diff new file: ("
-				   (file-name-nondirectory newf) ") ")
-			   nil newf t)
-			(read-file-name "Diff new file: " nil nil t)))
-       (setq oldf (file-newest-backup newf)
-	     oldf (if (and oldf (file-exists-p oldf))
-			  (read-file-name
-			   (concat "Diff original file: ("
-				   (file-name-nondirectory oldf) ") ")
-			   (file-name-directory oldf) oldf t)
-			(read-file-name "Diff original file: "
-					(file-name-directory newf) nil t)))))))
-  (message "Comparing files %s %s..." new old)
+     (setq newf (buffer-file-name)
+	   newf (if (and newf (file-exists-p newf))
+		    (read-file-name
+		     (concat "Diff new file: (default "
+			     (file-name-nondirectory newf) ") ")
+		     nil newf t)
+		  (read-file-name "Diff new file: " nil nil t)))
+     (setq oldf (file-newest-backup newf)
+	   oldf (if (and oldf (file-exists-p oldf))
+		    (read-file-name
+		     (concat "Diff original file: (default "
+			     (file-name-nondirectory oldf) ") ")
+		     (file-name-directory oldf) oldf t)
+		  (read-file-name "Diff original file: "
+				  (file-name-directory newf) nil t)))
+     (list oldf newf (diff-switches))))
   (setq new (expand-file-name new)
 	old (expand-file-name old))
-  (diff-internal-diff "diff" (append diff-switches (list new old)) nil))
-
-(defun diff-sccs (new)
-  "Find and display the differences between OLD and SCCS files."
-  (interactive
-   (let (newf)
-      (list
-       (setq newf (buffer-file-name)
-	     newf (if (and newf (file-exists-p newf))
-			  (read-file-name
-			   (concat "Diff new file: ("
-				   (file-name-nondirectory newf) ") ")
-			   nil newf t)
-			(read-file-name "Diff new file: " nil nil t))))))
-
-  (message "Comparing SCCS file %s..." new)
-  (setq new (expand-file-name new))
-  (if (file-exists-p (concat
-		      (file-name-directory new)
-		      "SCCS/s."
-		      (file-name-nondirectory new)))
-      (diff-internal-diff "sccs"
-			  (append '("diffs") diff-switches (list new))
-			  2)
-    (error "%s does not exist"
-	   (concat (file-name-directory new) "SCCS/s."
-		   (file-name-nondirectory new)))))
-
-(defun diff-rcs (new)
-  "Find and display the differences between OLD and RCS files."
-  (interactive
-   (let (newf)
-      (list
-       (setq newf (buffer-file-name)
-	     newf (if (and newf (file-exists-p newf))
-			  (read-file-name
-			   (concat "Diff new file: ("
-				   (file-name-nondirectory newf) ") ")
-			   nil newf t)
-			(read-file-name "Diff new file: " nil nil t))))))
+  (or switches (setq switches diff-switches)) ; If not specified, use default.
+  (let* ((old-alt (file-local-copy old))
+	(new-alt (file-local-copy new))
+	 (command
+	  (mapconcat 'identity
+		     `(,diff-command
+		       ;; Use explicitly specified switches
+		       ,@(if (listp switches) switches (list switches))
+		       ,@(if (or old-alt new-alt)
+			     (list "-L" old "-L" new))
+		       ,(shell-quote-argument (or old-alt old))
+		       ,(shell-quote-argument (or new-alt new)))
+		     " "))
+	 (buf (get-buffer-create "*Diff*"))
+	 (thisdir default-directory)
+	 proc)
+    (save-excursion
+      (display-buffer buf)
+      (set-buffer buf)
+      (setq buffer-read-only nil)
+      (buffer-disable-undo (current-buffer))
+      (erase-buffer)
+      (buffer-enable-undo (current-buffer))
+      (diff-mode)
+      (set (make-local-variable 'revert-buffer-function)
+	   `(lambda (ignore-auto noconfirm)
+	      (diff ',old ',new ',switches ',no-async)))
+      (set (make-local-variable 'diff-old-temp-file) old-alt)
+      (set (make-local-variable 'diff-new-temp-file) new-alt)
+      (setq default-directory thisdir)
+      (insert command "\n")
+      (if (and (not no-async) (fboundp 'start-process))
+	  (progn
+	    (setq proc (start-process "Diff" buf shell-file-name
+				      shell-command-switch command))
+	    (set-process-sentinel
+	     proc (lambda (proc msg)
+		    (with-current-buffer (process-buffer proc)
+		      (diff-sentinel (process-exit-status proc))))))
+	;; Async processes aren't available.
+	(diff-sentinel
+	 (call-process shell-file-name nil buf nil
+		       shell-command-switch command))))
+    buf))
 
-  (message "Comparing RCS file %s..." new)
-  (let* ((fullname (expand-file-name new))
-       (rcsfile (concat (file-name-directory fullname)
-                       "RCS/"
-                       (file-name-nondirectory fullname)
-                       diff-rcs-extension)))
-    (if (file-exists-p rcsfile)
-      (diff-internal-diff "rcsdiff" (append diff-switches (list fullname)) 4)
-      (error "%s does not exist" rcsfile))))
-
-(defun diff-internal-diff (diff-command sw strip)
-  (let ((buffer-read-only nil))
-    (with-output-to-temp-buffer "*Diff Output*"
-      (buffer-disable-undo standard-output)
-      (save-excursion
-	(set-buffer standard-output)
-	(erase-buffer)
-	(apply 'call-process diff-command nil t nil sw)))
-    (set-buffer "*Diff Output*")
-    (goto-char (point-min))
-    (while sw
-      (if (string= (car sw) "-c")
-	  ;; strip leading filenames from context diffs
-	  (progn (forward-line 2) (delete-region (point-min) (point))))
-      (if (and (string= (car sw) "-C") (string= "sccs" diff-command))
-	  ;; strip stuff from SCCS context diffs
-	  (progn (forward-line 2) (delete-region (point-min) (point))))
-      (setq sw (cdr sw)))
-    (if strip
-	;; strip stuff from SCCS context diffs
-	(progn (forward-line strip) (delete-region (point-min) (point)))))
-  (diff-mode)
-  (if (string= "0" diff-total-differences)
-      (let ((buffer-read-only nil))
-	(insert (message "There are no differences.")))
-    (narrow-to-region (point) (progn
-				(forward-line 1)
-				(if (re-search-forward diff-search-pattern
-						       nil t)
-				    (goto-char (match-beginning 0))
-				  (goto-char (point-max)))))
-    (setq diff-current-difference "1")))
-
-;; Take a buffer full of Unix diff output and go into a mode to easily
-;; see the next and previous difference
-(defun diff-mode ()
-  "Diff Mode is used by \\[diff] for perusing the output from the diff program.
-All normal editing commands are turned off.  Instead, these are available:
-\\<diff-mode-map>
-\\[diff-beginning-of-diff]	Move point to start of this difference.
-\\[scroll-up]	Scroll to next screen of this difference.
-\\[scroll-down]	Scroll to previous screen of this difference.
-\\[diff-next-difference]	Move to Next Difference.
-\\[diff-previous-difference]	Move to Previous Difference.
-\\[diff-show-difference]	Jump to difference specified by numeric position.
-"
-  (interactive)
-  (use-local-map diff-mode-map)
-  (setq buffer-read-only t
-	major-mode 'diff-mode
-	mode-name "Diff"
-	mode-line-modified "--- "
-	mode-line-process
-	'(" " diff-current-difference "/" diff-total-differences))
-  (make-local-variable 'diff-current-difference)
-  (set (make-local-variable 'diff-total-differences)
-       (int-to-string (diff-count-differences))))
-
-(defun diff-next-difference (n)
-  "Go to the beginning of the next difference.
-Differences are delimited by `diff-search-pattern'."
-  (interactive "p")
-  (if (< n 0) (diff-previous-difference (- n))
-    (if (zerop n) ()
-      (goto-char (point-min))
-      (forward-line 1) ; to get past the match for the start of this diff
-      (widen)
-      (if (re-search-forward diff-search-pattern nil 'move n)
-	  (let ((start (goto-char (match-beginning 0))))
-	    (forward-line 1)
-	    (if (re-search-forward diff-search-pattern nil 'move)
-		(goto-char (match-beginning 0)))
-	    (narrow-to-region start (point))
-	    (setq diff-current-difference
-		  (int-to-string (+ n (string-to-int
-				       diff-current-difference)))))
-	(re-search-backward diff-search-pattern nil)
-	(narrow-to-region (point) (point-max))
-	(message "No following differences.")
-	(setq diff-current-difference diff-total-differences))
-      (goto-char (point-min)))))
-
-(defun diff-previous-difference (n)
-  "Go the the beginning of the previous difference.
-Differences are delimited by `diff-search-pattern'."
-  (interactive "p")
-  (if (< n 0) (diff-next-difference (- n))
-    (if (zerop n) ()
-      (goto-char (point-min))
-      (widen)
-      (if (re-search-backward diff-search-pattern nil 'move n)
-	  (setq diff-current-difference
-		(int-to-string (- (string-to-int diff-current-difference) n)))
-	(message "No previous differences.")
-	(setq diff-current-difference "1"))
-      (narrow-to-region (point) (progn
-				  (forward-line 1)
-				  (re-search-forward diff-search-pattern nil)
-				  (goto-char (match-beginning 0))))
-      (goto-char (point-min)))))
-
-(defun diff-show-difference (n)
-  "Show difference number N (prefix argument)."
-  (interactive "p")
-  (let ((cur (string-to-int diff-current-difference)))
-    (cond ((or (= n cur)
-	       (zerop n)
-	       (not (natnump n))) ; should signal an error perhaps.
-	   ;; just redisplay.
-	   (goto-char (point-min)))
-	  ((< n cur)
-	   (diff-previous-difference (- cur n)))
-	  ((> n cur)
-	   (diff-next-difference (- n cur))))))
-
-(defun diff-beginning-of-diff ()
-  "Go to beginning of current difference."
-  (interactive)
-  (goto-char (point-min)))
-
-;; This function counts up the number of differences in the buffer.
-(defun diff-count-differences ()
-  "Count number of differences in the current buffer."
-  (message "Counting differences...")
-  (save-excursion
-    (save-restriction
-      (widen)
-      (goto-char (point-min))
-      (let ((cnt 0))
-	(while (re-search-forward diff-search-pattern nil t)
-	  (setq cnt (1+ cnt)))
-	(message "Counting differences...done (%d)" cnt)
-	cnt))))
+;;;###autoload
+(defun diff-backup (file &optional switches)
+  "Diff this file with its backup file or vice versa.
+Uses the latest backup, if there are several numerical backups.
+If this file is a backup, diff it with its original.
+The backup file is the first file given to `diff'.
+With prefix arg, prompt for diff switches."
+  (interactive (list (read-file-name "Diff (file with backup): ")
+		     (diff-switches)))
+  (let (bak ori)
+    (if (backup-file-name-p file)
+	(setq bak file
+	      ori (file-name-sans-versions file))
+      (setq bak (or (diff-latest-backup-file file)
+		    (error "No backup found for %s" file))
+	    ori file))
+    (diff bak ori switches)))
+
+(defun diff-latest-backup-file (fn)	; actually belongs into files.el
+  "Return the latest existing backup of FILE, or nil."
+  (let ((handler (find-file-name-handler fn 'diff-latest-backup-file)))
+    (if handler
+	(funcall handler 'diff-latest-backup-file fn)
+      (file-newest-backup fn))))
+
+(provide 'diff)
+
+;;; arch-tag: 7de2c29b-7ea5-4b85-9b9d-72dd860de2bd
+;;; diff.el ends here