[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
			    (list (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.
				  (list file nil)
				  (string-to-int
				   (buffer-substring
				    (match-beginning subexpr)
				    (match-end subexpr)))
				  nil)
			    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)

;;; arch-tag: 7de2c29b-7ea5-4b85-9b9d-72dd860de2bd
;;; 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
a6d3209f	121	(list (save-excursion
c21d3ee2 RS	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.
a6d3209f RS	129	(list file nil)
	130	(string-to-int
	131	(buffer-substring
	132	(match-beginning subexpr)
	133	(match-end subexpr)))
	134	nil)
646bd331 RM	135	compilation-error-list)))))
	136
	137	(found-desired nil)
6d670a70	138	(num-loci-found 0)
646bd331 RM	139	g)
	140
	141	(while (and (not found-desired)
	142	;; We don't just pass LIMIT-SEARCH to re-search-forward
	143	;; because we want to find matches containing LIMIT-SEARCH
	144	;; but which extend past it.
	145	(re-search-forward regexp nil t))
	146
	147	;; Find which individual regexp matched.
	148	(setq g groups)
	149	(while (and g (null (match-beginning (car (car g)))))
	150	(setq g (cdr g)))
	151	(setq g (car g))
	152
	153	(if (nth 1 g) ;OLD-IDX
	154	(funcall new-error diff-old-file (nth 1 g)))
	155	(if (nth 2 g) ;NEW-IDX
	156	(funcall new-error diff-new-file (nth 2 g)))
	157
6d670a70	158	(setq num-loci-found (1+ num-loci-found))
5d68c2c2	159	(if (or (and find-at-least
6d670a70	160	(>= num-loci-found find-at-least))
c540863c	161	(and limit-search (>= (point) limit-search)))
6d670a70	162	;; We have found as many new loci as the user wants,
c540863c RM	163	;; or the user wanted a specific diff, and we're past it.
c540863c RM	164	(setq found-desired t)))
5ef3e90c RS	165	(set-marker compilation-parsing-end
	166	(if found-desired (point)
	167	;; Set to point-max, not point, so we don't perpetually
	168	;; parse the last bit of text when it isn't a diff header.
	169	(point-max)))
