1 ;;; ediff-diff.el --- diff-related utilities
3 ;; Copyright (C) 1994-2013 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/>.
31 (require 'ediff-util
))
35 (defgroup ediff-diff nil
36 "Diff related utilities."
40 (defcustom ediff-diff-program
"diff"
41 "Program to use for generating the differential of the two files."
44 (defcustom ediff-diff3-program
"diff3"
45 "Program to be used for three-way comparison.
46 Must produce output compatible with Unix's diff3 program."
51 ;; The following functions must precede all defcustom-defined variables.
53 (fset 'ediff-set-actual-diff-options
(lambda () nil
))
55 (defcustom ediff-shell
56 (cond ((memq system-type
'(ms-dos windows-nt
))
57 shell-file-name
) ; no standard name on MS-DOS
59 "The shell used to run diff and patch.
60 If user's .profile or .cshrc files are set up correctly, any shell
61 will do. However, some people set $prompt or other things
62 incorrectly, which leads to undesirable output messages. These may
63 cause Ediff to fail. In such a case, set `ediff-shell' to a shell that
64 you are not using or, better, fix your shell's startup file."
68 (defcustom ediff-cmp-program
"cmp"
69 "Utility to use to determine if two files are identical.
70 It must return code 0, if its arguments are identical files."
74 (defcustom ediff-cmp-options nil
75 "Options to pass to `ediff-cmp-program'.
76 If GNU diff is used as `ediff-cmp-program', then the most useful options
77 are `-I REGEXP', to ignore changes whose lines match the REGEXP."
78 :type
'(repeat string
)
81 (defun ediff-set-diff-options (symbol value
)
83 (ediff-set-actual-diff-options))
85 (defcustom ediff-diff-options
86 (if (memq system-type
'(ms-dos windows-nt
)) "--binary" "")
87 "Options to pass to `ediff-diff-program'.
88 If Unix diff is used as `ediff-diff-program',
89 then a useful option is `-w', to ignore space.
90 Options `-c', `-u', and `-i' are not allowed. Case sensitivity can be
91 toggled interactively using \\[ediff-toggle-ignore-case].
93 Do not remove the default options. If you need to change this variable, add new
94 options after the default ones.
96 This variable is not for customizing the look of the differences produced by
97 the command \\[ediff-show-diff-output]. Use the variable
98 `ediff-custom-diff-options' for that."
99 :set
'ediff-set-diff-options
103 (ediff-defvar-local ediff-ignore-case nil
104 "If t, skip over difference regions that differ only in letter case.
105 This variable can be set either in .emacs or toggled interactively.
106 Use `setq-default' if setting it in .emacs")
108 (defcustom ediff-ignore-case-option
"-i"
109 "Option that causes the diff program to ignore case of letters."
113 (defcustom ediff-ignore-case-option3
""
114 "Option that causes the diff3 program to ignore case of letters.
115 GNU diff3 doesn't have such an option."
119 ;; the actual options used in comparison
120 (ediff-defvar-local ediff-actual-diff-options ediff-diff-options
"")
122 (defcustom ediff-custom-diff-program ediff-diff-program
123 "Program to use for generating custom diff output for saving it in a file.
124 This output is not used by Ediff internally."
127 (defcustom ediff-custom-diff-options
"-c"
128 "Options to pass to `ediff-custom-diff-program'."
132 ;;; Support for diff3
134 (defvar ediff-match-diff3-line
"^====\\(.?\\)\C-m?$"
135 "Pattern to match lines produced by diff3 that describe differences.")
136 (defcustom ediff-diff3-options
""
137 "Options to pass to `ediff-diff3-program'."
138 :set
'ediff-set-diff-options
142 ;; the actual options used in comparison
143 (ediff-defvar-local ediff-actual-diff3-options ediff-diff3-options
"")
145 (defcustom ediff-diff3-ok-lines-regexp
146 "^\\([1-3]:\\|====\\| \\|.*Warning *:\\|.*No newline\\|.*missing newline\\|^\C-m$\\)"
147 "Regexp that matches normal output lines from `ediff-diff3-program'.
148 Lines that do not match are assumed to be error messages."
152 ;; keeps the status of the current diff in 3-way jobs.
153 ;; the status can be =diff(A), =diff(B), or =diff(A+B)
154 (ediff-defvar-local ediff-diff-status
"" "")
159 (ediff-defvar-local ediff-auto-refine
(if (ediff-has-face-support-p) 'on
'nix
)
160 "If `on', Ediff auto-highlights fine diffs for the current diff region.
161 If `off', auto-highlighting is not used. If `nix', no fine diffs are shown
162 at all, unless the user force-refines the region by hitting `*'.
164 This variable can be set either in .emacs or toggled interactively.
165 Use `setq-default' if setting it in .emacs")
167 (ediff-defvar-local ediff-ignore-similar-regions nil
168 "If t, skip over difference regions that differ only in the white space and line breaks.
169 This variable can be set either in .emacs or toggled interactively.
170 Use `setq-default' if setting it in .emacs")
172 (ediff-defvar-local ediff-auto-refine-limit
14000
173 "Auto-refine only the regions of this size \(in bytes\) or less.")
177 (defvar ediff-diff-ok-lines-regexp
180 "[0-9,]+[acd][0-9,]+\C-m?$"
185 "\\|.*missing +newline"
188 "Regexp that matches normal output lines from `ediff-diff-program'.
189 This is mostly lifted from Emerge, except that Ediff also considers
190 warnings and `Missing newline'-type messages to be normal output.
191 Lines that do not match are assumed to be error messages.")
193 (defvar ediff-match-diff-line
194 (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
195 (concat "^" x
"\\([acd]\\)" x
"\C-m?$"))
196 "Pattern to match lines produced by diff that describe differences.")
198 (ediff-defvar-local ediff-setup-diff-regions-function nil
199 "value is a function symbol depending on the kind of job is to be done.
200 For 2-way jobs and for ediff-merge, it should be `ediff-setup-diff-regions'.
201 For jobs requiring diff3, it should be `ediff-setup-diff-regions3'.
203 The function should take three mandatory arguments, file-A, file-B, and
204 file-C. It may ignore file C for diff2 jobs. It should also take
205 one optional arguments, diff-number to refine.")
210 ;; Generate the difference vector and overlays for the two files
211 ;; With optional arg REG-TO-REFINE, refine this region.
212 ;; File-C argument is not used here. It is there just because
213 ;; ediff-setup-diff-regions is called via a funcall to
214 ;; ediff-setup-diff-regions-function, which can also have the value
215 ;; ediff-setup-diff-regions3, which takes 4 arguments.
216 (defun ediff-setup-diff-regions (file-A file-B file-C
)
217 ;; looking for '-c', '-i', '-u', or 'c', 'i', 'u' among clustered non-long options
218 (if (string-match "^-[ciu]\\| -[ciu]\\|\\(^\\| \\)-[^- ]+[ciu]"
220 (error "Options `-c', `-u', and `-i' are not allowed in `ediff-diff-options'"))
222 ;; create, if it doesn't exist
223 (or (ediff-buffer-live-p ediff-diff-buffer
)
224 (setq ediff-diff-buffer
225 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
226 (ediff-make-diff2-buffer ediff-diff-buffer file-A file-B
)
227 (ediff-prepare-error-list ediff-diff-ok-lines-regexp ediff-diff-buffer
)
228 (ediff-convert-diffs-to-overlays
230 ediff-diff-buffer ediff-word-mode ediff-narrow-bounds
)))
232 ;; Run the diff program on FILE1 and FILE2 and put the output in DIFF-BUFFER
233 ;; Return the size of DIFF-BUFFER
234 ;; The return code isn't used in the program at present.
235 (defun ediff-make-diff2-buffer (diff-buffer file1 file2
)
236 (let ((file1-size (ediff-file-size file1
))
237 (file2-size (ediff-file-size file2
)))
238 (cond ((not (numberp file1-size
))
239 (message "Can't find file: %s"
240 (ediff-abbreviate-file-name file1
))
242 ;; 1 is an error exit code
244 ((not (numberp file2-size
))
245 (message "Can't find file: %s"
246 (ediff-abbreviate-file-name file2
))
248 ;; 1 is an error exit code
250 (t (message "Computing differences between %s and %s ..."
251 (file-name-nondirectory file1
)
252 (file-name-nondirectory file2
))
253 ;; this erases the diff buffer automatically
254 (ediff-exec-process ediff-diff-program
257 ediff-actual-diff-options file1 file2
)
259 (ediff-with-current-buffer diff-buffer
264 ;; If file-A/B/C is nil, do 2-way comparison with the non-nil buffers
265 ;; This function works for diff3 and diff2 jobs
266 (defun ediff-setup-fine-diff-regions (file-A file-B file-C reg-num
)
267 (or (ediff-buffer-live-p ediff-fine-diff-buffer
)
268 (setq ediff-fine-diff-buffer
270 (ediff-unique-buffer-name "*ediff-fine-diff" "*"))))
272 (let (diff3-job diff-program diff-options ok-regexp diff-list
)
273 (setq diff3-job ediff-3way-job
274 diff-program
(if diff3-job ediff-diff3-program ediff-diff-program
)
275 diff-options
(if diff3-job
276 ediff-actual-diff3-options
277 ediff-actual-diff-options
)
278 ok-regexp
(if diff3-job
279 ediff-diff3-ok-lines-regexp
280 ediff-diff-ok-lines-regexp
))
282 (ediff-message-if-verbose "Refining difference region %d ..." (1+ reg-num
))
283 (ediff-exec-process diff-program ediff-fine-diff-buffer
'synchronize
285 ;; The shuffle below is because we can compare 3-way
286 ;; or in several 2-way fashions, like fA fC, fA fB,
288 (if file-A file-A file-B
)
289 (if file-B file-B file-A
)
291 (if file-C file-C file-B
))
294 (ediff-prepare-error-list ok-regexp ediff-fine-diff-buffer
)
295 (ediff-message-if-verbose
297 ;; "Refining difference region %d ... done" (1+ reg-num))
301 (ediff-extract-diffs3
302 ediff-fine-diff-buffer
'3way-comparison
'word-mode
)
303 (ediff-extract-diffs ediff-fine-diff-buffer
'word-mode
)))
323 (ediff-convert-fine-diffs-to-overlays diff-list reg-num
)
327 (defun ediff-prepare-error-list (ok-regexp diff-buff
)
328 (or (ediff-buffer-live-p ediff-error-buffer
)
329 (setq ediff-error-buffer
330 (get-buffer-create (ediff-unique-buffer-name
331 "*ediff-errors" "*"))))
332 (ediff-with-current-buffer ediff-error-buffer
333 (setq buffer-undo-list t
)
335 (insert (ediff-with-current-buffer diff-buff
(buffer-string)))
336 (goto-char (point-min))
337 (delete-matching-lines ok-regexp
))
338 ;; If diff reports errors, show them then quit.
339 (if (/= 0 (ediff-with-current-buffer ediff-error-buffer
(buffer-size)))
340 (let ((ctl-buf ediff-control-buffer
)
341 (error-buf ediff-error-buffer
))
342 (ediff-skip-unsuitable-frames)
343 (switch-to-buffer error-buf
)
344 (ediff-kill-buffer-carefully ctl-buf
)
345 (error "Errors in diff output. Diff output is in %S" diff-buff
))))
347 ;; BOUNDS specifies visibility bounds to use.
348 ;; WORD-MODE tells whether we are in the word-mode or not.
349 ;; If WORD-MODE, also construct vector of diffs using word numbers.
350 ;; Else, use point values.
351 ;; This function handles diff-2 jobs including the case of
352 ;; merging buffers and files without ancestor.
353 (defun ediff-extract-diffs (diff-buffer word-mode
&optional bounds
)
354 (let ((A-buffer ediff-buffer-A
)
355 (B-buffer ediff-buffer-B
)
356 (C-buffer ediff-buffer-C
)
357 (a-prev 1) ; this is needed to set the first diff line correctly
363 diff-list shift-A shift-B
366 ;; diff list contains word numbers, unless changed later
367 (setq diff-list
(cons (if word-mode
'words
'points
)
369 ;; we don't use visibility bounds for buffer C when merging
373 (ediff-get-value-according-to-buffer-type 'A bounds
))
376 (ediff-get-value-according-to-buffer-type 'B bounds
))))
378 ;; reset point in buffers A/B/C
379 (ediff-with-current-buffer A-buffer
380 (goto-char (if shift-A shift-A
(point-min))))
381 (ediff-with-current-buffer B-buffer
382 (goto-char (if shift-B shift-B
(point-min))))
383 (if (ediff-buffer-live-p C-buffer
)
384 (ediff-with-current-buffer C-buffer
385 (goto-char (point-min))))
387 (ediff-with-current-buffer diff-buffer
388 (goto-char (point-min))
389 (while (re-search-forward ediff-match-diff-line nil t
)
390 (let* ((a-begin (string-to-number (buffer-substring (match-beginning 1)
392 (a-end (let ((b (match-beginning 3))
395 (string-to-number (buffer-substring b e
))
397 (diff-type (buffer-substring (match-beginning 4) (match-end 4)))
398 (b-begin (string-to-number (buffer-substring (match-beginning 5)
400 (b-end (let ((b (match-beginning 7))
403 (string-to-number (buffer-substring b e
))
405 a-begin-pt a-end-pt b-begin-pt b-end-pt
406 c-begin c-end c-begin-pt c-end-pt
)
407 ;; fix the beginning and end numbers, because diff is somewhat
408 ;; strange about how it numbers lines
409 (if (string-equal diff-type
"a")
410 (setq b-end
(1+ b-end
)
413 (if (string-equal diff-type
"d")
414 (setq a-end
(1+ a-end
)
417 ;; (string-equal diff-type "c")
418 (setq a-end
(1+ a-end
)
421 (if (eq ediff-default-variant
'default-B
)
422 (setq c-begin b-begin
424 (setq c-begin a-begin
427 ;; compute main diff vector
429 ;; make diff-list contain word numbers
433 (if (ediff-buffer-live-p C-buffer
)
434 (vector (- a-begin a-prev
) (- a-end a-begin
)
435 (- b-begin b-prev
) (- b-end b-begin
)
436 (- c-begin c-prev
) (- c-end c-begin
)
437 nil nil
; dummy ancestor
440 nil
; state of ancestor
442 (vector (- a-begin a-prev
) (- a-end a-begin
)
443 (- b-begin b-prev
) (- b-end b-begin
)
444 nil nil
; dummy buf C
445 nil nil
; dummy ancestor
448 nil
; state of ancestor
454 ;; else convert lines to points
455 (ediff-with-current-buffer A-buffer
456 (goto-char (or a-prev-pt shift-A
(point-min)))
457 (forward-line (- a-begin a-prev
))
458 (setq a-begin-pt
(point))
459 (forward-line (- a-end a-begin
))
460 (setq a-end-pt
(point)
463 (ediff-with-current-buffer B-buffer
464 (goto-char (or b-prev-pt shift-B
(point-min)))
465 (forward-line (- b-begin b-prev
))
466 (setq b-begin-pt
(point))
467 (forward-line (- b-end b-begin
))
468 (setq b-end-pt
(point)
471 (if (ediff-buffer-live-p C-buffer
)
472 (ediff-with-current-buffer C-buffer
473 (goto-char (or c-prev-pt
(point-min)))
474 (forward-line (- c-begin c-prev
))
475 (setq c-begin-pt
(point))
476 (forward-line (- c-end c-begin
))
477 (setq c-end-pt
(point)
479 c-prev-pt c-end-pt
)))
484 (if (ediff-buffer-live-p C-buffer
)
486 a-begin-pt a-end-pt b-begin-pt b-end-pt
488 nil nil
; dummy ancestor
490 ;; shows which buff is different from the other two
491 (if (eq ediff-default-variant
'default-B
) 'A
'B
)
492 ediff-default-variant
; state of merge
493 nil
; state of ancestor
495 (vector a-begin-pt a-end-pt
497 nil nil
; dummy buf C
498 nil nil
; dummy ancestor
499 nil nil
; dummy state of diff & merge
500 nil
; dummy state of ancestor
504 ))) ; end ediff-with-current-buffer
509 (defun ediff-convert-diffs-to-overlays (diff-list)
510 (ediff-set-diff-overlays-in-one-buffer 'A diff-list
)
511 (ediff-set-diff-overlays-in-one-buffer 'B diff-list
)
513 (ediff-set-diff-overlays-in-one-buffer 'C diff-list
))
514 (if ediff-merge-with-ancestor-job
515 (ediff-set-diff-overlays-in-one-buffer 'Ancestor diff-list
))
516 ;; set up vector showing the status of merge regions
518 (setq ediff-state-of-merge
520 (mapcar (lambda (elt)
521 (let ((state-of-merge (aref elt
9))
522 (state-of-ancestor (aref elt
10)))
524 ;; state of merge: prefers/default-A/B or combined
525 (if state-of-merge
(format "%S" state-of-merge
))
526 ;; whether the ancestor region is empty
528 ;; the first elt designates type of list
531 (message "Processing difference regions ... done"))
534 (defun ediff-set-diff-overlays-in-one-buffer (buf-type diff-list
)
535 (let* ((current-diff -
1)
536 (buff (ediff-get-buffer buf-type
))
537 (ctl-buf ediff-control-buffer
)
538 ;; ediff-extract-diffs puts the type of diff-list as the first elt
539 ;; of this list. The type is either 'points or 'words
540 (diff-list-type (car diff-list
))
541 (shift (ediff-overlay-start
542 (ediff-get-value-according-to-buffer-type
543 buf-type ediff-narrow-bounds
)))
544 (limit (ediff-overlay-end
545 (ediff-get-value-according-to-buffer-type
546 buf-type ediff-narrow-bounds
)))
547 diff-overlay-list list-element total-diffs
548 begin end pt-saved overlay state-of-diff
)
550 (setq diff-list
(cdr diff-list
)) ; discard diff list type
551 (setq total-diffs
(length diff-list
))
553 ;; shift, if necessary
554 (ediff-with-current-buffer buff
(setq pt-saved shift
))
557 (setq current-diff
(1+ current-diff
)
558 list-element
(car diff-list
)
559 begin
(aref list-element
(cond ((eq buf-type
'A
) 0)
563 end
(aref list-element
(cond ((eq buf-type
'A
) 1)
567 state-of-diff
(aref list-element
8)
570 (cond ((and (not (eq buf-type state-of-diff
))
571 (not (eq buf-type
'Ancestor
))
572 (memq state-of-diff
'(A B C
)))
574 (car (delq buf-type
(delq state-of-diff
(list 'A
'B
'C
)))))
575 (setq state-of-diff
(format "=diff(%S)" state-of-diff
))
577 (t (setq state-of-diff nil
)))
579 ;; Put overlays at appropriate places in buffer
580 ;; convert word numbers to points, if necessary
581 (if (eq diff-list-type
'words
)
583 (ediff-with-current-buffer buff
(goto-char pt-saved
))
584 (ediff-with-current-buffer ctl-buf
585 (setq begin
(ediff-goto-word (1+ begin
) buff
)
586 end
(ediff-goto-word end buff
'end
)))
587 (if (> end limit
) (setq end limit
))
588 (if (> begin end
) (setq begin end
))
589 (setq pt-saved
(ediff-with-current-buffer buff
(point)))))
590 (setq overlay
(ediff-make-bullet-proof-overlay begin end buff
))
592 (ediff-overlay-put overlay
'priority ediff-shadow-overlay-priority
)
593 (ediff-overlay-put overlay
'ediff-diff-num current-diff
)
594 (if (and (ediff-has-face-support-p)
595 ediff-use-faces ediff-highlight-all-diffs
)
596 (ediff-set-overlay-face
597 overlay
(ediff-background-face buf-type current-diff
)))
599 (if (= 0 (mod current-diff
10))
600 (message "Buffer %S: Processing difference region %d of %d"
601 buf-type current-diff total-diffs
))
602 ;; Record all overlays for this difference.
603 ;; The 2-d elt, nil, is a place holder for the fine diff vector.
604 ;; The 3-d elt, nil, is a place holder for no-fine-diffs flag.
605 ;; The 4-th elt says which diff region is different from the other two
606 ;; (3-way jobs only).
607 (setq diff-overlay-list
610 (list (vector overlay nil nil state-of-diff
)))
615 (set (ediff-get-symbol-from-alist buf-type ediff-difference-vector-alist
)
616 (vconcat diff-overlay-list
))
619 ;; `n' is the diff region to work on. Default is ediff-current-difference.
620 ;; if `flag' is 'noforce then make fine-diffs only if this region's fine
621 ;; diffs have not been computed before.
622 ;; if `flag' is 'skip then don't compute fine diffs for this region.
623 (defun ediff-make-fine-diffs (&optional n flag
)
624 (or n
(setq n ediff-current-difference
))
626 (if (< ediff-number-of-differences
1)
627 (error ediff-NO-DIFFERENCES
))
631 ediff-auto-refine
'nix
))
634 (>= n ediff-number-of-differences
)
635 ;; n is within the range
636 (let ((tmp-buffer (get-buffer-create ediff-tmp-buffer
))
637 (file-A ediff-temp-file-A
)
638 (file-B ediff-temp-file-B
)
639 (file-C ediff-temp-file-C
)
640 (empty-A (ediff-empty-diff-region-p n
'A
))
641 (empty-B (ediff-empty-diff-region-p n
'B
))
642 (empty-C (ediff-empty-diff-region-p n
'C
))
643 (whitespace-A (ediff-whitespace-diff-region-p n
'A
))
644 (whitespace-B (ediff-whitespace-diff-region-p n
'B
))
645 (whitespace-C (ediff-whitespace-diff-region-p n
'C
))
646 cumulative-fine-diff-length
)
648 (cond ;; If one of the regions is empty (or 2 in 3way comparison)
649 ;; then don't refine.
650 ;; If the region happens to be entirely whitespace or empty then
652 ((> (length (delq nil
(list empty-A empty-B empty-C
))) 1)
653 (if (and (ediff-looks-like-combined-merge n
)
655 (ediff-set-fine-overlays-in-one-buffer 'C nil n
))
656 (if ediff-3way-comparison-job
657 (ediff-message-if-verbose
658 "Region %d is empty in all buffers but %S"
660 (cond ((not empty-A
) 'A
)
663 (ediff-message-if-verbose
664 "Region %d in buffer %S is empty"
670 ;; if all regions happen to be whitespace
671 (if (and whitespace-A whitespace-B whitespace-C
)
672 ;; mark as space only
673 (ediff-mark-diff-as-space-only n t
)
674 ;; if some regions are white and others don't, then mark as
675 ;; non-white-space-only
676 (ediff-mark-diff-as-space-only n nil
)))
678 ;; don't compute fine diffs if diff vector exists
679 ((and (eq flag
'noforce
) (ediff-get-fine-diff-vector n
'A
))
680 (if (ediff-no-fine-diffs-p n
)
682 "Only white-space differences in region %d %s"
684 (cond ((eq (ediff-no-fine-diffs-p n
) 'A
)
686 ((eq (ediff-no-fine-diffs-p n
) 'B
)
688 ((eq (ediff-no-fine-diffs-p n
) 'C
)
691 ;; don't compute fine diffs for this region
693 (or (ediff-get-fine-diff-vector n
'A
)
694 (memq ediff-auto-refine
'(off nix
))
695 (ediff-message-if-verbose
696 "Region %d exceeds the auto-refinement limit. Type `%s' to refine"
698 (substitute-command-keys
699 "\\[ediff-make-or-kill-fine-diffs]")
702 ;; recompute fine diffs
704 (ediff-get-diff-posn 'A
'beg n
)
705 (ediff-get-diff-posn 'A
'end n
)
708 ediff-control-buffer
)
710 (ediff-make-temp-file tmp-buffer
"fineDiffA" file-A
))
713 (ediff-get-diff-posn 'B
'beg n
)
714 (ediff-get-diff-posn 'B
'end n
)
717 ediff-control-buffer
)
719 (ediff-make-temp-file tmp-buffer
"fineDiffB" file-B
))
724 (ediff-get-diff-posn 'C
'beg n
)
725 (ediff-get-diff-posn 'C
'end n
)
728 ediff-control-buffer
)
730 (ediff-make-temp-file
731 tmp-buffer
"fineDiffC" file-C
))))
733 ;; save temp file names.
734 (setq ediff-temp-file-A file-A
735 ediff-temp-file-B file-B
736 ediff-temp-file-C file-C
)
738 ;; set the new vector of fine diffs, if none exists
739 (cond ((and ediff-3way-job whitespace-A
)
740 (ediff-setup-fine-diff-regions nil file-B file-C n
))
741 ((and ediff-3way-job whitespace-B
)
742 (ediff-setup-fine-diff-regions file-A nil file-C n
))
744 ;; In merge-jobs, whitespace-C is t, since
745 ;; ediff-empty-diff-region-p returns t in this case
747 (ediff-setup-fine-diff-regions file-A file-B nil n
))
749 (ediff-setup-fine-diff-regions file-A file-B file-C n
)))
751 (setq cumulative-fine-diff-length
752 (+ (length (ediff-get-fine-diff-vector n
'A
))
753 (length (ediff-get-fine-diff-vector n
'B
))
754 ;; in merge jobs, the merge buffer is never refined
755 (if (and file-C
(not ediff-merge-job
))
756 (length (ediff-get-fine-diff-vector n
'C
))
760 ;; all regions are white space
761 (and whitespace-A whitespace-B whitespace-C
)
762 ;; none is white space and no fine diffs detected
763 (and (not whitespace-A
)
765 (not (and ediff-3way-job whitespace-C
))
766 (eq cumulative-fine-diff-length
0)))
767 (ediff-mark-diff-as-space-only n t
)
768 (ediff-message-if-verbose
769 "Only white-space differences in region %d" (1+ n
)))
770 ((eq cumulative-fine-diff-length
0)
771 (ediff-message-if-verbose
772 "Only white-space differences in region %d %s"
774 (cond (whitespace-A (ediff-mark-diff-as-space-only n
'A
)
776 (whitespace-B (ediff-mark-diff-as-space-only n
'B
)
778 (whitespace-C (ediff-mark-diff-as-space-only n
'C
)
779 "in buffers A & B"))))
781 (ediff-mark-diff-as-space-only n nil
)))
784 (ediff-set-fine-diff-properties n
)
787 ;; Interface to ediff-make-fine-diffs. Checks for auto-refine limit, etc.
788 (defun ediff-install-fine-diff-if-necessary (n)
789 (cond ((and (eq ediff-auto-refine
'on
)
791 (not (eq ediff-highlighting-style
'off
))
792 (not (eq ediff-highlighting-style
'ascii
)))
794 (> ediff-auto-refine-limit
795 (- (ediff-get-diff-posn 'A
'end n
)
796 (ediff-get-diff-posn 'A
'beg n
)))
797 (> ediff-auto-refine-limit
798 (- (ediff-get-diff-posn 'B
'end n
)
799 (ediff-get-diff-posn 'B
'beg n
))))
800 (ediff-make-fine-diffs n
'noforce
)
801 (ediff-make-fine-diffs n
'skip
)))
803 ;; highlight if fine diffs already exist
804 ((eq ediff-auto-refine
'off
)
805 (ediff-make-fine-diffs n
'skip
))))
808 ;; if fine diff vector is not set for diff N, then do nothing
809 (defun ediff-set-fine-diff-properties (n &optional default
)
810 (or (not (ediff-has-face-support-p))
812 (>= n ediff-number-of-differences
)
813 ;; when faces are supported, set faces and priorities of fine overlays
815 (ediff-set-fine-diff-properties-in-one-buffer 'A n default
)
816 (ediff-set-fine-diff-properties-in-one-buffer 'B n default
)
818 (ediff-set-fine-diff-properties-in-one-buffer 'C n default
)))))
820 (defun ediff-set-fine-diff-properties-in-one-buffer (buf-type
822 (let ((fine-diff-vector (ediff-get-fine-diff-vector n buf-type
))
825 (ediff-get-symbol-from-alist
826 buf-type ediff-fine-diff-face-alist
)
828 (priority (if default
830 (1+ (or (ediff-overlay-get
832 (ediff-get-symbol-from-alist
834 ediff-current-diff-overlay-alist
))
837 (mapcar (lambda (overl)
838 (ediff-set-overlay-face overl face
)
839 (ediff-overlay-put overl
'priority priority
))
842 ;; Set overlays over the regions that denote delimiters
843 (defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num
)
844 (let (overlay overlay-list
)
848 (ediff-make-bullet-proof-overlay
849 (nth 0 diff-list
) (nth 1 diff-list
) ediff-buffer-C
))
851 (setq overlay-list
(cons overlay overlay-list
))
852 (if (> (length diff-list
) 1)
853 (setq diff-list
(cdr (cdr diff-list
)))
854 (error "ediff-set-fine-overlays-for-combined-merge: corrupt list of
857 (setq overlay-list
(reverse overlay-list
))
858 (ediff-set-fine-diff-vector
859 reg-num
'C
(apply 'vector overlay-list
))
863 ;; Convert diff list to overlays for a given DIFF-REGION
864 ;; in buffer of type BUF-TYPE
865 (defun ediff-set-fine-overlays-in-one-buffer (buf-type diff-list region-num
)
866 (let* ((current-diff -
1)
867 (reg-start (ediff-get-diff-posn buf-type
'beg region-num
))
868 (buff (ediff-get-buffer buf-type
))
869 (ctl-buf ediff-control-buffer
)
870 combined-merge-diff-list
871 diff-overlay-list list-element
874 (ediff-clear-fine-differences-in-one-buffer region-num buf-type
)
875 (setq diff-list
(cdr diff-list
)) ; discard list type (words or points)
876 (ediff-with-current-buffer buff
(goto-char reg-start
))
878 ;; if it is a combined merge then set overlays in buff C specially
879 (if (and ediff-merge-job
(eq buf-type
'C
)
880 (setq combined-merge-diff-list
881 (ediff-looks-like-combined-merge region-num
)))
882 (ediff-set-fine-overlays-for-combined-merge
883 combined-merge-diff-list region-num
)
886 (setq current-diff
(1+ current-diff
)
887 list-element
(car diff-list
)
888 begin
(aref list-element
(cond ((eq buf-type
'A
) 0)
891 end
(aref list-element
(cond ((eq buf-type
'A
) 1)
894 (if (not (or begin end
))
896 ;; Put overlays at appropriate places in buffers
897 ;; convert lines to points, if necessary
898 (ediff-with-current-buffer ctl-buf
899 (setq begin
(ediff-goto-word (1+ begin
) buff
)
900 end
(ediff-goto-word end buff
'end
)))
901 (setq overlay
(ediff-make-bullet-proof-overlay begin end buff
))
902 ;; record all overlays for this difference region
903 (setq diff-overlay-list
(nconc diff-overlay-list
(list overlay
))))
905 (setq diff-list
(cdr diff-list
))
907 ;; convert the list of difference information into a vector
909 (ediff-set-fine-diff-vector
910 region-num buf-type
(vconcat diff-overlay-list
))
914 (defun ediff-convert-fine-diffs-to-overlays (diff-list region-num
)
915 (ediff-set-fine-overlays-in-one-buffer 'A diff-list region-num
)
916 (ediff-set-fine-overlays-in-one-buffer 'B diff-list region-num
)
918 (ediff-set-fine-overlays-in-one-buffer 'C diff-list region-num
)
922 ;; Stolen from emerge.el
923 (defun ediff-get-diff3-group (file)
924 ;; This save-excursion allows ediff-get-diff3-group to be called for the
925 ;; various groups of lines (1, 2, 3) in any order, and for the lines to
926 ;; appear in any order. The reason this is necessary is that Gnu diff3
927 ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
930 (concat "^" file
":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)\C-m?$"))
931 (beginning-of-line 2)
932 ;; treatment depends on whether it is an "a" group or a "c" group
933 (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
935 (if (match-beginning 2)
936 ;; it has two numbers
937 (list (string-to-number
938 (buffer-substring (match-beginning 1) (match-end 1)))
939 (1+ (string-to-number
940 (buffer-substring (match-beginning 3) (match-end 3)))))
942 (let ((x (string-to-number
943 (buffer-substring (match-beginning 1) (match-end 1)))))
945 ;; it is an "a" group
946 (let ((x (1+ (string-to-number
947 (buffer-substring (match-beginning 1) (match-end 1))))))
951 ;; If WORD-MODE, construct vector of diffs using word numbers.
952 ;; Else, use point values.
953 ;; WORD-MODE also tells if we are in the word-mode or not.
954 ;; If THREE-WAY-COMP, then it is a 3-way comparison. Else, it is merging
955 ;; with ancestor, in which case buffer-C contents is identical to buffer-A/B,
956 ;; contents (unless buffer-A is narrowed) depending on ediff-default-variant's
958 ;; BOUNDS specifies visibility bounds to use.
959 (defun ediff-extract-diffs3 (diff-buffer word-mode three-way-comp
961 (let ((A-buffer ediff-buffer-A
)
962 (B-buffer ediff-buffer-B
)
963 (C-buffer ediff-buffer-C
)
964 (anc-buffer ediff-ancestor-buffer
)
965 (a-prev 1) ; needed to set the first diff line correctly
972 diff-list shift-A shift-B shift-C
975 ;; diff list contains word numbers or points, depending on word-mode
976 (setq diff-list
(cons (if word-mode
'words
'points
)
981 (ediff-get-value-according-to-buffer-type 'A bounds
))
984 (ediff-get-value-according-to-buffer-type 'B bounds
))
988 (ediff-get-value-according-to-buffer-type 'C bounds
)))))
990 ;; reset point in buffers A, B, C
991 (ediff-with-current-buffer A-buffer
992 (goto-char (if shift-A shift-A
(point-min))))
993 (ediff-with-current-buffer B-buffer
994 (goto-char (if shift-B shift-B
(point-min))))
996 (ediff-with-current-buffer C-buffer
997 (goto-char (if shift-C shift-C
(point-min)))))
998 (if (ediff-buffer-live-p anc-buffer
)
999 (ediff-with-current-buffer anc-buffer
1000 (goto-char (point-min))))
1002 (ediff-with-current-buffer diff-buffer
1003 (goto-char (point-min))
1004 (while (re-search-forward ediff-match-diff3-line nil t
)
1005 ;; leave point after matched line
1006 (beginning-of-line 2)
1007 (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
1008 ;; if the files A and B are the same and not 3way-comparison,
1009 ;; ignore the difference
1010 (if (or three-way-comp
(not (string-equal agreement
"3")))
1011 (let* ((a-begin (car (ediff-get-diff3-group "1")))
1012 (a-end (nth 1 (ediff-get-diff3-group "1")))
1013 (b-begin (car (ediff-get-diff3-group "2")))
1014 (b-end (nth 1 (ediff-get-diff3-group "2")))
1015 (c-or-anc-begin (car (ediff-get-diff3-group "3")))
1016 (c-or-anc-end (nth 1 (ediff-get-diff3-group "3")))
1018 (cond ((string-equal agreement
"1") 'prefer-A
)
1019 ((string-equal agreement
"2") 'prefer-B
)
1020 (t ediff-default-variant
)))
1021 (state-of-diff-merge
1022 (if (memq state-of-merge
'(default-A prefer-A
)) 'B
'A
))
1023 (state-of-diff-comparison
1024 (cond ((string-equal agreement
"1") 'A
)
1025 ((string-equal agreement
"2") 'B
)
1026 ((string-equal agreement
"3") 'C
)))
1032 anc-begin-pt anc-end-pt
)
1034 (setq state-of-ancestor
1035 (= c-or-anc-begin c-or-anc-end
))
1037 (cond (three-way-comp
1038 (setq c-begin c-or-anc-begin
1039 c-end c-or-anc-end
))
1040 ((eq ediff-default-variant
'default-B
)
1041 (setq c-begin b-begin
1044 (setq c-begin a-begin
1047 ;; compute main diff vector
1049 ;; make diff-list contain word numbers
1053 (- a-begin a-prev
) (- a-end a-begin
)
1054 (- b-begin b-prev
) (- b-end b-begin
)
1055 (- c-begin c-prev
) (- c-end c-begin
)
1056 nil nil
; dummy ancestor
1058 nil
; state of merge
1059 nil
; state of ancestor
1064 ;; else convert lines to points
1065 (ediff-with-current-buffer A-buffer
1066 (goto-char (or a-prev-pt shift-A
(point-min)))
1067 (forward-line (- a-begin a-prev
))
1068 (setq a-begin-pt
(point))
1069 (forward-line (- a-end a-begin
))
1070 (setq a-end-pt
(point)
1072 a-prev-pt a-end-pt
))
1073 (ediff-with-current-buffer B-buffer
1074 (goto-char (or b-prev-pt shift-B
(point-min)))
1075 (forward-line (- b-begin b-prev
))
1076 (setq b-begin-pt
(point))
1077 (forward-line (- b-end b-begin
))
1078 (setq b-end-pt
(point)
1080 b-prev-pt b-end-pt
))
1081 (ediff-with-current-buffer C-buffer
1082 (goto-char (or c-prev-pt shift-C
(point-min)))
1083 (forward-line (- c-begin c-prev
))
1084 (setq c-begin-pt
(point))
1085 (forward-line (- c-end c-begin
))
1086 (setq c-end-pt
(point)
1088 c-prev-pt c-end-pt
))
1089 (if (ediff-buffer-live-p anc-buffer
)
1090 (ediff-with-current-buffer anc-buffer
1091 (forward-line (- c-or-anc-begin anc-prev
))
1092 (setq anc-begin-pt
(point))
1093 (forward-line (- c-or-anc-end c-or-anc-begin
))
1094 (setq anc-end-pt
(point)
1095 anc-prev c-or-anc-end
)))
1099 ;; if comparing with ancestor, then there also is a
1100 ;; state-of-difference marker
1106 nil nil
; ancestor begin/end
1107 state-of-diff-comparison
1108 nil
; state of merge
1109 nil
; state of ancestor
1111 (list (vector a-begin-pt a-end-pt
1114 anc-begin-pt anc-end-pt
1122 ))) ; end ediff-with-current-buffer
1126 ;; Generate the difference vector and overlays for three files
1127 ;; File-C is either the third file to compare (in case of 3-way comparison)
1128 ;; or it is the ancestor file.
1129 (defun ediff-setup-diff-regions3 (file-A file-B file-C
)
1130 ;; looking for '-i' or a 'i' among clustered non-long options
1131 (if (string-match "^-i\\| -i\\|\\(^\\| \\)-[^- ]+i" ediff-diff-options
)
1132 (error "Option `-i' is not allowed in `ediff-diff3-options'"))
1134 (or (ediff-buffer-live-p ediff-diff-buffer
)
1135 (setq ediff-diff-buffer
1136 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
1138 (message "Computing differences ...")
1139 (ediff-exec-process ediff-diff3-program ediff-diff-buffer
'synchronize
1140 ediff-actual-diff3-options file-A file-B file-C
)
1142 (ediff-prepare-error-list ediff-diff3-ok-lines-regexp ediff-diff-buffer
)
1143 ;;(message "Computing differences ... done")
1144 (ediff-convert-diffs-to-overlays
1145 (ediff-extract-diffs3
1147 ediff-word-mode ediff-3way-comparison-job ediff-narrow-bounds
)
1151 ;; Execute PROGRAM asynchronously, unless OS/2, Windows-*, or DOS, or unless
1152 ;; SYNCH is non-nil. BUFFER must be a buffer object, and must be alive. The
1153 ;; OPTIONS arg is a list of options to pass to PROGRAM. It may be a blank
1154 ;; string. All elements in FILES must be strings. We also delete nil from
1156 (defun ediff-exec-process (program buffer synch options
&rest files
)
1157 (let ((data (match-data))
1158 ;; If this is a buffer job, we are diffing temporary files
1159 ;; produced by Emacs with ediff-coding-system-for-write, so
1160 ;; use the same encoding to read the results.
1161 (coding-system-for-read
1162 (if (string-match "buffer" (symbol-name ediff-job-name
))
1163 ediff-coding-system-for-write
1164 ediff-coding-system-for-read
))
1166 (setq args
(append (split-string options
) files
))
1167 (setq args
(delete "" (delq nil args
))) ; delete nil and "" from arguments
1168 ;; the --binary option, if present, should be used only for buffer jobs
1169 ;; or for refining the differences
1170 (or (string-match "buffer" (symbol-name ediff-job-name
))
1171 (eq buffer ediff-fine-diff-buffer
)
1172 (setq args
(delete "--binary" args
)))
1174 (let ((directory default-directory
)
1176 (with-current-buffer buffer
1178 (setq default-directory directory
)
1179 (if (or (memq system-type
'(ms-dos windows-nt
))
1181 ;; In Windows do it synchronously, since Windows doesn't let us
1182 ;; delete files used by other processes. Thus, in ediff-buffers
1183 ;; and similar functions, we can't delete temp files because
1184 ;; they might be used by the asynch process that computes
1185 ;; custom diffs. So, we have to wait till custom diff
1186 ;; subprocess is done.
1187 ;; In DOS, must synchronize because DOS doesn't have
1188 ;; asynchronous processes.
1189 (apply 'call-process program nil buffer nil args
)
1190 ;; On other systems, do it asynchronously.
1191 (setq proc
(get-buffer-process buffer
))
1192 (if proc
(kill-process proc
))
1194 (apply 'start-process
"Custom Diff" buffer program args
))
1195 (setq mode-line-process
'(":%s"))
1196 (set-process-sentinel proc
'ediff-process-sentinel
)
1197 (set-process-filter proc
'ediff-process-filter
)
1199 (store-match-data data
))))
1201 ;; This is shell-command-filter from simple.el in Emacs.
1202 ;; Copied here because XEmacs doesn't have it.
1203 (defun ediff-process-filter (proc string
)
1204 ;; Do save-excursion by hand so that we can leave point numerically unchanged
1205 ;; despite an insertion immediately after it.
1206 (let* ((obuf (current-buffer))
1207 (buffer (process-buffer proc
))
1209 (window (get-buffer-window buffer
))
1210 (pos (window-start window
)))
1214 (or (= (point) (point-max))
1215 (setq opoint
(point)))
1216 (goto-char (point-max))
1217 (insert-before-markers string
))
1218 ;; insert-before-markers moved this marker: set it back.
1219 (set-window-start window pos
)
1220 ;; Finish our save-excursion.
1223 (set-buffer obuf
))))
1225 ;; like shell-command-sentinel but doesn't print an exit status message
1226 ;; we do this because diff always exits with status 1, if diffs are found
1227 ;; so shell-command-sentinel displays a confusing message to the user
1228 (defun ediff-process-sentinel (process signal
)
1229 (if (and (memq (process-status process
) '(exit signal
))
1230 (buffer-name (process-buffer process
)))
1232 (with-current-buffer (process-buffer process
)
1233 (setq mode-line-process nil
))
1234 (delete-process process
))))
1237 ;;; Word functions used to refine the current diff
1239 (defvar ediff-forward-word-function
'ediff-forward-word
1240 "Function to call to move to the next word.
1241 Used for splitting difference regions into individual words.")
1242 (make-variable-buffer-local 'ediff-forward-word-function
)
1244 ;; \240 is Unicode symbol for nonbreakable whitespace
1245 (defvar ediff-whitespace
" \n\t\f\r\240"
1246 "Characters constituting white space.
1247 These characters are ignored when differing regions are split into words.")
1248 (make-variable-buffer-local 'ediff-whitespace
)
1250 (defvar ediff-word-1
1251 (if (featurep 'xemacs
) "a-zA-Z---_" "-[:word:]_")
1252 "Characters that constitute words of type 1.
1253 More precisely, [ediff-word-1] is a regexp that matches type 1 words.
1254 See `ediff-forward-word' for more details.")
1255 (make-variable-buffer-local 'ediff-word-1
)
1257 (defvar ediff-word-2
"0-9.,"
1258 "Characters that constitute words of type 2.
1259 More precisely, [ediff-word-2] is a regexp that matches type 2 words.
1260 See `ediff-forward-word' for more details.")
1261 (make-variable-buffer-local 'ediff-word-2
)
1263 (defvar ediff-word-3
"`'?!:;\"{}[]()"
1264 "Characters that constitute words of type 3.
1265 More precisely, [ediff-word-3] is a regexp that matches type 3 words.
1266 See `ediff-forward-word' for more details.")
1267 (make-variable-buffer-local 'ediff-word-3
)
1269 (defvar ediff-word-4
1270 (concat "^" ediff-word-1 ediff-word-2 ediff-word-3 ediff-whitespace
)
1271 "Characters that constitute words of type 4.
1272 More precisely, [ediff-word-4] is a regexp that matches type 4 words.
1273 See `ediff-forward-word' for more details.")
1274 (make-variable-buffer-local 'ediff-word-4
)
1276 ;; Split region along word boundaries. Each word will be on its own line.
1277 ;; Output to buffer out-buffer.
1278 (defun ediff-forward-word ()
1279 "Move point one word forward.
1280 There are four types of words, each of which consists entirely of
1281 characters in `ediff-word-1', `ediff-word-2', `ediff-word-3', or
1282 `ediff-word-4'. Words are recognized by passing these one after another as
1283 arguments to `skip-chars-forward'."
1284 (or (> (+ (skip-chars-forward ediff-word-1
)
1285 (skip-syntax-forward "w"))
1287 (> (skip-chars-forward ediff-word-2
) 0)
1288 (> (skip-chars-forward ediff-word-3
) 0)
1289 (> (skip-chars-forward ediff-word-4
) 0)
1293 (defun ediff-wordify (beg end in-buffer out-buffer
&optional control-buf
)
1294 (let ((forward-word-function
1295 ;; eval in control buf to let user create local versions for
1296 ;; different invocations
1298 (ediff-with-current-buffer control-buf
1299 ediff-forward-word-function
)
1300 ediff-forward-word-function
))
1301 inbuf-syntax-tbl sv-point diff-string
)
1302 (with-current-buffer in-buffer
1303 (setq inbuf-syntax-tbl
1305 (ediff-with-current-buffer control-buf
1308 (setq diff-string
(buffer-substring-no-properties beg end
))
1310 (set-buffer out-buffer
)
1311 ;; Make sure that temp buff syntax table is the same as the original buf
1312 ;; syntax tbl, because we use ediff-forward-word in both and
1313 ;; ediff-forward-word depends on the syntax classes of characters.
1314 (set-syntax-table inbuf-syntax-tbl
)
1316 (insert diff-string
)
1317 (goto-char (point-min))
1318 (skip-chars-forward ediff-whitespace
)
1319 (delete-region (point-min) (point))
1322 (funcall forward-word-function
)
1323 (setq sv-point
(point))
1324 (skip-chars-forward ediff-whitespace
)
1325 (delete-region sv-point
(point))
1328 ;; copy string specified as BEG END from IN-BUF to OUT-BUF
1329 (defun ediff-copy-to-buffer (beg end in-buffer out-buffer
)
1330 (with-current-buffer out-buffer
1332 (insert-buffer-substring in-buffer beg end
)
1333 (goto-char (point-min))))
1336 ;; goto word #n starting at current position in buffer `buf'
1337 ;; For ediff, a word is determined by ediff-forward-word-function
1338 ;; If `flag' is non-nil, goto the end of the n-th word.
1339 (defun ediff-goto-word (n buf
&optional flag
)
1340 ;; remember val ediff-forward-word-function has in ctl buf
1341 (let ((fwd-word-fun ediff-forward-word-function
)
1342 (syntax-tbl ediff-syntax-table
))
1343 (ediff-with-current-buffer buf
1344 (skip-chars-forward ediff-whitespace
)
1345 (ediff-with-syntax-table syntax-tbl
1347 (funcall fwd-word-fun
)
1348 (skip-chars-forward ediff-whitespace
)
1350 (if (and flag
(> n
0))
1351 (funcall fwd-word-fun
)))
1354 (defun ediff-same-file-contents (f1 f2
)
1355 "Return t if files F1 and F2 have identical contents."
1356 (if (and (not (file-directory-p f1
))
1357 (not (file-directory-p f2
)))
1358 (if (equal (file-remote-p f1
) (file-remote-p f2
))
1360 ;; In the remote case, this works only if F1 and F2 are
1361 ;; located on the same remote host.
1362 (apply 'process-file ediff-cmp-program nil nil nil
1363 (append ediff-cmp-options
1364 (list (or (file-remote-p f1
'localname
)
1365 (expand-file-name f1
))
1366 (or (file-remote-p f2
'localname
)
1367 (expand-file-name f2
)))))
1369 (and (numberp res
) (eq res
0)))
1371 ;; F1 and F2 are not located on the same host.
1372 (let ((t1 (file-local-copy f1
))
1373 (t2 (file-local-copy f2
)))
1375 (ediff-same-file-contents (or t1 f1
) (or t2 f2
))
1376 (and t1
(delete-file t1
))
1377 (and t2
(delete-file t2
))))
1381 (defun ediff-same-contents (d1 d2
&optional filter-re
)
1382 "Return t if D1 and D2 have the same content.
1383 D1 and D2 can either be both directories or both regular files.
1384 Symlinks and the likes are not handled.
1385 If FILTER-RE is non-nil, recursive checking in directories
1386 affects only files whose names match the expression."
1387 ;; Normalize empty filter RE to nil.
1388 (unless (> (length filter-re
) 0) (setq filter-re nil
))
1389 ;; Indicate progress
1390 (message "Comparing '%s' and '%s' modulo '%s'" d1 d2 filter-re
)
1392 ;; D1 & D2 directories => recurse
1393 ((and (file-directory-p d1
)
1394 (file-directory-p d2
))
1395 (if (null ediff-recurse-to-subdirectories
)
1396 (if (y-or-n-p "Compare subdirectories recursively? ")
1397 (setq ediff-recurse-to-subdirectories
'yes
)
1398 (setq ediff-recurse-to-subdirectories
'no
)))
1399 (if (eq ediff-recurse-to-subdirectories
'yes
)
1400 (let* ((all-entries-1 (directory-files d1 t filter-re
))
1401 (all-entries-2 (directory-files d2 t filter-re
))
1402 (entries-1 (ediff-delete-all-matches "^\\.\\.?$" all-entries-1
))
1403 (entries-2 (ediff-delete-all-matches "^\\.\\.?$" all-entries-2
))
1406 (ediff-same-file-contents-lists entries-1 entries-2 filter-re
)
1408 ) ; end of the directories case
1409 ;; D1 & D2 are both files => compare directly
1410 ((and (file-regular-p d1
)
1411 (file-regular-p d2
))
1412 (ediff-same-file-contents d1 d2
))
1413 ;; Otherwise => false: unequal contents
1417 ;; If lists have the same length and names of files are pairwise equal
1418 ;; (removing the directories) then compare contents pairwise.
1419 ;; True if all contents are the same; false otherwise
1420 (defun ediff-same-file-contents-lists (entries-1 entries-2 filter-re
)
1421 ;; First, check only the names (works quickly and ensures a
1422 ;; precondition for subsequent code)
1423 (if (and (= (length entries-1
) (length entries-2
))
1424 (equal (mapcar 'file-name-nondirectory entries-1
)
1425 (mapcar 'file-name-nondirectory entries-2
)))
1426 ;; With name equality established, compare the entries
1427 ;; through recursion.
1429 (while (and entries-1 continue
)
1430 (if (ediff-same-contents
1431 (car entries-1
) (car entries-2
) filter-re
)
1432 (setq entries-1
(cdr entries-1
)
1433 entries-2
(cdr entries-2
))
1434 (setq continue nil
))
1436 ;; if reached the end then lists are equal
1442 ;; ARG1 is a regexp, ARG2 is a list of full-filenames
1443 ;; Delete all entries that match the regexp
1444 (defun ediff-delete-all-matches (regex file-list-list
)
1446 (while file-list-list
1447 (setq elt
(car file-list-list
))
1448 (or (string-match regex
(file-name-nondirectory elt
))
1449 (setq result
(cons elt result
)))
1450 (setq file-list-list
(cdr file-list-list
)))
1454 (defun ediff-set-actual-diff-options ()
1455 (if ediff-ignore-case
1456 (setq ediff-actual-diff-options
1457 (concat ediff-diff-options
" " ediff-ignore-case-option
)
1458 ediff-actual-diff3-options
1459 (concat ediff-diff3-options
" " ediff-ignore-case-option3
))
1460 (setq ediff-actual-diff-options ediff-diff-options
1461 ediff-actual-diff3-options ediff-diff3-options
)
1463 (setq-default ediff-actual-diff-options ediff-actual-diff-options
1464 ediff-actual-diff3-options ediff-actual-diff3-options
)
1468 ;; Ignore case handling - some ideas from drew.adams@@oracle.com
1469 (defun ediff-toggle-ignore-case ()
1471 (ediff-barf-if-not-control-buffer)
1472 (setq ediff-ignore-case
(not ediff-ignore-case
))
1473 (ediff-set-actual-diff-options)
1474 (if ediff-ignore-case
1475 (message "Ignoring regions that differ only in case")
1476 (message "Ignoring case differences turned OFF"))
1477 (cond (ediff-merge-job
1478 (message "Ignoring letter case is too dangerous in merge jobs"))
1479 ((and ediff-diff3-job
(string= ediff-ignore-case-option3
""))
1480 (message "Ignoring letter case is not supported by this diff3 program"))
1481 ((and (not ediff-3way-job
) (string= ediff-ignore-case-option
""))
1482 (message "Ignoring letter case is not supported by this diff program"))
1485 (ediff-update-diffs)))
1491 ;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1492 ;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1493 ;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1496 ;;; ediff-diff.el ends here