1 ;;; ediff-diff.el --- diff-related utilities
3 ;; Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4 ;; 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 ;; Free Software Foundation, Inc.
7 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software: you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation, either version 3 of the License, or
15 ;; (at your option) any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
33 (require 'ediff-util
))
37 (defgroup ediff-diff nil
38 "Diff related utilities."
42 (defcustom ediff-diff-program
"diff"
43 "Program to use for generating the differential of the two files."
46 (defcustom ediff-diff3-program
"diff3"
47 "Program to be used for three-way comparison.
48 Must produce output compatible with Unix's diff3 program."
53 ;; The following functions must precede all defcustom-defined variables.
55 (fset 'ediff-set-actual-diff-options
'(lambda () nil
))
57 (defcustom ediff-shell
58 (cond ((memq system-type
'(ms-dos windows-nt
))
59 shell-file-name
) ; no standard name on MS-DOS
61 "The shell used to run diff and patch.
62 If user's .profile or .cshrc files are set up correctly, any shell
63 will do. However, some people set $prompt or other things
64 incorrectly, which leads to undesirable output messages. These may
65 cause Ediff to fail. In such a case, set `ediff-shell' to a shell that
66 you are not using or, better, fix your shell's startup file."
70 (defcustom ediff-cmp-program
"cmp"
71 "Utility to use to determine if two files are identical.
72 It must return code 0, if its arguments are identical files."
76 (defcustom ediff-cmp-options nil
77 "Options to pass to `ediff-cmp-program'.
78 If GNU diff is used as `ediff-cmp-program', then the most useful options
79 are `-I REGEXP', to ignore changes whose lines match the REGEXP."
80 :type
'(repeat string
)
83 (defun ediff-set-diff-options (symbol value
)
85 (ediff-set-actual-diff-options))
87 (defcustom ediff-diff-options
88 (if (memq system-type
'(ms-dos windows-nt
)) "--binary" "")
89 "Options to pass to `ediff-diff-program'.
90 If Unix diff is used as `ediff-diff-program',
91 then a useful option is `-w', to ignore space.
92 Options `-c', `-u', and `-i' are not allowed. Case sensitivity can be
93 toggled interactively using \\[ediff-toggle-ignore-case].
95 Do not remove the default options. If you need to change this variable, add new
96 options after the default ones.
98 This variable is not for customizing the look of the differences produced by
99 the command \\[ediff-show-diff-output]. Use the variable
100 `ediff-custom-diff-options' for that."
101 :set
'ediff-set-diff-options
105 (ediff-defvar-local ediff-ignore-case nil
106 "*If t, skip over difference regions that differ only in letter case.
107 This variable can be set either in .emacs or toggled interactively.
108 Use `setq-default' if setting it in .emacs")
110 (defcustom ediff-ignore-case-option
"-i"
111 "Option that causes the diff program to ignore case of letters."
115 (defcustom ediff-ignore-case-option3
""
116 "Option that causes the diff3 program to ignore case of letters.
117 GNU diff3 doesn't have such an option."
121 ;; the actual options used in comparison
122 (ediff-defvar-local ediff-actual-diff-options ediff-diff-options
"")
124 (defcustom ediff-custom-diff-program ediff-diff-program
125 "Program to use for generating custom diff output for saving it in a file.
126 This output is not used by Ediff internally."
129 (defcustom ediff-custom-diff-options
"-c"
130 "Options to pass to `ediff-custom-diff-program'."
134 ;;; Support for diff3
136 (defvar ediff-match-diff3-line
"^====\\(.?\\)\C-m?$"
137 "Pattern to match lines produced by diff3 that describe differences.")
138 (defcustom ediff-diff3-options
""
139 "Options to pass to `ediff-diff3-program'."
140 :set
'ediff-set-diff-options
144 ;; the actual options used in comparison
145 (ediff-defvar-local ediff-actual-diff3-options ediff-diff3-options
"")
147 (defcustom ediff-diff3-ok-lines-regexp
148 "^\\([1-3]:\\|====\\| \\|.*Warning *:\\|.*No newline\\|.*missing newline\\|^\C-m$\\)"
149 "Regexp that matches normal output lines from `ediff-diff3-program'.
150 Lines that do not match are assumed to be error messages."
154 ;; keeps the status of the current diff in 3-way jobs.
155 ;; the status can be =diff(A), =diff(B), or =diff(A+B)
156 (ediff-defvar-local ediff-diff-status
"" "")
161 (ediff-defvar-local ediff-auto-refine
(if (ediff-has-face-support-p) 'on
'nix
)
162 "If `on', Ediff auto-highlights fine diffs for the current diff region.
163 If `off', auto-highlighting is not used. If `nix', no fine diffs are shown
164 at all, unless the user force-refines the region by hitting `*'.
166 This variable can be set either in .emacs or toggled interactively.
167 Use `setq-default' if setting it in .emacs")
169 (ediff-defvar-local ediff-ignore-similar-regions nil
170 "*If t, skip over difference regions that differ only in the white space and line breaks.
171 This variable can be set either in .emacs or toggled interactively.
172 Use `setq-default' if setting it in .emacs")
174 (ediff-defvar-local ediff-auto-refine-limit
14000
175 "*Auto-refine only the regions of this size \(in bytes\) or less.")
179 (defvar ediff-diff-ok-lines-regexp
182 "[0-9,]+[acd][0-9,]+\C-m?$"
187 "\\|.*missing +newline"
190 "Regexp that matches normal output lines from `ediff-diff-program'.
191 This is mostly lifted from Emerge, except that Ediff also considers
192 warnings and `Missing newline'-type messages to be normal output.
193 Lines that do not match are assumed to be error messages.")
195 (defvar ediff-match-diff-line
196 (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
197 (concat "^" x
"\\([acd]\\)" x
"\C-m?$"))
198 "Pattern to match lines produced by diff that describe differences.")
200 (ediff-defvar-local ediff-setup-diff-regions-function nil
201 "value is a function symbol depending on the kind of job is to be done.
202 For 2-way jobs and for ediff-merge, it should be `ediff-setup-diff-regions'.
203 For jobs requiring diff3, it should be `ediff-setup-diff-regions3'.
205 The function should take three mandatory arguments, file-A, file-B, and
206 file-C. It may ignore file C for diff2 jobs. It should also take
207 one optional arguments, diff-number to refine.")
212 ;; Generate the difference vector and overlays for the two files
213 ;; With optional arg REG-TO-REFINE, refine this region.
214 ;; File-C argument is not used here. It is there just because
215 ;; ediff-setup-diff-regions is called via a funcall to
216 ;; ediff-setup-diff-regions-function, which can also have the value
217 ;; ediff-setup-diff-regions3, which takes 4 arguments.
218 (defun ediff-setup-diff-regions (file-A file-B file-C
)
219 ;; looking for '-c', '-i', '-u', or 'c', 'i', 'u' among clustered non-long options
220 (if (string-match "^-[ciu]\\| -[ciu]\\|\\(^\\| \\)-[^- ]+[ciu]"
222 (error "Options `-c', `-u', and `-i' are not allowed in `ediff-diff-options'"))
224 ;; create, if it doesn't exist
225 (or (ediff-buffer-live-p ediff-diff-buffer
)
226 (setq ediff-diff-buffer
227 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
228 (ediff-make-diff2-buffer ediff-diff-buffer file-A file-B
)
229 (ediff-prepare-error-list ediff-diff-ok-lines-regexp ediff-diff-buffer
)
230 (ediff-convert-diffs-to-overlays
232 ediff-diff-buffer ediff-word-mode ediff-narrow-bounds
)))
234 ;; Run the diff program on FILE1 and FILE2 and put the output in DIFF-BUFFER
235 ;; Return the size of DIFF-BUFFER
236 ;; The return code isn't used in the program at present.
237 (defun ediff-make-diff2-buffer (diff-buffer file1 file2
)
238 (let ((file1-size (ediff-file-size file1
))
239 (file2-size (ediff-file-size file2
)))
240 (cond ((not (numberp file1-size
))
241 (message "Can't find file: %s"
242 (ediff-abbreviate-file-name file1
))
244 ;; 1 is an error exit code
246 ((not (numberp file2-size
))
247 (message "Can't find file: %s"
248 (ediff-abbreviate-file-name file2
))
250 ;; 1 is an error exit code
252 (t (message "Computing differences between %s and %s ..."
253 (file-name-nondirectory file1
)
254 (file-name-nondirectory file2
))
255 ;; this erases the diff buffer automatically
256 (ediff-exec-process ediff-diff-program
259 ediff-actual-diff-options file1 file2
)
261 (ediff-with-current-buffer diff-buffer
266 ;; If file-A/B/C is nil, do 2-way comparison with the non-nil buffers
267 ;; This function works for diff3 and diff2 jobs
268 (defun ediff-setup-fine-diff-regions (file-A file-B file-C reg-num
)
269 (or (ediff-buffer-live-p ediff-fine-diff-buffer
)
270 (setq ediff-fine-diff-buffer
272 (ediff-unique-buffer-name "*ediff-fine-diff" "*"))))
274 (let (diff3-job diff-program diff-options ok-regexp diff-list
)
275 (setq diff3-job ediff-3way-job
276 diff-program
(if diff3-job ediff-diff3-program ediff-diff-program
)
277 diff-options
(if diff3-job
278 ediff-actual-diff3-options
279 ediff-actual-diff-options
)
280 ok-regexp
(if diff3-job
281 ediff-diff3-ok-lines-regexp
282 ediff-diff-ok-lines-regexp
))
284 (ediff-message-if-verbose "Refining difference region %d ..." (1+ reg-num
))
285 (ediff-exec-process diff-program ediff-fine-diff-buffer
'synchronize
287 ;; The shuffle below is because we can compare 3-way
288 ;; or in several 2-way fashions, like fA fC, fA fB,
290 (if file-A file-A file-B
)
291 (if file-B file-B file-A
)
293 (if file-C file-C file-B
))
296 (ediff-prepare-error-list ok-regexp ediff-fine-diff-buffer
)
297 (ediff-message-if-verbose
299 ;; "Refining difference region %d ... done" (1+ reg-num))
303 (ediff-extract-diffs3
304 ediff-fine-diff-buffer
'3way-comparison
'word-mode
)
305 (ediff-extract-diffs ediff-fine-diff-buffer
'word-mode
)))
325 (ediff-convert-fine-diffs-to-overlays diff-list reg-num
)
329 (defun ediff-prepare-error-list (ok-regexp diff-buff
)
330 (or (ediff-buffer-live-p ediff-error-buffer
)
331 (setq ediff-error-buffer
332 (get-buffer-create (ediff-unique-buffer-name
333 "*ediff-errors" "*"))))
334 (ediff-with-current-buffer ediff-error-buffer
335 (setq buffer-undo-list t
)
337 (insert (ediff-with-current-buffer diff-buff
(buffer-string)))
338 (goto-char (point-min))
339 (delete-matching-lines ok-regexp
))
340 ;; If diff reports errors, show them then quit.
341 (if (/= 0 (ediff-with-current-buffer ediff-error-buffer
(buffer-size)))
342 (let ((ctl-buf ediff-control-buffer
)
343 (error-buf ediff-error-buffer
))
344 (ediff-skip-unsuitable-frames)
345 (switch-to-buffer error-buf
)
346 (ediff-kill-buffer-carefully ctl-buf
)
347 (error "Errors in diff output. Diff output is in %S" diff-buff
))))
349 ;; BOUNDS specifies visibility bounds to use.
350 ;; WORD-MODE tells whether we are in the word-mode or not.
351 ;; If WORD-MODE, also construct vector of diffs using word numbers.
352 ;; Else, use point values.
353 ;; This function handles diff-2 jobs including the case of
354 ;; merging buffers and files without ancestor.
355 (defun ediff-extract-diffs (diff-buffer word-mode
&optional bounds
)
356 (let ((A-buffer ediff-buffer-A
)
357 (B-buffer ediff-buffer-B
)
358 (C-buffer ediff-buffer-C
)
359 (a-prev 1) ; this is needed to set the first diff line correctly
365 diff-list shift-A shift-B
368 ;; diff list contains word numbers, unless changed later
369 (setq diff-list
(cons (if word-mode
'words
'points
)
371 ;; we don't use visibility bounds for buffer C when merging
375 (ediff-get-value-according-to-buffer-type 'A bounds
))
378 (ediff-get-value-according-to-buffer-type 'B bounds
))))
380 ;; reset point in buffers A/B/C
381 (ediff-with-current-buffer A-buffer
382 (goto-char (if shift-A shift-A
(point-min))))
383 (ediff-with-current-buffer B-buffer
384 (goto-char (if shift-B shift-B
(point-min))))
385 (if (ediff-buffer-live-p C-buffer
)
386 (ediff-with-current-buffer C-buffer
387 (goto-char (point-min))))
389 (ediff-with-current-buffer diff-buffer
390 (goto-char (point-min))
391 (while (re-search-forward ediff-match-diff-line nil t
)
392 (let* ((a-begin (string-to-number (buffer-substring (match-beginning 1)
394 (a-end (let ((b (match-beginning 3))
397 (string-to-number (buffer-substring b e
))
399 (diff-type (buffer-substring (match-beginning 4) (match-end 4)))
400 (b-begin (string-to-number (buffer-substring (match-beginning 5)
402 (b-end (let ((b (match-beginning 7))
405 (string-to-number (buffer-substring b e
))
407 a-begin-pt a-end-pt b-begin-pt b-end-pt
408 c-begin c-end c-begin-pt c-end-pt
)
409 ;; fix the beginning and end numbers, because diff is somewhat
410 ;; strange about how it numbers lines
411 (if (string-equal diff-type
"a")
412 (setq b-end
(1+ b-end
)
415 (if (string-equal diff-type
"d")
416 (setq a-end
(1+ a-end
)
419 ;; (string-equal diff-type "c")
420 (setq a-end
(1+ a-end
)
423 (if (eq ediff-default-variant
'default-B
)
424 (setq c-begin b-begin
426 (setq c-begin a-begin
429 ;; compute main diff vector
431 ;; make diff-list contain word numbers
435 (if (ediff-buffer-live-p C-buffer
)
436 (vector (- a-begin a-prev
) (- a-end a-begin
)
437 (- b-begin b-prev
) (- b-end b-begin
)
438 (- c-begin c-prev
) (- c-end c-begin
)
439 nil nil
; dummy ancestor
442 nil
; state of ancestor
444 (vector (- a-begin a-prev
) (- a-end a-begin
)
445 (- b-begin b-prev
) (- b-end b-begin
)
446 nil nil
; dummy buf C
447 nil nil
; dummy ancestor
450 nil
; state of ancestor
456 ;; else convert lines to points
457 (ediff-with-current-buffer A-buffer
458 (let ((longlines-mode-val
459 (if (and (boundp 'longlines-mode
) longlines-mode
) 1 0)))
460 ;; we must disable and then restore longlines-mode
461 (if (eq longlines-mode-val
1)
463 (goto-char (or a-prev-pt shift-A
(point-min)))
464 (forward-line (- a-begin a-prev
))
465 (setq a-begin-pt
(point))
466 (forward-line (- a-end a-begin
))
467 (setq a-end-pt
(point)
470 (if (eq longlines-mode-val
1)
471 (longlines-mode longlines-mode-val
))
473 (ediff-with-current-buffer B-buffer
474 (let ((longlines-mode-val
475 (if (and (boundp 'longlines-mode
) longlines-mode
) 1 0)))
476 (if (eq longlines-mode-val
1)
478 (goto-char (or b-prev-pt shift-B
(point-min)))
479 (forward-line (- b-begin b-prev
))
480 (setq b-begin-pt
(point))
481 (forward-line (- b-end b-begin
))
482 (setq b-end-pt
(point)
485 (if (eq longlines-mode-val
1)
486 (longlines-mode longlines-mode-val
))
488 (if (ediff-buffer-live-p C-buffer
)
489 (ediff-with-current-buffer C-buffer
490 (let ((longlines-mode-val
491 (if (and (boundp 'longlines-mode
) longlines-mode
) 1 0)))
492 (if (eq longlines-mode-val
1)
494 (goto-char (or c-prev-pt
(point-min)))
495 (forward-line (- c-begin c-prev
))
496 (setq c-begin-pt
(point))
497 (forward-line (- c-end c-begin
))
498 (setq c-end-pt
(point)
501 (if (eq longlines-mode-val
1)
502 (longlines-mode longlines-mode-val
))
508 (if (ediff-buffer-live-p C-buffer
)
510 a-begin-pt a-end-pt b-begin-pt b-end-pt
512 nil nil
; dummy ancestor
514 ;; shows which buff is different from the other two
515 (if (eq ediff-default-variant
'default-B
) 'A
'B
)
516 ediff-default-variant
; state of merge
517 nil
; state of ancestor
519 (vector a-begin-pt a-end-pt
521 nil nil
; dummy buf C
522 nil nil
; dummy ancestor
523 nil nil
; dummy state of diff & merge
524 nil
; dummy state of ancestor
528 ))) ; end ediff-with-current-buffer
533 (defun ediff-convert-diffs-to-overlays (diff-list)
534 (ediff-set-diff-overlays-in-one-buffer 'A diff-list
)
535 (ediff-set-diff-overlays-in-one-buffer 'B diff-list
)
537 (ediff-set-diff-overlays-in-one-buffer 'C diff-list
))
538 (if ediff-merge-with-ancestor-job
539 (ediff-set-diff-overlays-in-one-buffer 'Ancestor diff-list
))
540 ;; set up vector showing the status of merge regions
542 (setq ediff-state-of-merge
544 (mapcar (lambda (elt)
545 (let ((state-of-merge (aref elt
9))
546 (state-of-ancestor (aref elt
10)))
548 ;; state of merge: prefers/default-A/B or combined
549 (if state-of-merge
(format "%S" state-of-merge
))
550 ;; whether the ancestor region is empty
552 ;; the first elt designates type of list
555 (message "Processing difference regions ... done"))
558 (defun ediff-set-diff-overlays-in-one-buffer (buf-type diff-list
)
559 (let* ((current-diff -
1)
560 (buff (ediff-get-buffer buf-type
))
561 (ctl-buf ediff-control-buffer
)
562 ;; ediff-extract-diffs puts the type of diff-list as the first elt
563 ;; of this list. The type is either 'points or 'words
564 (diff-list-type (car diff-list
))
565 (shift (ediff-overlay-start
566 (ediff-get-value-according-to-buffer-type
567 buf-type ediff-narrow-bounds
)))
568 (limit (ediff-overlay-end
569 (ediff-get-value-according-to-buffer-type
570 buf-type ediff-narrow-bounds
)))
571 diff-overlay-list list-element total-diffs
572 begin end pt-saved overlay state-of-diff
)
574 (setq diff-list
(cdr diff-list
)) ; discard diff list type
575 (setq total-diffs
(length diff-list
))
577 ;; shift, if necessary
578 (ediff-with-current-buffer buff
(setq pt-saved shift
))
581 (setq current-diff
(1+ current-diff
)
582 list-element
(car diff-list
)
583 begin
(aref list-element
(cond ((eq buf-type
'A
) 0)
587 end
(aref list-element
(cond ((eq buf-type
'A
) 1)
591 state-of-diff
(aref list-element
8)
594 (cond ((and (not (eq buf-type state-of-diff
))
595 (not (eq buf-type
'Ancestor
))
596 (memq state-of-diff
'(A B C
)))
598 (car (delq buf-type
(delq state-of-diff
(list 'A
'B
'C
)))))
599 (setq state-of-diff
(format "=diff(%S)" state-of-diff
))
601 (t (setq state-of-diff nil
)))
603 ;; Put overlays at appropriate places in buffer
604 ;; convert word numbers to points, if necessary
605 (if (eq diff-list-type
'words
)
607 (ediff-with-current-buffer buff
(goto-char pt-saved
))
608 (ediff-with-current-buffer ctl-buf
609 (setq begin
(ediff-goto-word (1+ begin
) buff
)
610 end
(ediff-goto-word end buff
'end
)))
611 (if (> end limit
) (setq end limit
))
612 (if (> begin end
) (setq begin end
))
613 (setq pt-saved
(ediff-with-current-buffer buff
(point)))))
614 (setq overlay
(ediff-make-bullet-proof-overlay begin end buff
))
616 (ediff-overlay-put overlay
'priority ediff-shadow-overlay-priority
)
617 (ediff-overlay-put overlay
'ediff-diff-num current-diff
)
618 (if (and (ediff-has-face-support-p)
619 ediff-use-faces ediff-highlight-all-diffs
)
620 (ediff-set-overlay-face
621 overlay
(ediff-background-face buf-type current-diff
)))
623 (if (= 0 (mod current-diff
10))
624 (message "Buffer %S: Processing difference region %d of %d"
625 buf-type current-diff total-diffs
))
626 ;; Record all overlays for this difference.
627 ;; The 2-d elt, nil, is a place holder for the fine diff vector.
628 ;; The 3-d elt, nil, is a place holder for no-fine-diffs flag.
629 ;; The 4-th elt says which diff region is different from the other two
630 ;; (3-way jobs only).
631 (setq diff-overlay-list
634 (list (vector overlay nil nil state-of-diff
)))
639 (set (ediff-get-symbol-from-alist buf-type ediff-difference-vector-alist
)
640 (vconcat diff-overlay-list
))
643 ;; `n' is the diff region to work on. Default is ediff-current-difference.
644 ;; if `flag' is 'noforce then make fine-diffs only if this region's fine
645 ;; diffs have not been computed before.
646 ;; if `flag' is 'skip then don't compute fine diffs for this region.
647 (defun ediff-make-fine-diffs (&optional n flag
)
648 (or n
(setq n ediff-current-difference
))
650 (if (< ediff-number-of-differences
1)
651 (error ediff-NO-DIFFERENCES
))
655 ediff-auto-refine
'nix
))
658 (>= n ediff-number-of-differences
)
659 ;; n is within the range
660 (let ((tmp-buffer (get-buffer-create ediff-tmp-buffer
))
661 (file-A ediff-temp-file-A
)
662 (file-B ediff-temp-file-B
)
663 (file-C ediff-temp-file-C
)
664 (empty-A (ediff-empty-diff-region-p n
'A
))
665 (empty-B (ediff-empty-diff-region-p n
'B
))
666 (empty-C (ediff-empty-diff-region-p n
'C
))
667 (whitespace-A (ediff-whitespace-diff-region-p n
'A
))
668 (whitespace-B (ediff-whitespace-diff-region-p n
'B
))
669 (whitespace-C (ediff-whitespace-diff-region-p n
'C
))
670 cumulative-fine-diff-length
)
672 (cond ;; If one of the regions is empty (or 2 in 3way comparison)
673 ;; then don't refine.
674 ;; If the region happens to be entirely whitespace or empty then
676 ((> (length (delq nil
(list empty-A empty-B empty-C
))) 1)
677 (if (and (ediff-looks-like-combined-merge n
)
679 (ediff-set-fine-overlays-in-one-buffer 'C nil n
))
680 (if ediff-3way-comparison-job
681 (ediff-message-if-verbose
682 "Region %d is empty in all buffers but %S"
684 (cond ((not empty-A
) 'A
)
687 (ediff-message-if-verbose
688 "Region %d in buffer %S is empty"
694 ;; if all regions happen to be whitespace
695 (if (and whitespace-A whitespace-B whitespace-C
)
696 ;; mark as space only
697 (ediff-mark-diff-as-space-only n t
)
698 ;; if some regions are white and others don't, then mark as
699 ;; non-white-space-only
700 (ediff-mark-diff-as-space-only n nil
)))
702 ;; don't compute fine diffs if diff vector exists
703 ((and (eq flag
'noforce
) (ediff-get-fine-diff-vector n
'A
))
704 (if (ediff-no-fine-diffs-p n
)
706 "Only white-space differences in region %d %s"
708 (cond ((eq (ediff-no-fine-diffs-p n
) 'A
)
710 ((eq (ediff-no-fine-diffs-p n
) 'B
)
712 ((eq (ediff-no-fine-diffs-p n
) 'C
)
715 ;; don't compute fine diffs for this region
717 (or (ediff-get-fine-diff-vector n
'A
)
718 (memq ediff-auto-refine
'(off nix
))
719 (ediff-message-if-verbose
720 "Region %d exceeds the auto-refinement limit. Type `%s' to refine"
722 (substitute-command-keys
723 "\\[ediff-make-or-kill-fine-diffs]")
726 ;; recompute fine diffs
728 (ediff-get-diff-posn 'A
'beg n
)
729 (ediff-get-diff-posn 'A
'end n
)
732 ediff-control-buffer
)
734 (ediff-make-temp-file tmp-buffer
"fineDiffA" file-A
))
737 (ediff-get-diff-posn 'B
'beg n
)
738 (ediff-get-diff-posn 'B
'end n
)
741 ediff-control-buffer
)
743 (ediff-make-temp-file tmp-buffer
"fineDiffB" file-B
))
748 (ediff-get-diff-posn 'C
'beg n
)
749 (ediff-get-diff-posn 'C
'end n
)
752 ediff-control-buffer
)
754 (ediff-make-temp-file
755 tmp-buffer
"fineDiffC" file-C
))))
757 ;; save temp file names.
758 (setq ediff-temp-file-A file-A
759 ediff-temp-file-B file-B
760 ediff-temp-file-C file-C
)
762 ;; set the new vector of fine diffs, if none exists
763 (cond ((and ediff-3way-job whitespace-A
)
764 (ediff-setup-fine-diff-regions nil file-B file-C n
))
765 ((and ediff-3way-job whitespace-B
)
766 (ediff-setup-fine-diff-regions file-A nil file-C n
))
768 ;; In merge-jobs, whitespace-C is t, since
769 ;; ediff-empty-diff-region-p returns t in this case
771 (ediff-setup-fine-diff-regions file-A file-B nil n
))
773 (ediff-setup-fine-diff-regions file-A file-B file-C n
)))
775 (setq cumulative-fine-diff-length
776 (+ (length (ediff-get-fine-diff-vector n
'A
))
777 (length (ediff-get-fine-diff-vector n
'B
))
778 ;; in merge jobs, the merge buffer is never refined
779 (if (and file-C
(not ediff-merge-job
))
780 (length (ediff-get-fine-diff-vector n
'C
))
784 ;; all regions are white space
785 (and whitespace-A whitespace-B whitespace-C
)
786 ;; none is white space and no fine diffs detected
787 (and (not whitespace-A
)
789 (not (and ediff-3way-job whitespace-C
))
790 (eq cumulative-fine-diff-length
0)))
791 (ediff-mark-diff-as-space-only n t
)
792 (ediff-message-if-verbose
793 "Only white-space differences in region %d" (1+ n
)))
794 ((eq cumulative-fine-diff-length
0)
795 (ediff-message-if-verbose
796 "Only white-space differences in region %d %s"
798 (cond (whitespace-A (ediff-mark-diff-as-space-only n
'A
)
800 (whitespace-B (ediff-mark-diff-as-space-only n
'B
)
802 (whitespace-C (ediff-mark-diff-as-space-only n
'C
)
803 "in buffers A & B"))))
805 (ediff-mark-diff-as-space-only n nil
)))
808 (ediff-set-fine-diff-properties n
)
811 ;; Interface to ediff-make-fine-diffs. Checks for auto-refine limit, etc.
812 (defun ediff-install-fine-diff-if-necessary (n)
813 (cond ((and (eq ediff-auto-refine
'on
)
815 (not (eq ediff-highlighting-style
'off
))
816 (not (eq ediff-highlighting-style
'ascii
)))
818 (> ediff-auto-refine-limit
819 (- (ediff-get-diff-posn 'A
'end n
)
820 (ediff-get-diff-posn 'A
'beg n
)))
821 (> ediff-auto-refine-limit
822 (- (ediff-get-diff-posn 'B
'end n
)
823 (ediff-get-diff-posn 'B
'beg n
))))
824 (ediff-make-fine-diffs n
'noforce
)
825 (ediff-make-fine-diffs n
'skip
)))
827 ;; highlight if fine diffs already exist
828 ((eq ediff-auto-refine
'off
)
829 (ediff-make-fine-diffs n
'skip
))))
832 ;; if fine diff vector is not set for diff N, then do nothing
833 (defun ediff-set-fine-diff-properties (n &optional default
)
834 (or (not (ediff-has-face-support-p))
836 (>= n ediff-number-of-differences
)
837 ;; when faces are supported, set faces and priorities of fine overlays
839 (ediff-set-fine-diff-properties-in-one-buffer 'A n default
)
840 (ediff-set-fine-diff-properties-in-one-buffer 'B n default
)
842 (ediff-set-fine-diff-properties-in-one-buffer 'C n default
)))))
844 (defun ediff-set-fine-diff-properties-in-one-buffer (buf-type
846 (let ((fine-diff-vector (ediff-get-fine-diff-vector n buf-type
))
849 (ediff-get-symbol-from-alist
850 buf-type ediff-fine-diff-face-alist
)
852 (priority (if default
854 (1+ (or (ediff-overlay-get
856 (ediff-get-symbol-from-alist
858 ediff-current-diff-overlay-alist
))
861 (mapcar (lambda (overl)
862 (ediff-set-overlay-face overl face
)
863 (ediff-overlay-put overl
'priority priority
))
866 ;; Set overlays over the regions that denote delimiters
867 (defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num
)
868 (let (overlay overlay-list
)
872 (ediff-make-bullet-proof-overlay
873 (nth 0 diff-list
) (nth 1 diff-list
) ediff-buffer-C
))
875 (setq overlay-list
(cons overlay overlay-list
))
876 (if (> (length diff-list
) 1)
877 (setq diff-list
(cdr (cdr diff-list
)))
878 (error "ediff-set-fine-overlays-for-combined-merge: corrupt list of
881 (setq overlay-list
(reverse overlay-list
))
882 (ediff-set-fine-diff-vector
883 reg-num
'C
(apply 'vector overlay-list
))
887 ;; Convert diff list to overlays for a given DIFF-REGION
888 ;; in buffer of type BUF-TYPE
889 (defun ediff-set-fine-overlays-in-one-buffer (buf-type diff-list region-num
)
890 (let* ((current-diff -
1)
891 (reg-start (ediff-get-diff-posn buf-type
'beg region-num
))
892 (buff (ediff-get-buffer buf-type
))
893 (ctl-buf ediff-control-buffer
)
894 combined-merge-diff-list
895 diff-overlay-list list-element
898 (ediff-clear-fine-differences-in-one-buffer region-num buf-type
)
899 (setq diff-list
(cdr diff-list
)) ; discard list type (words or points)
900 (ediff-with-current-buffer buff
(goto-char reg-start
))
902 ;; if it is a combined merge then set overlays in buff C specially
903 (if (and ediff-merge-job
(eq buf-type
'C
)
904 (setq combined-merge-diff-list
905 (ediff-looks-like-combined-merge region-num
)))
906 (ediff-set-fine-overlays-for-combined-merge
907 combined-merge-diff-list region-num
)
910 (setq current-diff
(1+ current-diff
)
911 list-element
(car diff-list
)
912 begin
(aref list-element
(cond ((eq buf-type
'A
) 0)
915 end
(aref list-element
(cond ((eq buf-type
'A
) 1)
918 (if (not (or begin end
))
920 ;; Put overlays at appropriate places in buffers
921 ;; convert lines to points, if necessary
922 (ediff-with-current-buffer ctl-buf
923 (setq begin
(ediff-goto-word (1+ begin
) buff
)
924 end
(ediff-goto-word end buff
'end
)))
925 (setq overlay
(ediff-make-bullet-proof-overlay begin end buff
))
926 ;; record all overlays for this difference region
927 (setq diff-overlay-list
(nconc diff-overlay-list
(list overlay
))))
929 (setq diff-list
(cdr diff-list
))
931 ;; convert the list of difference information into a vector
933 (ediff-set-fine-diff-vector
934 region-num buf-type
(vconcat diff-overlay-list
))
938 (defun ediff-convert-fine-diffs-to-overlays (diff-list region-num
)
939 (ediff-set-fine-overlays-in-one-buffer 'A diff-list region-num
)
940 (ediff-set-fine-overlays-in-one-buffer 'B diff-list region-num
)
942 (ediff-set-fine-overlays-in-one-buffer 'C diff-list region-num
)
946 ;; Stolen from emerge.el
947 (defun ediff-get-diff3-group (file)
948 ;; This save-excursion allows ediff-get-diff3-group to be called for the
949 ;; various groups of lines (1, 2, 3) in any order, and for the lines to
950 ;; appear in any order. The reason this is necessary is that Gnu diff3
951 ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
954 (concat "^" file
":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)\C-m?$"))
955 (beginning-of-line 2)
956 ;; treatment depends on whether it is an "a" group or a "c" group
957 (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
959 (if (match-beginning 2)
960 ;; it has two numbers
961 (list (string-to-number
962 (buffer-substring (match-beginning 1) (match-end 1)))
963 (1+ (string-to-number
964 (buffer-substring (match-beginning 3) (match-end 3)))))
966 (let ((x (string-to-number
967 (buffer-substring (match-beginning 1) (match-end 1)))))
969 ;; it is an "a" group
970 (let ((x (1+ (string-to-number
971 (buffer-substring (match-beginning 1) (match-end 1))))))
975 ;; If WORD-MODE, construct vector of diffs using word numbers.
976 ;; Else, use point values.
977 ;; WORD-MODE also tells if we are in the word-mode or not.
978 ;; If THREE-WAY-COMP, then it is a 3-way comparison. Else, it is merging
979 ;; with ancestor, in which case buffer-C contents is identical to buffer-A/B,
980 ;; contents (unless buffer-A is narrowed) depending on ediff-default-variant's
982 ;; BOUNDS specifies visibility bounds to use.
983 (defun ediff-extract-diffs3 (diff-buffer word-mode three-way-comp
985 (let ((A-buffer ediff-buffer-A
)
986 (B-buffer ediff-buffer-B
)
987 (C-buffer ediff-buffer-C
)
988 (anc-buffer ediff-ancestor-buffer
)
989 (a-prev 1) ; needed to set the first diff line correctly
996 diff-list shift-A shift-B shift-C
999 ;; diff list contains word numbers or points, depending on word-mode
1000 (setq diff-list
(cons (if word-mode
'words
'points
)
1004 (ediff-overlay-start
1005 (ediff-get-value-according-to-buffer-type 'A bounds
))
1007 (ediff-overlay-start
1008 (ediff-get-value-according-to-buffer-type 'B bounds
))
1011 (ediff-overlay-start
1012 (ediff-get-value-according-to-buffer-type 'C bounds
)))))
1014 ;; reset point in buffers A, B, C
1015 (ediff-with-current-buffer A-buffer
1016 (goto-char (if shift-A shift-A
(point-min))))
1017 (ediff-with-current-buffer B-buffer
1018 (goto-char (if shift-B shift-B
(point-min))))
1020 (ediff-with-current-buffer C-buffer
1021 (goto-char (if shift-C shift-C
(point-min)))))
1022 (if (ediff-buffer-live-p anc-buffer
)
1023 (ediff-with-current-buffer anc-buffer
1024 (goto-char (point-min))))
1026 (ediff-with-current-buffer diff-buffer
1027 (goto-char (point-min))
1028 (while (re-search-forward ediff-match-diff3-line nil t
)
1029 ;; leave point after matched line
1030 (beginning-of-line 2)
1031 (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
1032 ;; if the files A and B are the same and not 3way-comparison,
1033 ;; ignore the difference
1034 (if (or three-way-comp
(not (string-equal agreement
"3")))
1035 (let* ((a-begin (car (ediff-get-diff3-group "1")))
1036 (a-end (nth 1 (ediff-get-diff3-group "1")))
1037 (b-begin (car (ediff-get-diff3-group "2")))
1038 (b-end (nth 1 (ediff-get-diff3-group "2")))
1039 (c-or-anc-begin (car (ediff-get-diff3-group "3")))
1040 (c-or-anc-end (nth 1 (ediff-get-diff3-group "3")))
1042 (cond ((string-equal agreement
"1") 'prefer-A
)
1043 ((string-equal agreement
"2") 'prefer-B
)
1044 (t ediff-default-variant
)))
1045 (state-of-diff-merge
1046 (if (memq state-of-merge
'(default-A prefer-A
)) 'B
'A
))
1047 (state-of-diff-comparison
1048 (cond ((string-equal agreement
"1") 'A
)
1049 ((string-equal agreement
"2") 'B
)
1050 ((string-equal agreement
"3") 'C
)))
1056 anc-begin-pt anc-end-pt
)
1058 (setq state-of-ancestor
1059 (= c-or-anc-begin c-or-anc-end
))
1061 (cond (three-way-comp
1062 (setq c-begin c-or-anc-begin
1063 c-end c-or-anc-end
))
1064 ((eq ediff-default-variant
'default-B
)
1065 (setq c-begin b-begin
1068 (setq c-begin a-begin
1071 ;; compute main diff vector
1073 ;; make diff-list contain word numbers
1077 (- a-begin a-prev
) (- a-end a-begin
)
1078 (- b-begin b-prev
) (- b-end b-begin
)
1079 (- c-begin c-prev
) (- c-end c-begin
)
1080 nil nil
; dummy ancestor
1082 nil
; state of merge
1083 nil
; state of ancestor
1088 ;; else convert lines to points
1089 (ediff-with-current-buffer A-buffer
1090 (let ((longlines-mode-val
1091 (if (and (boundp 'longlines-mode
) longlines-mode
) 1 0)))
1092 ;; we must disable and then restore longlines-mode
1093 (if (eq longlines-mode-val
1)
1095 (goto-char (or a-prev-pt shift-A
(point-min)))
1096 (forward-line (- a-begin a-prev
))
1097 (setq a-begin-pt
(point))
1098 (forward-line (- a-end a-begin
))
1099 (setq a-end-pt
(point)
1102 (if (eq longlines-mode-val
1)
1103 (longlines-mode longlines-mode-val
))
1105 (ediff-with-current-buffer B-buffer
1106 (let ((longlines-mode-val
1107 (if (and (boundp 'longlines-mode
) longlines-mode
) 1 0)))
1108 (if (eq longlines-mode-val
1)
1110 (goto-char (or b-prev-pt shift-B
(point-min)))
1111 (forward-line (- b-begin b-prev
))
1112 (setq b-begin-pt
(point))
1113 (forward-line (- b-end b-begin
))
1114 (setq b-end-pt
(point)
1117 (if (eq longlines-mode-val
1)
1118 (longlines-mode longlines-mode-val
))
1120 (ediff-with-current-buffer C-buffer
1121 (let ((longlines-mode-val
1122 (if (and (boundp 'longlines-mode
) longlines-mode
) 1 0)))
1123 (if (eq longlines-mode-val
1)
1125 (goto-char (or c-prev-pt shift-C
(point-min)))
1126 (forward-line (- c-begin c-prev
))
1127 (setq c-begin-pt
(point))
1128 (forward-line (- c-end c-begin
))
1129 (setq c-end-pt
(point)
1132 (if (eq longlines-mode-val
1)
1133 (longlines-mode longlines-mode-val
))
1135 (if (ediff-buffer-live-p anc-buffer
)
1136 (ediff-with-current-buffer anc-buffer
1137 (let ((longlines-mode-val
1138 (if (and (boundp 'longlines-mode
) longlines-mode
) 1 0)))
1139 (if (eq longlines-mode-val
1)
1141 (forward-line (- c-or-anc-begin anc-prev
))
1142 (setq anc-begin-pt
(point))
1143 (forward-line (- c-or-anc-end c-or-anc-begin
))
1144 (setq anc-end-pt
(point)
1145 anc-prev c-or-anc-end
)
1146 (if (eq longlines-mode-val
1)
1147 (longlines-mode longlines-mode-val
))
1152 ;; if comparing with ancestor, then there also is a
1153 ;; state-of-difference marker
1159 nil nil
; ancestor begin/end
1160 state-of-diff-comparison
1161 nil
; state of merge
1162 nil
; state of ancestor
1164 (list (vector a-begin-pt a-end-pt
1167 anc-begin-pt anc-end-pt
1175 ))) ; end ediff-with-current-buffer
1179 ;; Generate the difference vector and overlays for three files
1180 ;; File-C is either the third file to compare (in case of 3-way comparison)
1181 ;; or it is the ancestor file.
1182 (defun ediff-setup-diff-regions3 (file-A file-B file-C
)
1183 ;; looking for '-i' or a 'i' among clustered non-long options
1184 (if (string-match "^-i\\| -i\\|\\(^\\| \\)-[^- ]+i" ediff-diff-options
)
1185 (error "Option `-i' is not allowed in `ediff-diff3-options'"))
1187 (or (ediff-buffer-live-p ediff-diff-buffer
)
1188 (setq ediff-diff-buffer
1189 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
1191 (message "Computing differences ...")
1192 (ediff-exec-process ediff-diff3-program ediff-diff-buffer
'synchronize
1193 ediff-actual-diff3-options file-A file-B file-C
)
1195 (ediff-prepare-error-list ediff-diff3-ok-lines-regexp ediff-diff-buffer
)
1196 ;;(message "Computing differences ... done")
1197 (ediff-convert-diffs-to-overlays
1198 (ediff-extract-diffs3
1200 ediff-word-mode ediff-3way-comparison-job ediff-narrow-bounds
)
1204 ;; Execute PROGRAM asynchronously, unless OS/2, Windows-*, or DOS, or unless
1205 ;; SYNCH is non-nil. BUFFER must be a buffer object, and must be alive. The
1206 ;; OPTIONS arg is a list of options to pass to PROGRAM. It may be a blank
1207 ;; string. All elements in FILES must be strings. We also delete nil from
1209 (defun ediff-exec-process (program buffer synch options
&rest files
)
1210 (let ((data (match-data))
1211 ;; If this is a buffer job, we are diffing temporary files
1212 ;; produced by Emacs with ediff-coding-system-for-write, so
1213 ;; use the same encoding to read the results.
1214 (coding-system-for-read
1215 (if (string-match "buffer" (symbol-name ediff-job-name
))
1216 ediff-coding-system-for-write
1217 ediff-coding-system-for-read
))
1219 (setq args
(append (split-string options
) files
))
1220 (setq args
(delete "" (delq nil args
))) ; delete nil and "" from arguments
1221 ;; the --binary option, if present, should be used only for buffer jobs
1222 ;; or for refining the differences
1223 (or (string-match "buffer" (symbol-name ediff-job-name
))
1224 (eq buffer ediff-fine-diff-buffer
)
1225 (setq args
(delete "--binary" args
)))
1227 (let ((directory default-directory
)
1229 (with-current-buffer buffer
1231 (setq default-directory directory
)
1232 (if (or (memq system-type
'(ms-dos windows-nt
))
1234 ;; In Windows do it synchronously, since Windows doesn't let us
1235 ;; delete files used by other processes. Thus, in ediff-buffers
1236 ;; and similar functions, we can't delete temp files because
1237 ;; they might be used by the asynch process that computes
1238 ;; custom diffs. So, we have to wait till custom diff
1239 ;; subprocess is done.
1240 ;; In DOS, must synchronize because DOS doesn't have
1241 ;; asynchronous processes.
1242 (apply 'call-process program nil buffer nil args
)
1243 ;; On other systems, do it asynchronously.
1244 (setq proc
(get-buffer-process buffer
))
1245 (if proc
(kill-process proc
))
1247 (apply 'start-process
"Custom Diff" buffer program args
))
1248 (setq mode-line-process
'(":%s"))
1249 (set-process-sentinel proc
'ediff-process-sentinel
)
1250 (set-process-filter proc
'ediff-process-filter
)
1252 (store-match-data data
))))
1254 ;; This is shell-command-filter from simple.el in Emacs.
1255 ;; Copied here because XEmacs doesn't have it.
1256 (defun ediff-process-filter (proc string
)
1257 ;; Do save-excursion by hand so that we can leave point numerically unchanged
1258 ;; despite an insertion immediately after it.
1259 (let* ((obuf (current-buffer))
1260 (buffer (process-buffer proc
))
1262 (window (get-buffer-window buffer
))
1263 (pos (window-start window
)))
1267 (or (= (point) (point-max))
1268 (setq opoint
(point)))
1269 (goto-char (point-max))
1270 (insert-before-markers string
))
1271 ;; insert-before-markers moved this marker: set it back.
1272 (set-window-start window pos
)
1273 ;; Finish our save-excursion.
1276 (set-buffer obuf
))))
1278 ;; like shell-command-sentinel but doesn't print an exit status message
1279 ;; we do this because diff always exits with status 1, if diffs are found
1280 ;; so shell-command-sentinel displays a confusing message to the user
1281 (defun ediff-process-sentinel (process signal
)
1282 (if (and (memq (process-status process
) '(exit signal
))
1283 (buffer-name (process-buffer process
)))
1285 (with-current-buffer (process-buffer process
)
1286 (setq mode-line-process nil
))
1287 (delete-process process
))))
1290 ;;; Word functions used to refine the current diff
1292 (defvar ediff-forward-word-function
'ediff-forward-word
1293 "*Function to call to move to the next word.
1294 Used for splitting difference regions into individual words.")
1295 (make-variable-buffer-local 'ediff-forward-word-function
)
1297 ;; \240 is unicode symbol for nonbreakable whitespace
1298 (defvar ediff-whitespace
" \n\t\f\r\240"
1299 "*Characters constituting white space.
1300 These characters are ignored when differing regions are split into words.")
1301 (make-variable-buffer-local 'ediff-whitespace
)
1303 (defvar ediff-word-1
1304 (if (featurep 'xemacs
) "a-zA-Z---_" "-[:word:]_")
1305 "*Characters that constitute words of type 1.
1306 More precisely, [ediff-word-1] is a regexp that matches type 1 words.
1307 See `ediff-forward-word' for more details.")
1308 (make-variable-buffer-local 'ediff-word-1
)
1310 (defvar ediff-word-2
"0-9.,"
1311 "*Characters that constitute words of type 2.
1312 More precisely, [ediff-word-2] is a regexp that matches type 2 words.
1313 See `ediff-forward-word' for more details.")
1314 (make-variable-buffer-local 'ediff-word-2
)
1316 (defvar ediff-word-3
"`'?!:;\"{}[]()"
1317 "*Characters that constitute words of type 3.
1318 More precisely, [ediff-word-3] is a regexp that matches type 3 words.
1319 See `ediff-forward-word' for more details.")
1320 (make-variable-buffer-local 'ediff-word-3
)
1322 (defvar ediff-word-4
1323 (concat "^" ediff-word-1 ediff-word-2 ediff-word-3 ediff-whitespace
)
1324 "*Characters that constitute words of type 4.
1325 More precisely, [ediff-word-4] is a regexp that matches type 4 words.
1326 See `ediff-forward-word' for more details.")
1327 (make-variable-buffer-local 'ediff-word-4
)
1329 ;; Split region along word boundaries. Each word will be on its own line.
1330 ;; Output to buffer out-buffer.
1331 (defun ediff-forward-word ()
1332 "Move point one word forward.
1333 There are four types of words, each of which consists entirely of
1334 characters in `ediff-word-1', `ediff-word-2', `ediff-word-3', or
1335 `ediff-word-4'. Words are recognized by passing these one after another as
1336 arguments to `skip-chars-forward'."
1337 (or (> (+ (skip-chars-forward ediff-word-1
)
1338 (skip-syntax-forward "w"))
1340 (> (skip-chars-forward ediff-word-2
) 0)
1341 (> (skip-chars-forward ediff-word-3
) 0)
1342 (> (skip-chars-forward ediff-word-4
) 0)
1346 (defun ediff-wordify (beg end in-buffer out-buffer
&optional control-buf
)
1347 (let ((forward-word-function
1348 ;; eval in control buf to let user create local versions for
1349 ;; different invocations
1351 (ediff-with-current-buffer control-buf
1352 ediff-forward-word-function
)
1353 ediff-forward-word-function
))
1354 inbuf-syntax-tbl sv-point diff-string
)
1355 (with-current-buffer in-buffer
1356 (setq inbuf-syntax-tbl
1358 (ediff-with-current-buffer control-buf
1361 (setq diff-string
(buffer-substring-no-properties beg end
))
1363 (set-buffer out-buffer
)
1364 ;; Make sure that temp buff syntax table is the same as the original buf
1365 ;; syntax tbl, because we use ediff-forward-word in both and
1366 ;; ediff-forward-word depends on the syntax classes of characters.
1367 (set-syntax-table inbuf-syntax-tbl
)
1369 (insert diff-string
)
1370 (goto-char (point-min))
1371 (skip-chars-forward ediff-whitespace
)
1372 (delete-region (point-min) (point))
1375 (funcall forward-word-function
)
1376 (setq sv-point
(point))
1377 (skip-chars-forward ediff-whitespace
)
1378 (delete-region sv-point
(point))
1381 ;; copy string specified as BEG END from IN-BUF to OUT-BUF
1382 (defun ediff-copy-to-buffer (beg end in-buffer out-buffer
)
1383 (with-current-buffer out-buffer
1385 (insert-buffer-substring in-buffer beg end
)
1386 (goto-char (point-min))))
1389 ;; goto word #n starting at current position in buffer `buf'
1390 ;; For ediff, a word is determined by ediff-forward-word-function
1391 ;; If `flag' is non-nil, goto the end of the n-th word.
1392 (defun ediff-goto-word (n buf
&optional flag
)
1393 ;; remember val ediff-forward-word-function has in ctl buf
1394 (let ((fwd-word-fun ediff-forward-word-function
)
1395 (syntax-tbl ediff-syntax-table
))
1396 (ediff-with-current-buffer buf
1397 (skip-chars-forward ediff-whitespace
)
1398 (ediff-with-syntax-table syntax-tbl
1400 (funcall fwd-word-fun
)
1401 (skip-chars-forward ediff-whitespace
)
1403 (if (and flag
(> n
0))
1404 (funcall fwd-word-fun
)))
1407 (defun ediff-same-file-contents (f1 f2
)
1408 "Return t if files F1 and F2 have identical contents."
1409 (if (and (not (file-directory-p f1
))
1410 (not (file-directory-p f2
)))
1412 (apply 'call-process ediff-cmp-program nil nil nil
1413 (append ediff-cmp-options
(list (expand-file-name f1
)
1414 (expand-file-name f2
))))
1416 (and (numberp res
) (eq res
0)))
1420 (defun ediff-same-contents (d1 d2
&optional filter-re
)
1421 "Return t if D1 and D2 have the same content.
1422 D1 and D2 can either be both directories or both regular files.
1423 Symlinks and the likes are not handled.
1424 If FILTER-RE is non-nil, recursive checking in directories
1425 affects only files whose names match the expression."
1426 ;; Normalize empty filter RE to nil.
1427 (unless (> (length filter-re
) 0) (setq filter-re nil
))
1428 ;; Indicate progress
1429 (message "Comparing '%s' and '%s' modulo '%s'" d1 d2 filter-re
)
1431 ;; D1 & D2 directories => recurse
1432 ((and (file-directory-p d1
)
1433 (file-directory-p d2
))
1434 (if (null ediff-recurse-to-subdirectories
)
1435 (if (y-or-n-p "Compare subdirectories recursively? ")
1436 (setq ediff-recurse-to-subdirectories
'yes
)
1437 (setq ediff-recurse-to-subdirectories
'no
)))
1438 (if (eq ediff-recurse-to-subdirectories
'yes
)
1439 (let* ((all-entries-1 (directory-files d1 t filter-re
))
1440 (all-entries-2 (directory-files d2 t filter-re
))
1441 (entries-1 (ediff-delete-all-matches "^\\.\\.?$" all-entries-1
))
1442 (entries-2 (ediff-delete-all-matches "^\\.\\.?$" all-entries-2
))
1445 (ediff-same-file-contents-lists entries-1 entries-2 filter-re
)
1447 ) ; end of the directories case
1448 ;; D1 & D2 are both files => compare directly
1449 ((and (file-regular-p d1
)
1450 (file-regular-p d2
))
1451 (ediff-same-file-contents d1 d2
))
1452 ;; Otherwise => false: unequal contents
1456 ;; If lists have the same length and names of files are pairwise equal
1457 ;; (removing the directories) then compare contents pairwise.
1458 ;; True if all contents are the same; false otherwise
1459 (defun ediff-same-file-contents-lists (entries-1 entries-2 filter-re
)
1460 ;; First, check only the names (works quickly and ensures a
1461 ;; precondition for subsequent code)
1462 (if (and (= (length entries-1
) (length entries-2
))
1463 (equal (mapcar 'file-name-nondirectory entries-1
)
1464 (mapcar 'file-name-nondirectory entries-2
)))
1465 ;; With name equality established, compare the entries
1466 ;; through recursion.
1468 (while (and entries-1 continue
)
1469 (if (ediff-same-contents
1470 (car entries-1
) (car entries-2
) filter-re
)
1471 (setq entries-1
(cdr entries-1
)
1472 entries-2
(cdr entries-2
))
1473 (setq continue nil
))
1475 ;; if reached the end then lists are equal
1481 ;; ARG1 is a regexp, ARG2 is a list of full-filenames
1482 ;; Delete all entries that match the regexp
1483 (defun ediff-delete-all-matches (regex file-list-list
)
1485 (while file-list-list
1486 (setq elt
(car file-list-list
))
1487 (or (string-match regex
(file-name-nondirectory elt
))
1488 (setq result
(cons elt result
)))
1489 (setq file-list-list
(cdr file-list-list
)))
1493 (defun ediff-set-actual-diff-options ()
1494 (if ediff-ignore-case
1495 (setq ediff-actual-diff-options
1496 (concat ediff-diff-options
" " ediff-ignore-case-option
)
1497 ediff-actual-diff3-options
1498 (concat ediff-diff3-options
" " ediff-ignore-case-option3
))
1499 (setq ediff-actual-diff-options ediff-diff-options
1500 ediff-actual-diff3-options ediff-diff3-options
)
1502 (setq-default ediff-actual-diff-options ediff-actual-diff-options
1503 ediff-actual-diff3-options ediff-actual-diff3-options
)
1507 ;; Ignore case handling - some ideas from drew.adams@@oracle.com
1508 (defun ediff-toggle-ignore-case ()
1510 (ediff-barf-if-not-control-buffer)
1511 (setq ediff-ignore-case
(not ediff-ignore-case
))
1512 (ediff-set-actual-diff-options)
1513 (if ediff-ignore-case
1514 (message "Ignoring regions that differ only in case")
1515 (message "Ignoring case differences turned OFF"))
1516 (cond (ediff-merge-job
1517 (message "Ignoring letter case is too dangerous in merge jobs"))
1518 ((and ediff-diff3-job
(string= ediff-ignore-case-option3
""))
1519 (message "Ignoring letter case is not supported by this diff3 program"))
1520 ((and (not ediff-3way-job
) (string= ediff-ignore-case-option
""))
1521 (message "Ignoring letter case is not supported by this diff program"))
1524 (ediff-update-diffs)))
1530 ;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1531 ;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1532 ;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1535 ;;; ediff-diff.el ends here