1 ;;; ediff-diff.el --- diff-related utilities
3 ;; Copyright (C) 1994-2014 Free Software Foundation, Inc.
5 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
8 ;; This file is part of GNU Emacs.
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
12 ;; the Free Software Foundation, either version 3 of the License, or
13 ;; (at your option) any later version.
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.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
33 (defgroup ediff-diff nil
34 "Diff related utilities."
38 (defcustom ediff-diff-program
"diff"
39 "Program to use for generating the differential of the two files."
42 (defcustom ediff-diff3-program
"diff3"
43 "Program to be used for three-way comparison.
44 Must produce output compatible with Unix's diff3 program."
49 ;; The following functions must precede all defcustom-defined variables.
51 (fset 'ediff-set-actual-diff-options
(lambda () nil
))
53 (defcustom ediff-shell
54 (cond ((memq system-type
'(ms-dos windows-nt
))
55 shell-file-name
) ; no standard name on MS-DOS
57 "The shell used to run diff and patch.
58 If user's .profile or .cshrc files are set up correctly, any shell
59 will do. However, some people set $prompt or other things
60 incorrectly, which leads to undesirable output messages. These may
61 cause Ediff to fail. In such a case, set `ediff-shell' to a shell that
62 you are not using or, better, fix your shell's startup file."
66 (defcustom ediff-cmp-program
"cmp"
67 "Utility to use to determine if two files are identical.
68 It must return code 0, if its arguments are identical files."
72 (defcustom ediff-cmp-options nil
73 "Options to pass to `ediff-cmp-program'.
74 If GNU diff is used as `ediff-cmp-program', then the most useful options
75 are `-I REGEXP', to ignore changes whose lines match the REGEXP."
76 :type
'(repeat string
)
79 (defun ediff-set-diff-options (symbol value
)
81 (ediff-set-actual-diff-options))
83 (defcustom ediff-diff-options
84 (if (memq system-type
'(ms-dos windows-nt
)) "--binary" "")
85 "Options to pass to `ediff-diff-program'.
86 If Unix diff is used as `ediff-diff-program',
87 then a useful option is `-w', to ignore space.
88 Options `-c', `-u', and `-i' are not allowed. Case sensitivity can be
89 toggled interactively using \\[ediff-toggle-ignore-case].
91 Do not remove the default options. If you need to change this variable, add new
92 options after the default ones.
94 This variable is not for customizing the look of the differences produced by
95 the command \\[ediff-show-diff-output]. Use the variable
96 `ediff-custom-diff-options' for that."
97 :set
'ediff-set-diff-options
101 (ediff-defvar-local ediff-ignore-case nil
102 "If t, skip over difference regions that differ only in letter case.
103 This variable can be set either in .emacs or toggled interactively.
104 Use `setq-default' if setting it in .emacs")
106 (defcustom ediff-ignore-case-option
"-i"
107 "Option that causes the diff program to ignore case of letters."
111 (defcustom ediff-ignore-case-option3
""
112 "Option that causes the diff3 program to ignore case of letters.
113 GNU diff3 doesn't have such an option."
117 ;; the actual options used in comparison
118 (ediff-defvar-local ediff-actual-diff-options ediff-diff-options
"")
120 (defcustom ediff-custom-diff-program ediff-diff-program
121 "Program to use for generating custom diff output for saving it in a file.
122 This output is not used by Ediff internally."
125 (defcustom ediff-custom-diff-options
"-c"
126 "Options to pass to `ediff-custom-diff-program'."
130 ;;; Support for diff3
132 (defvar ediff-match-diff3-line
"^====\\(.?\\)\C-m?$"
133 "Pattern to match lines produced by diff3 that describe differences.")
134 (defcustom ediff-diff3-options
""
135 "Options to pass to `ediff-diff3-program'."
136 :set
'ediff-set-diff-options
140 ;; the actual options used in comparison
141 (ediff-defvar-local ediff-actual-diff3-options ediff-diff3-options
"")
143 (defcustom ediff-diff3-ok-lines-regexp
144 "^\\([1-3]:\\|====\\| \\|.*Warning *:\\|.*No newline\\|.*missing newline\\|^\C-m$\\)"
145 "Regexp that matches normal output lines from `ediff-diff3-program'.
146 Lines that do not match are assumed to be error messages."
150 ;; keeps the status of the current diff in 3-way jobs.
151 ;; the status can be =diff(A), =diff(B), or =diff(A+B)
152 (ediff-defvar-local ediff-diff-status
"" "")
157 (ediff-defvar-local ediff-auto-refine
(if (ediff-has-face-support-p) 'on
'nix
)
158 "If `on', Ediff auto-highlights fine diffs for the current diff region.
159 If `off', auto-highlighting is not used. If `nix', no fine diffs are shown
160 at all, unless the user force-refines the region by hitting `*'.
162 This variable can be set either in .emacs or toggled interactively.
163 Use `setq-default' if setting it in .emacs")
165 (ediff-defvar-local ediff-ignore-similar-regions nil
166 "If t, skip over difference regions that differ only in the white space and line breaks.
167 This variable can be set either in .emacs or toggled interactively.
168 Use `setq-default' if setting it in .emacs")
170 (ediff-defvar-local ediff-auto-refine-limit
14000
171 "Auto-refine only the regions of this size \(in bytes\) or less.")
175 (defvar ediff-diff-ok-lines-regexp
178 "[0-9,]+[acd][0-9,]+\C-m?$"
183 "\\|.*missing +newline"
186 "Regexp that matches normal output lines from `ediff-diff-program'.
187 This is mostly lifted from Emerge, except that Ediff also considers
188 warnings and `Missing newline'-type messages to be normal output.
189 Lines that do not match are assumed to be error messages.")
191 (defvar ediff-match-diff-line
192 (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
193 (concat "^" x
"\\([acd]\\)" x
"\C-m?$"))
194 "Pattern to match lines produced by diff that describe differences.")
196 (ediff-defvar-local ediff-setup-diff-regions-function nil
197 "value is a function symbol depending on the kind of job is to be done.
198 For 2-way jobs and for ediff-merge, it should be `ediff-setup-diff-regions'.
199 For jobs requiring diff3, it should be `ediff-setup-diff-regions3'.
201 The function should take three mandatory arguments, file-A, file-B, and
202 file-C. It may ignore file C for diff2 jobs. It should also take
203 one optional arguments, diff-number to refine.")
208 ;; Generate the difference vector and overlays for the two files
209 ;; With optional arg REG-TO-REFINE, refine this region.
210 ;; File-C argument is not used here. It is there just because
211 ;; ediff-setup-diff-regions is called via a funcall to
212 ;; ediff-setup-diff-regions-function, which can also have the value
213 ;; ediff-setup-diff-regions3, which takes 4 arguments.
214 (defun ediff-setup-diff-regions (file-A file-B _file-C
)
215 ;; looking for '-c', '-i', '-u', or 'c', 'i', 'u' among clustered non-long options
216 (if (string-match "^-[ciu]\\| -[ciu]\\|\\(^\\| \\)-[^- ]+[ciu]"
218 (error "Options `-c', `-u', and `-i' are not allowed in `ediff-diff-options'"))
220 ;; create, if it doesn't exist
221 (or (ediff-buffer-live-p ediff-diff-buffer
)
222 (setq ediff-diff-buffer
223 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
224 (ediff-make-diff2-buffer ediff-diff-buffer file-A file-B
)
225 (ediff-prepare-error-list ediff-diff-ok-lines-regexp ediff-diff-buffer
)
226 (ediff-convert-diffs-to-overlays
228 ediff-diff-buffer ediff-word-mode ediff-narrow-bounds
)))
230 ;; Run the diff program on FILE1 and FILE2 and put the output in DIFF-BUFFER
231 ;; Return the size of DIFF-BUFFER
232 ;; The return code isn't used in the program at present.
233 (defun ediff-make-diff2-buffer (diff-buffer file1 file2
)
234 (let ((file1-size (ediff-file-size file1
))
235 (file2-size (ediff-file-size file2
)))
236 (cond ((not (numberp file1-size
))
237 (message "Can't find file: %s"
238 (ediff-abbreviate-file-name file1
))
240 ;; 1 is an error exit code
242 ((not (numberp file2-size
))
243 (message "Can't find file: %s"
244 (ediff-abbreviate-file-name file2
))
246 ;; 1 is an error exit code
248 (t (message "Computing differences between %s and %s ..."
249 (file-name-nondirectory file1
)
250 (file-name-nondirectory file2
))
251 ;; this erases the diff buffer automatically
252 (ediff-exec-process ediff-diff-program
255 ediff-actual-diff-options file1 file2
)
257 (ediff-with-current-buffer diff-buffer
262 ;; If file-A/B/C is nil, do 2-way comparison with the non-nil buffers
263 ;; This function works for diff3 and diff2 jobs
264 (defun ediff-setup-fine-diff-regions (file-A file-B file-C reg-num
)
265 (or (ediff-buffer-live-p ediff-fine-diff-buffer
)
266 (setq ediff-fine-diff-buffer
268 (ediff-unique-buffer-name "*ediff-fine-diff" "*"))))
270 (let (diff3-job diff-program diff-options ok-regexp diff-list
)
271 (setq diff3-job ediff-3way-job
272 diff-program
(if diff3-job ediff-diff3-program ediff-diff-program
)
273 diff-options
(if diff3-job
274 ediff-actual-diff3-options
275 ediff-actual-diff-options
)
276 ok-regexp
(if diff3-job
277 ediff-diff3-ok-lines-regexp
278 ediff-diff-ok-lines-regexp
))
280 (ediff-message-if-verbose "Refining difference region %d ..." (1+ reg-num
))
281 (ediff-exec-process diff-program ediff-fine-diff-buffer
'synchronize
283 ;; The shuffle below is because we can compare 3-way
284 ;; or in several 2-way fashions, like fA fC, fA fB,
286 (if file-A file-A file-B
)
287 (if file-B file-B file-A
)
289 (if file-C file-C file-B
))
292 (ediff-prepare-error-list ok-regexp ediff-fine-diff-buffer
)
293 (ediff-message-if-verbose
295 ;; "Refining difference region %d ... done" (1+ reg-num))
299 (ediff-extract-diffs3
300 ediff-fine-diff-buffer
'3way-comparison
'word-mode
)
301 (ediff-extract-diffs ediff-fine-diff-buffer
'word-mode
)))
321 (ediff-convert-fine-diffs-to-overlays diff-list reg-num
)
325 (defun ediff-prepare-error-list (ok-regexp diff-buff
)
326 (or (ediff-buffer-live-p ediff-error-buffer
)
327 (setq ediff-error-buffer
328 (get-buffer-create (ediff-unique-buffer-name
329 "*ediff-errors" "*"))))
330 (ediff-with-current-buffer ediff-error-buffer
331 (setq buffer-undo-list t
)
333 (insert (ediff-with-current-buffer diff-buff
(buffer-string)))
334 (goto-char (point-min))
335 (delete-matching-lines ok-regexp
))
336 ;; If diff reports errors, show them then quit.
337 (if (/= 0 (ediff-with-current-buffer ediff-error-buffer
(buffer-size)))
338 (let ((ctl-buf ediff-control-buffer
)
339 (error-buf ediff-error-buffer
))
340 (ediff-skip-unsuitable-frames)
341 (switch-to-buffer error-buf
)
342 (ediff-kill-buffer-carefully ctl-buf
)
343 (error "Errors in diff output. Diff output is in %S" diff-buff
))))
345 ;; BOUNDS specifies visibility bounds to use.
346 ;; WORD-MODE tells whether we are in the word-mode or not.
347 ;; If WORD-MODE, also construct vector of diffs using word numbers.
348 ;; Else, use point values.
349 ;; This function handles diff-2 jobs including the case of
350 ;; merging buffers and files without ancestor.
351 (defun ediff-extract-diffs (diff-buffer word-mode
&optional bounds
)
352 (let ((A-buffer ediff-buffer-A
)
353 (B-buffer ediff-buffer-B
)
354 (C-buffer ediff-buffer-C
)
355 (a-prev 1) ; this is needed to set the first diff line correctly
361 diff-list shift-A shift-B
364 ;; diff list contains word numbers, unless changed later
365 (setq diff-list
(cons (if word-mode
'words
'points
)
367 ;; we don't use visibility bounds for buffer C when merging
371 (ediff-get-value-according-to-buffer-type 'A bounds
))
374 (ediff-get-value-according-to-buffer-type 'B bounds
))))
376 ;; reset point in buffers A/B/C
377 (ediff-with-current-buffer A-buffer
378 (goto-char (if shift-A shift-A
(point-min))))
379 (ediff-with-current-buffer B-buffer
380 (goto-char (if shift-B shift-B
(point-min))))
381 (if (ediff-buffer-live-p C-buffer
)
382 (ediff-with-current-buffer C-buffer
383 (goto-char (point-min))))
385 (ediff-with-current-buffer diff-buffer
386 (goto-char (point-min))
387 (while (re-search-forward ediff-match-diff-line nil t
)
388 (let* ((a-begin (string-to-number (buffer-substring (match-beginning 1)
390 (a-end (let ((b (match-beginning 3))
393 (string-to-number (buffer-substring b e
))
395 (diff-type (buffer-substring (match-beginning 4) (match-end 4)))
396 (b-begin (string-to-number (buffer-substring (match-beginning 5)
398 (b-end (let ((b (match-beginning 7))
401 (string-to-number (buffer-substring b e
))
403 a-begin-pt a-end-pt b-begin-pt b-end-pt
404 c-begin c-end c-begin-pt c-end-pt
)
405 ;; fix the beginning and end numbers, because diff is somewhat
406 ;; strange about how it numbers lines
407 (if (string-equal diff-type
"a")
408 (setq b-end
(1+ b-end
)
411 (if (string-equal diff-type
"d")
412 (setq a-end
(1+ a-end
)
415 ;; (string-equal diff-type "c")
416 (setq a-end
(1+ a-end
)
419 (if (eq ediff-default-variant
'default-B
)
420 (setq c-begin b-begin
422 (setq c-begin a-begin
425 ;; compute main diff vector
427 ;; make diff-list contain word numbers
431 (if (ediff-buffer-live-p C-buffer
)
432 (vector (- a-begin a-prev
) (- a-end a-begin
)
433 (- b-begin b-prev
) (- b-end b-begin
)
434 (- c-begin c-prev
) (- c-end c-begin
)
435 nil nil
; dummy ancestor
438 nil
; state of ancestor
440 (vector (- a-begin a-prev
) (- a-end a-begin
)
441 (- b-begin b-prev
) (- b-end b-begin
)
442 nil nil
; dummy buf C
443 nil nil
; dummy ancestor
446 nil
; state of ancestor
452 ;; else convert lines to points
453 (ediff-with-current-buffer A-buffer
454 (goto-char (or a-prev-pt shift-A
(point-min)))
455 (forward-line (- a-begin a-prev
))
456 (setq a-begin-pt
(point))
457 (forward-line (- a-end a-begin
))
458 (setq a-end-pt
(point)
461 (ediff-with-current-buffer B-buffer
462 (goto-char (or b-prev-pt shift-B
(point-min)))
463 (forward-line (- b-begin b-prev
))
464 (setq b-begin-pt
(point))
465 (forward-line (- b-end b-begin
))
466 (setq b-end-pt
(point)
469 (if (ediff-buffer-live-p C-buffer
)
470 (ediff-with-current-buffer C-buffer
471 (goto-char (or c-prev-pt
(point-min)))
472 (forward-line (- c-begin c-prev
))
473 (setq c-begin-pt
(point))
474 (forward-line (- c-end c-begin
))
475 (setq c-end-pt
(point)
477 c-prev-pt c-end-pt
)))
482 (if (ediff-buffer-live-p C-buffer
)
484 a-begin-pt a-end-pt b-begin-pt b-end-pt
486 nil nil
; dummy ancestor
488 ;; shows which buff is different from the other two
489 (if (eq ediff-default-variant
'default-B
) 'A
'B
)
490 ediff-default-variant
; state of merge
491 nil
; state of ancestor
493 (vector a-begin-pt a-end-pt
495 nil nil
; dummy buf C
496 nil nil
; dummy ancestor
497 nil nil
; dummy state of diff & merge
498 nil
; dummy state of ancestor
502 ))) ; end ediff-with-current-buffer
507 (defun ediff-convert-diffs-to-overlays (diff-list)
508 (ediff-set-diff-overlays-in-one-buffer 'A diff-list
)
509 (ediff-set-diff-overlays-in-one-buffer 'B diff-list
)
511 (ediff-set-diff-overlays-in-one-buffer 'C diff-list
))
512 (if ediff-merge-with-ancestor-job
513 (ediff-set-diff-overlays-in-one-buffer 'Ancestor diff-list
))
514 ;; set up vector showing the status of merge regions
516 (setq ediff-state-of-merge
518 (mapcar (lambda (elt)
519 (let ((state-of-merge (aref elt
9))
520 (state-of-ancestor (aref elt
10)))
522 ;; state of merge: prefers/default-A/B or combined
523 (if state-of-merge
(format "%S" state-of-merge
))
524 ;; whether the ancestor region is empty
526 ;; the first elt designates type of list
529 (message "Processing difference regions ... done"))
532 (defun ediff-set-diff-overlays-in-one-buffer (buf-type diff-list
)
533 (let* ((current-diff -
1)
534 (buff (ediff-get-buffer buf-type
))
535 (ctl-buf ediff-control-buffer
)
536 ;; ediff-extract-diffs puts the type of diff-list as the first elt
537 ;; of this list. The type is either 'points or 'words
538 (diff-list-type (car diff-list
))
539 (shift (ediff-overlay-start
540 (ediff-get-value-according-to-buffer-type
541 buf-type ediff-narrow-bounds
)))
542 (limit (ediff-overlay-end
543 (ediff-get-value-according-to-buffer-type
544 buf-type ediff-narrow-bounds
)))
545 diff-overlay-list list-element total-diffs
546 begin end pt-saved overlay state-of-diff
)
548 (setq diff-list
(cdr diff-list
)) ; discard diff list type
549 (setq total-diffs
(length diff-list
))
551 ;; shift, if necessary
552 (ediff-with-current-buffer buff
(setq pt-saved shift
))
555 (setq current-diff
(1+ current-diff
)
556 list-element
(car diff-list
)
557 begin
(aref list-element
(cond ((eq buf-type
'A
) 0)
561 end
(aref list-element
(cond ((eq buf-type
'A
) 1)
565 state-of-diff
(aref list-element
8)
568 (cond ((and (not (eq buf-type state-of-diff
))
569 (not (eq buf-type
'Ancestor
))
570 (memq state-of-diff
'(A B C
)))
572 (car (delq buf-type
(delq state-of-diff
(list 'A
'B
'C
)))))
573 (setq state-of-diff
(format "=diff(%S)" state-of-diff
))
575 (t (setq state-of-diff nil
)))
577 ;; Put overlays at appropriate places in buffer
578 ;; convert word numbers to points, if necessary
579 (if (eq diff-list-type
'words
)
581 (ediff-with-current-buffer buff
(goto-char pt-saved
))
582 (ediff-with-current-buffer ctl-buf
583 (setq begin
(ediff-goto-word (1+ begin
) buff
)
584 end
(ediff-goto-word end buff
'end
)))
585 (if (> end limit
) (setq end limit
))
586 (if (> begin end
) (setq begin end
))
587 (setq pt-saved
(ediff-with-current-buffer buff
(point)))))
588 (setq overlay
(ediff-make-bullet-proof-overlay begin end buff
))
590 (ediff-overlay-put overlay
'ediff-diff-num current-diff
)
591 (if (and (ediff-has-face-support-p)
592 ediff-use-faces ediff-highlight-all-diffs
)
593 (ediff-set-overlay-face
594 overlay
(ediff-background-face buf-type current-diff
)))
596 (if (= 0 (mod current-diff
10))
597 (message "Buffer %S: Processing difference region %d of %d"
598 buf-type current-diff total-diffs
))
599 ;; Record all overlays for this difference.
600 ;; The 2-d elt, nil, is a place holder for the fine diff vector.
601 ;; The 3-d elt, nil, is a place holder for no-fine-diffs flag.
602 ;; The 4-th elt says which diff region is different from the other two
603 ;; (3-way jobs only).
604 (setq diff-overlay-list
607 (list (vector overlay nil nil state-of-diff
)))
612 (set (ediff-get-symbol-from-alist buf-type ediff-difference-vector-alist
)
613 (vconcat diff-overlay-list
))
616 ;; `n' is the diff region to work on. Default is ediff-current-difference.
617 ;; if `flag' is 'noforce then make fine-diffs only if this region's fine
618 ;; diffs have not been computed before.
619 ;; if `flag' is 'skip then don't compute fine diffs for this region.
620 (defun ediff-make-fine-diffs (&optional n flag
)
621 (or n
(setq n ediff-current-difference
))
623 (if (< ediff-number-of-differences
1)
624 (error ediff-NO-DIFFERENCES
))
628 ediff-auto-refine
'nix
))
631 (>= n ediff-number-of-differences
)
632 ;; n is within the range
633 (let ((tmp-buffer (get-buffer-create ediff-tmp-buffer
))
634 (file-A ediff-temp-file-A
)
635 (file-B ediff-temp-file-B
)
636 (file-C ediff-temp-file-C
)
637 (empty-A (ediff-empty-diff-region-p n
'A
))
638 (empty-B (ediff-empty-diff-region-p n
'B
))
639 (empty-C (ediff-empty-diff-region-p n
'C
))
640 (whitespace-A (ediff-whitespace-diff-region-p n
'A
))
641 (whitespace-B (ediff-whitespace-diff-region-p n
'B
))
642 (whitespace-C (ediff-whitespace-diff-region-p n
'C
))
643 cumulative-fine-diff-length
)
645 (cond ;; If one of the regions is empty (or 2 in 3way comparison)
646 ;; then don't refine.
647 ;; If the region happens to be entirely whitespace or empty then
649 ((> (length (delq nil
(list empty-A empty-B empty-C
))) 1)
650 (if (and (ediff-looks-like-combined-merge n
)
652 (ediff-set-fine-overlays-in-one-buffer 'C nil n
))
653 (if ediff-3way-comparison-job
654 (ediff-message-if-verbose
655 "Region %d is empty in all buffers but %S"
657 (cond ((not empty-A
) 'A
)
660 (ediff-message-if-verbose
661 "Region %d in buffer %S is empty"
667 ;; if all regions happen to be whitespace
668 (if (and whitespace-A whitespace-B whitespace-C
)
669 ;; mark as space only
670 (ediff-mark-diff-as-space-only n t
)
671 ;; if some regions are white and others don't, then mark as
672 ;; non-white-space-only
673 (ediff-mark-diff-as-space-only n nil
)))
675 ;; don't compute fine diffs if diff vector exists
676 ((and (eq flag
'noforce
) (ediff-get-fine-diff-vector n
'A
))
677 (if (ediff-no-fine-diffs-p n
)
679 "Only white-space differences in region %d %s"
681 (cond ((eq (ediff-no-fine-diffs-p n
) 'A
)
683 ((eq (ediff-no-fine-diffs-p n
) 'B
)
685 ((eq (ediff-no-fine-diffs-p n
) 'C
)
688 ;; don't compute fine diffs for this region
690 (or (ediff-get-fine-diff-vector n
'A
)
691 (memq ediff-auto-refine
'(off nix
))
692 (ediff-message-if-verbose
693 "Region %d exceeds the auto-refinement limit. Type `%s' to refine"
695 (substitute-command-keys
696 "\\[ediff-make-or-kill-fine-diffs]")
699 ;; recompute fine diffs
701 (ediff-get-diff-posn 'A
'beg n
)
702 (ediff-get-diff-posn 'A
'end n
)
705 ediff-control-buffer
)
707 (ediff-make-temp-file tmp-buffer
"fineDiffA" file-A
))
710 (ediff-get-diff-posn 'B
'beg n
)
711 (ediff-get-diff-posn 'B
'end n
)
714 ediff-control-buffer
)
716 (ediff-make-temp-file tmp-buffer
"fineDiffB" file-B
))
721 (ediff-get-diff-posn 'C
'beg n
)
722 (ediff-get-diff-posn 'C
'end n
)
725 ediff-control-buffer
)
727 (ediff-make-temp-file
728 tmp-buffer
"fineDiffC" file-C
))))
730 ;; save temp file names.
731 (setq ediff-temp-file-A file-A
732 ediff-temp-file-B file-B
733 ediff-temp-file-C file-C
)
735 ;; set the new vector of fine diffs, if none exists
736 (cond ((and ediff-3way-job whitespace-A
)
737 (ediff-setup-fine-diff-regions nil file-B file-C n
))
738 ((and ediff-3way-job whitespace-B
)
739 (ediff-setup-fine-diff-regions file-A nil file-C n
))
741 ;; In merge-jobs, whitespace-C is t, since
742 ;; ediff-empty-diff-region-p returns t in this case
744 (ediff-setup-fine-diff-regions file-A file-B nil n
))
746 (ediff-setup-fine-diff-regions file-A file-B file-C n
)))
748 (setq cumulative-fine-diff-length
749 (+ (length (ediff-get-fine-diff-vector n
'A
))
750 (length (ediff-get-fine-diff-vector n
'B
))
751 ;; in merge jobs, the merge buffer is never refined
752 (if (and file-C
(not ediff-merge-job
))
753 (length (ediff-get-fine-diff-vector n
'C
))
757 ;; all regions are white space
758 (and whitespace-A whitespace-B whitespace-C
)
759 ;; none is white space and no fine diffs detected
760 (and (not whitespace-A
)
762 (not (and ediff-3way-job whitespace-C
))
763 (eq cumulative-fine-diff-length
0)))
764 (ediff-mark-diff-as-space-only n t
)
765 (ediff-message-if-verbose
766 "Only white-space differences in region %d" (1+ n
)))
767 ((eq cumulative-fine-diff-length
0)
768 (ediff-message-if-verbose
769 "Only white-space differences in region %d %s"
771 (cond (whitespace-A (ediff-mark-diff-as-space-only n
'A
)
773 (whitespace-B (ediff-mark-diff-as-space-only n
'B
)
775 (whitespace-C (ediff-mark-diff-as-space-only n
'C
)
776 "in buffers A & B"))))
778 (ediff-mark-diff-as-space-only n nil
)))
781 (ediff-set-fine-diff-properties n
)
784 ;; Interface to ediff-make-fine-diffs. Checks for auto-refine limit, etc.
785 (defun ediff-install-fine-diff-if-necessary (n)
786 (cond ((and (eq ediff-auto-refine
'on
)
788 (not (eq ediff-highlighting-style
'off
))
789 (not (eq ediff-highlighting-style
'ascii
)))
791 (> ediff-auto-refine-limit
792 (- (ediff-get-diff-posn 'A
'end n
)
793 (ediff-get-diff-posn 'A
'beg n
)))
794 (> ediff-auto-refine-limit
795 (- (ediff-get-diff-posn 'B
'end n
)
796 (ediff-get-diff-posn 'B
'beg n
))))
797 (ediff-make-fine-diffs n
'noforce
)
798 (ediff-make-fine-diffs n
'skip
)))
800 ;; highlight if fine diffs already exist
801 ((eq ediff-auto-refine
'off
)
802 (ediff-make-fine-diffs n
'skip
))))
805 ;; if fine diff vector is not set for diff N, then do nothing
806 (defun ediff-set-fine-diff-properties (n &optional default
)
807 (or (not (ediff-has-face-support-p))
809 (>= n ediff-number-of-differences
)
810 ;; when faces are supported, set faces and priorities of fine overlays
812 (ediff-set-fine-diff-properties-in-one-buffer 'A n default
)
813 (ediff-set-fine-diff-properties-in-one-buffer 'B n default
)
815 (ediff-set-fine-diff-properties-in-one-buffer 'C n default
)))))
817 (defun ediff-set-fine-diff-properties-in-one-buffer (buf-type
819 (let ((fine-diff-vector (ediff-get-fine-diff-vector n buf-type
))
822 (ediff-get-symbol-from-alist
823 buf-type ediff-fine-diff-face-alist
)
825 (mapc (lambda (overl)
826 (ediff-set-overlay-face overl face
))
829 ;; Set overlays over the regions that denote delimiters
830 (defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num
)
831 (let (overlay overlay-list
)
835 (ediff-make-bullet-proof-overlay
836 (nth 0 diff-list
) (nth 1 diff-list
) ediff-buffer-C
))
838 (setq overlay-list
(cons overlay overlay-list
))
839 (if (> (length diff-list
) 1)
840 (setq diff-list
(cdr (cdr diff-list
)))
841 (error "ediff-set-fine-overlays-for-combined-merge: corrupt list of
844 (setq overlay-list
(reverse overlay-list
))
845 (ediff-set-fine-diff-vector
846 reg-num
'C
(apply 'vector overlay-list
))
850 ;; Convert diff list to overlays for a given DIFF-REGION
851 ;; in buffer of type BUF-TYPE
852 (defun ediff-set-fine-overlays-in-one-buffer (buf-type diff-list region-num
)
853 (let* ((current-diff -
1)
854 (reg-start (ediff-get-diff-posn buf-type
'beg region-num
))
855 (buff (ediff-get-buffer buf-type
))
856 (ctl-buf ediff-control-buffer
)
857 combined-merge-diff-list
858 diff-overlay-list list-element
861 (ediff-clear-fine-differences-in-one-buffer region-num buf-type
)
862 (setq diff-list
(cdr diff-list
)) ; discard list type (words or points)
863 (ediff-with-current-buffer buff
(goto-char reg-start
))
865 ;; if it is a combined merge then set overlays in buff C specially
866 (if (and ediff-merge-job
(eq buf-type
'C
)
867 (setq combined-merge-diff-list
868 (ediff-looks-like-combined-merge region-num
)))
869 (ediff-set-fine-overlays-for-combined-merge
870 combined-merge-diff-list region-num
)
873 (setq current-diff
(1+ current-diff
)
874 list-element
(car diff-list
)
875 begin
(aref list-element
(cond ((eq buf-type
'A
) 0)
878 end
(aref list-element
(cond ((eq buf-type
'A
) 1)
881 (if (not (or begin end
))
883 ;; Put overlays at appropriate places in buffers
884 ;; convert lines to points, if necessary
885 (ediff-with-current-buffer ctl-buf
886 (setq begin
(ediff-goto-word (1+ begin
) buff
)
887 end
(ediff-goto-word end buff
'end
)))
888 (setq overlay
(ediff-make-bullet-proof-overlay begin end buff
))
889 ;; record all overlays for this difference region
890 (setq diff-overlay-list
(nconc diff-overlay-list
(list overlay
))))
892 (setq diff-list
(cdr diff-list
))
894 ;; convert the list of difference information into a vector
896 (ediff-set-fine-diff-vector
897 region-num buf-type
(vconcat diff-overlay-list
))
901 (defun ediff-convert-fine-diffs-to-overlays (diff-list region-num
)
902 (ediff-set-fine-overlays-in-one-buffer 'A diff-list region-num
)
903 (ediff-set-fine-overlays-in-one-buffer 'B diff-list region-num
)
905 (ediff-set-fine-overlays-in-one-buffer 'C diff-list region-num
)
909 ;; Stolen from emerge.el
910 (defun ediff-get-diff3-group (file)
911 ;; This save-excursion allows ediff-get-diff3-group to be called for the
912 ;; various groups of lines (1, 2, 3) in any order, and for the lines to
913 ;; appear in any order. The reason this is necessary is that Gnu diff3
914 ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
917 (concat "^" file
":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)\C-m?$"))
918 (beginning-of-line 2)
919 ;; treatment depends on whether it is an "a" group or a "c" group
920 (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
922 (if (match-beginning 2)
923 ;; it has two numbers
924 (list (string-to-number
925 (buffer-substring (match-beginning 1) (match-end 1)))
926 (1+ (string-to-number
927 (buffer-substring (match-beginning 3) (match-end 3)))))
929 (let ((x (string-to-number
930 (buffer-substring (match-beginning 1) (match-end 1)))))
932 ;; it is an "a" group
933 (let ((x (1+ (string-to-number
934 (buffer-substring (match-beginning 1) (match-end 1))))))
938 ;; If WORD-MODE, construct vector of diffs using word numbers.
939 ;; Else, use point values.
940 ;; WORD-MODE also tells if we are in the word-mode or not.
941 ;; If THREE-WAY-COMP, then it is a 3-way comparison. Else, it is merging
942 ;; with ancestor, in which case buffer-C contents is identical to buffer-A/B,
943 ;; contents (unless buffer-A is narrowed) depending on ediff-default-variant's
945 ;; BOUNDS specifies visibility bounds to use.
946 (defun ediff-extract-diffs3 (diff-buffer word-mode three-way-comp
948 (let ((A-buffer ediff-buffer-A
)
949 (B-buffer ediff-buffer-B
)
950 (C-buffer ediff-buffer-C
)
951 (anc-buffer ediff-ancestor-buffer
)
952 (a-prev 1) ; needed to set the first diff line correctly
959 diff-list shift-A shift-B shift-C
962 ;; diff list contains word numbers or points, depending on word-mode
963 (setq diff-list
(cons (if word-mode
'words
'points
)
968 (ediff-get-value-according-to-buffer-type 'A bounds
))
971 (ediff-get-value-according-to-buffer-type 'B bounds
))
975 (ediff-get-value-according-to-buffer-type 'C bounds
)))))
977 ;; reset point in buffers A, B, C
978 (ediff-with-current-buffer A-buffer
979 (goto-char (if shift-A shift-A
(point-min))))
980 (ediff-with-current-buffer B-buffer
981 (goto-char (if shift-B shift-B
(point-min))))
983 (ediff-with-current-buffer C-buffer
984 (goto-char (if shift-C shift-C
(point-min)))))
985 (if (ediff-buffer-live-p anc-buffer
)
986 (ediff-with-current-buffer anc-buffer
987 (goto-char (point-min))))
989 (ediff-with-current-buffer diff-buffer
990 (goto-char (point-min))
991 (while (re-search-forward ediff-match-diff3-line nil t
)
992 ;; leave point after matched line
993 (beginning-of-line 2)
994 (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
995 ;; if the files A and B are the same and not 3way-comparison,
996 ;; ignore the difference
997 (if (or three-way-comp
(not (string-equal agreement
"3")))
998 (let* ((a-begin (car (ediff-get-diff3-group "1")))
999 (a-end (nth 1 (ediff-get-diff3-group "1")))
1000 (b-begin (car (ediff-get-diff3-group "2")))
1001 (b-end (nth 1 (ediff-get-diff3-group "2")))
1002 (c-or-anc-begin (car (ediff-get-diff3-group "3")))
1003 (c-or-anc-end (nth 1 (ediff-get-diff3-group "3")))
1005 (cond ((string-equal agreement
"1") 'prefer-A
)
1006 ((string-equal agreement
"2") 'prefer-B
)
1007 (t ediff-default-variant
)))
1008 (state-of-diff-merge
1009 (if (memq state-of-merge
'(default-A prefer-A
)) 'B
'A
))
1010 (state-of-diff-comparison
1011 (cond ((string-equal agreement
"1") 'A
)
1012 ((string-equal agreement
"2") 'B
)
1013 ((string-equal agreement
"3") 'C
)))
1019 anc-begin-pt anc-end-pt
)
1021 (setq state-of-ancestor
1022 (= c-or-anc-begin c-or-anc-end
))
1024 (cond (three-way-comp
1025 (setq c-begin c-or-anc-begin
1026 c-end c-or-anc-end
))
1027 ((eq ediff-default-variant
'default-B
)
1028 (setq c-begin b-begin
1031 (setq c-begin a-begin
1034 ;; compute main diff vector
1036 ;; make diff-list contain word numbers
1040 (- a-begin a-prev
) (- a-end a-begin
)
1041 (- b-begin b-prev
) (- b-end b-begin
)
1042 (- c-begin c-prev
) (- c-end c-begin
)
1043 nil nil
; dummy ancestor
1045 nil
; state of merge
1046 nil
; state of ancestor
1051 ;; else convert lines to points
1052 (ediff-with-current-buffer A-buffer
1053 (goto-char (or a-prev-pt shift-A
(point-min)))
1054 (forward-line (- a-begin a-prev
))
1055 (setq a-begin-pt
(point))
1056 (forward-line (- a-end a-begin
))
1057 (setq a-end-pt
(point)
1059 a-prev-pt a-end-pt
))
1060 (ediff-with-current-buffer B-buffer
1061 (goto-char (or b-prev-pt shift-B
(point-min)))
1062 (forward-line (- b-begin b-prev
))
1063 (setq b-begin-pt
(point))
1064 (forward-line (- b-end b-begin
))
1065 (setq b-end-pt
(point)
1067 b-prev-pt b-end-pt
))
1068 (ediff-with-current-buffer C-buffer
1069 (goto-char (or c-prev-pt shift-C
(point-min)))
1070 (forward-line (- c-begin c-prev
))
1071 (setq c-begin-pt
(point))
1072 (forward-line (- c-end c-begin
))
1073 (setq c-end-pt
(point)
1075 c-prev-pt c-end-pt
))
1076 (if (ediff-buffer-live-p anc-buffer
)
1077 (ediff-with-current-buffer anc-buffer
1078 (forward-line (- c-or-anc-begin anc-prev
))
1079 (setq anc-begin-pt
(point))
1080 (forward-line (- c-or-anc-end c-or-anc-begin
))
1081 (setq anc-end-pt
(point)
1082 anc-prev c-or-anc-end
)))
1086 ;; if comparing with ancestor, then there also is a
1087 ;; state-of-difference marker
1093 nil nil
; ancestor begin/end
1094 state-of-diff-comparison
1095 nil
; state of merge
1096 nil
; state of ancestor
1098 (list (vector a-begin-pt a-end-pt
1101 anc-begin-pt anc-end-pt
1109 ))) ; end ediff-with-current-buffer
1113 ;; Generate the difference vector and overlays for three files
1114 ;; File-C is either the third file to compare (in case of 3-way comparison)
1115 ;; or it is the ancestor file.
1116 (defun ediff-setup-diff-regions3 (file-A file-B file-C
)
1117 ;; looking for '-i' or a 'i' among clustered non-long options
1118 (if (string-match "^-i\\| -i\\|\\(^\\| \\)-[^- ]+i" ediff-diff-options
)
1119 (error "Option `-i' is not allowed in `ediff-diff3-options'"))
1121 (or (ediff-buffer-live-p ediff-diff-buffer
)
1122 (setq ediff-diff-buffer
1123 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
1125 (message "Computing differences ...")
1126 (ediff-exec-process ediff-diff3-program ediff-diff-buffer
'synchronize
1127 ediff-actual-diff3-options file-A file-B file-C
)
1129 (ediff-prepare-error-list ediff-diff3-ok-lines-regexp ediff-diff-buffer
)
1130 ;;(message "Computing differences ... done")
1131 (ediff-convert-diffs-to-overlays
1132 (ediff-extract-diffs3
1134 ediff-word-mode ediff-3way-comparison-job ediff-narrow-bounds
)
1138 ;; Execute PROGRAM asynchronously, unless OS/2, Windows-*, or DOS, or unless
1139 ;; SYNCH is non-nil. BUFFER must be a buffer object, and must be alive. The
1140 ;; OPTIONS arg is a list of options to pass to PROGRAM. It may be a blank
1141 ;; string. All elements in FILES must be strings. We also delete nil from
1143 (defun ediff-exec-process (program buffer synch options
&rest files
)
1144 (let ((data (match-data))
1145 ;; If this is a buffer job, we are diffing temporary files
1146 ;; produced by Emacs with ediff-coding-system-for-write, so
1147 ;; use the same encoding to read the results.
1148 (coding-system-for-read
1149 (if (string-match "buffer" (symbol-name ediff-job-name
))
1150 ediff-coding-system-for-write
1151 ediff-coding-system-for-read
))
1153 (setq args
(append (split-string options
) files
))
1154 (setq args
(delete "" (delq nil args
))) ; delete nil and "" from arguments
1155 ;; the --binary option, if present, should be used only for buffer jobs
1156 ;; or for refining the differences
1157 (or (string-match "buffer" (symbol-name ediff-job-name
))
1158 (eq buffer ediff-fine-diff-buffer
)
1159 (setq args
(delete "--binary" args
)))
1161 (let ((directory default-directory
)
1163 (with-current-buffer buffer
1165 (setq default-directory directory
)
1166 (if (or (memq system-type
'(ms-dos windows-nt
))
1168 ;; In Windows do it synchronously, since Windows doesn't let us
1169 ;; delete files used by other processes. Thus, in ediff-buffers
1170 ;; and similar functions, we can't delete temp files because
1171 ;; they might be used by the asynch process that computes
1172 ;; custom diffs. So, we have to wait till custom diff
1173 ;; subprocess is done.
1174 ;; In DOS, must synchronize because DOS doesn't have
1175 ;; asynchronous processes.
1176 (apply 'call-process program nil buffer nil args
)
1177 ;; On other systems, do it asynchronously.
1178 (setq proc
(get-buffer-process buffer
))
1179 (if proc
(kill-process proc
))
1181 (apply 'start-process
"Custom Diff" buffer program args
))
1182 (setq mode-line-process
'(":%s"))
1183 (set-process-sentinel proc
'ediff-process-sentinel
)
1184 (set-process-filter proc
'ediff-process-filter
)
1186 (store-match-data data
))))
1188 ;; This is shell-command-filter from simple.el in Emacs.
1189 ;; Copied here because XEmacs doesn't have it.
1190 (defun ediff-process-filter (proc string
)
1191 ;; Do save-excursion by hand so that we can leave point numerically unchanged
1192 ;; despite an insertion immediately after it.
1193 (let* ((obuf (current-buffer))
1194 (buffer (process-buffer proc
))
1196 (window (get-buffer-window buffer
))
1197 (pos (window-start window
)))
1201 (or (= (point) (point-max))
1202 (setq opoint
(point)))
1203 (goto-char (point-max))
1204 (insert-before-markers string
))
1205 ;; insert-before-markers moved this marker: set it back.
1206 (set-window-start window pos
)
1207 ;; Finish our save-excursion.
1210 (set-buffer obuf
))))
1212 ;; like shell-command-sentinel but doesn't print an exit status message
1213 ;; we do this because diff always exits with status 1, if diffs are found
1214 ;; so shell-command-sentinel displays a confusing message to the user
1215 (defun ediff-process-sentinel (process _signal
)
1216 (if (and (memq (process-status process
) '(exit signal
))
1217 (buffer-name (process-buffer process
)))
1219 (with-current-buffer (process-buffer process
)
1220 (setq mode-line-process nil
))
1221 (delete-process process
))))
1224 ;;; Word functions used to refine the current diff
1226 (defvar ediff-forward-word-function
'ediff-forward-word
1227 "Function to call to move to the next word.
1228 Used for splitting difference regions into individual words.")
1229 (make-variable-buffer-local 'ediff-forward-word-function
)
1231 ;; \240 is Unicode symbol for nonbreakable whitespace
1232 (defvar ediff-whitespace
" \n\t\f\r\240"
1233 "Characters constituting white space.
1234 These characters are ignored when differing regions are split into words.")
1235 (make-variable-buffer-local 'ediff-whitespace
)
1237 (defvar ediff-word-1
1238 (if (featurep 'xemacs
) "a-zA-Z---_" "-[:word:]_")
1239 "Characters that constitute words of type 1.
1240 More precisely, [ediff-word-1] is a regexp that matches type 1 words.
1241 See `ediff-forward-word' for more details.")
1242 (make-variable-buffer-local 'ediff-word-1
)
1244 (defvar ediff-word-2
"0-9.,"
1245 "Characters that constitute words of type 2.
1246 More precisely, [ediff-word-2] is a regexp that matches type 2 words.
1247 See `ediff-forward-word' for more details.")
1248 (make-variable-buffer-local 'ediff-word-2
)
1250 (defvar ediff-word-3
"`'?!:;\"{}[]()"
1251 "Characters that constitute words of type 3.
1252 More precisely, [ediff-word-3] is a regexp that matches type 3 words.
1253 See `ediff-forward-word' for more details.")
1254 (make-variable-buffer-local 'ediff-word-3
)
1256 (defvar ediff-word-4
1257 (concat "^" ediff-word-1 ediff-word-2 ediff-word-3 ediff-whitespace
)
1258 "Characters that constitute words of type 4.
1259 More precisely, [ediff-word-4] is a regexp that matches type 4 words.
1260 See `ediff-forward-word' for more details.")
1261 (make-variable-buffer-local 'ediff-word-4
)
1263 ;; Split region along word boundaries. Each word will be on its own line.
1264 ;; Output to buffer out-buffer.
1265 (defun ediff-forward-word ()
1266 "Move point one word forward.
1267 There are four types of words, each of which consists entirely of
1268 characters in `ediff-word-1', `ediff-word-2', `ediff-word-3', or
1269 `ediff-word-4'. Words are recognized by passing these one after another as
1270 arguments to `skip-chars-forward'."
1271 (or (> (+ (skip-chars-forward ediff-word-1
)
1272 (skip-syntax-forward "w"))
1274 (> (skip-chars-forward ediff-word-2
) 0)
1275 (> (skip-chars-forward ediff-word-3
) 0)
1276 (> (skip-chars-forward ediff-word-4
) 0)
1280 (defun ediff-wordify (beg end in-buffer out-buffer
&optional control-buf
)
1281 (let ((forward-word-function
1282 ;; eval in control buf to let user create local versions for
1283 ;; different invocations
1285 (ediff-with-current-buffer control-buf
1286 ediff-forward-word-function
)
1287 ediff-forward-word-function
))
1288 inbuf-syntax-tbl sv-point diff-string
)
1289 (with-current-buffer in-buffer
1290 (setq inbuf-syntax-tbl
1292 (ediff-with-current-buffer control-buf
1295 (setq diff-string
(buffer-substring-no-properties beg end
))
1297 (set-buffer out-buffer
)
1298 ;; Make sure that temp buff syntax table is the same as the original buf
1299 ;; syntax tbl, because we use ediff-forward-word in both and
1300 ;; ediff-forward-word depends on the syntax classes of characters.
1301 (set-syntax-table inbuf-syntax-tbl
)
1303 (insert diff-string
)
1304 (goto-char (point-min))
1305 (skip-chars-forward ediff-whitespace
)
1306 (delete-region (point-min) (point))
1309 (funcall forward-word-function
)
1310 (setq sv-point
(point))
1311 (skip-chars-forward ediff-whitespace
)
1312 (delete-region sv-point
(point))
1315 ;; copy string specified as BEG END from IN-BUF to OUT-BUF
1316 (defun ediff-copy-to-buffer (beg end in-buffer out-buffer
)
1317 (with-current-buffer out-buffer
1319 (insert-buffer-substring in-buffer beg end
)
1320 (goto-char (point-min))))
1323 ;; goto word #n starting at current position in buffer `buf'
1324 ;; For ediff, a word is determined by ediff-forward-word-function
1325 ;; If `flag' is non-nil, goto the end of the n-th word.
1326 (defun ediff-goto-word (n buf
&optional flag
)
1327 ;; remember val ediff-forward-word-function has in ctl buf
1328 (let ((fwd-word-fun ediff-forward-word-function
)
1329 (syntax-tbl ediff-syntax-table
))
1330 (ediff-with-current-buffer buf
1331 (skip-chars-forward ediff-whitespace
)
1332 (ediff-with-syntax-table syntax-tbl
1334 (funcall fwd-word-fun
)
1335 (skip-chars-forward ediff-whitespace
)
1337 (if (and flag
(> n
0))
1338 (funcall fwd-word-fun
)))
1341 (defun ediff-same-file-contents (f1 f2
)
1342 "Return t if files F1 and F2 have identical contents."
1343 (if (and (not (file-directory-p f1
))
1344 (not (file-directory-p f2
)))
1345 (if (equal (file-remote-p f1
) (file-remote-p f2
))
1347 ;; In the remote case, this works only if F1 and F2 are
1348 ;; located on the same remote host.
1349 (apply 'process-file ediff-cmp-program nil nil nil
1350 (append ediff-cmp-options
1351 (list (or (file-remote-p f1
'localname
)
1352 (expand-file-name f1
))
1353 (or (file-remote-p f2
'localname
)
1354 (expand-file-name f2
)))))
1356 (and (numberp res
) (eq res
0)))
1358 ;; F1 and F2 are not located on the same host.
1359 (let ((t1 (file-local-copy f1
))
1360 (t2 (file-local-copy f2
)))
1362 (ediff-same-file-contents (or t1 f1
) (or t2 f2
))
1363 (and t1
(delete-file t1
))
1364 (and t2
(delete-file t2
))))
1368 (defun ediff-same-contents (d1 d2
&optional filter-re
)
1369 "Return t if D1 and D2 have the same content.
1370 D1 and D2 can either be both directories or both regular files.
1371 Symlinks and the likes are not handled.
1372 If FILTER-RE is non-nil, recursive checking in directories
1373 affects only files whose names match the expression."
1374 ;; Normalize empty filter RE to nil.
1375 (unless (> (length filter-re
) 0) (setq filter-re nil
))
1376 ;; Indicate progress
1377 (message "Comparing '%s' and '%s' modulo '%s'" d1 d2 filter-re
)
1379 ;; D1 & D2 directories => recurse
1380 ((and (file-directory-p d1
)
1381 (file-directory-p d2
))
1382 (if (null ediff-recurse-to-subdirectories
)
1383 (if (y-or-n-p "Compare subdirectories recursively? ")
1384 (setq ediff-recurse-to-subdirectories
'yes
)
1385 (setq ediff-recurse-to-subdirectories
'no
)))
1386 (if (eq ediff-recurse-to-subdirectories
'yes
)
1387 (let* ((all-entries-1 (directory-files d1 t filter-re
))
1388 (all-entries-2 (directory-files d2 t filter-re
))
1389 (entries-1 (ediff-delete-all-matches "^\\.\\.?$" all-entries-1
))
1390 (entries-2 (ediff-delete-all-matches "^\\.\\.?$" all-entries-2
))
1393 (ediff-same-file-contents-lists entries-1 entries-2 filter-re
)
1395 ) ; end of the directories case
1396 ;; D1 & D2 are both files => compare directly
1397 ((and (file-regular-p d1
)
1398 (file-regular-p d2
))
1399 (ediff-same-file-contents d1 d2
))
1400 ;; Otherwise => false: unequal contents
1404 ;; If lists have the same length and names of files are pairwise equal
1405 ;; (removing the directories) then compare contents pairwise.
1406 ;; True if all contents are the same; false otherwise
1407 (defun ediff-same-file-contents-lists (entries-1 entries-2 filter-re
)
1408 ;; First, check only the names (works quickly and ensures a
1409 ;; precondition for subsequent code)
1410 (if (and (= (length entries-1
) (length entries-2
))
1411 (equal (mapcar 'file-name-nondirectory entries-1
)
1412 (mapcar 'file-name-nondirectory entries-2
)))
1413 ;; With name equality established, compare the entries
1414 ;; through recursion.
1416 (while (and entries-1 continue
)
1417 (if (ediff-same-contents
1418 (car entries-1
) (car entries-2
) filter-re
)
1419 (setq entries-1
(cdr entries-1
)
1420 entries-2
(cdr entries-2
))
1421 (setq continue nil
))
1423 ;; if reached the end then lists are equal
1429 ;; ARG1 is a regexp, ARG2 is a list of full-filenames
1430 ;; Delete all entries that match the regexp
1431 (defun ediff-delete-all-matches (regex file-list-list
)
1433 (while file-list-list
1434 (setq elt
(car file-list-list
))
1435 (or (string-match regex
(file-name-nondirectory elt
))
1436 (setq result
(cons elt result
)))
1437 (setq file-list-list
(cdr file-list-list
)))
1441 (defun ediff-set-actual-diff-options ()
1442 (if ediff-ignore-case
1443 (setq ediff-actual-diff-options
1444 (concat ediff-diff-options
" " ediff-ignore-case-option
)
1445 ediff-actual-diff3-options
1446 (concat ediff-diff3-options
" " ediff-ignore-case-option3
))
1447 (setq ediff-actual-diff-options ediff-diff-options
1448 ediff-actual-diff3-options ediff-diff3-options
)
1450 (setq-default ediff-actual-diff-options ediff-actual-diff-options
1451 ediff-actual-diff3-options ediff-actual-diff3-options
)
1455 ;; Ignore case handling - some ideas from drew.adams@@oracle.com
1456 (defun ediff-toggle-ignore-case ()
1458 (ediff-barf-if-not-control-buffer)
1459 (setq ediff-ignore-case
(not ediff-ignore-case
))
1460 (ediff-set-actual-diff-options)
1461 (if ediff-ignore-case
1462 (message "Ignoring regions that differ only in case")
1463 (message "Ignoring case differences turned OFF"))
1464 (cond (ediff-merge-job
1465 (message "Ignoring letter case is too dangerous in merge jobs"))
1466 ((and ediff-diff3-job
(string= ediff-ignore-case-option3
""))
1467 (message "Ignoring letter case is not supported by this diff3 program"))
1468 ((and (not ediff-3way-job
) (string= ediff-ignore-case-option
""))
1469 (message "Ignoring letter case is not supported by this diff program"))
1472 (ediff-update-diffs)))
1478 ;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1479 ;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1480 ;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1483 ;;; ediff-diff.el ends here