[Emacs-diffs] Changes to emacs/lisp/ediff-diff.el

[Juanma Barranquero]

Index: emacs/lisp/ediff-diff.el
diff -c emacs/lisp/ediff-diff.el:1.37 emacs/lisp/ediff-diff.el:1.38
*** emacs/lisp/ediff-diff.el:1.37       Sun Nov 17 17:26:48 2002
--- emacs/lisp/ediff-diff.el    Tue Feb  4 06:15:06 2003
***************
*** 126,132 ****
    :group 'ediff-diff)
  
  (defcustom ediff-diff-options ""
!   "*Options to pass to `ediff-diff-program'. 
  If Unix diff is used as `ediff-diff-program', then the most useful options are
  `-w', to ignore space, and `-i', to ignore case of letters.
  At present, the option `-c' is not allowed."
--- 126,132 ----
    :group 'ediff-diff)
  
  (defcustom ediff-diff-options ""
!   "*Options to pass to `ediff-diff-program'.
  If Unix diff is used as `ediff-diff-program', then the most useful options are
  `-w', to ignore space, and `-i', to ignore case of letters.
  At present, the option `-c' is not allowed."
***************
*** 164,170 ****
  ;; the status can be =diff(A), =diff(B), or =diff(A+B)
  (ediff-defvar-local ediff-diff-status "" "")
  
!   
  ;;; Fine differences
  
  (ediff-defvar-local ediff-auto-refine (if (ediff-has-face-support-p) 'on 'nix)
--- 164,170 ----
  ;; the status can be =diff(A), =diff(B), or =diff(A+B)
  (ediff-defvar-local ediff-diff-status "" "")
  
! 
  ;;; Fine differences
  
  (ediff-defvar-local ediff-auto-refine (if (ediff-has-face-support-p) 'on 'nix)
***************
*** 182,188 ****
  
  (ediff-defvar-local ediff-auto-refine-limit 1400
    "*Auto-refine only the regions of this size \(in bytes\) or less.")
!   
  ;;; General
  
  (defvar ediff-diff-ok-lines-regexp
--- 182,188 ----
  
  (ediff-defvar-local ediff-auto-refine-limit 1400
    "*Auto-refine only the regions of this size \(in bytes\) or less.")
! 
  ;;; General
  
  (defvar ediff-diff-ok-lines-regexp
***************
*** 215,221 ****
  file-C. It may ignore file C for diff2 jobs. It should also take
  one optional arguments, diff-number to refine.")
  
!   
  ;;; Functions
  
  ;; Generate the difference vector and overlays for the two files
--- 215,221 ----
  file-C. It may ignore file C for diff2 jobs. It should also take
  one optional arguments, diff-number to refine.")
  
! 
  ;;; Functions
  
  ;; Generate the difference vector and overlays for the two files
***************
*** 228,234 ****
    ;; looking either for '-c' or a 'c' in a set of clustered non-long options
    (if (string-match "^-c\\| -c\\|-[^- ]+c" ediff-diff-options)
        (error "Option `-c' is not allowed in `ediff-diff-options'"))
!                                                 
    ;; create, if it doesn't exist
    (or (ediff-buffer-live-p ediff-diff-buffer)
        (setq ediff-diff-buffer
--- 228,234 ----
    ;; looking either for '-c' or a 'c' in a set of clustered non-long options
    (if (string-match "^-c\\| -c\\|-[^- ]+c" ediff-diff-options)
        (error "Option `-c' is not allowed in `ediff-diff-options'"))
! 
    ;; create, if it doesn't exist
    (or (ediff-buffer-live-p ediff-diff-buffer)
        (setq ediff-diff-buffer
***************
*** 268,276 ****
             (message "")
             (ediff-with-current-buffer diff-buffer
               (buffer-size))))))
-   
  
!      
  ;; If file-A/B/C is nil, do 2-way comparison with the non-nil buffers
  ;; This function works for diff3 and diff2 jobs
  (defun ediff-setup-fine-diff-regions (file-A file-B file-C reg-num)
--- 268,276 ----
             (message "")
             (ediff-with-current-buffer diff-buffer
               (buffer-size))))))
  
