lisp/ediff-diff.el

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