[bpt/emacs.git] / lisp / diff.el

;;; diff.el --- run `diff' in compilation-mode

;; Copyright (C) 1992, 1994, 1996, 2001 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 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.

;;; Commentary:

;; 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'.

;;; Code:

(require 'compile)

(defgroup diff nil
  "Comparing files with `diff'."
  :group 'tools)

;;;###autoload
(defcustom diff-switches "-c"
  "*A string or list of strings specifying switches to be be passed to diff."
  :type '(choice string (repeat string))
  :group 'diff)

;;;###autoload
(defcustom diff-command "diff"
  "*The command to use to run diff."
  :type 'string
  :group 'diff)

(defvar diff-regexp-alist
  '(
    ;; -u format: @@ -OLDSTART,OLDEND +NEWSTART,NEWEND @@
    ("^@@ -\\([0-9]+\\),[0-9]+ \\+\\([0-9]+\\),[0-9]+ @@$" 1 2)

    ;; -c format: *** OLDSTART,OLDEND ****
    ("^\\*\\*\\* \\([0-9]+\\),[0-9]+ \\*\\*\\*\\*$" 1 nil)
    ;;            --- NEWSTART,NEWEND ----
    ("^--- \\([0-9]+\\),[0-9]+ ----$" nil 1)

    ;; plain diff format: OLDSTART[,OLDEND]{a,d,c}NEWSTART[,NEWEND]
    ("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]\\([0-9]+\\)\\(,[0-9]+\\)?$" 1 3)

    ;; -e (ed) format: OLDSTART[,OLDEND]{a,d,c}
    ("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]$" 1)

    ;; -f format: {a,d,c}OLDSTART[ OLDEND]
    ;; -n format: {a,d,c}OLDSTART LINES-CHANGED
    ("^[adc]\\([0-9]+\\)\\( [0-9]+\\)?$" 1)
    )
  "Alist of regular expressions to match difference sections in \\[diff] output.
Each element has the form (REGEXP OLD-IDX NEW-IDX).
Any text that REGEXP matches identifies one difference hunk
or the header of a hunk.

The OLD-IDX'th subexpression of REGEXP gives the line number
in the old file, and NEW-IDX'th subexpression gives the line number
in the new file.  If OLD-IDX or NEW-IDX
is nil, REGEXP matches only half a hunk.")

(defvar diff-old-file nil
  "This is the old file name in the comparison in this buffer.")
(defvar diff-new-file nil
  "This is the new file name in the comparison in this buffer.")
(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.")

;; See compilation-parse-errors-function (compile.el).
(defun diff-parse-differences (limit-search find-at-least)
  (setq compilation-error-list nil)
  (message "Parsing differences...")

  ;; Don't reparse diffs already seen at last parse.
  (if compilation-parsing-end (goto-char compilation-parsing-end))

  ;; Construct in REGEXP a regexp composed of all those in dired-regexp-alist.
  (let ((regexp (mapconcat (lambda (elt)
			     (concat "\\(" (car elt) "\\)"))
			   diff-regexp-alist
			   "\\|"))
	;; (GROUP-IDX OLD-IDX NEW-IDX)
	(groups (let ((subexpr 1))
		  (mapcar (lambda (elt)
			    (prog1
				(cons subexpr
				      (mapcar (lambda (n)
						(and n
						     (+ subexpr n)))
					      (cdr elt)))
			      (setq subexpr (+ subexpr 1
					       (count-regexp-groupings
						(car elt))))))
			  diff-regexp-alist)))

	(new-error
	 (function (lambda (file subexpr)
		     (setq compilation-error-list
			   (cons
			    (cons (save-excursion
				    ;; Report location of message
				    ;; at beginning of line.
				    (goto-char
				     (match-beginning subexpr))
				    (beginning-of-line)
				    (point-marker))
				  ;; Report location of corresponding text.
				  (let ((line (string-to-int
					       (buffer-substring
						(match-beginning subexpr)
						(match-end subexpr)))))
				    (save-excursion
				      (save-match-data
					(set-buffer (find-file-noselect file)))
				      (save-excursion
					(goto-line line)
					(point-marker)))))
			    compilation-error-list)))))

	(found-desired nil)
	(num-loci-found 0)
	g)

    (while (and (not found-desired)
		;; We don't just pass LIMIT-SEARCH to re-search-forward
		;; because we want to find matches containing LIMIT-SEARCH
		;; but which extend past it.
		(re-search-forward regexp nil t))

      ;; Find which individual regexp matched.
      (setq g groups)
      (while (and g (null (match-beginning (car (car g)))))
	(setq g (cdr g)))
      (setq g (car g))

      (if (nth 1 g)			;OLD-IDX
	  (funcall new-error diff-old-file (nth 1 g)))
      (if (nth 2 g)			;NEW-IDX
	  (funcall new-error diff-new-file (nth 2 g)))

      (setq num-loci-found (1+ num-loci-found))
      (if (or (and find-at-least
		   (>= num-loci-found find-at-least))
	      (and limit-search (>= (point) limit-search)))
	      ;; We have found as many new loci as the user wants,
	      ;; or the user wanted a specific diff, and we're past it.
	  (setq found-desired t)))
    (set-marker compilation-parsing-end
		(if found-desired (point)
		  ;; Set to point-max, not point, so we don't perpetually
		  ;; parse the last bit of text when it isn't a diff header.
		  (point-max)))
    (message "Parsing differences...done"))
  (setq compilation-error-list (nreverse compilation-error-list)))

(defun diff-process-setup ()
  "Set up \`compilation-exit-message-function' for \`diff'."
  ;; Avoid frightening people with "abnormally terminated"
  ;; if diff finds differences.
  (set (make-local-variable 'compilation-exit-message-function)
       (lambda (status code msg)
	 (cond ((not (eq status 'exit))
		(cons msg code))
	       ((zerop code)
		'("finished (no differences)\n" . "no differences"))
	       ((= code 1)
		'("finished\n" . "differences found"))
	       (t
		(cons msg code))))))

;;;###autoload
(defun diff (old new &optional switches no-async)
  "Find and display the differences between OLD and NEW files.
Interactively the current buffer's file name is the default for NEW
and a backup file for NEW is the default for OLD.
With prefix arg, prompt for diff switches.
If NO-ASYNC is non-nil, call diff synchronously."
  (interactive
   (nconc
    (let (oldf newf)
      (nreverse
       (list
	(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))))))
    (if current-prefix-arg
	(list (read-string "Diff switches: "
			   (if (stringp diff-switches)
			       diff-switches
			     (mapconcat 'identity diff-switches " "))))
      nil)))
  (setq new (expand-file-name new)
	old (expand-file-name old))
  (let ((old-alt (file-local-copy old))
	(new-alt (file-local-copy new))
	buf)
    (save-excursion
	(let ((compilation-process-setup-function 'diff-process-setup)
	      (command
	       (mapconcat 'identity
			  (append (list diff-command)
				  ;; Use explicitly specified switches
				  (if switches
				      (if (consp switches)
					  switches (list switches))
				    ;; If not specified, use default.
				    (if (consp diff-switches)
					diff-switches
				      (list diff-switches)))
				  (if (or old-alt new-alt)
				      (list "-L" old "-L" new))
				  (list
				   (shell-quote-argument (or old-alt old)))
				  (list
				   (shell-quote-argument (or new-alt new))))
			  " ")))
	  (setq buf
		(compile-internal command
				  "No more differences" "Diff"
				  'diff-parse-differences
				  nil nil nil nil nil nil no-async))
	  (set-buffer buf)
	  (set (make-local-variable 'diff-old-file) old)
	  (set (make-local-variable 'diff-new-file) new)
	  (set (make-local-variable 'diff-old-temp-file) old-alt)
	  (set (make-local-variable 'diff-new-temp-file) new-alt)
	  (set (make-local-variable 'compilation-finish-function)
	       (function (lambda (buff msg)
			   (if diff-old-temp-file
			       (delete-file diff-old-temp-file))
			   (if diff-new-temp-file
			       (delete-file diff-new-temp-file)))))
	  ;; When async processes aren't available, the compilation finish
	  ;; function doesn't get chance to run.  Invoke it by hand.
	  (or (fboundp 'start-process)
	      (funcall compilation-finish-function nil nil))
	  buf))))

;;;###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'."
  (interactive (list (read-file-name "Diff (file with backup): ")
		     (if current-prefix-arg
			 (read-string "Diff switches: "
				      (if (stringp diff-switches)
					  diff-switches
					(mapconcat 'identity
						   diff-switches " ")))
		       nil)))
  (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)

;;; diff.el ends here
Commit	Line	Data
60370d40	1	;;; diff.el --- run `diff' in compilation-mode
c0274f38	2
219637a4	3	;; Copyright (C) 1992, 1994, 1996, 2001 Free Software Foundation, Inc.
3a801d0c	4
6228c05b	5	;; Maintainer: FSF
e9571d2a	6	;; Keywords: unix, tools
e5167999	7
b10a4379 JB	8	;; This file is part of GNU Emacs.
	9
	10	;; GNU Emacs is free software; you can redistribute it and/or modify
	11	;; it under the terms of the GNU General Public License as published by
e5167999	12	;; the Free Software Foundation; either version 2, or (at your option)
b10a4379 JB	13	;; any later version.
	14
	15	;; GNU Emacs is distributed in the hope that it will be useful,
	16	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	;; GNU General Public License for more details.
	19
	20	;; You should have received a copy of the GNU General Public License
b578f267 EN	21	;; along with GNU Emacs; see the file COPYING. If not, write to the
	22	;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	23	;; Boston, MA 02111-1307, USA.
b10a4379	24
e41b2db1 ER	25	;;; Commentary:
	26
	27	;; This package helps you explore differences between files, using the
	28	;; UNIX command diff(1). The commands are `diff' and `diff-backup'.
	29	;; You can specify options with `diff-switches'.
	30
e5167999 ER	31	;;; Code:
e5167999 ER	32
646bd331	33	(require 'compile)
aa228418	34
85b6275f RS	35	(defgroup diff nil
	36	"Comparing files with `diff'."
	37	:group 'tools)
	38
	39	;;;###autoload
	40	(defcustom diff-switches "-c"
	41	"*A string or list of strings specifying switches to be be passed to diff."
	42	:type '(choice string (repeat string))
	43	:group 'diff)
	44
	45	;;;###autoload
	46	(defcustom diff-command "diff"
	47	"*The command to use to run diff."
660d4800	48	:type 'string
85b6275f	49	:group 'diff)
d009603c	50
646bd331 RM	51	(defvar diff-regexp-alist
	52	'(
	53	;; -u format: @@ -OLDSTART,OLDEND +NEWSTART,NEWEND @@
	54	("^@@ -\\([0-9]+\\),[0-9]+ \\+\\([0-9]+\\),[0-9]+ @@$" 1 2)
4cb4ed41	55
646bd331 RM	56	;; -c format: * OLDSTART,OLDEND **
	57	("^\\\\\\* \\([0-9]+\\),[0-9]+ \\\\\\\\$" 1 nil)
	58	;; --- NEWSTART,NEWEND ----
	59	("^--- \\([0-9]+\\),[0-9]+ ----$" nil 1)
	60
	61	;; plain diff format: OLDSTART[,OLDEND]{a,d,c}NEWSTART[,NEWEND]
	62	("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]\\([0-9]+\\)\\(,[0-9]+\\)?$" 1 3)
	63
	64	;; -e (ed) format: OLDSTART[,OLDEND]{a,d,c}
	65	("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]$" 1)
	66
	67	;; -f format: {a,d,c}OLDSTART[ OLDEND]
	68	;; -n format: {a,d,c}OLDSTART LINES-CHANGED
	69	("^[adc]\\([0-9]+\\)\\( [0-9]+\\)?$" 1)
	70	)
21494aab RS	71	"Alist of regular expressions to match difference sections in \\[diff] output.
	72	Each element has the form (REGEXP OLD-IDX NEW-IDX).
	73	Any text that REGEXP matches identifies one difference hunk
	74	or the header of a hunk.
	75
	76	The OLD-IDX'th subexpression of REGEXP gives the line number
	77	in the old file, and NEW-IDX'th subexpression gives the line number
	78	in the new file. If OLD-IDX or NEW-IDX
	79	is nil, REGEXP matches only half a hunk.")
646bd331	80
5d68c2c2 RS	81	(defvar diff-old-file nil
	82	"This is the old file name in the comparison in this buffer.")
	83	(defvar diff-new-file nil
	84	"This is the new file name in the comparison in this buffer.")
	85	(defvar diff-old-temp-file nil
	86	"This is the name of a temp file to be deleted after diff finishes.")
	87	(defvar diff-new-temp-file nil
	88	"This is the name of a temp file to be deleted after diff finishes.")
	89
646bd331	90	;; See compilation-parse-errors-function (compile.el).
c540863c	91	(defun diff-parse-differences (limit-search find-at-least)
646bd331 RM	92	(setq compilation-error-list nil)
	93	(message "Parsing differences...")
	94
	95	;; Don't reparse diffs already seen at last parse.
a4ef6584	96	(if compilation-parsing-end (goto-char compilation-parsing-end))
646bd331 RM	97
	98	;; Construct in REGEXP a regexp composed of all those in dired-regexp-alist.
	99	(let ((regexp (mapconcat (lambda (elt)
	100	(concat "\\(" (car elt) "\\)"))
	101	diff-regexp-alist
	102	"\\\|"))
	103	;; (GROUP-IDX OLD-IDX NEW-IDX)
	104	(groups (let ((subexpr 1))
	105	(mapcar (lambda (elt)
	106	(prog1
	107	(cons subexpr
	108	(mapcar (lambda (n)
	109	(and n
	110	(+ subexpr n)))
	111	(cdr elt)))
	112	(setq subexpr (+ subexpr 1
	113	(count-regexp-groupings
	114	(car elt))))))
	115	diff-regexp-alist)))
	116
	117	(new-error
	118	(function (lambda (file subexpr)
	119	(setq compilation-error-list
	120	(cons
c21d3ee2 RS	121	(cons (save-excursion
	122	;; Report location of message
	123	;; at beginning of line.
	124	(goto-char
	125	(match-beginning subexpr))
	126	(beginning-of-line)
	127	(point-marker))
	128	;; Report location of corresponding text.
646bd331 RM	129	(let ((line (string-to-int
	130	(buffer-substring
	131	(match-beginning subexpr)
	132	(match-end subexpr)))))
	133	(save-excursion
929cc9de JB	134	(save-match-data
929cc9de JB	135	(set-buffer (find-file-noselect file)))
646bd331 RM	136	(save-excursion
	137	(goto-line line)
	138	(point-marker)))))
	139	compilation-error-list)))))
	140
	141	(found-desired nil)
6d670a70	142	(num-loci-found 0)
646bd331 RM	143	g)
	144
	145	(while (and (not found-desired)
	146	;; We don't just pass LIMIT-SEARCH to re-search-forward
	147	;; because we want to find matches containing LIMIT-SEARCH
	148	;; but which extend past it.
	149	(re-search-forward regexp nil t))
	150
	151	;; Find which individual regexp matched.
	152	(setq g groups)
	153	(while (and g (null (match-beginning (car (car g)))))
	154	(setq g (cdr g)))
	155	(setq g (car g))
	156
	157	(if (nth 1 g) ;OLD-IDX
	158	(funcall new-error diff-old-file (nth 1 g)))
	159	(if (nth 2 g) ;NEW-IDX
	160	(funcall new-error diff-new-file (nth 2 g)))
	161
6d670a70	162	(setq num-loci-found (1+ num-loci-found))
5d68c2c2	163	(if (or (and find-at-least
6d670a70	164	(>= num-loci-found find-at-least))
c540863c	165	(and limit-search (>= (point) limit-search)))
6d670a70	166	;; We have found as many new loci as the user wants,
c540863c RM	167	;; or the user wanted a specific diff, and we're past it.
c540863c RM	168	(setq found-desired t)))
5ef3e90c RS	169	(set-marker compilation-parsing-end
	170	(if found-desired (point)
	171	;; Set to point-max, not point, so we don't perpetually
	172	;; parse the last bit of text when it isn't a diff header.
	173	(point-max)))
6d670a70	174	(message "Parsing differences...done"))
646bd331	175	(setq compilation-error-list (nreverse compilation-error-list)))
b10a4379	176
8785daf3 EZ	177	(defun diff-process-setup ()
	178	"Set up \`compilation-exit-message-function' for \`diff'."
	179	;; Avoid frightening people with "abnormally terminated"
	180	;; if diff finds differences.
	181	(set (make-local-variable 'compilation-exit-message-function)
	182	(lambda (status code msg)
	183	(cond ((not (eq status 'exit))
	184	(cons msg code))
	185	((zerop code)
	186	'("finished (no differences)\n" . "no differences"))
	187	((= code 1)
	188	'("finished\n" . "differences found"))
	189	(t
	190	(cons msg code))))))
	191
b10a4379	192	;;;###autoload
0f7b0f88	193	(defun diff (old new &optional switches no-async)
b10a4379	194	"Find and display the differences between OLD and NEW files.
4b00edc8	195	Interactively the current buffer's file name is the default for NEW
646bd331	196	and a backup file for NEW is the default for OLD.
0f7b0f88	197	With prefix arg, prompt for diff switches.
ab9ecc74	198	If NO-ASYNC is non-nil, call diff synchronously."
b10a4379	199	(interactive
646bd331 RM	200	(nconc
	201	(let (oldf newf)
	202	(nreverse
	203	(list
	204	(setq newf (buffer-file-name)
	205	newf (if (and newf (file-exists-p newf))
	206	(read-file-name
219637a4	207	(concat "Diff new file: (default "
646bd331 RM	208	(file-name-nondirectory newf) ") ")
	209	nil newf t)
	210	(read-file-name "Diff new file: " nil nil t)))
	211	(setq oldf (file-newest-backup newf)
	212	oldf (if (and oldf (file-exists-p oldf))
	213	(read-file-name
219637a4	214	(concat "Diff original file: (default "
646bd331 RM	215	(file-name-nondirectory oldf) ") ")
	216	(file-name-directory oldf) oldf t)
	217	(read-file-name "Diff original file: "
	218	(file-name-directory newf) nil t))))))
	219	(if current-prefix-arg
	220	(list (read-string "Diff switches: "
	221	(if (stringp diff-switches)
	222	diff-switches
	223	(mapconcat 'identity diff-switches " "))))
	224	nil)))
b10a4379 JB	225	(setq new (expand-file-name new)
b10a4379 JB	226	old (expand-file-name old))
5d68c2c2 RS	227	(let ((old-alt (file-local-copy old))
5d68c2c2 RS	228	(new-alt (file-local-copy new))
bfe81e78	229	buf)
9f748a35	230	(save-excursion
8785daf3 EZ	231	(let ((compilation-process-setup-function 'diff-process-setup)
8785daf3 EZ	232	(command
bfe81e78	233	(mapconcat 'identity
d009603c	234	(append (list diff-command)
16776caa RS	235	;; Use explicitly specified switches
	236	(if switches
	237	(if (consp switches)
	238	switches (list switches))
	239	;; If not specified, use default.
	240	(if (consp diff-switches)
	241	diff-switches
	242	(list diff-switches)))
bfe81e78 RS	243	(if (or old-alt new-alt)
bfe81e78 RS	244	(list "-L" old "-L" new))
c9cebcb1 RS	245	(list
	246	(shell-quote-argument (or old-alt old)))
	247	(list
	248	(shell-quote-argument (or new-alt new))))
bfe81e78 RS	249	" ")))
	250	(setq buf
	251	(compile-internal command
	252	"No more differences" "Diff"
0f7b0f88 CW	253	'diff-parse-differences
0f7b0f88 CW	254	nil nil nil nil nil nil no-async))
9f748a35	255	(set-buffer buf)
a6609a36 RS	256	(set (make-local-variable 'diff-old-file) old)
	257	(set (make-local-variable 'diff-new-file) new)
	258	(set (make-local-variable 'diff-old-temp-file) old-alt)
	259	(set (make-local-variable 'diff-new-temp-file) new-alt)
	260	(set (make-local-variable 'compilation-finish-function)
	261	(function (lambda (buff msg)
	262	(if diff-old-temp-file
	263	(delete-file diff-old-temp-file))
	264	(if diff-new-temp-file
	265	(delete-file diff-new-temp-file)))))
8785daf3 EZ	266	;; When async processes aren't available, the compilation finish
	267	;; function doesn't get chance to run. Invoke it by hand.
	268	(or (fboundp 'start-process)
	269	(funcall compilation-finish-function nil nil))
5d68c2c2	270	buf))))
aa228418	271
646bd331 RM	272	;;;###autoload
646bd331 RM	273	(defun diff-backup (file &optional switches)
37c51f00 RS	274	"Diff this file with its backup file or vice versa.
	275	Uses the latest backup, if there are several numerical backups.
	276	If this file is a backup, diff it with its original.
	277	The backup file is the first file given to `diff'."
646bd331 RM	278	(interactive (list (read-file-name "Diff (file with backup): ")
	279	(if current-prefix-arg
	280	(read-string "Diff switches: "
	281	(if (stringp diff-switches)
	282	diff-switches
	283	(mapconcat 'identity
	284	diff-switches " ")))
	285	nil)))
37c51f00 RS	286	(let (bak ori)
	287	(if (backup-file-name-p file)
	288	(setq bak file
	289	ori (file-name-sans-versions file))
	290	(setq bak (or (diff-latest-backup-file file)
	291	(error "No backup found for %s" file))
	292	ori file))
646bd331	293	(diff bak ori switches)))
37c51f00 RS	294
	295	(defun diff-latest-backup-file (fn) ; actually belongs into files.el
	296	"Return the latest existing backup of FILE, or nil."
a617e913	297	(let ((handler (find-file-name-handler fn 'diff-latest-backup-file)))
34c46d87	298	(if handler
6d0d0e8d	299	(funcall handler 'diff-latest-backup-file fn)
a8090e38	300	(file-newest-backup fn))))
aa228418	301
a4ef6584 ER	302	(provide 'diff)
a4ef6584 ER	303
c0274f38	304	;;; diff.el ends here