! 
! 
  ;; If file-A/B/C is nil, do 2-way comparison with the non-nil buffers
  ;; This function works for diff3 and diff2 jobs
  (defun ediff-setup-fine-diff-regions (file-A file-B file-C reg-num)
***************
*** 278,284 ****
        (setq ediff-fine-diff-buffer
            (get-buffer-create
             (ediff-unique-buffer-name "*ediff-fine-diff" "*"))))
!   
    (let (diff3-job diff-program diff-options ok-regexp diff-list)
      (setq diff3-job ediff-3way-job
          diff-program (if diff3-job ediff-diff3-program ediff-diff-program)
--- 278,284 ----
        (setq ediff-fine-diff-buffer
            (get-buffer-create
             (ediff-unique-buffer-name "*ediff-fine-diff" "*"))))
! 
    (let (diff3-job diff-program diff-options ok-regexp diff-list)
      (setq diff3-job ediff-3way-job
          diff-program (if diff3-job ediff-diff3-program ediff-diff-program)
***************
*** 286,292 ****
          ok-regexp (if diff3-job
                        ediff-diff3-ok-lines-regexp
                        ediff-diff-ok-lines-regexp))
!     
      (ediff-message-if-verbose "Refining difference region %d ..." (1+ 
reg-num))
      (ediff-exec-process diff-program ediff-fine-diff-buffer 'synchronize
                        diff-options
--- 286,292 ----
          ok-regexp (if diff3-job
                        ediff-diff3-ok-lines-regexp
                        ediff-diff-ok-lines-regexp))
! 
      (ediff-message-if-verbose "Refining difference region %d ..." (1+ 
reg-num))
      (ediff-exec-process diff-program ediff-fine-diff-buffer 'synchronize
                        diff-options
***************
*** 298,309 ****
                        (if diff3-job
                            (if file-C file-C file-B))
                        ) ; exec process
!   
      (ediff-prepare-error-list ok-regexp ediff-fine-diff-buffer)
      (ediff-message-if-verbose
       "")
      ;; "Refining difference region %d ... done" (1+ reg-num))
!     
      (setq diff-list
          (if diff3-job
              (ediff-extract-diffs3
--- 298,309 ----
                        (if diff3-job
                            (if file-C file-C file-B))
                        ) ; exec process
! 
      (ediff-prepare-error-list ok-regexp ediff-fine-diff-buffer)
      (ediff-message-if-verbose
       "")
      ;; "Refining difference region %d ... done" (1+ reg-num))
! 
      (setq diff-list
          (if diff3-job
              (ediff-extract-diffs3
***************
*** 327,337 ****
                         (aset elt 5 nil))
                       (cdr diff-list)))
          ))
!     
      (ediff-convert-fine-diffs-to-overlays diff-list reg-num)
      ))
!   
!     
  (defun ediff-prepare-error-list (ok-regexp diff-buff)
    (or (ediff-buffer-live-p ediff-error-buffer)
        (setq ediff-error-buffer
--- 327,337 ----
                         (aset elt 5 nil))
                       (cdr diff-list)))
          ))
! 
      (ediff-convert-fine-diffs-to-overlays diff-list reg-num)
      ))
