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