Merge from origin/emacs-24
[emacs.git] / lisp / vc / ediff-diff.el
blobd0c0f7b3e8365d6d58062299f06118ec298edfc6
1 ;;; ediff-diff.el --- diff-related utilities
3 ;; Copyright (C) 1994-2015 Free Software Foundation, Inc.
5 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
6 ;; Package: ediff
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/>.
23 ;;; Commentary:
25 ;;; Code:
28 (provide 'ediff-diff)
30 (require 'ediff-init)
31 (require 'ediff-util)
33 (defgroup ediff-diff nil
34 "Diff related utilities."
35 :prefix "ediff-"
36 :group 'ediff)
38 (defcustom ediff-diff-program "diff"
39 "Program to use for generating the differential of the two files."
40 :type 'string
41 :group 'ediff-diff)
42 (defcustom ediff-diff3-program "diff3"
43 "Program to be used for three-way comparison.
44 Must produce output compatible with Unix's diff3 program."
45 :type 'string
46 :group 'ediff-diff)
49 ;; The following functions must precede all defcustom-defined variables.
51 (fset 'ediff-set-actual-diff-options (lambda () nil))
53 (defcustom ediff-shell
54 (cond ((memq system-type '(ms-dos windows-nt))
55 shell-file-name) ; no standard name on MS-DOS
56 (t "sh")) ; UNIX
57 "The shell used to run diff and patch.
58 If user's .profile or .cshrc files are set up correctly, any shell
59 will do. However, some people set $prompt or other things
60 incorrectly, which leads to undesirable output messages. These may
61 cause Ediff to fail. In such a case, set `ediff-shell' to a shell that
62 you are not using or, better, fix your shell's startup file."
63 :type 'string
64 :group 'ediff-diff)
66 (defcustom ediff-cmp-program "cmp"
67 "Utility to use to determine if two files are identical.
68 It must return code 0, if its arguments are identical files."
69 :type 'string
70 :group 'ediff-diff)
72 (defcustom ediff-cmp-options nil
73 "Options to pass to `ediff-cmp-program'.
74 If GNU diff is used as `ediff-cmp-program', then the most useful options
75 are `-I REGEXP', to ignore changes whose lines match the REGEXP."
76 :type '(repeat string)
77 :group 'ediff-diff)
79 (defun ediff-set-diff-options (symbol value)
80 (set symbol value)
81 (ediff-set-actual-diff-options))
83 (defcustom ediff-diff-options
84 (if (memq system-type '(ms-dos windows-nt)) "--binary" "")
85 "Options to pass to `ediff-diff-program'.
86 If Unix diff is used as `ediff-diff-program',
87 then a useful option is `-w', to ignore space.
88 Options `-c', `-u', and `-i' are not allowed. Case sensitivity can be
89 toggled interactively using \\[ediff-toggle-ignore-case].
91 Do not remove the default options. If you need to change this variable, add new
92 options after the default ones.
94 This variable is not for customizing the look of the differences produced by
95 the command \\[ediff-show-diff-output]. Use the variable
96 `ediff-custom-diff-options' for that."
97 :set 'ediff-set-diff-options
98 :type 'string
99 :group 'ediff-diff)
101 (ediff-defvar-local ediff-ignore-case nil
102 "If t, skip over difference regions that differ only in letter case.
103 This variable can be set either in .emacs or toggled interactively.
104 Use `setq-default' if setting it in .emacs")
106 (defcustom ediff-ignore-case-option "-i"
107 "Option that causes the diff program to ignore case of letters."
108 :type 'string
109 :group 'ediff-diff)
111 (defcustom ediff-ignore-case-option3 ""
112 "Option that causes the diff3 program to ignore case of letters.
113 GNU diff3 doesn't have such an option."
114 :type 'string
115 :group 'ediff-diff)
117 ;; the actual options used in comparison
118 (ediff-defvar-local ediff-actual-diff-options ediff-diff-options "")
120 (defcustom ediff-custom-diff-program ediff-diff-program
121 "Program to use for generating custom diff output for saving it in a file.
122 This output is not used by Ediff internally."
123 :type 'string
124 :group 'ediff-diff)
125 (defcustom ediff-custom-diff-options "-c"
126 "Options to pass to `ediff-custom-diff-program'."
127 :type 'string
128 :group 'ediff-diff)
130 ;;; Support for diff3
132 (defvar ediff-match-diff3-line "^====\\(.?\\)\C-m?$"
133 "Pattern to match lines produced by diff3 that describe differences.")
134 (defcustom ediff-diff3-options ""
135 "Options to pass to `ediff-diff3-program'."
136 :set 'ediff-set-diff-options
137 :type 'string
138 :group 'ediff-diff)
140 ;; the actual options used in comparison
141 (ediff-defvar-local ediff-actual-diff3-options ediff-diff3-options "")
143 (defcustom ediff-diff3-ok-lines-regexp
144 "^\\([1-3]:\\|====\\| \\|.*Warning *:\\|.*No newline\\|.*missing newline\\|^\C-m$\\)"
145 "Regexp that matches normal output lines from `ediff-diff3-program'.
146 Lines that do not match are assumed to be error messages."
147 :type 'regexp
148 :group 'ediff-diff)
150 ;; keeps the status of the current diff in 3-way jobs.
151 ;; the status can be =diff(A), =diff(B), or =diff(A+B)
152 (ediff-defvar-local ediff-diff-status "" "")
155 ;;; Fine differences
157 (ediff-defvar-local ediff-auto-refine (if (ediff-has-face-support-p) 'on 'nix)
158 "If `on', Ediff auto-highlights fine diffs for the current diff region.
159 If `off', auto-highlighting is not used. If `nix', no fine diffs are shown
160 at all, unless the user force-refines the region by hitting `*'.
162 This variable can be set either in .emacs or toggled interactively.
163 Use `setq-default' if setting it in .emacs")
165 (ediff-defvar-local ediff-ignore-similar-regions nil
166 "If t, skip over difference regions that differ only in the white space and line breaks.
167 This variable can be set either in .emacs or toggled interactively.
168 Use `setq-default' if setting it in .emacs")
170 (ediff-defvar-local ediff-auto-refine-limit 14000
171 "Auto-refine only the regions of this size \(in bytes\) or less.")
173 ;;; General
175 (defvar ediff-diff-ok-lines-regexp
176 (concat
177 "^\\("
178 "[0-9,]+[acd][0-9,]+\C-m?$"
179 "\\|[<>] "
180 "\\|---"
181 "\\|.*Warning *:"
182 "\\|.*No +newline"
183 "\\|.*missing +newline"
184 "\\|^\C-m?$"
185 "\\)")
186 "Regexp that matches normal output lines from `ediff-diff-program'.
187 This is mostly lifted from Emerge, except that Ediff also considers
188 warnings and `Missing newline'-type messages to be normal output.
189 Lines that do not match are assumed to be error messages.")
191 (defvar ediff-match-diff-line
192 (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
193 (concat "^" x "\\([acd]\\)" x "\C-m?$"))
194 "Pattern to match lines produced by diff that describe differences.")
196 (ediff-defvar-local ediff-setup-diff-regions-function nil
197 "value is a function symbol depending on the kind of job is to be done.
198 For 2-way jobs and for ediff-merge, it should be `ediff-setup-diff-regions'.
199 For jobs requiring diff3, it should be `ediff-setup-diff-regions3'.
201 The function should take three mandatory arguments, file-A, file-B, and
202 file-C. It may ignore file C for diff2 jobs. It should also take
203 one optional arguments, diff-number to refine.")
206 ;;; Functions
208 ;; Generate the difference vector and overlays for the two files
209 ;; With optional arg REG-TO-REFINE, refine this region.
210 ;; File-C argument is not used here. It is there just because
211 ;; ediff-setup-diff-regions is called via a funcall to
212 ;; ediff-setup-diff-regions-function, which can also have the value
213 ;; ediff-setup-diff-regions3, which takes 4 arguments.
214 (defun ediff-setup-diff-regions (file-A file-B _file-C)
215 ;; looking for '-c', '-i', '-u', or 'c', 'i', 'u' among clustered non-long options
216 (if (string-match "^-[ciu]\\| -[ciu]\\|\\(^\\| \\)-[^- ]+[ciu]"
217 ediff-diff-options)
218 (error "Options `-c', `-u', and `-i' are not allowed in `ediff-diff-options'"))
220 ;; create, if it doesn't exist
221 (or (ediff-buffer-live-p ediff-diff-buffer)
222 (setq ediff-diff-buffer
223 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
224 (ediff-make-diff2-buffer ediff-diff-buffer file-A file-B)
225 (ediff-prepare-error-list ediff-diff-ok-lines-regexp ediff-diff-buffer)
226 (ediff-convert-diffs-to-overlays
227 (ediff-extract-diffs
228 ediff-diff-buffer ediff-word-mode ediff-narrow-bounds)))
230 ;; Run the diff program on FILE1 and FILE2 and put the output in DIFF-BUFFER
231 ;; Return the size of DIFF-BUFFER
232 ;; The return code isn't used in the program at present.
233 (defun ediff-make-diff2-buffer (diff-buffer file1 file2)
234 (let ((file1-size (ediff-file-size file1))
235 (file2-size (ediff-file-size file2)))
236 (cond ((not (numberp file1-size))
237 (message "Can't find file: %s"
238 (ediff-abbreviate-file-name file1))
239 (sit-for 2)
240 ;; 1 is an error exit code
242 ((not (numberp file2-size))
243 (message "Can't find file: %s"
244 (ediff-abbreviate-file-name file2))
245 (sit-for 2)
246 ;; 1 is an error exit code
248 (t (message "Computing differences between %s and %s ..."
249 (file-name-nondirectory file1)
250 (file-name-nondirectory file2))
251 ;; this erases the diff buffer automatically
252 (ediff-exec-process ediff-diff-program
253 diff-buffer
254 'synchronize
255 ediff-actual-diff-options file1 file2)
256 (message "")
257 (ediff-with-current-buffer diff-buffer
258 (buffer-size))))))
262 ;; If file-A/B/C is nil, do 2-way comparison with the non-nil buffers
263 ;; This function works for diff3 and diff2 jobs
264 (defun ediff-setup-fine-diff-regions (file-A file-B file-C reg-num)
265 (or (ediff-buffer-live-p ediff-fine-diff-buffer)
266 (setq ediff-fine-diff-buffer
267 (get-buffer-create
268 (ediff-unique-buffer-name "*ediff-fine-diff" "*"))))
270 (let (diff3-job diff-program diff-options ok-regexp diff-list)
271 (setq diff3-job ediff-3way-job
272 diff-program (if diff3-job ediff-diff3-program ediff-diff-program)
273 diff-options (if diff3-job
274 ediff-actual-diff3-options
275 ediff-actual-diff-options)
276 ok-regexp (if diff3-job
277 ediff-diff3-ok-lines-regexp
278 ediff-diff-ok-lines-regexp))
280 (ediff-message-if-verbose "Refining difference region %d ..." (1+ reg-num))
281 (ediff-exec-process diff-program ediff-fine-diff-buffer 'synchronize
282 diff-options
283 ;; The shuffle below is because we can compare 3-way
284 ;; or in several 2-way fashions, like fA fC, fA fB,
285 ;; or fB fC.
286 (if file-A file-A file-B)
287 (if file-B file-B file-A)
288 (if diff3-job
289 (if file-C file-C file-B))
290 ) ; exec process
292 (ediff-prepare-error-list ok-regexp ediff-fine-diff-buffer)
293 (ediff-message-if-verbose
295 ;; "Refining difference region %d ... done" (1+ reg-num))
297 (setq diff-list
298 (if diff3-job
299 (ediff-extract-diffs3
300 ediff-fine-diff-buffer '3way-comparison 'word-mode)
301 (ediff-extract-diffs ediff-fine-diff-buffer 'word-mode)))
302 ;; fixup diff-list
303 (if diff3-job
304 (cond ((not file-A)
305 (mapc (lambda (elt)
306 (aset elt 0 nil)
307 (aset elt 1 nil))
308 (cdr diff-list)))
309 ((not file-B)
310 (mapc (lambda (elt)
311 (aset elt 2 nil)
312 (aset elt 3 nil))
313 (cdr diff-list)))
314 ((not file-C)
315 (mapc (lambda (elt)
316 (aset elt 4 nil)
317 (aset elt 5 nil))
318 (cdr diff-list)))
321 (ediff-convert-fine-diffs-to-overlays diff-list reg-num)
325 (defun ediff-prepare-error-list (ok-regexp diff-buff)
326 (or (ediff-buffer-live-p ediff-error-buffer)
327 (setq ediff-error-buffer
328 (get-buffer-create (ediff-unique-buffer-name
329 "*ediff-errors" "*"))))
330 (ediff-with-current-buffer ediff-error-buffer
331 (setq buffer-undo-list t)
332 (erase-buffer)
333 (insert (ediff-with-current-buffer diff-buff (buffer-string)))
334 (goto-char (point-min))
335 (delete-matching-lines ok-regexp))
336 ;; If diff reports errors, show them then quit.
337 (if (/= 0 (ediff-with-current-buffer ediff-error-buffer (buffer-size)))
338 (let ((ctl-buf ediff-control-buffer)
339 (error-buf ediff-error-buffer))
340 (ediff-skip-unsuitable-frames)
341 (switch-to-buffer error-buf)
342 (ediff-kill-buffer-carefully ctl-buf)
343 (error "Errors in diff output. Diff output is in %S" diff-buff))))
345 ;; BOUNDS specifies visibility bounds to use.
346 ;; WORD-MODE tells whether we are in the word-mode or not.
347 ;; If WORD-MODE, also construct vector of diffs using word numbers.
348 ;; Else, use point values.
349 ;; This function handles diff-2 jobs including the case of
350 ;; merging buffers and files without ancestor.
351 (defun ediff-extract-diffs (diff-buffer word-mode &optional bounds)
352 (let ((A-buffer ediff-buffer-A)
353 (B-buffer ediff-buffer-B)
354 (C-buffer ediff-buffer-C)
355 (a-prev 1) ; this is needed to set the first diff line correctly
356 (a-prev-pt nil)
357 (b-prev 1)
358 (b-prev-pt nil)
359 (c-prev 1)
360 (c-prev-pt nil)
361 diff-list shift-A shift-B
364 ;; diff list contains word numbers, unless changed later
365 (setq diff-list (cons (if word-mode 'words 'points)
366 diff-list))
367 ;; we don't use visibility bounds for buffer C when merging
368 (if bounds
369 (setq shift-A
370 (ediff-overlay-start
371 (ediff-get-value-according-to-buffer-type 'A bounds))
372 shift-B
373 (ediff-overlay-start
374 (ediff-get-value-according-to-buffer-type 'B bounds))))
376 ;; reset point in buffers A/B/C
377 (ediff-with-current-buffer A-buffer
378 (goto-char (if shift-A shift-A (point-min))))
379 (ediff-with-current-buffer B-buffer
380 (goto-char (if shift-B shift-B (point-min))))
381 (if (ediff-buffer-live-p C-buffer)
382 (ediff-with-current-buffer C-buffer
383 (goto-char (point-min))))
385 (ediff-with-current-buffer diff-buffer
386 (goto-char (point-min))
387 (while (re-search-forward ediff-match-diff-line nil t)
388 (let* ((a-begin (string-to-number (buffer-substring (match-beginning 1)
389 (match-end 1))))
390 (a-end (let ((b (match-beginning 3))
391 (e (match-end 3)))
392 (if b
393 (string-to-number (buffer-substring b e))
394 a-begin)))
395 (diff-type (buffer-substring (match-beginning 4) (match-end 4)))
396 (b-begin (string-to-number (buffer-substring (match-beginning 5)
397 (match-end 5))))
398 (b-end (let ((b (match-beginning 7))
399 (e (match-end 7)))
400 (if b
401 (string-to-number (buffer-substring b e))
402 b-begin)))
403 a-begin-pt a-end-pt b-begin-pt b-end-pt
404 c-begin c-end c-begin-pt c-end-pt)
405 ;; fix the beginning and end numbers, because diff is somewhat
406 ;; strange about how it numbers lines
407 (if (string-equal diff-type "a")
408 (setq b-end (1+ b-end)
409 a-begin (1+ a-begin)
410 a-end a-begin)
411 (if (string-equal diff-type "d")
412 (setq a-end (1+ a-end)
413 b-begin (1+ b-begin)
414 b-end b-begin)
415 ;; (string-equal diff-type "c")
416 (setq a-end (1+ a-end)
417 b-end (1+ b-end))))
419 (if (eq ediff-default-variant 'default-B)
420 (setq c-begin b-begin
421 c-end b-end)
422 (setq c-begin a-begin
423 c-end a-end))
425 ;; compute main diff vector
426 (if word-mode
427 ;; make diff-list contain word numbers
428 (setq diff-list
429 (nconc diff-list
430 (list
431 (if (ediff-buffer-live-p C-buffer)
432 (vector (- a-begin a-prev) (- a-end a-begin)
433 (- b-begin b-prev) (- b-end b-begin)
434 (- c-begin c-prev) (- c-end c-begin)
435 nil nil ; dummy ancestor
436 nil ; state of diff
437 nil ; state of merge
438 nil ; state of ancestor
440 (vector (- a-begin a-prev) (- a-end a-begin)
441 (- b-begin b-prev) (- b-end b-begin)
442 nil nil ; dummy buf C
443 nil nil ; dummy ancestor
444 nil ; state of diff
445 nil ; state of merge
446 nil ; state of ancestor
449 a-prev a-end
450 b-prev b-end
451 c-prev c-end)
452 ;; else convert lines to points
453 (ediff-with-current-buffer A-buffer
454 (goto-char (or a-prev-pt shift-A (point-min)))
455 (forward-line (- a-begin a-prev))
456 (setq a-begin-pt (point))
457 (forward-line (- a-end a-begin))
458 (setq a-end-pt (point)
459 a-prev a-end
460 a-prev-pt a-end-pt))
461 (ediff-with-current-buffer B-buffer
462 (goto-char (or b-prev-pt shift-B (point-min)))
463 (forward-line (- b-begin b-prev))
464 (setq b-begin-pt (point))
465 (forward-line (- b-end b-begin))
466 (setq b-end-pt (point)
467 b-prev b-end
468 b-prev-pt b-end-pt))
469 (if (ediff-buffer-live-p C-buffer)
470 (ediff-with-current-buffer C-buffer
471 (goto-char (or c-prev-pt (point-min)))
472 (forward-line (- c-begin c-prev))
473 (setq c-begin-pt (point))
474 (forward-line (- c-end c-begin))
475 (setq c-end-pt (point)
476 c-prev c-end
477 c-prev-pt c-end-pt)))
478 (setq diff-list
479 (nconc
480 diff-list
481 (list
482 (if (ediff-buffer-live-p C-buffer)
483 (vector
484 a-begin-pt a-end-pt b-begin-pt b-end-pt
485 c-begin-pt c-end-pt
486 nil nil ; dummy ancestor
487 ;; state of diff
488 ;; shows which buff is different from the other two
489 (if (eq ediff-default-variant 'default-B) 'A 'B)
490 ediff-default-variant ; state of merge
491 nil ; state of ancestor
493 (vector a-begin-pt a-end-pt
494 b-begin-pt b-end-pt
495 nil nil ; dummy buf C
496 nil nil ; dummy ancestor
497 nil nil ; dummy state of diff & merge
498 nil ; dummy state of ancestor
502 ))) ; end ediff-with-current-buffer
503 diff-list
507 (defun ediff-convert-diffs-to-overlays (diff-list)
508 (ediff-set-diff-overlays-in-one-buffer 'A diff-list)
509 (ediff-set-diff-overlays-in-one-buffer 'B diff-list)
510 (if ediff-3way-job
511 (ediff-set-diff-overlays-in-one-buffer 'C diff-list))
512 (if ediff-merge-with-ancestor-job
513 (ediff-set-diff-overlays-in-one-buffer 'Ancestor diff-list))
514 ;; set up vector showing the status of merge regions
515 (if ediff-merge-job
516 (setq ediff-state-of-merge
517 (vconcat
518 (mapcar (lambda (elt)
519 (let ((state-of-merge (aref elt 9))
520 (state-of-ancestor (aref elt 10)))
521 (vector
522 ;; state of merge: prefers/default-A/B or combined
523 (if state-of-merge (format "%S" state-of-merge))
524 ;; whether the ancestor region is empty
525 state-of-ancestor)))
526 ;; the first elt designates type of list
527 (cdr diff-list))
529 (message "Processing difference regions ... done"))
532 (defun ediff-set-diff-overlays-in-one-buffer (buf-type diff-list)
533 (let* ((current-diff -1)
534 (buff (ediff-get-buffer buf-type))
535 (ctl-buf ediff-control-buffer)
536 ;; ediff-extract-diffs puts the type of diff-list as the first elt
537 ;; of this list. The type is either 'points or 'words
538 (diff-list-type (car diff-list))
539 (shift (ediff-overlay-start
540 (ediff-get-value-according-to-buffer-type
541 buf-type ediff-narrow-bounds)))
542 (limit (ediff-overlay-end
543 (ediff-get-value-according-to-buffer-type
544 buf-type ediff-narrow-bounds)))
545 diff-overlay-list list-element total-diffs
546 begin end pt-saved overlay state-of-diff)
548 (setq diff-list (cdr diff-list)) ; discard diff list type
549 (setq total-diffs (length diff-list))
551 ;; shift, if necessary
552 (ediff-with-current-buffer buff (setq pt-saved shift))
554 (while diff-list
555 (setq current-diff (1+ current-diff)
556 list-element (car diff-list)
557 begin (aref list-element (cond ((eq buf-type 'A) 0)
558 ((eq buf-type 'B) 2)
559 ((eq buf-type 'C) 4)
560 (t 6))) ; Ancestor
561 end (aref list-element (cond ((eq buf-type 'A) 1)
562 ((eq buf-type 'B) 3)
563 ((eq buf-type 'C) 5)
564 (t 7))) ; Ancestor
565 state-of-diff (aref list-element 8)
568 (cond ((and (not (eq buf-type state-of-diff))
569 (not (eq buf-type 'Ancestor))
570 (memq state-of-diff '(A B C)))
571 (setq state-of-diff
572 (car (delq buf-type (delq state-of-diff (list 'A 'B 'C)))))
573 (setq state-of-diff (format "=diff(%S)" state-of-diff))
575 (t (setq state-of-diff nil)))
577 ;; Put overlays at appropriate places in buffer
578 ;; convert word numbers to points, if necessary
579 (if (eq diff-list-type 'words)
580 (progn
581 (ediff-with-current-buffer buff (goto-char pt-saved))
582 (ediff-with-current-buffer ctl-buf
583 (setq begin (ediff-goto-word (1+ begin) buff)
584 end (ediff-goto-word end buff 'end)))
585 (if (> end limit) (setq end limit))
586 (if (> begin end) (setq begin end))
587 (setq pt-saved (ediff-with-current-buffer buff (point)))))
588 (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
590 (ediff-overlay-put overlay 'ediff-diff-num current-diff)
591 (if (and (ediff-has-face-support-p)
592 ediff-use-faces ediff-highlight-all-diffs)
593 (ediff-set-overlay-face
594 overlay (ediff-background-face buf-type current-diff)))
596 (if (= 0 (mod current-diff 10))
597 (message "Buffer %S: Processing difference region %d of %d"
598 buf-type current-diff total-diffs))
599 ;; Record all overlays for this difference.
600 ;; The 2-d elt, nil, is a place holder for the fine diff vector.
601 ;; The 3-d elt, nil, is a place holder for no-fine-diffs flag.
602 ;; The 4-th elt says which diff region is different from the other two
603 ;; (3-way jobs only).
604 (setq diff-overlay-list
605 (nconc
606 diff-overlay-list
607 (list (vector overlay nil nil state-of-diff)))
608 diff-list
609 (cdr diff-list))
610 ) ; while
612 (set (ediff-get-symbol-from-alist buf-type ediff-difference-vector-alist)
613 (vconcat diff-overlay-list))
616 ;; `n' is the diff region to work on. Default is ediff-current-difference.
617 ;; if `flag' is 'noforce then make fine-diffs only if this region's fine
618 ;; diffs have not been computed before.
619 ;; if `flag' is 'skip then don't compute fine diffs for this region.
620 (defun ediff-make-fine-diffs (&optional n flag)
621 (or n (setq n ediff-current-difference))
623 (if (< ediff-number-of-differences 1)
624 (error ediff-NO-DIFFERENCES))
626 (if ediff-word-mode
627 (setq flag 'skip
628 ediff-auto-refine 'nix))
630 (or (< n 0)
631 (>= n ediff-number-of-differences)
632 ;; n is within the range
633 (let ((tmp-buffer (get-buffer-create ediff-tmp-buffer))
634 (file-A ediff-temp-file-A)
635 (file-B ediff-temp-file-B)
636 (file-C ediff-temp-file-C)
637 (empty-A (ediff-empty-diff-region-p n 'A))
638 (empty-B (ediff-empty-diff-region-p n 'B))
639 (empty-C (ediff-empty-diff-region-p n 'C))
640 (whitespace-A (ediff-whitespace-diff-region-p n 'A))
641 (whitespace-B (ediff-whitespace-diff-region-p n 'B))
642 (whitespace-C (ediff-whitespace-diff-region-p n 'C))
643 cumulative-fine-diff-length)
645 (cond ;; If one of the regions is empty (or 2 in 3way comparison)
646 ;; then don't refine.
647 ;; If the region happens to be entirely whitespace or empty then
648 ;; mark as such.
649 ((> (length (delq nil (list empty-A empty-B empty-C))) 1)
650 (if (and (ediff-looks-like-combined-merge n)
651 ediff-merge-job)
652 (ediff-set-fine-overlays-in-one-buffer 'C nil n))
653 (if ediff-3way-comparison-job
654 (ediff-message-if-verbose
655 "Region %d is empty in all buffers but %S"
656 (1+ n)
657 (cond ((not empty-A) 'A)
658 ((not empty-B) 'B)
659 ((not empty-C) 'C)))
660 (ediff-message-if-verbose
661 "Region %d in buffer %S is empty"
662 (1+ n)
663 (cond (empty-A 'A)
664 (empty-B 'B)
665 (empty-C 'C)))
667 ;; if all regions happen to be whitespace
668 (if (and whitespace-A whitespace-B whitespace-C)
669 ;; mark as space only
670 (ediff-mark-diff-as-space-only n t)
671 ;; if some regions are white and others don't, then mark as
672 ;; non-white-space-only
673 (ediff-mark-diff-as-space-only n nil)))
675 ;; don't compute fine diffs if diff vector exists
676 ((and (eq flag 'noforce) (ediff-get-fine-diff-vector n 'A))
677 (if (ediff-no-fine-diffs-p n)
678 (message
679 "Only white-space differences in region %d %s"
680 (1+ n)
681 (cond ((eq (ediff-no-fine-diffs-p n) 'A)
682 "in buffers B & C")
683 ((eq (ediff-no-fine-diffs-p n) 'B)
684 "in buffers A & C")
685 ((eq (ediff-no-fine-diffs-p n) 'C)
686 "in buffers A & B")
687 (t "")))))
688 ;; don't compute fine diffs for this region
689 ((eq flag 'skip)
690 (or (ediff-get-fine-diff-vector n 'A)
691 (memq ediff-auto-refine '(off nix))
692 (ediff-message-if-verbose
693 "Region %d exceeds the auto-refinement limit. Type `%s' to refine"
694 (1+ n)
695 (substitute-command-keys
696 "\\[ediff-make-or-kill-fine-diffs]")
699 ;; recompute fine diffs
700 (ediff-wordify
701 (ediff-get-diff-posn 'A 'beg n)
702 (ediff-get-diff-posn 'A 'end n)
703 ediff-buffer-A
704 tmp-buffer
705 ediff-control-buffer)
706 (setq file-A
707 (ediff-make-temp-file tmp-buffer "fineDiffA" file-A))
709 (ediff-wordify
710 (ediff-get-diff-posn 'B 'beg n)
711 (ediff-get-diff-posn 'B 'end n)
712 ediff-buffer-B
713 tmp-buffer
714 ediff-control-buffer)
715 (setq file-B
716 (ediff-make-temp-file tmp-buffer "fineDiffB" file-B))
718 (if ediff-3way-job
719 (progn
720 (ediff-wordify
721 (ediff-get-diff-posn 'C 'beg n)
722 (ediff-get-diff-posn 'C 'end n)
723 ediff-buffer-C
724 tmp-buffer
725 ediff-control-buffer)
726 (setq file-C
727 (ediff-make-temp-file
728 tmp-buffer "fineDiffC" file-C))))
730 ;; save temp file names.
731 (setq ediff-temp-file-A file-A
732 ediff-temp-file-B file-B
733 ediff-temp-file-C file-C)
735 ;; set the new vector of fine diffs, if none exists
736 (cond ((and ediff-3way-job whitespace-A)
737 (ediff-setup-fine-diff-regions nil file-B file-C n))
738 ((and ediff-3way-job whitespace-B)
739 (ediff-setup-fine-diff-regions file-A nil file-C n))
740 ((and ediff-3way-job
741 ;; In merge-jobs, whitespace-C is t, since
742 ;; ediff-empty-diff-region-p returns t in this case
743 whitespace-C)
744 (ediff-setup-fine-diff-regions file-A file-B nil n))
746 (ediff-setup-fine-diff-regions file-A file-B file-C n)))
748 (setq cumulative-fine-diff-length
749 (+ (length (ediff-get-fine-diff-vector n 'A))
750 (length (ediff-get-fine-diff-vector n 'B))
751 ;; in merge jobs, the merge buffer is never refined
752 (if (and file-C (not ediff-merge-job))
753 (length (ediff-get-fine-diff-vector n 'C))
754 0)))
756 (cond ((or
757 ;; all regions are white space
758 (and whitespace-A whitespace-B whitespace-C)
759 ;; none is white space and no fine diffs detected
760 (and (not whitespace-A)
761 (not whitespace-B)
762 (not (and ediff-3way-job whitespace-C))
763 (eq cumulative-fine-diff-length 0)))
764 (ediff-mark-diff-as-space-only n t)
765 (ediff-message-if-verbose
766 "Only white-space differences in region %d" (1+ n)))
767 ((eq cumulative-fine-diff-length 0)
768 (ediff-message-if-verbose
769 "Only white-space differences in region %d %s"
770 (1+ n)
771 (cond (whitespace-A (ediff-mark-diff-as-space-only n 'A)
772 "in buffers B & C")
773 (whitespace-B (ediff-mark-diff-as-space-only n 'B)
774 "in buffers A & C")
775 (whitespace-C (ediff-mark-diff-as-space-only n 'C)
776 "in buffers A & B"))))
778 (ediff-mark-diff-as-space-only n nil)))
780 ) ; end cond
781 (ediff-set-fine-diff-properties n)
784 ;; Interface to ediff-make-fine-diffs. Checks for auto-refine limit, etc.
785 (defun ediff-install-fine-diff-if-necessary (n)
786 (cond ((and (eq ediff-auto-refine 'on)
787 ediff-use-faces
788 (not (eq ediff-highlighting-style 'off))
789 (not (eq ediff-highlighting-style 'ascii)))
790 (if (and
791 (> ediff-auto-refine-limit
792 (- (ediff-get-diff-posn 'A 'end n)
793 (ediff-get-diff-posn 'A 'beg n)))
794 (> ediff-auto-refine-limit
795 (- (ediff-get-diff-posn 'B 'end n)
796 (ediff-get-diff-posn 'B 'beg n))))
797 (ediff-make-fine-diffs n 'noforce)
798 (ediff-make-fine-diffs n 'skip)))
800 ;; highlight if fine diffs already exist
801 ((eq ediff-auto-refine 'off)
802 (ediff-make-fine-diffs n 'skip))))
805 ;; if fine diff vector is not set for diff N, then do nothing
806 (defun ediff-set-fine-diff-properties (n &optional default)
807 (or (not (ediff-has-face-support-p))
808 (< n 0)
809 (>= n ediff-number-of-differences)
810 ;; when faces are supported, set faces and priorities of fine overlays
811 (progn
812 (ediff-set-fine-diff-properties-in-one-buffer 'A n default)
813 (ediff-set-fine-diff-properties-in-one-buffer 'B n default)
814 (if ediff-3way-job
815 (ediff-set-fine-diff-properties-in-one-buffer 'C n default)))))
817 (defun ediff-set-fine-diff-properties-in-one-buffer (buf-type
818 n &optional default)
819 (let ((fine-diff-vector (ediff-get-fine-diff-vector n buf-type))
820 (face (if default
822 (ediff-get-symbol-from-alist
823 buf-type ediff-fine-diff-face-alist))))
824 (mapc (lambda (overl)
825 (ediff-set-overlay-face overl face))
826 fine-diff-vector)))
828 ;; Set overlays over the regions that denote delimiters
829 (defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num)
830 (let (overlay overlay-list)
831 (while diff-list
832 (condition-case nil
833 (setq overlay
834 (ediff-make-bullet-proof-overlay
835 (nth 0 diff-list) (nth 1 diff-list) ediff-buffer-C))
836 (error ""))
837 (setq overlay-list (cons overlay overlay-list))
838 (if (> (length diff-list) 1)
839 (setq diff-list (cdr (cdr diff-list)))
840 (error "ediff-set-fine-overlays-for-combined-merge: corrupt list of
841 delimiter regions"))
843 (setq overlay-list (reverse overlay-list))
844 (ediff-set-fine-diff-vector
845 reg-num 'C (apply 'vector overlay-list))
849 ;; Convert diff list to overlays for a given DIFF-REGION
850 ;; in buffer of type BUF-TYPE
851 (defun ediff-set-fine-overlays-in-one-buffer (buf-type diff-list region-num)
852 (let* ((current-diff -1)
853 (reg-start (ediff-get-diff-posn buf-type 'beg region-num))
854 (buff (ediff-get-buffer buf-type))
855 (ctl-buf ediff-control-buffer)
856 combined-merge-diff-list
857 diff-overlay-list list-element
858 begin end overlay)
860 (ediff-clear-fine-differences-in-one-buffer region-num buf-type)
861 (setq diff-list (cdr diff-list)) ; discard list type (words or points)
862 (ediff-with-current-buffer buff (goto-char reg-start))
864 ;; if it is a combined merge then set overlays in buff C specially
865 (if (and ediff-merge-job (eq buf-type 'C)
866 (setq combined-merge-diff-list
867 (ediff-looks-like-combined-merge region-num)))
868 (ediff-set-fine-overlays-for-combined-merge
869 combined-merge-diff-list region-num)
870 ;; regular fine diff
871 (while diff-list
872 (setq current-diff (1+ current-diff)
873 list-element (car diff-list)
874 begin (aref list-element (cond ((eq buf-type 'A) 0)
875 ((eq buf-type 'B) 2)
876 (t 4))) ; buf C
877 end (aref list-element (cond ((eq buf-type 'A) 1)
878 ((eq buf-type 'B) 3)
879 (t 5)))) ; buf C
880 (if (not (or begin end))
881 () ; skip this diff
882 ;; Put overlays at appropriate places in buffers
883 ;; convert lines to points, if necessary
884 (ediff-with-current-buffer ctl-buf
885 (setq begin (ediff-goto-word (1+ begin) buff)
886 end (ediff-goto-word end buff 'end)))
887 (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
888 ;; record all overlays for this difference region
889 (setq diff-overlay-list (nconc diff-overlay-list (list overlay))))
891 (setq diff-list (cdr diff-list))
892 ) ; while
893 ;; convert the list of difference information into a vector
894 ;; for fast access
895 (ediff-set-fine-diff-vector
896 region-num buf-type (vconcat diff-overlay-list))
900 (defun ediff-convert-fine-diffs-to-overlays (diff-list region-num)
901 (ediff-set-fine-overlays-in-one-buffer 'A diff-list region-num)
902 (ediff-set-fine-overlays-in-one-buffer 'B diff-list region-num)
903 (if ediff-3way-job
904 (ediff-set-fine-overlays-in-one-buffer 'C diff-list region-num)
908 ;; Stolen from emerge.el
909 (defun ediff-get-diff3-group (file)
910 ;; This save-excursion allows ediff-get-diff3-group to be called for the
911 ;; various groups of lines (1, 2, 3) in any order, and for the lines to
912 ;; appear in any order. The reason this is necessary is that Gnu diff3
913 ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
914 (save-excursion
915 (re-search-forward
916 (concat "^" file ":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)\C-m?$"))
917 (beginning-of-line 2)
918 ;; treatment depends on whether it is an "a" group or a "c" group
919 (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
920 ;; it is a "c" group
921 (if (match-beginning 2)
922 ;; it has two numbers
923 (list (string-to-number
924 (buffer-substring (match-beginning 1) (match-end 1)))
925 (1+ (string-to-number
926 (buffer-substring (match-beginning 3) (match-end 3)))))
927 ;; it has one number
928 (let ((x (string-to-number
929 (buffer-substring (match-beginning 1) (match-end 1)))))
930 (list x (1+ x))))
931 ;; it is an "a" group
932 (let ((x (1+ (string-to-number
933 (buffer-substring (match-beginning 1) (match-end 1))))))
934 (list x x)))))
937 ;; If WORD-MODE, construct vector of diffs using word numbers.
938 ;; Else, use point values.
939 ;; WORD-MODE also tells if we are in the word-mode or not.
940 ;; If THREE-WAY-COMP, then it is a 3-way comparison. Else, it is merging
941 ;; with ancestor, in which case buffer-C contents is identical to buffer-A/B,
942 ;; contents (unless buffer-A is narrowed) depending on ediff-default-variant's
943 ;; value.
944 ;; BOUNDS specifies visibility bounds to use.
945 (defun ediff-extract-diffs3 (diff-buffer word-mode three-way-comp
946 &optional bounds)
947 (let ((A-buffer ediff-buffer-A)
948 (B-buffer ediff-buffer-B)
949 (C-buffer ediff-buffer-C)
950 (anc-buffer ediff-ancestor-buffer)
951 (a-prev 1) ; needed to set the first diff line correctly
952 (a-prev-pt nil)
953 (b-prev 1)
954 (b-prev-pt nil)
955 (c-prev 1)
956 (c-prev-pt nil)
957 (anc-prev 1)
958 diff-list shift-A shift-B shift-C
961 ;; diff list contains word numbers or points, depending on word-mode
962 (setq diff-list (cons (if word-mode 'words 'points)
963 diff-list))
964 (if bounds
965 (setq shift-A
966 (ediff-overlay-start
967 (ediff-get-value-according-to-buffer-type 'A bounds))
968 shift-B
969 (ediff-overlay-start
970 (ediff-get-value-according-to-buffer-type 'B bounds))
971 shift-C
972 (if three-way-comp
973 (ediff-overlay-start
974 (ediff-get-value-according-to-buffer-type 'C bounds)))))
976 ;; reset point in buffers A, B, C
977 (ediff-with-current-buffer A-buffer
978 (goto-char (if shift-A shift-A (point-min))))
979 (ediff-with-current-buffer B-buffer
980 (goto-char (if shift-B shift-B (point-min))))
981 (if three-way-comp
982 (ediff-with-current-buffer C-buffer
983 (goto-char (if shift-C shift-C (point-min)))))
984 (if (ediff-buffer-live-p anc-buffer)
985 (ediff-with-current-buffer anc-buffer
986 (goto-char (point-min))))
988 (ediff-with-current-buffer diff-buffer
989 (goto-char (point-min))
990 (while (re-search-forward ediff-match-diff3-line nil t)
991 ;; leave point after matched line
992 (beginning-of-line 2)
993 (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
994 ;; if the files A and B are the same and not 3way-comparison,
995 ;; ignore the difference
996 (if (or three-way-comp (not (string-equal agreement "3")))
997 (let* ((a-begin (car (ediff-get-diff3-group "1")))
998 (a-end (nth 1 (ediff-get-diff3-group "1")))
999 (b-begin (car (ediff-get-diff3-group "2")))
1000 (b-end (nth 1 (ediff-get-diff3-group "2")))
1001 (c-or-anc-begin (car (ediff-get-diff3-group "3")))
1002 (c-or-anc-end (nth 1 (ediff-get-diff3-group "3")))
1003 (state-of-merge
1004 (cond ((string-equal agreement "1") 'prefer-A)
1005 ((string-equal agreement "2") 'prefer-B)
1006 (t ediff-default-variant)))
1007 (state-of-diff-merge
1008 (if (memq state-of-merge '(default-A prefer-A)) 'B 'A))
1009 (state-of-diff-comparison
1010 (cond ((string-equal agreement "1") 'A)
1011 ((string-equal agreement "2") 'B)
1012 ((string-equal agreement "3") 'C)))
1013 state-of-ancestor
1014 c-begin c-end
1015 a-begin-pt a-end-pt
1016 b-begin-pt b-end-pt
1017 c-begin-pt c-end-pt
1018 anc-begin-pt anc-end-pt)
1020 (setq state-of-ancestor
1021 (= c-or-anc-begin c-or-anc-end))
1023 (cond (three-way-comp
1024 (setq c-begin c-or-anc-begin
1025 c-end c-or-anc-end))
1026 ((eq ediff-default-variant 'default-B)
1027 (setq c-begin b-begin
1028 c-end b-end))
1030 (setq c-begin a-begin
1031 c-end a-end)))
1033 ;; compute main diff vector
1034 (if word-mode
1035 ;; make diff-list contain word numbers
1036 (setq diff-list
1037 (nconc diff-list
1038 (list (vector
1039 (- a-begin a-prev) (- a-end a-begin)
1040 (- b-begin b-prev) (- b-end b-begin)
1041 (- c-begin c-prev) (- c-end c-begin)
1042 nil nil ; dummy ancestor
1043 nil ; state of diff
1044 nil ; state of merge
1045 nil ; state of ancestor
1047 a-prev a-end
1048 b-prev b-end
1049 c-prev c-end)
1050 ;; else convert lines to points
1051 (ediff-with-current-buffer A-buffer
1052 (goto-char (or a-prev-pt shift-A (point-min)))
1053 (forward-line (- a-begin a-prev))
1054 (setq a-begin-pt (point))
1055 (forward-line (- a-end a-begin))
1056 (setq a-end-pt (point)
1057 a-prev a-end
1058 a-prev-pt a-end-pt))
1059 (ediff-with-current-buffer B-buffer
1060 (goto-char (or b-prev-pt shift-B (point-min)))
1061 (forward-line (- b-begin b-prev))
1062 (setq b-begin-pt (point))
1063 (forward-line (- b-end b-begin))
1064 (setq b-end-pt (point)
1065 b-prev b-end
1066 b-prev-pt b-end-pt))
1067 (ediff-with-current-buffer C-buffer
1068 (goto-char (or c-prev-pt shift-C (point-min)))
1069 (forward-line (- c-begin c-prev))
1070 (setq c-begin-pt (point))
1071 (forward-line (- c-end c-begin))
1072 (setq c-end-pt (point)
1073 c-prev c-end
1074 c-prev-pt c-end-pt))
1075 (if (ediff-buffer-live-p anc-buffer)
1076 (ediff-with-current-buffer anc-buffer
1077 (forward-line (- c-or-anc-begin anc-prev))
1078 (setq anc-begin-pt (point))
1079 (forward-line (- c-or-anc-end c-or-anc-begin))
1080 (setq anc-end-pt (point)
1081 anc-prev c-or-anc-end)))
1082 (setq diff-list
1083 (nconc
1084 diff-list
1085 ;; if comparing with ancestor, then there also is a
1086 ;; state-of-difference marker
1087 (if three-way-comp
1088 (list (vector
1089 a-begin-pt a-end-pt
1090 b-begin-pt b-end-pt
1091 c-begin-pt c-end-pt
1092 nil nil ; ancestor begin/end
1093 state-of-diff-comparison
1094 nil ; state of merge
1095 nil ; state of ancestor
1097 (list (vector a-begin-pt a-end-pt
1098 b-begin-pt b-end-pt
1099 c-begin-pt c-end-pt
1100 anc-begin-pt anc-end-pt
1101 state-of-diff-merge
1102 state-of-merge
1103 state-of-ancestor
1108 ))) ; end ediff-with-current-buffer
1109 diff-list
1112 ;; Generate the difference vector and overlays for three files
1113 ;; File-C is either the third file to compare (in case of 3-way comparison)
1114 ;; or it is the ancestor file.
1115 (defun ediff-setup-diff-regions3 (file-A file-B file-C)
1116 ;; looking for '-i' or a 'i' among clustered non-long options
1117 (if (string-match "^-i\\| -i\\|\\(^\\| \\)-[^- ]+i" ediff-diff-options)
1118 (error "Option `-i' is not allowed in `ediff-diff3-options'"))
1120 (or (ediff-buffer-live-p ediff-diff-buffer)
1121 (setq ediff-diff-buffer
1122 (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
1124 (message "Computing differences ...")
1125 (ediff-exec-process ediff-diff3-program ediff-diff-buffer 'synchronize
1126 ediff-actual-diff3-options file-A file-B file-C)
1128 (ediff-prepare-error-list ediff-diff3-ok-lines-regexp ediff-diff-buffer)
1129 ;;(message "Computing differences ... done")
1130 (ediff-convert-diffs-to-overlays
1131 (ediff-extract-diffs3
1132 ediff-diff-buffer
1133 ediff-word-mode ediff-3way-comparison-job ediff-narrow-bounds)
1137 ;; Execute PROGRAM asynchronously, unless OS/2, Windows-*, or DOS, or unless
1138 ;; SYNCH is non-nil. BUFFER must be a buffer object, and must be alive. The
1139 ;; OPTIONS arg is a list of options to pass to PROGRAM. It may be a blank
1140 ;; string. All elements in FILES must be strings. We also delete nil from
1141 ;; args.
1142 (defun ediff-exec-process (program buffer synch options &rest files)
1143 (let ((data (match-data))
1144 ;; If this is a buffer job, we are diffing temporary files
1145 ;; produced by Emacs with ediff-coding-system-for-write, so
1146 ;; use the same encoding to read the results.
1147 (coding-system-for-read
1148 (if (string-match "buffer" (symbol-name ediff-job-name))
1149 ediff-coding-system-for-write
1150 ediff-coding-system-for-read))
1151 args)
1152 (setq args (append (split-string options) files))
1153 (setq args (delete "" (delq nil args))) ; delete nil and "" from arguments
1154 ;; the --binary option, if present, should be used only for buffer jobs
1155 ;; or for refining the differences
1156 (or (string-match "buffer" (symbol-name ediff-job-name))
1157 (eq buffer ediff-fine-diff-buffer)
1158 (setq args (delete "--binary" args)))
1159 (unwind-protect
1160 (let ((directory default-directory)
1161 proc)
1162 (with-current-buffer buffer
1163 (erase-buffer)
1164 (setq default-directory directory)
1165 (if (or (memq system-type '(ms-dos windows-nt))
1166 synch)
1167 ;; In Windows do it synchronously, since Windows doesn't let us
1168 ;; delete files used by other processes. Thus, in ediff-buffers
1169 ;; and similar functions, we can't delete temp files because
1170 ;; they might be used by the asynch process that computes
1171 ;; custom diffs. So, we have to wait till custom diff
1172 ;; subprocess is done.
1173 ;; In DOS, must synchronize because DOS doesn't have
1174 ;; asynchronous processes.
1175 (apply 'call-process program nil buffer nil args)
1176 ;; On other systems, do it asynchronously.
1177 (setq proc (get-buffer-process buffer))
1178 (if proc (kill-process proc))
1179 (setq proc
1180 (apply 'start-process "Custom Diff" buffer program args))
1181 (setq mode-line-process '(":%s"))
1182 (set-process-sentinel proc 'ediff-process-sentinel)
1183 (set-process-filter proc 'ediff-process-filter)
1185 (store-match-data data))))
1187 ;; This is shell-command-filter from simple.el in Emacs.
1188 ;; Copied here because XEmacs doesn't have it.
1189 (defun ediff-process-filter (proc string)
1190 ;; Do save-excursion by hand so that we can leave point numerically unchanged
1191 ;; despite an insertion immediately after it.
1192 (let* ((obuf (current-buffer))
1193 (buffer (process-buffer proc))
1194 opoint
1195 (window (get-buffer-window buffer))
1196 (pos (window-start window)))
1197 (unwind-protect
1198 (progn
1199 (set-buffer buffer)
1200 (or (= (point) (point-max))
1201 (setq opoint (point)))
1202 (goto-char (point-max))
1203 (insert-before-markers string))
1204 ;; insert-before-markers moved this marker: set it back.
1205 (set-window-start window pos)
1206 ;; Finish our save-excursion.
1207 (if opoint
1208 (goto-char opoint))
1209 (set-buffer obuf))))
1211 ;; like shell-command-sentinel but doesn't print an exit status message
1212 ;; we do this because diff always exits with status 1, if diffs are found
1213 ;; so shell-command-sentinel displays a confusing message to the user
1214 (defun ediff-process-sentinel (process _signal)
1215 (if (and (memq (process-status process) '(exit signal))
1216 (buffer-name (process-buffer process)))
1217 (progn
1218 (with-current-buffer (process-buffer process)
1219 (setq mode-line-process nil))
1220 (delete-process process))))
1223 ;;; Word functions used to refine the current diff
1225 (defvar ediff-forward-word-function 'ediff-forward-word
1226 "Function to call to move to the next word.
1227 Used for splitting difference regions into individual words.")
1228 (make-variable-buffer-local 'ediff-forward-word-function)
1230 ;; \240 is Unicode symbol for nonbreakable whitespace
1231 (defvar ediff-whitespace " \n\t\f\r\240"
1232 "Characters constituting white space.
1233 These characters are ignored when differing regions are split into words.")
1234 (make-variable-buffer-local 'ediff-whitespace)
1236 (defvar ediff-word-1
1237 (if (featurep 'xemacs) "a-zA-Z---_" "-[:word:]_")
1238 "Characters that constitute words of type 1.
1239 More precisely, [ediff-word-1] is a regexp that matches type 1 words.
1240 See `ediff-forward-word' for more details.")
1241 (make-variable-buffer-local 'ediff-word-1)
1243 (defvar ediff-word-2 "0-9.,"
1244 "Characters that constitute words of type 2.
1245 More precisely, [ediff-word-2] is a regexp that matches type 2 words.
1246 See `ediff-forward-word' for more details.")
1247 (make-variable-buffer-local 'ediff-word-2)
1249 (defvar ediff-word-3 "`'?!:;\"{}[]()"
1250 "Characters that constitute words of type 3.
1251 More precisely, [ediff-word-3] is a regexp that matches type 3 words.
1252 See `ediff-forward-word' for more details.")
1253 (make-variable-buffer-local 'ediff-word-3)
1255 (defvar ediff-word-4
1256 (concat "^" ediff-word-1 ediff-word-2 ediff-word-3 ediff-whitespace)
1257 "Characters that constitute words of type 4.
1258 More precisely, [ediff-word-4] is a regexp that matches type 4 words.
1259 See `ediff-forward-word' for more details.")
1260 (make-variable-buffer-local 'ediff-word-4)
1262 ;; Split region along word boundaries. Each word will be on its own line.
1263 ;; Output to buffer out-buffer.
1264 (defun ediff-forward-word ()
1265 "Move point one word forward.
1266 There are four types of words, each of which consists entirely of
1267 characters in `ediff-word-1', `ediff-word-2', `ediff-word-3', or
1268 `ediff-word-4'. Words are recognized by passing these one after another as
1269 arguments to `skip-chars-forward'."
1270 (or (> (+ (skip-chars-forward ediff-word-1)
1271 (skip-syntax-forward "w"))
1273 (> (skip-chars-forward ediff-word-2) 0)
1274 (> (skip-chars-forward ediff-word-3) 0)
1275 (> (skip-chars-forward ediff-word-4) 0)
1279 (defun ediff-wordify (beg end in-buffer out-buffer &optional control-buf)
1280 (let ((forward-word-function
1281 ;; eval in control buf to let user create local versions for
1282 ;; different invocations
1283 (if control-buf
1284 (ediff-with-current-buffer control-buf
1285 ediff-forward-word-function)
1286 ediff-forward-word-function))
1287 inbuf-syntax-tbl sv-point diff-string)
1288 (with-current-buffer in-buffer
1289 (setq inbuf-syntax-tbl
1290 (if control-buf
1291 (ediff-with-current-buffer control-buf
1292 ediff-syntax-table)
1293 (syntax-table)))
1294 (setq diff-string (buffer-substring-no-properties beg end))
1296 (set-buffer out-buffer)
1297 ;; Make sure that temp buff syntax table is the same as the original buf
1298 ;; syntax tbl, because we use ediff-forward-word in both and
1299 ;; ediff-forward-word depends on the syntax classes of characters.
1300 (set-syntax-table inbuf-syntax-tbl)
1301 (erase-buffer)
1302 (insert diff-string)
1303 (goto-char (point-min))
1304 (skip-chars-forward ediff-whitespace)
1305 (delete-region (point-min) (point))
1307 (while (not (eobp))
1308 (funcall forward-word-function)
1309 (setq sv-point (point))
1310 (skip-chars-forward ediff-whitespace)
1311 (delete-region sv-point (point))
1312 (insert "\n")))))
1314 ;; copy string specified as BEG END from IN-BUF to OUT-BUF
1315 (defun ediff-copy-to-buffer (beg end in-buffer out-buffer)
1316 (with-current-buffer out-buffer
1317 (erase-buffer)
1318 (insert-buffer-substring in-buffer beg end)
1319 (goto-char (point-min))))
1322 ;; goto word #n starting at current position in buffer `buf'
1323 ;; For ediff, a word is determined by ediff-forward-word-function
1324 ;; If `flag' is non-nil, goto the end of the n-th word.
1325 (defun ediff-goto-word (n buf &optional flag)
1326 ;; remember val ediff-forward-word-function has in ctl buf
1327 (let ((fwd-word-fun ediff-forward-word-function)
1328 (syntax-tbl ediff-syntax-table))
1329 (ediff-with-current-buffer buf
1330 (skip-chars-forward ediff-whitespace)
1331 (ediff-with-syntax-table syntax-tbl
1332 (while (> n 1)
1333 (funcall fwd-word-fun)
1334 (skip-chars-forward ediff-whitespace)
1335 (setq n (1- n)))
1336 (if (and flag (> n 0))
1337 (funcall fwd-word-fun)))
1338 (point))))
1340 (defun ediff-same-file-contents (f1 f2)
1341 "Return t if files F1 and F2 have identical contents."
1342 (if (and (not (file-directory-p f1))
1343 (not (file-directory-p f2)))
1344 (if (equal (file-remote-p f1) (file-remote-p f2))
1345 (let ((res
1346 ;; In the remote case, this works only if F1 and F2 are
1347 ;; located on the same remote host.
1348 (apply 'process-file ediff-cmp-program nil nil nil
1349 (append ediff-cmp-options
1350 (list (or (file-remote-p f1 'localname)
1351 (expand-file-name f1))
1352 (or (file-remote-p f2 'localname)
1353 (expand-file-name f2)))))
1355 (and (numberp res) (eq res 0)))
1357 ;; F1 and F2 are not located on the same host.
1358 (let ((t1 (file-local-copy f1))
1359 (t2 (file-local-copy f2)))
1360 (unwind-protect
1361 (ediff-same-file-contents (or t1 f1) (or t2 f2))
1362 (and t1 (delete-file t1))
1363 (and t2 (delete-file t2))))
1367 (defun ediff-same-contents (d1 d2 &optional filter-re)
1368 "Return t if D1 and D2 have the same content.
1369 D1 and D2 can either be both directories or both regular files.
1370 Symlinks and the likes are not handled.
1371 If FILTER-RE is non-nil, recursive checking in directories
1372 affects only files whose names match the expression."
1373 ;; Normalize empty filter RE to nil.
1374 (unless (> (length filter-re) 0) (setq filter-re nil))
1375 ;; Indicate progress
1376 (message "Comparing '%s' and '%s' modulo '%s'" d1 d2 filter-re)
1377 (cond
1378 ;; D1 & D2 directories => recurse
1379 ((and (file-directory-p d1)
1380 (file-directory-p d2))
1381 (if (null ediff-recurse-to-subdirectories)
1382 (if (y-or-n-p "Compare subdirectories recursively? ")
1383 (setq ediff-recurse-to-subdirectories 'yes)
1384 (setq ediff-recurse-to-subdirectories 'no)))
1385 (if (eq ediff-recurse-to-subdirectories 'yes)
1386 (let* ((all-entries-1 (directory-files d1 t filter-re))
1387 (all-entries-2 (directory-files d2 t filter-re))
1388 (entries-1 (ediff-delete-all-matches "^\\.\\.?$" all-entries-1))
1389 (entries-2 (ediff-delete-all-matches "^\\.\\.?$" all-entries-2))
1392 (ediff-same-file-contents-lists entries-1 entries-2 filter-re)
1394 ) ; end of the directories case
1395 ;; D1 & D2 are both files => compare directly
1396 ((and (file-regular-p d1)
1397 (file-regular-p d2))
1398 (ediff-same-file-contents d1 d2))
1399 ;; Otherwise => false: unequal contents
1403 ;; If lists have the same length and names of files are pairwise equal
1404 ;; (removing the directories) then compare contents pairwise.
1405 ;; True if all contents are the same; false otherwise
1406 (defun ediff-same-file-contents-lists (entries-1 entries-2 filter-re)
1407 ;; First, check only the names (works quickly and ensures a
1408 ;; precondition for subsequent code)
1409 (if (and (= (length entries-1) (length entries-2))
1410 (equal (mapcar 'file-name-nondirectory entries-1)
1411 (mapcar 'file-name-nondirectory entries-2)))
1412 ;; With name equality established, compare the entries
1413 ;; through recursion.
1414 (let ((continue t))
1415 (while (and entries-1 continue)
1416 (if (ediff-same-contents
1417 (car entries-1) (car entries-2) filter-re)
1418 (setq entries-1 (cdr entries-1)
1419 entries-2 (cdr entries-2))
1420 (setq continue nil))
1422 ;; if reached the end then lists are equal
1423 (null entries-1))
1428 ;; ARG1 is a regexp, ARG2 is a list of full-filenames
1429 ;; Delete all entries that match the regexp
1430 (defun ediff-delete-all-matches (regex file-list-list)
1431 (let (result elt)
1432 (while file-list-list
1433 (setq elt (car file-list-list))
1434 (or (string-match regex (file-name-nondirectory elt))
1435 (setq result (cons elt result)))
1436 (setq file-list-list (cdr file-list-list)))
1437 (reverse result)))
1440 (defun ediff-set-actual-diff-options ()
1441 (if ediff-ignore-case
1442 (setq ediff-actual-diff-options
1443 (concat ediff-diff-options " " ediff-ignore-case-option)
1444 ediff-actual-diff3-options
1445 (concat ediff-diff3-options " " ediff-ignore-case-option3))
1446 (setq ediff-actual-diff-options ediff-diff-options
1447 ediff-actual-diff3-options ediff-diff3-options)
1449 (setq-default ediff-actual-diff-options ediff-actual-diff-options
1450 ediff-actual-diff3-options ediff-actual-diff3-options)
1454 ;; Ignore case handling - some ideas from drew.adams@@oracle.com
1455 (defun ediff-toggle-ignore-case ()
1456 (interactive)
1457 (ediff-barf-if-not-control-buffer)
1458 (setq ediff-ignore-case (not ediff-ignore-case))
1459 (ediff-set-actual-diff-options)
1460 (if ediff-ignore-case
1461 (message "Ignoring regions that differ only in case")
1462 (message "Ignoring case differences turned OFF"))
1463 (cond (ediff-merge-job
1464 (message "Ignoring letter case is too dangerous in merge jobs"))
1465 ((and ediff-diff3-job (string= ediff-ignore-case-option3 ""))
1466 (message "Ignoring letter case is not supported by this diff3 program"))
1467 ((and (not ediff-3way-job) (string= ediff-ignore-case-option ""))
1468 (message "Ignoring letter case is not supported by this diff program"))
1470 (sit-for 1)
1471 (ediff-update-diffs)))
1476 ;; Local Variables:
1477 ;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1478 ;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1479 ;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1480 ;; End:
1482 ;;; ediff-diff.el ends here