6d670a70	170	(message "Parsing differences...done"))
646bd331	171	(setq compilation-error-list (nreverse compilation-error-list)))
b10a4379	172
8785daf3 EZ	173	(defun diff-process-setup ()
	174	"Set up \`compilation-exit-message-function' for \`diff'."
	175	;; Avoid frightening people with "abnormally terminated"
	176	;; if diff finds differences.
	177	(set (make-local-variable 'compilation-exit-message-function)
	178	(lambda (status code msg)
	179	(cond ((not (eq status 'exit))
	180	(cons msg code))
	181	((zerop code)
	182	'("finished (no differences)\n" . "no differences"))
	183	((= code 1)
	184	'("finished\n" . "differences found"))
	185	(t
	186	(cons msg code))))))
	187
b10a4379	188	;;;###autoload
0f7b0f88	189	(defun diff (old new &optional switches no-async)
b10a4379	190	"Find and display the differences between OLD and NEW files.
4b00edc8	191	Interactively the current buffer's file name is the default for NEW
646bd331	192	and a backup file for NEW is the default for OLD.
0f7b0f88	193	With prefix arg, prompt for diff switches.
ab9ecc74	194	If NO-ASYNC is non-nil, call diff synchronously."
b10a4379	195	(interactive
646bd331 RM	196	(nconc
	197	(let (oldf newf)
	198	(nreverse
	199	(list
	200	(setq newf (buffer-file-name)
	201	newf (if (and newf (file-exists-p newf))
	202	(read-file-name
219637a4	203	(concat "Diff new file: (default "
646bd331 RM	204	(file-name-nondirectory newf) ") ")
	205	nil newf t)
	206	(read-file-name "Diff new file: " nil nil t)))
	207	(setq oldf (file-newest-backup newf)
	208	oldf (if (and oldf (file-exists-p oldf))
	209	(read-file-name
219637a4	210	(concat "Diff original file: (default "
646bd331 RM	211	(file-name-nondirectory oldf) ") ")
	212	(file-name-directory oldf) oldf t)
	213	(read-file-name "Diff original file: "
	214	(file-name-directory newf) nil t))))))
	215	(if current-prefix-arg
	216	(list (read-string "Diff switches: "
	217	(if (stringp diff-switches)
	218	diff-switches
	219	(mapconcat 'identity diff-switches " "))))
	220	nil)))
b10a4379 JB	221	(setq new (expand-file-name new)
b10a4379 JB	222	old (expand-file-name old))
5d68c2c2 RS	223	(let ((old-alt (file-local-copy old))
5d68c2c2 RS	224	(new-alt (file-local-copy new))
bfe81e78	225	buf)
9f748a35	226	(save-excursion
8785daf3 EZ	227	(let ((compilation-process-setup-function 'diff-process-setup)
8785daf3 EZ	228	(command
bfe81e78	229	(mapconcat 'identity
d009603c	230	(append (list diff-command)
16776caa RS	231	;; Use explicitly specified switches
	232	(if switches
	233	(if (consp switches)
	234	switches (list switches))
	235	;; If not specified, use default.
	236	(if (consp diff-switches)
	237	diff-switches
	238	(list diff-switches)))
bfe81e78 RS	239	(if (or old-alt new-alt)
bfe81e78 RS	240	(list "-L" old "-L" new))
c9cebcb1 RS	241	(list
	242	(shell-quote-argument (or old-alt old)))
	243	(list
	244	(shell-quote-argument (or new-alt new))))
bfe81e78 RS	245	" ")))
	246	(setq buf
	247	(compile-internal command
	248	"No more differences" "Diff"
0f7b0f88 CW	249	'diff-parse-differences
0f7b0f88 CW	250	nil nil nil nil nil nil no-async))
9f748a35	251	(set-buffer buf)
a6609a36 RS	252	(set (make-local-variable 'diff-old-file) old)
	253	(set (make-local-variable 'diff-new-file) new)
	254	(set (make-local-variable 'diff-old-temp-file) old-alt)
	255	(set (make-local-variable 'diff-new-temp-file) new-alt)
	256	(set (make-local-variable 'compilation-finish-function)
	257	(function (lambda (buff msg)
	258	(if diff-old-temp-file
	259	(delete-file diff-old-temp-file))
	260	(if diff-new-temp-file
	261	(delete-file diff-new-temp-file)))))
8785daf3 EZ	262	;; When async processes aren't available, the compilation finish
	263	;; function doesn't get chance to run. Invoke it by hand.
	264	(or (fboundp 'start-process)
	265	(funcall compilation-finish-function nil nil))
5d68c2c2	266	buf))))
aa228418	267
646bd331 RM	268	;;;###autoload
646bd331 RM	269	(defun diff-backup (file &optional switches)
37c51f00 RS	270	"Diff this file with its backup file or vice versa.
	271	Uses the latest backup, if there are several numerical backups.
	272	If this file is a backup, diff it with its original.
	273	The backup file is the first file given to `diff'."
646bd331 RM	274	(interactive (list (read-file-name "Diff (file with backup): ")
	275	(if current-prefix-arg
	276	(read-string "Diff switches: "
	277	(if (stringp diff-switches)
	278	diff-switches
	279	(mapconcat 'identity
	280	diff-switches " ")))
	281	nil)))
37c51f00 RS	282	(let (bak ori)
	283	(if (backup-file-name-p file)
	284	(setq bak file
	285	ori (file-name-sans-versions file))
	286	(setq bak (or (diff-latest-backup-file file)
	287	(error "No backup found for %s" file))
	288	ori file))
646bd331	289	(diff bak ori switches)))
37c51f00 RS	290
	291	(defun diff-latest-backup-file (fn) ; actually belongs into files.el
	292	"Return the latest existing backup of FILE, or nil."
a617e913	293	(let ((handler (find-file-name-handler fn 'diff-latest-backup-file)))
34c46d87	294	(if handler
6d0d0e8d	295	(funcall handler 'diff-latest-backup-file fn)
a8090e38	296	(file-newest-backup fn))))
aa228418	297
a4ef6584 ER	298	(provide 'diff)
a4ef6584 ER	299
ab5796a9	300	;;; arch-tag: 7de2c29b-7ea5-4b85-9b9d-72dd860de2bd
c0274f38	301	;;; diff.el ends here