1 ;;; ediff-diff.el --- diff-related utilities
3 ;; Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02 Free Software Foundation, Inc.
5 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
7 ;; This file is part of GNU Emacs.
9 ;; GNU Emacs is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; GNU Emacs is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GNU Emacs; see the file COPYING. If not, write to the
21 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 ;; Boston, MA 02110-1301, USA.
31 (defvar ediff-default-variant)
33 (defvar longlines-mode)
36 (let ((load-path (cons (expand-file-name ".") load-path)))
37 (or (featurep 'ediff-init)
38 (load "ediff-init.el" nil nil 'nosuffix))
39 (or (featurep 'ediff-util)
40 (load "ediff-util.el" nil nil 'nosuffix))
46 (defgroup ediff-diff nil
47 "Diff related utilities."
51 ;; these two must be here to prevent ediff-test-utility from barking
52 (defcustom ediff-diff-program "diff"
53 "*Program to use for generating the differential of the two files."
56 (defcustom ediff-diff3-program "diff3"
57 "*Program to be used for three-way comparison.
58 Must produce output compatible with Unix's diff3 program."
63 ;; The following functions must precede all defcustom-defined variables.
65 ;; The following functions needed for setting diff/diff3 options
66 ;; test if diff supports the --binary option
67 (defsubst ediff-test-utility (diff-util option &optional files)
68 (eq 0 (apply 'call-process
69 (append (list diff-util nil nil nil option) files))))
71 (defun ediff-diff-mandatory-option (diff-util)
72 (let ((file (if (boundp 'null-device) null-device "/dev/null")))
73 (cond ((not (memq system-type '(ms-dos windows-nt windows-95)))
75 ((and (string= diff-util ediff-diff-program)
77 ediff-diff-program "--binary" (list file file)))
79 ((and (string= diff-util ediff-diff3-program)
81 ediff-diff3-program "--binary" (list file file file)))
85 ;; make sure that mandatory options are added even if the user changes
86 ;; ediff-diff-options or ediff-diff3-options in the customization widget
87 (defun ediff-reset-diff-options (symb val)
89 (if (eq symb 'ediff-diff-options)
92 (mandatory-option (ediff-diff-mandatory-option diff-program))
93 (spacer (if (string-equal mandatory-option "") "" " ")))
95 (if (string-match mandatory-option val)
97 (concat mandatory-option spacer val)))
101 (defcustom ediff-shell
102 (cond ((eq system-type 'emx) "cmd") ; OS/2
103 ((memq system-type '(ms-dos windows-nt windows-95))
104 shell-file-name) ; no standard name on MS-DOS
105 ((memq system-type '(vax-vms axp-vms)) "*dcl*") ; VMS
107 "*The shell used to run diff and patch.
108 If user's .profile or .cshrc files are set up correctly, any shell
109 will do. However, some people set $prompt or other things
110 incorrectly, which leads to undesirable output messages. These may
111 cause Ediff to fail. In such a case, set `ediff-shell' to a shell that
112 you are not using or, better, fix your shell's startup file."
116 (defcustom ediff-cmp-program "cmp"
117 "*Utility to use to determine if two files are identical.
118 It must return code 0, if its arguments are identical files."
122 (defcustom ediff-cmp-options nil
123 "*Options to pass to `ediff-cmp-program'.
124 If GNU diff is used as `ediff-cmp-program', then the most useful options
125 are `-I REGEXP', to ignore changes whose lines match the REGEXP."
126 :type '(repeat string)
129 (defcustom ediff-diff-options ""
130 "*Options to pass to `ediff-diff-program'.
131 If Unix diff is used as `ediff-diff-program', then the most useful options are
132 `-w', to ignore space, and `-i', to ignore case of letters.
133 At present, the option `-c' is not allowed."
134 :set 'ediff-reset-diff-options
138 (defcustom ediff-custom-diff-program ediff-diff-program
139 "*Program to use for generating custom diff output for saving it in a file.
140 This output is not used by Ediff internally."
143 (defcustom ediff-custom-diff-options "-c"
144 "*Options to pass to `ediff-custom-diff-program'."
148 ;;; Support for diff3
150 (defvar ediff-match-diff3-line "^====\\(.?\\)\C-m?$"
151 "Pattern to match lines produced by diff3 that describe differences.")
152 (defcustom ediff-diff3-options ""
153 "*Options to pass to `ediff-diff3-program'."
154 :set 'ediff-reset-diff-options
157 (defcustom ediff-diff3-ok-lines-regexp
158 "^\\([1-3]:\\|====\\| \\|.*Warning *:\\|.*No newline\\|.*missing newline\\|^\C-m$\\)"
159 "*Regexp that matches normal output lines from `ediff-diff3-program'.
160 Lines that do not match are assumed to be error messages."
164 ;; keeps the status of the current diff in 3-way jobs.
165 ;; the status can be =diff(A), =diff(B), or =diff(A+B)
166 (ediff-defvar-local ediff-diff-status "" "")
171 (ediff-defvar-local ediff-auto-refine (if (ediff-has-face-support-p) 'on 'nix)
172 "If `on', Ediff auto-highlights fine diffs for the current diff region.
173 If `off', auto-highlighting is not used. If `nix', no fine diffs are shown
174 at all, unless the user force-refines the region by hitting `*'.
176 This variable can be set either in .emacs or toggled interactively.
177 Use `setq-default' if setting it in .emacs")
179 (ediff-defvar-local ediff-ignore-similar-regions nil
180 "*If t, skip over difference regions that differ only in the white space and line breaks.
181 This variable can be set either in .emacs or toggled interactively.
182 Use `setq-default' if setting it in .emacs")
184 (ediff-defvar-local ediff-auto-refine-limit 1400
185 "*Auto-refine only the regions of this size \(in bytes\) or less.")
189 (defvar ediff-diff-ok-lines-regexp
192 "[0-9,]+[acd][0-9,]+\C-m?$"
197 "\\|.*missing +newline"
200 "Regexp that matches normal output lines from `ediff-diff-program'.
201 This is mostly lifted from Emerge, except that Ediff also considers
202 warnings and `Missing newline'-type messages to be normal output.
203 Lines that do not match are assumed to be error messages.")
205 (defvar ediff-match-diff-line
206 (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
207 (concat "^" x "\\([acd]\\)" x "\C-m?$"))
208 "Pattern to match lines produced by diff that describe differences.")
210 (ediff-defvar-local ediff-setup-diff-regions-function nil
211 "value is a function symbol depending on the kind of job is to be done.
212 For 2-way jobs and for ediff-merge, it should be `ediff-setup-diff-regions'.
213 For jobs requiring diff3, it should be `ediff-setup-diff-regions3'.
215 The function should take three mandatory arguments, file-A, file-B, and
216 file-C. It may ignore file C for diff2 jobs. It should also take
217 one optional arguments, diff-number to refine.")
222 ;; Generate the difference vector and overlays for the two files
223 ;; With optional arg REG-TO-REFINE, refine this region.
224 ;; File-C argument is not used here. It is there just because
225 ;; ediff-setup-diff-regions is called via a funcall to
226 ;; ediff-setup-diff-regions-function, which can also have the value
227 ;; ediff-setup-diff-regions3, which takes 4 arguments.
228 (defun ediff-setup-diff-regions (file-A file-B file-C)
229 ;; looking either for '-c' or a 'c' in a set of clustered non-long options
230 (if (string-match "^-c\\| -c\\|-[^- ]+c" ediff-diff-options)
231 (error "Option `-c' is not allowed in `ediff-diff-options'"))
233 ;; create, if it doesn't exist
234 (or (ediff-buffer-live-p ediff-diff-buffer)
235 (setq ediff-diff-buffer
236 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
237 (ediff-make-diff2-buffer ediff-diff-buffer file-A file-B)
238 (ediff-prepare-error-list ediff-diff-ok-lines-regexp ediff-diff-buffer)
239 (ediff-convert-diffs-to-overlays
241 ediff-diff-buffer ediff-word-mode ediff-narrow-bounds)))
243 ;; Run the diff program on FILE1 and FILE2 and put the output in DIFF-BUFFER
244 ;; Return the size of DIFF-BUFFER
245 ;; The return code isn't used in the program at present.
246 (defun ediff-make-diff2-buffer (diff-buffer file1 file2)
247 (let ((file1-size (ediff-file-size file1))
248 (file2-size (ediff-file-size file2)))
249 (cond ((not (numberp file1-size))
250 (message "Can't find file: %s"
251 (ediff-abbreviate-file-name file1))
253 ;; 1 is an error exit code
255 ((not (numberp file2-size))
256 (message "Can't find file: %s"
257 (ediff-abbreviate-file-name file2))
259 ;; 1 is an error exit code
261 (t (message "Computing differences between %s and %s ..."
262 (file-name-nondirectory file1)
263 (file-name-nondirectory file2))
264 ;; this erases the diff buffer automatically
265 (ediff-exec-process ediff-diff-program
268 ediff-diff-options file1 file2)
270 (ediff-with-current-buffer diff-buffer
275 ;; If file-A/B/C is nil, do 2-way comparison with the non-nil buffers
276 ;; This function works for diff3 and diff2 jobs
277 (defun ediff-setup-fine-diff-regions (file-A file-B file-C reg-num)
278 (or (ediff-buffer-live-p ediff-fine-diff-buffer)
279 (setq ediff-fine-diff-buffer
281 (ediff-unique-buffer-name "*ediff-fine-diff" "*"))))
283 (let (diff3-job diff-program diff-options ok-regexp diff-list)
284 (setq diff3-job ediff-3way-job
285 diff-program (if diff3-job ediff-diff3-program ediff-diff-program)
286 diff-options (if diff3-job ediff-diff3-options ediff-diff-options)
287 ok-regexp (if diff3-job
288 ediff-diff3-ok-lines-regexp
289 ediff-diff-ok-lines-regexp))
291 (ediff-message-if-verbose "Refining difference region %d ..." (1+ reg-num))
292 (ediff-exec-process diff-program ediff-fine-diff-buffer 'synchronize
294 ;; The shuffle below is because we can compare 3-way
295 ;; or in several 2-way fashions, like fA fC, fA fB,
297 (if file-A file-A file-B)
298 (if file-B file-B file-A)
300 (if file-C file-C file-B))
303 (ediff-prepare-error-list ok-regexp ediff-fine-diff-buffer)
304 (ediff-message-if-verbose
306 ;; "Refining difference region %d ... done" (1+ reg-num))
310 (ediff-extract-diffs3
311 ediff-fine-diff-buffer '3way-comparison 'word-mode)
312 (ediff-extract-diffs ediff-fine-diff-buffer 'word-mode)))
316 (mapcar (lambda (elt)
321 (mapcar (lambda (elt)
326 (mapcar (lambda (elt)
332 (ediff-convert-fine-diffs-to-overlays diff-list reg-num)
336 (defun ediff-prepare-error-list (ok-regexp diff-buff)
337 (or (ediff-buffer-live-p ediff-error-buffer)
338 (setq ediff-error-buffer
339 (get-buffer-create (ediff-unique-buffer-name
340 "*ediff-errors" "*"))))
341 (ediff-with-current-buffer ediff-error-buffer
343 (insert (ediff-with-current-buffer diff-buff (buffer-string)))
344 (goto-char (point-min))
345 (delete-matching-lines ok-regexp)
346 (if (memq system-type '(vax-vms axp-vms))
347 (delete-matching-lines "^$")))
348 ;; If diff reports errors, show them then quit.
349 (if (/= 0 (ediff-with-current-buffer ediff-error-buffer (buffer-size)))
350 (let ((ctl-buf ediff-control-buffer)
351 (error-buf ediff-error-buffer))
352 (ediff-skip-unsuitable-frames)
353 (switch-to-buffer error-buf)
354 (ediff-kill-buffer-carefully ctl-buf)
355 (error "Errors in diff output. Diff output is in %S" diff-buff))))
357 ;; BOUNDS specifies visibility bounds to use.
358 ;; WORD-MODE tells whether we are in the word-mode or not.
359 ;; If WORD-MODE, also construct vector of diffs using word numbers.
360 ;; Else, use point values.
361 ;; This function handles diff-2 jobs including the case of
362 ;; merging buffers and files without ancestor.
363 (defun ediff-extract-diffs (diff-buffer word-mode &optional bounds)
364 (let ((A-buffer ediff-buffer-A)
365 (B-buffer ediff-buffer-B)
366 (C-buffer ediff-buffer-C)
367 (a-prev 1) ; this is needed to set the first diff line correctly
370 diff-list shift-A shift-B
373 ;; diff list contains word numbers, unless changed later
374 (setq diff-list (cons (if word-mode 'words 'points)
376 ;; we don't use visibility bounds for buffer C when merging
380 (ediff-get-value-according-to-buffer-type 'A bounds))
383 (ediff-get-value-according-to-buffer-type 'B bounds))))
385 ;; reset point in buffers A/B/C
386 (ediff-with-current-buffer A-buffer
387 (goto-char (if shift-A shift-A (point-min))))
388 (ediff-with-current-buffer B-buffer
389 (goto-char (if shift-B shift-B (point-min))))
390 (if (ediff-buffer-live-p C-buffer)
391 (ediff-with-current-buffer C-buffer
392 (goto-char (point-min))))
394 (ediff-with-current-buffer diff-buffer
395 (goto-char (point-min))
396 (while (re-search-forward ediff-match-diff-line nil t)
397 (let* ((a-begin (string-to-number (buffer-substring (match-beginning 1)
399 (a-end (let ((b (match-beginning 3))
402 (string-to-number (buffer-substring b e))
404 (diff-type (buffer-substring (match-beginning 4) (match-end 4)))
405 (b-begin (string-to-number (buffer-substring (match-beginning 5)
407 (b-end (let ((b (match-beginning 7))
410 (string-to-number (buffer-substring b e))
412 a-begin-pt a-end-pt b-begin-pt b-end-pt
413 c-begin c-end c-begin-pt c-end-pt)
414 ;; fix the beginning and end numbers, because diff is somewhat
415 ;; strange about how it numbers lines
416 (if (string-equal diff-type "a")
417 (setq b-end (1+ b-end)
420 (if (string-equal diff-type "d")
421 (setq a-end (1+ a-end)
424 ;; (string-equal diff-type "c")
425 (setq a-end (1+ a-end)
428 (if (eq ediff-default-variant 'default-B)
429 (setq c-begin b-begin
431 (setq c-begin a-begin
434 ;; compute main diff vector
436 ;; make diff-list contain word numbers
440 (if (ediff-buffer-live-p C-buffer)
441 (vector (- a-begin a-prev) (- a-end a-begin)
442 (- b-begin b-prev) (- b-end b-begin)
443 (- c-begin c-prev) (- c-end c-begin)
444 nil nil ; dummy ancestor
447 nil ; state of ancestor
449 (vector (- a-begin a-prev) (- a-end a-begin)
450 (- b-begin b-prev) (- b-end b-begin)
451 nil nil ; dummy buf C
452 nil nil ; dummy ancestor
455 nil ; state of ancestor
461 ;; else convert lines to points
462 (ediff-with-current-buffer A-buffer
463 (let ((longlines-mode-val
464 (if (and (boundp 'longlines-mode) longlines-mode) 1 0)))
465 ;; we must disable and then restore longlines-mode
466 (if (eq longlines-mode-val 1)
468 (forward-line (- a-begin a-prev))
469 (setq a-begin-pt (point))
470 (forward-line (- a-end a-begin))
471 (setq a-end-pt (point)
473 (if (eq longlines-mode-val 1)
474 (longlines-mode longlines-mode-val))
476 (ediff-with-current-buffer B-buffer
477 (let ((longlines-mode-val
478 (if (and (boundp 'longlines-mode) longlines-mode) 1 0)))
479 (if (eq longlines-mode-val 1)
481 (forward-line (- b-begin b-prev))
482 (setq b-begin-pt (point))
483 (forward-line (- b-end b-begin))
484 (setq b-end-pt (point)
486 (if (eq longlines-mode-val 1)
487 (longlines-mode longlines-mode-val))
489 (if (ediff-buffer-live-p C-buffer)
490 (ediff-with-current-buffer C-buffer
491 (let ((longlines-mode-val
492 (if (and (boundp 'longlines-mode) longlines-mode) 1 0)))
493 (if (eq longlines-mode-val 1)
495 (forward-line (- c-begin c-prev))
496 (setq c-begin-pt (point))
497 (forward-line (- c-end c-begin))
498 (setq c-end-pt (point)
500 (if (eq longlines-mode-val 1)
501 (longlines-mode longlines-mode-val))
507 (if (ediff-buffer-live-p C-buffer)
509 a-begin-pt a-end-pt b-begin-pt b-end-pt
511 nil nil ; dummy ancestor
513 ;; shows which buff is different from the other two
514 (if (eq ediff-default-variant 'default-B) 'A 'B)
515 ediff-default-variant ; state of merge
516 nil ; state of ancestor
518 (vector a-begin-pt a-end-pt
520 nil nil ; dummy buf C
521 nil nil ; dummy ancestor
522 nil nil ; dummy state of diff & merge
523 nil ; dummy state of ancestor
527 ))) ; end ediff-with-current-buffer
532 (defun ediff-convert-diffs-to-overlays (diff-list)
533 (ediff-set-diff-overlays-in-one-buffer 'A diff-list)
534 (ediff-set-diff-overlays-in-one-buffer 'B diff-list)
536 (ediff-set-diff-overlays-in-one-buffer 'C diff-list))
537 (if ediff-merge-with-ancestor-job
538 (ediff-set-diff-overlays-in-one-buffer 'Ancestor diff-list))
539 ;; set up vector showing the status of merge regions
541 (setq ediff-state-of-merge
543 (mapcar (lambda (elt)
544 (let ((state-of-merge (aref elt 9))
545 (state-of-ancestor (aref elt 10)))
547 ;; state of merge: prefers/default-A/B or combined
548 (if state-of-merge (format "%S" state-of-merge))
549 ;; whether the ancestor region is empty
551 ;; the first elt designates type of list
554 (message "Processing difference regions ... done"))
557 (defun ediff-set-diff-overlays-in-one-buffer (buf-type diff-list)
558 (let* ((current-diff -1)
559 (buff (ediff-get-buffer buf-type))
560 (ctl-buf ediff-control-buffer)
561 ;; ediff-extract-diffs puts the type of diff-list as the first elt
562 ;; of this list. The type is either 'points or 'words
563 (diff-list-type (car diff-list))
564 (shift (ediff-overlay-start
565 (ediff-get-value-according-to-buffer-type
566 buf-type ediff-narrow-bounds)))
567 (limit (ediff-overlay-end
568 (ediff-get-value-according-to-buffer-type
569 buf-type ediff-narrow-bounds)))
570 diff-overlay-list list-element total-diffs
571 begin end pt-saved overlay state-of-diff)
573 (setq diff-list (cdr diff-list)) ; discard diff list type
574 (setq total-diffs (length diff-list))
576 ;; shift, if necessary
577 (ediff-with-current-buffer buff (setq pt-saved shift))
580 (setq current-diff (1+ current-diff)
581 list-element (car diff-list)
582 begin (aref list-element (cond ((eq buf-type 'A) 0)
586 end (aref list-element (cond ((eq buf-type 'A) 1)
590 state-of-diff (aref list-element 8)
593 (cond ((and (not (eq buf-type state-of-diff))
594 (not (eq buf-type 'Ancestor))
595 (memq state-of-diff '(A B C)))
597 (car (delq buf-type (delq state-of-diff (list 'A 'B 'C)))))
598 (setq state-of-diff (format "=diff(%S)" state-of-diff))
600 (t (setq state-of-diff nil)))
602 ;; Put overlays at appropriate places in buffer
603 ;; convert word numbers to points, if necessary
604 (if (eq diff-list-type 'words)
606 (ediff-with-current-buffer buff (goto-char pt-saved))
607 (ediff-with-current-buffer ctl-buf
608 (setq begin (ediff-goto-word (1+ begin) buff)
609 end (ediff-goto-word end buff 'end)))
610 (if (> end limit) (setq end limit))
611 (if (> begin end) (setq begin end))
612 (setq pt-saved (ediff-with-current-buffer buff (point)))))
613 (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
615 (ediff-overlay-put overlay 'priority ediff-shadow-overlay-priority)
616 (ediff-overlay-put overlay 'ediff-diff-num current-diff)
617 (if (and (ediff-has-face-support-p)
618 ediff-use-faces ediff-highlight-all-diffs)
619 (ediff-set-overlay-face
620 overlay (ediff-background-face buf-type current-diff)))
622 (if (= 0 (mod current-diff 10))
623 (message "Buffer %S: Processing difference region %d of %d"
624 buf-type current-diff total-diffs))
625 ;; Record all overlays for this difference.
626 ;; The 2-d elt, nil, is a place holder for the fine diff vector.
627 ;; The 3-d elt, nil, is a place holder for no-fine-diffs flag.
628 ;; The 4-th elt says which diff region is different from the other two
629 ;; (3-way jobs only).
630 (setq diff-overlay-list
633 (list (vector overlay nil nil state-of-diff)))
638 (set (ediff-get-symbol-from-alist buf-type ediff-difference-vector-alist)
639 (vconcat diff-overlay-list))
642 ;; `n' is the diff region to work on. Default is ediff-current-difference.
643 ;; if `flag' is 'noforce then make fine-diffs only if this region's fine
644 ;; diffs have not been computed before.
645 ;; if `flag' is 'skip then don't compute fine diffs for this region.
646 (defun ediff-make-fine-diffs (&optional n flag)
647 (or n (setq n ediff-current-difference))
649 (if (< ediff-number-of-differences 1)
650 (error ediff-NO-DIFFERENCES))
654 ediff-auto-refine 'nix))
657 (>= n ediff-number-of-differences)
658 ;; n is within the range
659 (let ((tmp-buffer (get-buffer-create ediff-tmp-buffer))
660 (file-A ediff-temp-file-A)
661 (file-B ediff-temp-file-B)
662 (file-C ediff-temp-file-C)
663 (empty-A (ediff-empty-diff-region-p n 'A))
664 (empty-B (ediff-empty-diff-region-p n 'B))
665 (empty-C (ediff-empty-diff-region-p n 'C))
666 (whitespace-A (ediff-whitespace-diff-region-p n 'A))
667 (whitespace-B (ediff-whitespace-diff-region-p n 'B))
668 (whitespace-C (ediff-whitespace-diff-region-p n 'C))
669 cumulative-fine-diff-length)
671 (cond ;; If one of the regions is empty (or 2 in 3way comparison)
672 ;; then don't refine.
673 ;; If the region happens to be entirely whitespace or empty then
675 ((> (length (delq nil (list empty-A empty-B empty-C))) 1)
676 (if (and (ediff-looks-like-combined-merge n)
678 (ediff-set-fine-overlays-in-one-buffer 'C nil n))
679 (if ediff-3way-comparison-job
680 (ediff-message-if-verbose
681 "Region %d is empty in all buffers but %S"
683 (cond ((not empty-A) 'A)
686 (ediff-message-if-verbose
687 "Region %d in buffer %S is empty"
693 ;; if all regions happen to be whitespace
694 (if (and whitespace-A whitespace-B whitespace-C)
695 ;; mark as space only
696 (ediff-mark-diff-as-space-only n t)
697 ;; if some regions are white and others don't, then mark as
698 ;; non-white-space-only
699 (ediff-mark-diff-as-space-only n nil)))
701 ;; don't compute fine diffs if diff vector exists
702 ((and (eq flag 'noforce) (ediff-get-fine-diff-vector n 'A))
703 (if (ediff-no-fine-diffs-p n)
705 "Only white-space differences in region %d %s"
707 (cond ((eq (ediff-no-fine-diffs-p n) 'A)
709 ((eq (ediff-no-fine-diffs-p n) 'B)
711 ((eq (ediff-no-fine-diffs-p n) 'C)
714 ;; don't compute fine diffs for this region
716 (or (ediff-get-fine-diff-vector n 'A)
717 (memq ediff-auto-refine '(off nix))
718 (ediff-message-if-verbose
719 "Region %d exceeds the auto-refinement limit. Type `%s' to refine"
721 (substitute-command-keys
722 "\\[ediff-make-or-kill-fine-diffs]")
725 ;; recompute fine diffs
727 (ediff-get-diff-posn 'A 'beg n)
728 (ediff-get-diff-posn 'A 'end n)
731 ediff-control-buffer)
733 (ediff-make-temp-file tmp-buffer "fineDiffA" file-A))
736 (ediff-get-diff-posn 'B 'beg n)
737 (ediff-get-diff-posn 'B 'end n)
740 ediff-control-buffer)
742 (ediff-make-temp-file tmp-buffer "fineDiffB" file-B))
747 (ediff-get-diff-posn 'C 'beg n)
748 (ediff-get-diff-posn 'C 'end n)
751 ediff-control-buffer)
753 (ediff-make-temp-file
754 tmp-buffer "fineDiffC" file-C))))
756 ;; save temp file names.
757 (setq ediff-temp-file-A file-A
758 ediff-temp-file-B file-B
759 ediff-temp-file-C file-C)
761 ;; set the new vector of fine diffs, if none exists
762 (cond ((and ediff-3way-job whitespace-A)
763 (ediff-setup-fine-diff-regions nil file-B file-C n))
764 ((and ediff-3way-job whitespace-B)
765 (ediff-setup-fine-diff-regions file-A nil file-C n))
767 ;; In merge-jobs, whitespace-C is t, since
768 ;; ediff-empty-diff-region-p returns t in this case
770 (ediff-setup-fine-diff-regions file-A file-B nil n))
772 (ediff-setup-fine-diff-regions file-A file-B file-C n)))
774 (setq cumulative-fine-diff-length
775 (+ (length (ediff-get-fine-diff-vector n 'A))
776 (length (ediff-get-fine-diff-vector n 'B))
777 ;; in merge jobs, the merge buffer is never refined
778 (if (and file-C (not ediff-merge-job))
779 (length (ediff-get-fine-diff-vector n 'C))
783 ;; all regions are white space
784 (and whitespace-A whitespace-B whitespace-C)
785 ;; none is white space and no fine diffs detected
786 (and (not whitespace-A)
788 (not (and ediff-3way-job whitespace-C))
789 (eq cumulative-fine-diff-length 0)))
790 (ediff-mark-diff-as-space-only n t)
791 (ediff-message-if-verbose
792 "Only white-space differences in region %d" (1+ n)))
793 ((eq cumulative-fine-diff-length 0)
794 (ediff-message-if-verbose
795 "Only white-space differences in region %d %s"
797 (cond (whitespace-A (ediff-mark-diff-as-space-only n 'A)
799 (whitespace-B (ediff-mark-diff-as-space-only n 'B)
801 (whitespace-C (ediff-mark-diff-as-space-only n 'C)
802 "in buffers A & B"))))
804 (ediff-mark-diff-as-space-only n nil)))
807 (ediff-set-fine-diff-properties n)
810 ;; Interface to ediff-make-fine-diffs. Checks for auto-refine limit, etc.
811 (defun ediff-install-fine-diff-if-necessary (n)
812 (cond ((and (eq ediff-auto-refine 'on)
814 (not (eq ediff-highlighting-style 'off))
815 (not (eq ediff-highlighting-style 'ascii)))
817 (> ediff-auto-refine-limit
818 (- (ediff-get-diff-posn 'A 'end n)
819 (ediff-get-diff-posn 'A 'beg n)))
820 (> ediff-auto-refine-limit
821 (- (ediff-get-diff-posn 'B 'end n)
822 (ediff-get-diff-posn 'B 'beg n))))
823 (ediff-make-fine-diffs n 'noforce)
824 (ediff-make-fine-diffs n 'skip)))
826 ;; highlight iff fine diffs already exist
827 ((eq ediff-auto-refine 'off)
828 (ediff-make-fine-diffs n 'skip))))
831 ;; if fine diff vector is not set for diff N, then do nothing
832 (defun ediff-set-fine-diff-properties (n &optional default)
833 (or (not (ediff-has-face-support-p))
835 (>= n ediff-number-of-differences)
836 ;; when faces are supported, set faces and priorities of fine overlays
838 (ediff-set-fine-diff-properties-in-one-buffer 'A n default)
839 (ediff-set-fine-diff-properties-in-one-buffer 'B n default)
841 (ediff-set-fine-diff-properties-in-one-buffer 'C n default)))))
843 (defun ediff-set-fine-diff-properties-in-one-buffer (buf-type
845 (let ((fine-diff-vector (ediff-get-fine-diff-vector n buf-type))
849 (ediff-get-symbol-from-alist
850 buf-type ediff-fine-diff-face-alist))))
851 (priority (if default
853 (1+ (or (ediff-overlay-get
855 (ediff-get-symbol-from-alist
857 ediff-current-diff-overlay-alist))
860 (mapcar (lambda (overl)
861 (ediff-set-overlay-face overl face)
862 (ediff-overlay-put overl 'priority priority))
865 ;; Set overlays over the regions that denote delimiters
866 (defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num)
867 (let (overlay overlay-list)
871 (ediff-make-bullet-proof-overlay
872 (nth 0 diff-list) (nth 1 diff-list) ediff-buffer-C))
874 (setq overlay-list (cons overlay overlay-list))
875 (if (> (length diff-list) 1)
876 (setq diff-list (cdr (cdr diff-list)))
877 (error "ediff-set-fine-overlays-for-combined-merge: corrupt list of
880 (setq overlay-list (reverse overlay-list))
881 (ediff-set-fine-diff-vector
882 reg-num 'C (apply 'vector overlay-list))
886 ;; Convert diff list to overlays for a given DIFF-REGION
887 ;; in buffer of type BUF-TYPE
888 (defun ediff-set-fine-overlays-in-one-buffer (buf-type diff-list region-num)
889 (let* ((current-diff -1)
890 (reg-start (ediff-get-diff-posn buf-type 'beg region-num))
891 (buff (ediff-get-buffer buf-type))
892 (ctl-buf ediff-control-buffer)
893 combined-merge-diff-list
894 diff-overlay-list list-element
897 (ediff-clear-fine-differences-in-one-buffer region-num buf-type)
898 (setq diff-list (cdr diff-list)) ; discard list type (words or points)
899 (ediff-with-current-buffer buff (goto-char reg-start))
901 ;; if it is a combined merge then set overlays in buff C specially
902 (if (and ediff-merge-job (eq buf-type 'C)
903 (setq combined-merge-diff-list
904 (ediff-looks-like-combined-merge region-num)))
905 (ediff-set-fine-overlays-for-combined-merge
906 combined-merge-diff-list region-num)
909 (setq current-diff (1+ current-diff)
910 list-element (car diff-list)
911 begin (aref list-element (cond ((eq buf-type 'A) 0)
914 end (aref list-element (cond ((eq buf-type 'A) 1)
917 (if (not (or begin end))
919 ;; Put overlays at appropriate places in buffers
920 ;; convert lines to points, if necessary
921 (ediff-with-current-buffer ctl-buf
922 (setq begin (ediff-goto-word (1+ begin) buff)
923 end (ediff-goto-word end buff 'end)))
924 (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
925 ;; record all overlays for this difference region
926 (setq diff-overlay-list (nconc diff-overlay-list (list overlay))))
928 (setq diff-list (cdr diff-list))
930 ;; convert the list of difference information into a vector
932 (ediff-set-fine-diff-vector
933 region-num buf-type (vconcat diff-overlay-list))
937 (defsubst ediff-convert-fine-diffs-to-overlays (diff-list region-num)
938 (ediff-set-fine-overlays-in-one-buffer 'A diff-list region-num)
939 (ediff-set-fine-overlays-in-one-buffer 'B diff-list region-num)
941 (ediff-set-fine-overlays-in-one-buffer 'C diff-list region-num)
945 ;; Stolen from emerge.el
946 (defun ediff-get-diff3-group (file)
947 ;; This save-excursion allows ediff-get-diff3-group to be called for the
948 ;; various groups of lines (1, 2, 3) in any order, and for the lines to
949 ;; appear in any order. The reason this is necessary is that Gnu diff3
950 ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
953 (concat "^" file ":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)\C-m?$"))
954 (beginning-of-line 2)
955 ;; treatment depends on whether it is an "a" group or a "c" group
956 (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
958 (if (match-beginning 2)
959 ;; it has two numbers
960 (list (string-to-number
961 (buffer-substring (match-beginning 1) (match-end 1)))
962 (1+ (string-to-number
963 (buffer-substring (match-beginning 3) (match-end 3)))))
965 (let ((x (string-to-number
966 (buffer-substring (match-beginning 1) (match-end 1)))))
968 ;; it is an "a" group
969 (let ((x (1+ (string-to-number
970 (buffer-substring (match-beginning 1) (match-end 1))))))
974 ;; If WORD-MODE, construct vector of diffs using word numbers.
975 ;; Else, use point values.
976 ;; WORD-MODE also tells if we are in the word-mode or not.
977 ;; If THREE-WAY-COMP, then it is a 3-way comparison. Else, it is merging
978 ;; with ancestor, in which case buffer-C contents is identical to buffer-A/B,
979 ;; contents (unless buffer-A is narrowed) depending on ediff-default-variant's
981 ;; BOUNDS specifies visibility bounds to use.
982 (defun ediff-extract-diffs3 (diff-buffer word-mode three-way-comp
984 (let ((A-buffer ediff-buffer-A)
985 (B-buffer ediff-buffer-B)
986 (C-buffer ediff-buffer-C)
987 (anc-buffer ediff-ancestor-buffer)
988 (a-prev 1) ; needed to set the first diff line correctly
992 diff-list shift-A shift-B shift-C
995 ;; diff list contains word numbers or points, depending on word-mode
996 (setq diff-list (cons (if word-mode 'words 'points)
1000 (ediff-overlay-start
1001 (ediff-get-value-according-to-buffer-type 'A bounds))
1003 (ediff-overlay-start
1004 (ediff-get-value-according-to-buffer-type 'B bounds))
1007 (ediff-overlay-start
1008 (ediff-get-value-according-to-buffer-type 'C bounds)))))
1010 ;; reset point in buffers A, B, C
1011 (ediff-with-current-buffer A-buffer
1012 (goto-char (if shift-A shift-A (point-min))))
1013 (ediff-with-current-buffer B-buffer
1014 (goto-char (if shift-B shift-B (point-min))))
1016 (ediff-with-current-buffer C-buffer
1017 (goto-char (if shift-C shift-C (point-min)))))
1018 (if (ediff-buffer-live-p anc-buffer)
1019 (ediff-with-current-buffer anc-buffer
1020 (goto-char (point-min))))
1022 (ediff-with-current-buffer diff-buffer
1023 (goto-char (point-min))
1024 (while (re-search-forward ediff-match-diff3-line nil t)
1025 ;; leave point after matched line
1026 (beginning-of-line 2)
1027 (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
1028 ;; if the files A and B are the same and not 3way-comparison,
1029 ;; ignore the difference
1030 (if (or three-way-comp (not (string-equal agreement "3")))
1031 (let* ((a-begin (car (ediff-get-diff3-group "1")))
1032 (a-end (nth 1 (ediff-get-diff3-group "1")))
1033 (b-begin (car (ediff-get-diff3-group "2")))
1034 (b-end (nth 1 (ediff-get-diff3-group "2")))
1035 (c-or-anc-begin (car (ediff-get-diff3-group "3")))
1036 (c-or-anc-end (nth 1 (ediff-get-diff3-group "3")))
1038 (cond ((string-equal agreement "1") 'prefer-A)
1039 ((string-equal agreement "2") 'prefer-B)
1040 (t ediff-default-variant)))
1041 (state-of-diff-merge
1042 (if (memq state-of-merge '(default-A prefer-A)) 'B 'A))
1043 (state-of-diff-comparison
1044 (cond ((string-equal agreement "1") 'A)
1045 ((string-equal agreement "2") 'B)
1046 ((string-equal agreement "3") 'C)))
1052 anc-begin-pt anc-end-pt)
1054 (setq state-of-ancestor
1055 (= c-or-anc-begin c-or-anc-end))
1057 (cond (three-way-comp
1058 (setq c-begin c-or-anc-begin
1059 c-end c-or-anc-end))
1060 ((eq ediff-default-variant 'default-B)
1061 (setq c-begin b-begin
1064 (setq c-begin a-begin
1067 ;; compute main diff vector
1069 ;; make diff-list contain word numbers
1073 (- a-begin a-prev) (- a-end a-begin)
1074 (- b-begin b-prev) (- b-end b-begin)
1075 (- c-begin c-prev) (- c-end c-begin)
1076 nil nil ; dummy ancestor
1078 nil ; state of merge
1079 nil ; state of ancestor
1084 ;; else convert lines to points
1085 (ediff-with-current-buffer A-buffer
1086 (let ((longlines-mode-val
1087 (if (and (boundp 'longlines-mode) longlines-mode) 1 0)))
1088 ;; we must disable and then restore longlines-mode
1089 (if (eq longlines-mode-val 1)
1091 (forward-line (- a-begin a-prev))
1092 (setq a-begin-pt (point))
1093 (forward-line (- a-end a-begin))
1094 (setq a-end-pt (point)
1096 (if (eq longlines-mode-val 1)
1097 (longlines-mode longlines-mode-val))
1099 (ediff-with-current-buffer B-buffer
1100 (let ((longlines-mode-val
1101 (if (and (boundp 'longlines-mode) longlines-mode) 1 0)))
1102 (if (eq longlines-mode-val 1)
1104 (forward-line (- b-begin b-prev))
1105 (setq b-begin-pt (point))
1106 (forward-line (- b-end b-begin))
1107 (setq b-end-pt (point)
1109 (if (eq longlines-mode-val 1)
1110 (longlines-mode longlines-mode-val))
1112 (ediff-with-current-buffer C-buffer
1113 (let ((longlines-mode-val
1114 (if (and (boundp 'longlines-mode) longlines-mode) 1 0)))
1115 (if (eq longlines-mode-val 1)
1117 (forward-line (- c-begin c-prev))
1118 (setq c-begin-pt (point))
1119 (forward-line (- c-end c-begin))
1120 (setq c-end-pt (point)
1122 (if (eq longlines-mode-val 1)
1123 (longlines-mode longlines-mode-val))
1125 (if (ediff-buffer-live-p anc-buffer)
1126 (ediff-with-current-buffer anc-buffer
1127 (let ((longlines-mode-val
1128 (if (and (boundp 'longlines-mode) longlines-mode) 1 0)))
1129 (if (eq longlines-mode-val 1)
1131 (forward-line (- c-or-anc-begin anc-prev))
1132 (setq anc-begin-pt (point))
1133 (forward-line (- c-or-anc-end c-or-anc-begin))
1134 (setq anc-end-pt (point)
1135 anc-prev c-or-anc-end)
1136 (if (eq longlines-mode-val 1)
1137 (longlines-mode longlines-mode-val))
1142 ;; if comparing with ancestor, then there also is a
1143 ;; state-of-difference marker
1149 nil nil ; ancestor begin/end
1150 state-of-diff-comparison
1151 nil ; state of merge
1152 nil ; state of ancestor
1154 (list (vector a-begin-pt a-end-pt
1157 anc-begin-pt anc-end-pt
1165 ))) ; end ediff-with-current-buffer
1169 ;; Generate the difference vector and overlays for three files
1170 ;; File-C is either the third file to compare (in case of 3-way comparison)
1171 ;; or it is the ancestor file.
1172 (defun ediff-setup-diff-regions3 (file-A file-B file-C)
1173 (or (ediff-buffer-live-p ediff-diff-buffer)
1174 (setq ediff-diff-buffer
1175 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
1177 (message "Computing differences ...")
1178 (ediff-exec-process ediff-diff3-program ediff-diff-buffer 'synchronize
1179 ediff-diff3-options file-A file-B file-C)
1181 (ediff-prepare-error-list ediff-diff3-ok-lines-regexp ediff-diff-buffer)
1182 ;;(message "Computing differences ... done")
1183 (ediff-convert-diffs-to-overlays
1184 (ediff-extract-diffs3
1186 ediff-word-mode ediff-3way-comparison-job ediff-narrow-bounds)
1190 ;; Execute PROGRAM asynchronously, unless OS/2, Windows-*, or DOS, or unless
1191 ;; SYNCH is non-nil. BUFFER must be a buffer object, and must be alive. The
1192 ;; OPTIONS arg is a list of options to pass to PROGRAM. It may be a blank
1193 ;; string. All elements in FILES must be strings. We also delete nil from
1195 (defun ediff-exec-process (program buffer synch options &rest files)
1196 (let ((data (match-data))
1197 (coding-system-for-read ediff-coding-system-for-read)
1199 (setq args (append (split-string options) files))
1200 (setq args (delete "" (delq nil args))) ; delete nil and "" from arguments
1201 ;; the --binary option, if present, should be used only for buffer jobs
1202 ;; or for refining the differences
1203 (or (string-match "buffer" (symbol-name ediff-job-name))
1204 (eq buffer ediff-fine-diff-buffer)
1205 (setq args (delete "--binary" args)))
1207 (let ((directory default-directory)
1212 (setq default-directory directory)
1213 (if (or (memq system-type '(emx ms-dos windows-nt windows-95))
1215 ;; In OS/2 (emx) do it synchronously, since OS/2 doesn't let us
1216 ;; delete files used by other processes. Thus, in ediff-buffers
1217 ;; and similar functions, we can't delete temp files because
1218 ;; they might be used by the asynch process that computes
1219 ;; custom diffs. So, we have to wait till custom diff
1220 ;; subprocess is done.
1221 ;; Similarly for Windows-*
1222 ;; In DOS, must synchronize because DOS doesn't have
1223 ;; asynchronous processes.
1224 (apply 'call-process program nil buffer nil args)
1225 ;; On other systems, do it asynchronously.
1226 (setq proc (get-buffer-process buffer))
1227 (if proc (kill-process proc))
1229 (apply 'start-process "Custom Diff" buffer program args))
1230 (setq mode-line-process '(":%s"))
1231 (set-process-sentinel proc 'ediff-process-sentinel)
1232 (set-process-filter proc 'ediff-process-filter)
1234 (store-match-data data))))
1236 ;; This is shell-command-filter from simple.el in Emacs.
1237 ;; Copied here because XEmacs doesn't have it.
1238 (defun ediff-process-filter (proc string)
1239 ;; Do save-excursion by hand so that we can leave point numerically unchanged
1240 ;; despite an insertion immediately after it.
1241 (let* ((obuf (current-buffer))
1242 (buffer (process-buffer proc))
1244 (window (get-buffer-window buffer))
1245 (pos (window-start window)))
1249 (or (= (point) (point-max))
1250 (setq opoint (point)))
1251 (goto-char (point-max))
1252 (insert-before-markers string))
1253 ;; insert-before-markers moved this marker: set it back.
1254 (set-window-start window pos)
1255 ;; Finish our save-excursion.
1258 (set-buffer obuf))))
1260 ;; like shell-command-sentinel but doesn't print an exit status message
1261 ;; we do this because diff always exits with status 1, if diffs are found
1262 ;; so shell-command-sentinel displays a confusing message to the user
1263 (defun ediff-process-sentinel (process signal)
1264 (if (and (memq (process-status process) '(exit signal))
1265 (buffer-name (process-buffer process)))
1268 (set-buffer (process-buffer process))
1269 (setq mode-line-process nil))
1270 (delete-process process))))
1273 ;;; Word functions used to refine the current diff
1275 (defvar ediff-forward-word-function 'ediff-forward-word
1276 "*Function to call to move to the next word.
1277 Used for splitting difference regions into individual words.")
1278 (make-variable-buffer-local 'ediff-forward-word-function)
1280 (defvar ediff-whitespace " \n\t\f"
1281 "*Characters constituting white space.
1282 These characters are ignored when differing regions are split into words.")
1283 (make-variable-buffer-local 'ediff-whitespace)
1285 (defvar ediff-word-1
1286 (ediff-cond-compile-for-xemacs-or-emacs "a-zA-Z---_" "-[:word:]_")
1287 "*Characters that constitute words of type 1.
1288 More precisely, [ediff-word-1] is a regexp that matches type 1 words.
1289 See `ediff-forward-word' for more details.")
1290 (make-variable-buffer-local 'ediff-word-1)
1292 (defvar ediff-word-2 "0-9.,"
1293 "*Characters that constitute words of type 2.
1294 More precisely, [ediff-word-2] is a regexp that matches type 2 words.
1295 See `ediff-forward-word' for more details.")
1296 (make-variable-buffer-local 'ediff-word-2)
1298 (defvar ediff-word-3 "`'?!:;\"{}[]()"
1299 "*Characters that constitute words of type 3.
1300 More precisely, [ediff-word-3] is a regexp that matches type 3 words.
1301 See `ediff-forward-word' for more details.")
1302 (make-variable-buffer-local 'ediff-word-3)
1304 (defvar ediff-word-4
1305 (concat "^" ediff-word-1 ediff-word-2 ediff-word-3 ediff-whitespace)
1306 "*Characters that constitute words of type 4.
1307 More precisely, [ediff-word-4] is a regexp that matches type 4 words.
1308 See `ediff-forward-word' for more details.")
1309 (make-variable-buffer-local 'ediff-word-4)
1311 ;; Split region along word boundaries. Each word will be on its own line.
1312 ;; Output to buffer out-buffer.
1313 (defun ediff-forward-word ()
1314 "Move point one word forward.
1315 There are four types of words, each of which consists entirely of
1316 characters in `ediff-word-1', `ediff-word-2', `ediff-word-3', or
1317 `ediff-word-4'. Words are recognized by passing these one after another as
1318 arguments to `skip-chars-forward'."
1319 (or (> (+ (skip-chars-forward ediff-word-1)
1320 (skip-syntax-forward "w"))
1322 (> (skip-chars-forward ediff-word-2) 0)
1323 (> (skip-chars-forward ediff-word-3) 0)
1324 (> (skip-chars-forward ediff-word-4) 0)
1328 (defun ediff-wordify (beg end in-buffer out-buffer &optional control-buf)
1329 (let ((forward-word-function
1330 ;; eval in control buf to let user create local versions for
1331 ;; different invocations
1333 (ediff-with-current-buffer control-buf
1334 ediff-forward-word-function)
1335 ediff-forward-word-function))
1336 inbuf-syntax-tbl sv-point diff-string)
1338 (set-buffer in-buffer)
1339 (setq inbuf-syntax-tbl
1341 (ediff-with-current-buffer control-buf
1344 (setq diff-string (buffer-substring-no-properties beg end))
1346 (set-buffer out-buffer)
1347 ;; Make sure that temp buff syntax table is the same as the original buf
1348 ;; syntax tbl, because we use ediff-forward-word in both and
1349 ;; ediff-forward-word depends on the syntax classes of characters.
1350 (set-syntax-table inbuf-syntax-tbl)
1352 (insert diff-string)
1353 (goto-char (point-min))
1354 (skip-chars-forward ediff-whitespace)
1355 (delete-region (point-min) (point))
1358 (funcall forward-word-function)
1359 (setq sv-point (point))
1360 (skip-chars-forward ediff-whitespace)
1361 (delete-region sv-point (point))
1364 ;; copy string specified as BEG END from IN-BUF to OUT-BUF
1365 (defun ediff-copy-to-buffer (beg end in-buffer out-buffer)
1366 (with-current-buffer out-buffer
1368 (insert-buffer-substring in-buffer beg end)
1369 (goto-char (point-min))))
1372 ;; goto word #n starting at current position in buffer `buf'
1373 ;; For ediff, a word is determined by ediff-forward-word-function
1374 ;; If `flag' is non-nil, goto the end of the n-th word.
1375 (defun ediff-goto-word (n buf &optional flag)
1376 ;; remember val ediff-forward-word-function has in ctl buf
1377 (let ((fwd-word-fun ediff-forward-word-function)
1378 (syntax-tbl ediff-syntax-table))
1379 (ediff-with-current-buffer buf
1380 (skip-chars-forward ediff-whitespace)
1381 (ediff-with-syntax-table syntax-tbl
1383 (funcall fwd-word-fun)
1384 (skip-chars-forward ediff-whitespace)
1386 (if (and flag (> n 0))
1387 (funcall fwd-word-fun)))
1390 (defun ediff-same-file-contents (f1 f2)
1391 "Return t if files F1 and F2 have identical contents."
1392 (if (and (not (file-directory-p f1))
1393 (not (file-directory-p f2)))
1395 (apply 'call-process ediff-cmp-program nil nil nil
1396 (append ediff-cmp-options (list f1 f2)))))
1397 (and (numberp res) (eq res 0))))
1401 (defun ediff-same-contents (d1 d2 &optional filter-re)
1402 "Returns t iff D1 and D2 have the same content.
1403 D1 and D2 can either be both directories or both regular files.
1404 Symlinks and the likes are not handled.
1405 If FILTER-RE is non-nil, recursive checking in directories
1406 affects only files whose names match the expression."
1407 ;; Normalize empty filter RE to nil.
1408 (unless (> (length filter-re) 0) (setq filter-re nil))
1409 ;; Indicate progress
1410 (message "Comparing '%s' and '%s' modulo '%s'" d1 d2 filter-re)
1412 ;; D1 & D2 directories => recurse
1413 ((and (file-directory-p d1)
1414 (file-directory-p d2))
1415 (if (null ediff-recurse-to-subdirectories)
1416 (if (y-or-n-p "Compare subdirectories recursively? ")
1417 (setq ediff-recurse-to-subdirectories 'yes)
1418 (setq ediff-recurse-to-subdirectories 'no)))
1419 (if (eq ediff-recurse-to-subdirectories 'yes)
1420 (let* ((all-entries-1 (directory-files d1 t filter-re))
1421 (all-entries-2 (directory-files d2 t filter-re))
1422 (entries-1 (ediff-delete-all-matches "^\\.\\.?$" all-entries-1))
1423 (entries-2 (ediff-delete-all-matches "^\\.\\.?$" all-entries-2))
1426 (ediff-same-file-contents-lists entries-1 entries-2 filter-re)
1428 ) ; end of the directories case
1429 ;; D1 & D2 are both files => compare directly
1430 ((and (file-regular-p d1)
1431 (file-regular-p d2))
1432 (ediff-same-file-contents d1 d2))
1433 ;; Otherwise => false: unequal contents
1437 ;; If lists have the same length and names of files are pairwise equal
1438 ;; (removing the directories) then compare contents pairwise.
1439 ;; True if all contents are the same; false otherwise
1440 (defun ediff-same-file-contents-lists (entries-1 entries-2 filter-re)
1441 ;; First, check only the names (works quickly and ensures a
1442 ;; precondition for subsequent code)
1443 (if (and (= (length entries-1) (length entries-2))
1444 (equal (mapcar 'file-name-nondirectory entries-1)
1445 (mapcar 'file-name-nondirectory entries-2)))
1446 ;; With name equality established, compare the entries
1447 ;; through recursion.
1449 (while (and entries-1 continue)
1450 (if (ediff-same-contents
1451 (car entries-1) (car entries-2) filter-re)
1452 (setq entries-1 (cdr entries-1)
1453 entries-2 (cdr entries-2))
1454 (setq continue nil))
1456 ;; if reached the end then lists are equal
1462 ;; ARG1 is a regexp, ARG2 is a list of full-filenames
1463 ;; Delete all entries that match the regexp
1464 (defun ediff-delete-all-matches (regex file-list-list)
1466 (while file-list-list
1467 (setq elt (car file-list-list))
1468 (or (string-match regex (file-name-nondirectory elt))
1469 (setq result (cons elt result)))
1470 (setq file-list-list (cdr file-list-list)))
1474 ;;; Local Variables:
1475 ;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1476 ;;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1477 ;;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1480 ;;; arch-tag: a86d448e-58d7-4572-a1d9-fdedfa22f648
1481 ;;; ediff-diff.el ends here