! 
! 
  (defun ediff-prepare-error-list (ok-regexp diff-buff)
    (or (ediff-buffer-live-p ediff-error-buffer)
        (setq ediff-error-buffer
***************
*** 368,374 ****
        (c-prev 1)
        diff-list shift-A shift-B
        )
!  
      ;; diff list contains word numbers, unless changed later
      (setq diff-list (cons (if word-mode 'words 'points)
                          diff-list))
--- 368,374 ----
        (c-prev 1)
        diff-list shift-A shift-B
        )
! 
      ;; diff list contains word numbers, unless changed later
      (setq diff-list (cons (if word-mode 'words 'points)
                          diff-list))
***************
*** 380,386 ****
              shift-B
              (ediff-overlay-start
               (ediff-get-value-according-to-buffer-type 'B bounds))))
!     
      ;; reset point in buffers A/B/C
      (ediff-with-current-buffer A-buffer
        (goto-char (if shift-A shift-A (point-min))))
--- 380,386 ----
              shift-B
              (ediff-overlay-start
               (ediff-get-value-according-to-buffer-type 'B bounds))))
! 
      ;; reset point in buffers A/B/C
      (ediff-with-current-buffer A-buffer
        (goto-char (if shift-A shift-A (point-min))))
***************
*** 389,395 ****
      (if (ediff-buffer-live-p C-buffer)
        (ediff-with-current-buffer C-buffer
          (goto-char (point-min))))
!     
      (ediff-with-current-buffer diff-buffer
        (goto-char (point-min))
        (while (re-search-forward ediff-match-diff-line nil t)
--- 389,395 ----
      (if (ediff-buffer-live-p C-buffer)
        (ediff-with-current-buffer C-buffer
          (goto-char (point-min))))
! 
      (ediff-with-current-buffer diff-buffer
        (goto-char (point-min))
        (while (re-search-forward ediff-match-diff-line nil t)
***************
*** 423,435 ****
             ;; (string-equal diff-type "c")
             (setq a-end (1+ a-end)
                   b-end (1+ b-end))))
!                  
         (if (eq ediff-default-variant 'default-B)
             (setq c-begin b-begin
                   c-end b-end)
           (setq c-begin a-begin
                 c-end a-end))
!        
         ;; compute main diff vector
         (if word-mode
             ;; make diff-list contain word numbers
--- 423,435 ----
             ;; (string-equal diff-type "c")
             (setq a-end (1+ a-end)
                   b-end (1+ b-end))))
! 
         (if (eq ediff-default-variant 'default-B)
             (setq c-begin b-begin
                   c-end b-end)
           (setq c-begin a-begin
                 c-end a-end))
! 
         ;; compute main diff vector
         (if word-mode
             ;; make diff-list contain word numbers
***************
*** 500,510 ****
                             nil        ; dummy state of ancestor
                             )))
                  )))
!                 
         ))) ; end ediff-with-current-buffer
      diff-list
      ))
!     
  
  (defun ediff-convert-diffs-to-overlays (diff-list)
    (ediff-set-diff-overlays-in-one-buffer 'A diff-list)
--- 500,510 ----
                             nil        ; dummy state of ancestor
                             )))
                  )))
! 
         ))) ; end ediff-with-current-buffer
      diff-list
      ))
! 
  
  (defun ediff-convert-diffs-to-overlays (diff-list)
    (ediff-set-diff-overlays-in-one-buffer 'A diff-list)
***************
*** 530,536 ****
             )))
    (message "Processing difference regions ... done"))
  
!   
  (defun ediff-set-diff-overlays-in-one-buffer (buf-type diff-list)
    (let* ((current-diff -1)
         (buff (ediff-get-buffer buf-type))
--- 530,536 ----
             )))
    (message "Processing difference regions ... done"))
  
