:prefix "ediff-"
:group 'ediff)
+;; these two must be here to prevent ediff-test-utility from barking
+(defcustom ediff-diff-program "diff"
+ "*Program to use for generating the differential of the two files."
+ :type 'string
+ :group 'ediff-diff)
+(defcustom ediff-diff3-program "diff3"
+ "*Program to be used for three-way comparison.
+Must produce output compatible with Unix's diff3 program."
+ :type 'string
+ :group 'ediff-diff)
+
+;; The following functions must precede all defcustom-defined variables.
+
+;; The following functions needed for setting diff/diff3 options
+;; test if diff supports the --binary option
+(defsubst ediff-test-utility (diff-util option &optional files)
+ (zerop (apply 'call-process
+ (append (list diff-util nil nil nil option) files))))
+
+(defun ediff-diff-mandatory-option (diff-util)
+ (let ((file (if (boundp 'null-device) null-device "/dev/null")))
+ (cond ((not (memq system-type '(ms-dos windows-nt windows-95)))
+ "")
+ ((and (string= diff-util ediff-diff-program)
+ (ediff-test-utility
+ ediff-diff-program "--binary" (list file file)))
+ "--binary")
+ ((and (string= diff-util ediff-diff3-program)
+ (ediff-test-utility
+ ediff-diff3-program "--binary" (list file file file)))
+ "--binary")
+ (t ""))))
+
+;; make sure that mandatory options are added even if the user changes
+;; ediff-diff-options or ediff-diff3-options in the customization widget
+(defun ediff-reset-diff-options (symb val)
+ (let* ((diff-program
+ (if (eq symb 'ediff-diff-options)
+ ediff-diff-program
+ ediff-diff3-program))
+ (mandatory-option (ediff-diff-mandatory-option diff-program))
+ (spacer (if (string-equal mandatory-option "") "" " ")))
+ (set symb
+ (if (string-match mandatory-option val)
+ val
+ (concat mandatory-option spacer val)))
+ ))
+
(defcustom ediff-shell
(cond ((eq system-type 'emx) "cmd") ; OS/2
:type 'string
:group 'ediff-diff)
-(defcustom ediff-diff-program "diff"
- "*Program to use for generating the differential of the two files."
- :type 'string
+(defcustom ediff-cmp-options nil
+ "*Options to pass to `ediff-cmp-program'. If GNUS diff is used as
+`ediff-cmp-program', then the most useful options are `-I' RE, to
+ignore changes whose lines all match RE."
+ :type '(repeat string)
:group 'ediff-diff)
-(defcustom ediff-diff-options ""
+
+(defcustom ediff-diff-options ""
"*Options to pass to `ediff-diff-program'.
If diff\(1\) 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."
+ :set 'ediff-reset-diff-options
:type 'string
:group 'ediff-diff)
(defvar ediff-match-diff3-line "^====\\(.?\\)$"
"Pattern to match lines produced by diff3 that describe differences.")
-(defcustom ediff-diff3-program "diff3"
- "*Program to be used for three-way comparison.
-Must produce output compatible with Unix's diff3 program."
- :type 'string
- :group 'ediff-diff)
(defcustom ediff-diff3-options ""
"*Options to pass to `ediff-diff3-program'."
+ :set 'ediff-reset-diff-options
:type 'string
:group 'ediff-diff)
(defcustom ediff-diff3-ok-lines-regexp
;; fixup diff-list
(if diff3-job
(cond ((not file-A)
- (mapcar (function (lambda (elt)
- (aset elt 0 nil)
- (aset elt 1 nil)))
+ (mapcar (lambda (elt)
+ (aset elt 0 nil)
+ (aset elt 1 nil))
(cdr diff-list)))
((not file-B)
- (mapcar (function (lambda (elt)
- (aset elt 2 nil)
- (aset elt 3 nil)))
+ (mapcar (lambda (elt)
+ (aset elt 2 nil)
+ (aset elt 3 nil))
(cdr diff-list)))
((not file-C)
- (mapcar (function (lambda (elt)
- (aset elt 4 nil)
- (aset elt 5 nil)))
+ (mapcar (lambda (elt)
+ (aset elt 4 nil)
+ (aset elt 5 nil))
(cdr diff-list)))
))
(if ediff-merge-job
(setq ediff-state-of-merge
(vconcat
- (mapcar (function
- (lambda (elt)
- (let ((state-of-merge (aref elt 9))
- (state-of-ancestor (aref elt 10)))
- (vector
- (if state-of-merge (format "%S" state-of-merge))
- state-of-ancestor))))
+ (mapcar (lambda (elt)
+ (let ((state-of-merge (aref elt 9))
+ (state-of-ancestor (aref elt 10)))
+ (vector
+ ;; state of merge: prefers/default-A/B or combined
+ (if state-of-merge (format "%S" state-of-merge))
+ ;; whether the ancestor region is empty
+ state-of-ancestor)))
;; the first elt designates type of list
(cdr diff-list))
)))
(if (= 0 (mod current-diff 10))
(message "Buffer %S: Processing difference region %d of %d"
buf-type current-diff total-diffs))
- ;; record all overlays for this difference
- ;; the second elt, nil, is a place holder for the fine diff vector.
- ;; the third elt, nil, is a place holder for no-fine-diffs flag.
+ ;; Record all overlays for this difference.
+ ;; The 2-d elt, nil, is a place holder for the fine diff vector.
+ ;; The 3-d elt, nil, is a place holder for no-fine-diffs flag.
+ ;; The 4-th elt says which diff region is different from the other two
+ ;; (3-way jobs only).
(setq diff-overlay-list
(nconc
diff-overlay-list
(or (ediff-get-fine-diff-vector n 'A)
(memq ediff-auto-refine '(off nix))
(ediff-message-if-verbose
- "Region %d exceeds auto-refine limit. Type `%s' to refine"
+ "Region %d exceeds the auto-refinement limit. Type `%s' to refine"
(1+ n)
(substitute-command-keys
"\\[ediff-make-or-kill-fine-diffs]")
ediff-current-diff-overlay-alist))
'priority)
0)))))
- (mapcar
- (function (lambda (overl)
- (ediff-set-overlay-face overl face)
- (ediff-overlay-put overl 'priority priority)))
- fine-diff-vector)))
+ (mapcar (lambda (overl)
+ (ediff-set-overlay-face overl face)
+ (ediff-overlay-put overl 'priority priority))
+ fine-diff-vector)))
-;; This assumes buffer C and that the region looks like a combination of
-;; regions in buffer A and C.
+;; Set overlays over the regions that denote delimiters
(defun ediff-set-fine-overlays-for-combined-merge (diff-list reg-num)
- (let (overlay1 overlay2 overlay3)
- (setq overlay1 (ediff-make-bullet-proof-overlay (nth 0 diff-list)
- (nth 1 diff-list)
- ediff-buffer-C)
- overlay2 (ediff-make-bullet-proof-overlay (nth 2 diff-list)
- (nth 3 diff-list)
- ediff-buffer-C)
- overlay3 (ediff-make-bullet-proof-overlay (nth 4 diff-list)
- (nth 5 diff-list)
- ediff-buffer-C))
- (ediff-set-fine-diff-vector reg-num 'C (vector overlay1 overlay2 overlay3))
+ (let (overlay overlay-list)
+ (while diff-list
+ (condition-case nil
+ (setq overlay
+ (ediff-make-bullet-proof-overlay
+ (nth 0 diff-list) (nth 1 diff-list) ediff-buffer-C))
+ (error ""))
+ (setq overlay-list (cons overlay overlay-list))
+ (if (> (length diff-list) 1)
+ (setq diff-list (cdr (cdr diff-list)))
+ (error "ediff-set-fine-overlays-for-combined-merge: corrupt list of
+delimiter regions"))
+ )
+ (setq overlay-list (reverse overlay-list))
+ (ediff-set-fine-diff-vector
+ reg-num 'C (apply 'vector overlay-list))
))
;; args.
(defun ediff-exec-process (program buffer synch options &rest files)
(let ((data (match-data))
+ (coding-system-for-read 'no-conversion)
args)
(setq args (append (split-string options) files))
(setq args (delete "" (delq nil args))) ; delete nil and "" from arguments
+ ;; the --binary option, if present, should be used only for buffer jobs
+ ;; or for refining the differences
+ (or (string-match "buffer" (symbol-name ediff-job-name))
+ (eq buffer ediff-fine-diff-buffer)
+ (setq args (delete "--binary" args)))
(unwind-protect
(let ((directory default-directory)
proc)
)))
(store-match-data data))))
-;; This is shell-command-filter from simple.el in FSF Emacs.
+;; This is shell-command-filter from simple.el in Emacs.
;; Copied here because XEmacs doesn't have it.
(defun ediff-process-filter (proc string)
;; Do save-excursion by hand so that we can leave point numerically unchanged
"*Characters constituting white space.
These characters are ignored when differing regions are split into words.")
-;;(defvar ediff-word-1 "a-zA-Z---_`'.?!:"
(defvar ediff-word-1 "a-zA-Z---_"
"*Characters that constitute words of type 1.
More precisely, [ediff-word-1] is a regexp that matches type 1 words.
"Move point one word forward.
There are four types of words, each of which consists entirely of
characters in `ediff-word-1', `ediff-word-2', `ediff-word-3', or
-`ediff-word-4'. Words are recognized by passing these in turn as the
-argument to `skip-chars-forward'."
- (or (> (skip-chars-forward ediff-word-1) 0)
+`ediff-word-4'. Words are recognized by passing these one after another as
+arguments to `skip-chars-forward'."
+ (or (> (+ (skip-chars-forward ediff-word-1)
+ (skip-syntax-forward "w"))
+ 0)
(> (skip-chars-forward ediff-word-2) 0)
(> (skip-chars-forward ediff-word-3) 0)
(> (skip-chars-forward ediff-word-4) 0)
))
+
(defun ediff-wordify (beg end in-buffer out-buffer &optional control-buf)
- (let (sv-point string)
+ (let (inbuf-syntax-tbl sv-point string)
(save-excursion
(set-buffer in-buffer)
+ (setq inbuf-syntax-tbl (syntax-table))
(setq string (buffer-substring-no-properties beg end))
(set-buffer out-buffer)
+ ;; Make sure that temp buff syntax table is the same a the original buf
+ ;; syntax tbl, because we use ediff-forward-word in both and
+ ;; ediff-forward-word depends on the syntax classes of characters.
+ (set-syntax-table inbuf-syntax-tbl)
(erase-buffer)
(insert string)
(goto-char (point-min))
;; different invocations
(if control-buf
(funcall
- (ediff-with-current-buffer control-buf ediff-forward-word-function))
+ (ediff-with-current-buffer
+ control-buf ediff-forward-word-function))
(funcall ediff-forward-word-function))
(setq sv-point (point))
(skip-chars-forward ediff-whitespace)
(defun ediff-same-file-contents (f1 f2)
"T if F1 and F2 have identical contents."
- (let ((res (call-process ediff-cmp-program nil nil nil f1 f2)))
+ (let ((res
+ (apply 'call-process ediff-cmp-program nil nil nil
+ (append ediff-cmp-options (list f1 f2)))))
(and (numberp res) (eq res 0))))
HCoop / bpt / emacs.git / blobdiff