! 
  (defun ediff-set-diff-overlays-in-one-buffer (buf-type diff-list)
    (let* ((current-diff -1)
         (buff (ediff-get-buffer buf-type))
***************
*** 548,557 ****
  
      (setq diff-list (cdr diff-list)) ; discard diff list type
      (setq total-diffs (length diff-list))
!       
      ;; shift, if necessary
      (ediff-with-current-buffer buff (setq pt-saved shift))
!          
      (while diff-list
        (setq current-diff (1+ current-diff)
            list-element (car diff-list)
--- 548,557 ----
  
      (setq diff-list (cdr diff-list)) ; discard diff list type
      (setq total-diffs (length diff-list))
! 
      ;; shift, if necessary
      (ediff-with-current-buffer buff (setq pt-saved shift))
! 
      (while diff-list
        (setq current-diff (1+ current-diff)
            list-element (car diff-list)
***************
*** 565,571 ****
                                                  (t 7)))  ; Ancestor
            state-of-diff (aref list-element 8)
            )
!               
        (cond ((and (not (eq buf-type state-of-diff))
                  (not (eq buf-type 'Ancestor))
                  (memq state-of-diff '(A B C)))
--- 565,571 ----
                                                  (t 7)))  ; Ancestor
            state-of-diff (aref list-element 8)
            )
! 
        (cond ((and (not (eq buf-type state-of-diff))
                  (not (eq buf-type 'Ancestor))
                  (memq state-of-diff '(A B C)))
***************
*** 574,580 ****
             (setq state-of-diff (format "=diff(%S)" state-of-diff))
             )
            (t (setq state-of-diff nil)))
!           
        ;; Put overlays at appropriate places in buffer
        ;; convert word numbers to points, if necessary
        (if (eq diff-list-type 'words)
--- 574,580 ----
             (setq state-of-diff (format "=diff(%S)" state-of-diff))
             )
            (t (setq state-of-diff nil)))
! 
        ;; Put overlays at appropriate places in buffer
        ;; convert word numbers to points, if necessary
        (if (eq diff-list-type 'words)
***************
*** 586,592 ****
            (if (> begin end) (setq begin end))
            (setq pt-saved (ediff-with-current-buffer buff (point)))))
        (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
!       
        (ediff-overlay-put overlay 'priority ediff-shadow-overlay-priority)
        (ediff-overlay-put overlay 'ediff-diff-num current-diff)
        (if (and (ediff-has-face-support-p)
--- 586,592 ----
            (if (> begin end) (setq begin end))
            (setq pt-saved (ediff-with-current-buffer buff (point)))))
        (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
! 
        (ediff-overlay-put overlay 'priority ediff-shadow-overlay-priority)
        (ediff-overlay-put overlay 'ediff-diff-num current-diff)
        (if (and (ediff-has-face-support-p)
***************
*** 609,615 ****
            diff-list
            (cdr diff-list))
        ) ; while
!       
      (set (ediff-get-symbol-from-alist buf-type ediff-difference-vector-alist)
         (vconcat diff-overlay-list))
      ))
--- 609,615 ----
            diff-list
            (cdr diff-list))
        ) ; while
! 
      (set (ediff-get-symbol-from-alist buf-type ediff-difference-vector-alist)
         (vconcat diff-overlay-list))
      ))
***************
*** 620,633 ****
  ;; if `flag' is 'skip then don't compute fine diffs for this region.
  (defun ediff-make-fine-diffs (&optional n flag)
    (or n  (setq n ediff-current-difference))
!   
    (if (< ediff-number-of-differences 1)
        (error ediff-NO-DIFFERENCES))
!       
    (if ediff-word-mode
        (setq flag 'skip
            ediff-auto-refine 'nix))
!   
    (or (< n 0)
        (>= n ediff-number-of-differences)
        ;; n is within the range
--- 620,633 ----
  ;; if `flag' is 'skip then don't compute fine diffs for this region.
  (defun ediff-make-fine-diffs (&optional n flag)
    (or n  (setq n ediff-current-difference))
! 
    (if (< ediff-number-of-differences 1)
        (error ediff-NO-DIFFERENCES))
! 
    (if ediff-word-mode
        (setq flag 'skip
            ediff-auto-refine 'nix))
! 
    (or (< n 0)
        (>= n ediff-number-of-differences)
        ;; n is within the range
***************
*** 642,648 ****
            (whitespace-B (ediff-whitespace-diff-region-p n 'B))
            (whitespace-C (ediff-whitespace-diff-region-p n 'C))
            cumulative-fine-diff-length)
!       
        (cond ;; If one of the regions is empty (or 2 in 3way comparison)
              ;; then don't refine.
              ;; If the region happens to be entirely whitespace or empty then
--- 642,648 ----
            (whitespace-B (ediff-whitespace-diff-region-p n 'B))
            (whitespace-C (ediff-whitespace-diff-region-p n 'C))
            cumulative-fine-diff-length)
! 
        (cond ;; If one of the regions is empty (or 2 in 3way comparison)
              ;; then don't refine.
              ;; If the region happens to be entirely whitespace or empty then
***************
*** 706,712 ****
                ediff-control-buffer)
               (setq file-A
                     (ediff-make-temp-file tmp-buffer "fineDiffA" file-A))
!              
               (ediff-wordify
                (ediff-get-diff-posn 'B 'beg n)
                (ediff-get-diff-posn 'B 'end n)
--- 706,712 ----
                ediff-control-buffer)
               (setq file-A
                     (ediff-make-temp-file tmp-buffer "fineDiffA" file-A))
! 
               (ediff-wordify
                (ediff-get-diff-posn 'B 'beg n)
                (ediff-get-diff-posn 'B 'end n)
***************
*** 715,721 ****
                ediff-control-buffer)
               (setq file-B
                     (ediff-make-temp-file tmp-buffer "fineDiffB" file-B))
!              
               (if ediff-3way-job
                   (progn
                     (ediff-wordify
--- 715,721 ----
                ediff-control-buffer)
               (setq file-B
                     (ediff-make-temp-file tmp-buffer "fineDiffB" file-B))
! 
               (if ediff-3way-job
                   (progn
                     (ediff-wordify
***************
*** 727,738 ****
                     (setq file-C
                           (ediff-make-temp-file
                            tmp-buffer "fineDiffC" file-C))))
!              
               ;; save temp file names.
               (setq ediff-temp-file-A file-A
                     ediff-temp-file-B file-B
                     ediff-temp-file-C file-C)
!              
               ;; set the new vector of fine diffs, if none exists
               (cond ((and ediff-3way-job whitespace-A)
                      (ediff-setup-fine-diff-regions nil file-B file-C n))
--- 727,738 ----
                     (setq file-C
                           (ediff-make-temp-file
                            tmp-buffer "fineDiffC" file-C))))
! 
               ;; save temp file names.
               (setq ediff-temp-file-A file-A
                     ediff-temp-file-B file-B
                     ediff-temp-file-C file-C)
! 
               ;; set the new vector of fine diffs, if none exists
               (cond ((and ediff-3way-job whitespace-A)
                      (ediff-setup-fine-diff-regions nil file-B file-C n))
***************
*** 745,751 ****
                      (ediff-setup-fine-diff-regions file-A file-B nil n))
                     (t
                      (ediff-setup-fine-diff-regions file-A file-B file-C n)))
!                     
               (setq cumulative-fine-diff-length
                     (+ (length (ediff-get-fine-diff-vector n 'A))
                        (length (ediff-get-fine-diff-vector n 'B))
--- 745,751 ----
                      (ediff-setup-fine-diff-regions file-A file-B nil n))
                     (t
                      (ediff-setup-fine-diff-regions file-A file-B file-C n)))
! 
               (setq cumulative-fine-diff-length
                     (+ (length (ediff-get-fine-diff-vector n 'A))
                        (length (ediff-get-fine-diff-vector n 'B))
***************
*** 753,759 ****
                        (if (and file-C (not ediff-merge-job))
                            (length (ediff-get-fine-diff-vector n 'C))
                          0)))
!                     
               (cond ((or
                       ;; all regions are white space
                       (and whitespace-A whitespace-B whitespace-C)
--- 753,759 ----
                        (if (and file-C (not ediff-merge-job))
                            (length (ediff-get-fine-diff-vector n 'C))
                          0)))
! 
               (cond ((or
                       ;; all regions are white space
                       (and whitespace-A whitespace-B whitespace-C)
***************
*** 781,787 ****
              ) ; end cond
        (ediff-set-fine-diff-properties n)
        )))
!       
  ;; Interface to ediff-make-fine-diffs. Checks for auto-refine limit, etc.
  (defun ediff-install-fine-diff-if-necessary (n)
    (cond ((and (eq ediff-auto-refine 'on)
--- 781,787 ----
              ) ; end cond
        (ediff-set-fine-diff-properties n)
        )))
! 
  ;; Interface to ediff-make-fine-diffs. Checks for auto-refine limit, etc.
  (defun ediff-install-fine-diff-if-necessary (n)
    (cond ((and (eq ediff-auto-refine 'on)
***************
*** 797,808 ****
                    (ediff-get-diff-posn 'B 'beg n))))
             (ediff-make-fine-diffs n 'noforce)
           (ediff-make-fine-diffs n 'skip)))
!       
        ;; highlight iff fine diffs already exist
        ((eq ediff-auto-refine 'off)
         (ediff-make-fine-diffs n 'skip))))
!     
!     
  ;; if fine diff vector is not set for diff N, then do nothing
  (defun ediff-set-fine-diff-properties (n &optional default)
    (or (not (ediff-has-face-support-p))
--- 797,808 ----
                    (ediff-get-diff-posn 'B 'beg n))))
             (ediff-make-fine-diffs n 'noforce)
           (ediff-make-fine-diffs n 'skip)))
! 
        ;; highlight iff fine diffs already exist
        ((eq ediff-auto-refine 'off)
         (ediff-make-fine-diffs n 'skip))))
! 
! 
  ;; if fine diff vector is not set for diff N, then do nothing
  (defun ediff-set-fine-diff-properties (n &optional default)
    (or (not (ediff-has-face-support-p))
***************
*** 814,820 ****
        (ediff-set-fine-diff-properties-in-one-buffer 'B n default)
        (if ediff-3way-job
            (ediff-set-fine-diff-properties-in-one-buffer 'C n default)))))
!       
  (defun ediff-set-fine-diff-properties-in-one-buffer (buf-type
                                                     n &optional default)
    (let ((fine-diff-vector  (ediff-get-fine-diff-vector n buf-type))
--- 814,820 ----
        (ediff-set-fine-diff-properties-in-one-buffer 'B n default)
        (if ediff-3way-job
            (ediff-set-fine-diff-properties-in-one-buffer 'C n default)))))
! 
  (defun ediff-set-fine-diff-properties-in-one-buffer (buf-type
                                                     n &optional default)
    (let ((fine-diff-vector  (ediff-get-fine-diff-vector n buf-type))
***************
*** 836,842 ****
              (ediff-set-overlay-face overl face)
              (ediff-overlay-put overl 'priority priority))
            fine-diff-vector)))
!      
  ;; Set overlays over the regions that denote delimiters
  (defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num)
    (let (overlay overlay-list)
--- 836,842 ----
              (ediff-set-overlay-face overl face)
              (ediff-overlay-put overl 'priority priority))
            fine-diff-vector)))
! 
  ;; Set overlays over the regions that denote delimiters
  (defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num)
    (let (overlay overlay-list)
***************
*** 856,863 ****
      (ediff-set-fine-diff-vector
       reg-num 'C (apply 'vector overlay-list))
      ))
!       
!     
  ;; Convert diff list to overlays for a given DIFF-REGION
  ;; in buffer of type BUF-TYPE
  (defun ediff-set-fine-overlays-in-one-buffer (buf-type diff-list region-num)
--- 856,863 ----
      (ediff-set-fine-diff-vector
       reg-num 'C (apply 'vector overlay-list))
      ))
! 
! 
  ;; Convert diff list to overlays for a given DIFF-REGION
  ;; in buffer of type BUF-TYPE
  (defun ediff-set-fine-overlays-in-one-buffer (buf-type diff-list region-num)
***************
*** 871,877 ****
      (ediff-clear-fine-differences-in-one-buffer region-num buf-type)
      (setq diff-list (cdr diff-list)) ; discard list type (words or points)
      (ediff-with-current-buffer buff (goto-char reg-start))
!     
      ;; if it is a combined merge then set overlays in buff C specially
      (if (and ediff-merge-job (eq buf-type 'C)
             (setq combined-merge-diff-list
--- 871,877 ----
      (ediff-clear-fine-differences-in-one-buffer region-num buf-type)
      (setq diff-list (cdr diff-list)) ; discard list type (words or points)
      (ediff-with-current-buffer buff (goto-char reg-start))
! 
      ;; if it is a combined merge then set overlays in buff C specially
      (if (and ediff-merge-job (eq buf-type 'C)
             (setq combined-merge-diff-list
***************
*** 897,903 ****
          (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
          ;; record all overlays for this difference region
          (setq diff-overlay-list (nconc diff-overlay-list (list overlay))))
!       
        (setq diff-list (cdr diff-list))
        ) ; while
        ;; convert the list of difference information into a vector
--- 897,903 ----
          (setq overlay (ediff-make-bullet-proof-overlay begin end buff))
          ;; record all overlays for this difference region
          (setq diff-overlay-list (nconc diff-overlay-list (list overlay))))
! 
        (setq diff-list (cdr diff-list))
        ) ; while
        ;; convert the list of difference information into a vector
***************
*** 964,970 ****
        (anc-prev 1)
        diff-list shift-A shift-B shift-C
        )
!  
      ;; diff list contains word numbers or points, depending on word-mode
      (setq diff-list (cons (if word-mode 'words 'points)
                          diff-list))
--- 964,970 ----
        (anc-prev 1)
        diff-list shift-A shift-B shift-C
        )
! 
      ;; diff list contains word numbers or points, depending on word-mode
      (setq diff-list (cons (if word-mode 'words 'points)
                          diff-list))
***************
*** 979,985 ****
              (if three-way-comp
                  (ediff-overlay-start
                   (ediff-get-value-according-to-buffer-type 'C bounds)))))
!     
      ;; reset point in buffers A, B, C
      (ediff-with-current-buffer A-buffer
        (goto-char (if shift-A shift-A (point-min))))
--- 979,985 ----
              (if three-way-comp
                  (ediff-overlay-start
                   (ediff-get-value-according-to-buffer-type 'C bounds)))))
! 
      ;; reset point in buffers A, B, C
      (ediff-with-current-buffer A-buffer
        (goto-char (if shift-A shift-A (point-min))))
***************
*** 991,997 ****
      (if (ediff-buffer-live-p anc-buffer)
        (ediff-with-current-buffer anc-buffer
          (goto-char (point-min))))
!     
      (ediff-with-current-buffer diff-buffer
        (goto-char (point-min))
        (while (re-search-forward ediff-match-diff3-line nil t)
--- 991,997 ----
      (if (ediff-buffer-live-p anc-buffer)
        (ediff-with-current-buffer anc-buffer
          (goto-char (point-min))))
! 
      (ediff-with-current-buffer diff-buffer
        (goto-char (point-min))
        (while (re-search-forward ediff-match-diff3-line nil t)
***************
*** 1023,1029 ****
                    b-begin-pt b-end-pt
                    c-begin-pt c-end-pt
                    anc-begin-pt anc-end-pt)
!                   
               (setq state-of-ancestor
                     (= c-or-anc-begin c-or-anc-end))
  
--- 1023,1029 ----
                    b-begin-pt b-end-pt
                    c-begin-pt c-end-pt
                    anc-begin-pt anc-end-pt)
! 
               (setq state-of-ancestor
                     (= c-or-anc-begin c-or-anc-end))
  
***************
*** 1036,1042 ****
                     (t
                      (setq c-begin a-begin
                            c-end a-end)))
!        
               ;; compute main diff vector
               (if word-mode
                   ;; make diff-list contain word numbers
--- 1036,1042 ----
                     (t
                      (setq c-begin a-begin
                            c-end a-end)))
! 
               ;; compute main diff vector
               (if word-mode
                   ;; make diff-list contain word numbers
***************
*** 1105,1115 ****
                                        )))
                        )))
               ))
!              
         ))) ; end ediff-with-current-buffer
      diff-list
      ))
!     
  ;; Generate the difference vector and overlays for three files
  ;; File-C is either the third file to compare (in case of 3-way comparison)
  ;; or it is the ancestor file.
--- 1105,1115 ----
                                        )))
                        )))
               ))
! 
         ))) ; end ediff-with-current-buffer
      diff-list
      ))
! 
  ;; Generate the difference vector and overlays for three files
  ;; File-C is either the third file to compare (in case of 3-way comparison)
  ;; or it is the ancestor file.
***************
*** 1117,1127 ****
    (or (ediff-buffer-live-p ediff-diff-buffer)
        (setq ediff-diff-buffer
            (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
!   
    (message "Computing differences ...")
    (ediff-exec-process ediff-diff3-program ediff-diff-buffer 'synchronize
                      ediff-diff3-options file-A file-B file-C)
!   
    (ediff-prepare-error-list ediff-diff3-ok-lines-regexp ediff-diff-buffer)
    ;;(message "Computing differences ... done")
    (ediff-convert-diffs-to-overlays
--- 1117,1127 ----
    (or (ediff-buffer-live-p ediff-diff-buffer)
        (setq ediff-diff-buffer
            (get-buffer-create (ediff-unique-buffer-name "*ediff-diff" "*"))))
! 
    (message "Computing differences ...")
    (ediff-exec-process ediff-diff3-program ediff-diff-buffer 'synchronize
                      ediff-diff3-options file-A file-B file-C)
! 
    (ediff-prepare-error-list ediff-diff3-ok-lines-regexp ediff-diff-buffer)
    ;;(message "Computing differences ... done")
    (ediff-convert-diffs-to-overlays
***************
*** 1129,1135 ****
      ediff-diff-buffer
      ediff-word-mode ediff-3way-comparison-job ediff-narrow-bounds)
     ))
!    
  
  ;; Execute PROGRAM asynchronously, unless OS/2, Windows-*, or DOS, or unless
  ;; SYNCH is non-nil.  BUFFER must be a buffer object, and must be alive.  The
--- 1129,1135 ----
      ediff-diff-buffer
      ediff-word-mode ediff-3way-comparison-job ediff-narrow-bounds)
     ))
! 
  
  ;; Execute PROGRAM asynchronously, unless OS/2, Windows-*, or DOS, or unless
  ;; SYNCH is non-nil.  BUFFER must be a buffer object, and must be alive.  The
***************
*** 1176,1182 ****
              (set-process-filter proc 'ediff-process-filter)
              )))
        (store-match-data data))))
!       
  ;; This is shell-command-filter from simple.el in Emacs.
  ;; Copied here because XEmacs doesn't have it.
  (defun ediff-process-filter (proc string)
--- 1176,1182 ----
              (set-process-filter proc 'ediff-process-filter)
              )))
        (store-match-data data))))
! 
  ;; This is shell-command-filter from simple.el in Emacs.
  ;; Copied here because XEmacs doesn't have it.
  (defun ediff-process-filter (proc string)
***************
*** 1200,1206 ****
        (if opoint
            (goto-char opoint))
        (set-buffer obuf))))
!       
  ;; like shell-command-sentinel but doesn't print an exit status message
  ;; we do this because diff always exits with status 1, if diffs are found
  ;; so shell-command-sentinel displays a confusing message to the user
--- 1200,1206 ----
        (if opoint
            (goto-char opoint))
        (set-buffer obuf))))
! 
  ;; like shell-command-sentinel but doesn't print an exit status message
  ;; we do this because diff always exits with status 1, if diffs are found
  ;; so shell-command-sentinel displays a confusing message to the user
***************
*** 1212,1218 ****
            (set-buffer (process-buffer process))
            (setq mode-line-process nil))
          (delete-process process))))
!       
  
  ;;; Word functions used to refine the current diff
  
--- 1212,1218 ----
            (set-buffer (process-buffer process))
            (setq mode-line-process nil))
          (delete-process process))))
! 
  
  ;;; Word functions used to refine the current diff
  
***************
*** 1297,1310 ****
       (goto-char (point-min))
       (skip-chars-forward ediff-whitespace)
       (delete-region (point-min) (point))
!      
       (while (not (eobp))
         (funcall forward-word-function)
         (setq sv-point (point))
         (skip-chars-forward ediff-whitespace)
         (delete-region sv-point (point))
         (insert "\n")))))
!        
  ;; copy string specified as BEG END from IN-BUF to OUT-BUF
  (defun ediff-copy-to-buffer (beg end in-buffer out-buffer)
    (with-current-buffer out-buffer
--- 1297,1310 ----
       (goto-char (point-min))
       (skip-chars-forward ediff-whitespace)
       (delete-region (point-min) (point))
! 
       (while (not (eobp))
         (funcall forward-word-function)
         (setq sv-point (point))
         (skip-chars-forward ediff-whitespace)
         (delete-region sv-point (point))
         (insert "\n")))))
! 
  ;; copy string specified as BEG END from IN-BUF to OUT-BUF
  (defun ediff-copy-to-buffer (beg end in-buffer out-buffer)
    (with-current-buffer out-buffer