X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/1e70790f2f4826c646d5640a9f6162aa78ea682b..ae0317df2293c5f60a82e2a6ee994c9b1f08a195:/lisp/ediff-init.el

diff --git a/lisp/ediff-init.el b/lisp/ediff-init.el
index d825cae43f..21416c8ee6 100644
--- a/lisp/ediff-init.el
+++ b/lisp/ediff-init.el
@@ -1,6 +1,6 @@
 ;;; ediff-init.el --- Macros, variables, and defsubsts used by Ediff
 
-;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1996, 1997, 2000 Free Software Foundation, Inc.
 
 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
 
@@ -32,6 +32,7 @@
 (defvar ediff-mouse-pixel-threshold)
 (defvar ediff-whitespace)
 (defvar ediff-multiframe)
+(defvar ediff-use-toolbar-p)
 
 (and noninteractive
      (eval-when-compile
@@ -59,15 +60,23 @@ that Ediff doesn't know about.")
   (and (ediff-device-type) (not (memq (ediff-device-type) '(tty pc stream)))))
 
 ;; test if supports faces
-;; ediff-force-faces is for those devices that support faces, but we don't know
-;; this yet
 (defun ediff-has-face-support-p ()
   (cond ((ediff-window-display-p))
 	(ediff-force-faces)
+	((ediff-color-display-p))
 	(ediff-emacs-p (memq (ediff-device-type) '(pc)))
 	(ediff-xemacs-p (memq (ediff-device-type) '(tty pc)))))
 
-  
+(defun ediff-has-toolbar-support-p ()
+  (and ediff-xemacs-p
+       (featurep 'toolbar)
+       (console-on-window-system-p)))
+
+(defun ediff-use-toolbar-p ()
+  (and (ediff-has-toolbar-support-p)	;Can it do it ?
+       (boundp 'ediff-use-toolbar-p)
+       ediff-use-toolbar-p))		;Does the user want it ?
+
 ;; Defines SYMBOL as an advertised local variable.  
 ;; Performs a defvar, then executes `make-variable-buffer-local' on
 ;; the variable.  Also sets the `permanent-local' property,
@@ -76,10 +85,10 @@ that Ediff doesn't know about.")
 ;; 
 ;; Plagiarised from `emerge-defvar-local' for XEmacs.
 (defmacro ediff-defvar-local (var value doc) 
-  (` (progn
-       (defvar (, var) (, value) (, doc))
-       (make-variable-buffer-local '(, var))
-       (put '(, var) 'permanent-local t))))
+  `(progn
+     (defvar ,var ,value ,doc)
+     (make-variable-buffer-local ',var)
+     (put ',var 'permanent-local t)))
     
 
 
@@ -90,49 +99,71 @@ that Ediff doesn't know about.")
 (ediff-defvar-local ediff-buffer-A nil "")
 ;; The buffer in which the B variant is stored.
 (ediff-defvar-local ediff-buffer-B nil "")
-;; The buffer in which the C variant is stored.
+;; The buffer in which the C variant is stored or where the merge buffer lives.
 (ediff-defvar-local ediff-buffer-C nil "")
 ;; Ancestor buffer
 (ediff-defvar-local ediff-ancestor-buffer nil "")
 ;; The Ediff control buffer
 (ediff-defvar-local ediff-control-buffer nil "")
 
+
+;; Association between buff-type and ediff-buffer-*
+(defconst ediff-buffer-alist
+  '((?A . ediff-buffer-A)
+    (?B . ediff-buffer-B)
+    (?C . ediff-buffer-C)))
+
 ;;; Macros
 (defmacro ediff-odd-p (arg)
-  (` (eq (logand (, arg) 1) 1)))
+  `(eq (logand ,arg 1) 1))
 
 (defmacro ediff-buffer-live-p (buf)
-  (` (and (, buf) (get-buffer (, buf)) (buffer-name (get-buffer (, buf))))))
+  `(and ,buf (get-buffer ,buf) (buffer-name (get-buffer ,buf))))
 
 (defmacro ediff-get-buffer (arg)
-  (` (cond ((eq (, arg) 'A) ediff-buffer-A)
-	   ((eq (, arg) 'B) ediff-buffer-B)
-	   ((eq (, arg) 'C) ediff-buffer-C)
-	   ((eq (, arg) 'Ancestor) ediff-ancestor-buffer)
-	   )
-  ))
+  `(cond ((eq ,arg 'A) ediff-buffer-A)
+	 ((eq ,arg 'B) ediff-buffer-B)
+	 ((eq ,arg 'C) ediff-buffer-C)
+	 ((eq ,arg 'Ancestor) ediff-ancestor-buffer)
+	 ))
   
 (defmacro ediff-get-value-according-to-buffer-type (buf-type list)
-  (` (cond ((eq (, buf-type) 'A) (nth 0 (, list)))
-	   ((eq (, buf-type) 'B) (nth 1 (, list)))
-	   ((eq (, buf-type) 'C) (nth 2 (, list))))))
+  `(cond ((eq ,buf-type 'A) (nth 0 ,list))
+	 ((eq ,buf-type 'B) (nth 1 ,list))
+	 ((eq ,buf-type 'C) (nth 2 ,list))
+	 ))
 	   
 (defmacro ediff-char-to-buftype (arg)
-  (` (cond ((memq (, arg) '(?a ?A)) 'A)
-	   ((memq (, arg) '(?b ?B)) 'B)
-	   ((memq (, arg) '(?c ?C)) 'C)
-	   )
-  ))
+  `(cond ((memq ,arg '(?a ?A)) 'A)
+	 ((memq ,arg '(?b ?B)) 'B)
+	 ((memq ,arg '(?c ?C)) 'C)
+	 ))
+
+
+;; A-list is supposed to be of the form (A . symb) (B . symb)...)
+;; where the first part of any association is a buffer type and the second is
+;; an appropriate symbol.  Given buffer-type, this function returns the
+;; symbol.  This is used to avoid using `intern'
+(defsubst ediff-get-symbol-from-alist (buf-type alist)
+  (cdr (assoc buf-type alist)))
   
+(defconst ediff-difference-vector-alist
+  '((A . ediff-difference-vector-A)
+    (B . ediff-difference-vector-B)
+    (C . ediff-difference-vector-C)
+    (Ancestor . ediff-difference-vector-Ancestor)))
+
 (defmacro ediff-get-difference (n buf-type)
-  (` (aref
-      (symbol-value
-       (intern (format "ediff-difference-vector-%S" (, buf-type)))) (, n))))
+  `(aref
+    (symbol-value
+     (ediff-get-symbol-from-alist
+      ,buf-type ediff-difference-vector-alist))
+    ,n))
   
 ;; Tell if it has been previously determined that the region has
 ;; no diffs other than the white space and newlines
 ;; The argument, N, is the diff region number used by Ediff to index the
-;; diff vector. It is 1 less than the number seen by the user.
+;; diff vector.  It is 1 less than the number seen by the user.
 ;; Returns:
 ;;		t  if the diffs are whitespace in all buffers
 ;;		'A (in 3-buf comparison only) if there are only whitespace
@@ -142,125 +173,127 @@ that Ediff doesn't know about.")
 ;;		'C (in 3-buf comparison only) if there are only whitespace
 ;;		   diffs in bufs A and B
 ;;
-;; A difference vector has the form:
+;; A Difference Vector has the form:
 ;; [diff diff diff ...]
 ;; where each diff has the form:
-;; [overlay fine-diff-vector no-fine-diffs-flag]
+;; [overlay fine-diff-vector no-fine-diffs-flag state-of-difference]
 ;; fine-diff-vector is a vector [fine-diff fine-diff fine-diff ...]
+;; no-fine-diffs-flag says if there are fine differences.
+;; state-of-difference is A, B, C, or nil, indicating which buffer is
+;; 	different from the other two (used only in 3-way jobs).
 (defmacro ediff-no-fine-diffs-p (n)
-  (` (aref (ediff-get-difference (, n) 'A) 2)))
+  `(aref (ediff-get-difference ,n 'A) 2))
   
 (defmacro ediff-get-diff-overlay-from-diff-record (diff-rec)
-  (` (aref (, diff-rec) 0)))
+  `(aref ,diff-rec 0))
   
 (defmacro ediff-get-diff-overlay (n buf-type)  
-  (` (ediff-get-diff-overlay-from-diff-record
-      (ediff-get-difference (, n) (, buf-type)))))
+  `(ediff-get-diff-overlay-from-diff-record
+    (ediff-get-difference ,n ,buf-type)))
 
 (defmacro ediff-get-fine-diff-vector-from-diff-record (diff-rec)
-  (` (aref (, diff-rec) 1)))
+  `(aref ,diff-rec 1))
       
 (defmacro ediff-set-fine-diff-vector (n buf-type fine-vec)
-  (` (aset (ediff-get-difference (, n) (, buf-type)) 1 (, fine-vec))))
+  `(aset (ediff-get-difference ,n ,buf-type) 1 ,fine-vec))
   
 (defmacro ediff-get-state-of-diff (n buf-type)
-  (` (if (ediff-buffer-live-p ediff-buffer-C)
-	 (aref (ediff-get-difference (, n) (, buf-type)) 3))))
+  `(if (ediff-buffer-live-p ediff-buffer-C)
+       (aref (ediff-get-difference ,n ,buf-type) 3)))
 (defmacro ediff-set-state-of-diff (n buf-type val)
-  (` (aset (ediff-get-difference (, n) (, buf-type)) 3 (, val))))
+  `(aset (ediff-get-difference ,n ,buf-type) 3 ,val))
+
 (defmacro ediff-get-state-of-merge (n)
-  (` (if ediff-state-of-merge
-	 (aref (aref ediff-state-of-merge (, n)) 0))))
-(defmacro ediff-get-state-of-ancestor (n)
-  (` (if ediff-state-of-merge
-	 (aref (aref ediff-state-of-merge (, n)) 1))))
+  `(if ediff-state-of-merge
+       (aref (aref ediff-state-of-merge ,n) 0)))
 (defmacro ediff-set-state-of-merge (n val)
-  (` (if ediff-state-of-merge
-	 (aset (aref ediff-state-of-merge (, n)) 0 (, val)))))
+  `(if ediff-state-of-merge
+       (aset (aref ediff-state-of-merge ,n) 0 ,val)))
+
+(defmacro ediff-get-state-of-ancestor (n)
+  `(if ediff-state-of-merge
+       (aref (aref ediff-state-of-merge ,n) 1)))
 
 ;; if flag is t, puts a mark on diff region saying that 
-;; the differences are in white space only. If flag is nil,
+;; the differences are in white space only.  If flag is nil,
 ;; the region is marked as essential (i.e., differences are
 ;; not just in the white space and newlines.)
 (defmacro ediff-mark-diff-as-space-only (n flag)
-  (` (aset (ediff-get-difference (, n) 'A) 2 (, flag))))
+  `(aset (ediff-get-difference ,n 'A) 2 ,flag))
   
 (defmacro ediff-get-fine-diff-vector (n buf-type)
-  (` (ediff-get-fine-diff-vector-from-diff-record
-      (ediff-get-difference (, n) (, buf-type)))))
+  `(ediff-get-fine-diff-vector-from-diff-record
+    (ediff-get-difference ,n ,buf-type)))
   
-;; Macro to switch to BUFFER, evaluate FORMS, returns to original buffer.
-;; Differs from `save-excursion' in that it doesn't save the point and mark.
-;; This is essentially `emerge-eval-in-buffer' with the test for live buffers."
-(defmacro ediff-eval-in-buffer (buffer &rest forms)
-  (` (let ((StartBuffer (current-buffer)))
-       (if (ediff-buffer-live-p (, buffer))
-	   (unwind-protect
-	       (progn
-		 (set-buffer (, buffer))
-		 (,@ forms))
-	     (set-buffer StartBuffer))
-	 (or (eq this-command 'ediff-quit)
-	     (error ediff-KILLED-VITAL-BUFFER))
-	 ))))
-	 
+;; Macro to switch to BUFFER, evaluate BODY, returns to original buffer.
+;; Doesn't save the point and mark.
+;; This is `with-current-buffer' with the added test for live buffers."
+(defmacro ediff-with-current-buffer (buffer &rest body)
+  `(if (ediff-buffer-live-p ,buffer)
+       (save-current-buffer
+	 (set-buffer ,buffer)
+	 ,@body)
+     (or (eq this-command 'ediff-quit)
+	 (error ediff-KILLED-VITAL-BUFFER))
+     ))
+     
 
 (defsubst ediff-multiframe-setup-p ()
   (and (ediff-window-display-p) ediff-multiframe))
 			 
 (defmacro ediff-narrow-control-frame-p ()
-  (` (and (ediff-multiframe-setup-p)
-	  (equal ediff-help-message ediff-brief-message-string))))
+  `(and (ediff-multiframe-setup-p)
+	(equal ediff-help-message ediff-brief-message-string)))
 	  
 (defmacro ediff-3way-comparison-job ()
-  (` (memq
-      ediff-job-name
-      '(ediff-files3 ediff-buffers3))))
+  `(memq
+    ediff-job-name
+    '(ediff-files3 ediff-buffers3)))
 (ediff-defvar-local ediff-3way-comparison-job nil "")
       
 (defmacro ediff-merge-job ()
-  (` (memq
-      ediff-job-name
-      '(ediff-merge-files
-	ediff-merge-buffers
-	ediff-merge-files-with-ancestor
-	ediff-merge-buffers-with-ancestor
-	ediff-merge-revisions
-	ediff-merge-revisions-with-ancestor))))
+  `(memq
+    ediff-job-name
+    '(ediff-merge-files
+      ediff-merge-buffers
+      ediff-merge-files-with-ancestor
+      ediff-merge-buffers-with-ancestor
+      ediff-merge-revisions
+      ediff-merge-revisions-with-ancestor)))
 (ediff-defvar-local ediff-merge-job nil "")
 
 (defmacro ediff-merge-with-ancestor-job ()
-  (` (memq
-      ediff-job-name
-      '(ediff-merge-files-with-ancestor
-	ediff-merge-buffers-with-ancestor
-	ediff-merge-revisions-with-ancestor))))
+  `(memq
+    ediff-job-name
+    '(ediff-merge-files-with-ancestor
+      ediff-merge-buffers-with-ancestor
+      ediff-merge-revisions-with-ancestor)))
 (ediff-defvar-local ediff-merge-with-ancestor-job nil "")
 
 (defmacro ediff-3way-job ()
-  (` (or ediff-3way-comparison-job ediff-merge-job)))
+  `(or ediff-3way-comparison-job ediff-merge-job))
 (ediff-defvar-local ediff-3way-job nil "")
 
 ;; A diff3 job is like a 3way job, but ediff-merge doesn't require the use
 ;; of diff3.
 (defmacro ediff-diff3-job ()
-  (` (or ediff-3way-comparison-job
-	 ediff-merge-with-ancestor-job)))
+  `(or ediff-3way-comparison-job
+       ediff-merge-with-ancestor-job))
 (ediff-defvar-local ediff-diff3-job nil "")
 	 
 (defmacro ediff-windows-job ()
-  (` (memq ediff-job-name '(ediff-windows-wordwise ediff-windows-linewise))))
+  `(memq ediff-job-name '(ediff-windows-wordwise ediff-windows-linewise)))
 (ediff-defvar-local ediff-windows-job nil "")
 
 (defmacro ediff-word-mode-job ()
-  (` (memq ediff-job-name '(ediff-windows-wordwise  ediff-regions-wordwise))))
+  `(memq ediff-job-name '(ediff-windows-wordwise ediff-regions-wordwise)))
 (ediff-defvar-local ediff-word-mode-job nil "")
 
 (defmacro ediff-narrow-job ()
-  (` (memq ediff-job-name '(ediff-windows-wordwise
-			    ediff-regions-wordwise
-			    ediff-windows-linewise
-			    ediff-regions-linewise))))
+  `(memq ediff-job-name '(ediff-windows-wordwise
+			  ediff-regions-wordwise
+			  ediff-windows-linewise
+			  ediff-regions-linewise)))
 (ediff-defvar-local ediff-narrow-job nil "")
 
 ;; Note: ediff-merge-directory-revisions-with-ancestor is not treated as an
@@ -326,6 +359,21 @@ that Ediff doesn't know about.")
       (error "%S: This command runs in Ediff Control Buffer only!"
 	     this-command)))
 
+(defgroup ediff-highlighting nil
+  "Hilighting of difference regions in Ediff"
+  :prefix "ediff-"
+  :group 'ediff)
+
+(defgroup ediff-merge nil
+  "Merging utilities"
+  :prefix "ediff-"
+  :group 'ediff)
+
+(defgroup ediff-hook nil
+  "Hooks called by Ediff"
+  :prefix "ediff-"
+  :group 'ediff)
+
 ;; Hook variables
 
 (defcustom ediff-before-setup-windows-hook nil
@@ -333,74 +381,72 @@ that Ediff doesn't know about.")
 This can be used to save the previous window config, which can be restored
 on ediff-quit or ediff-suspend."
   :type 'hook
-  :group 'ediff) 
+  :group 'ediff-hook) 
 (defcustom ediff-after-setup-windows-hook nil
   "*Hooks to run after Ediff sets its window configuration. 
 This can be used to set up control window or icon in a desired place."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-before-setup-control-frame-hook nil
   "*Hooks run before setting up the frame to display Ediff Control Panel.
 Can be used to change control frame parameters to position it where it
 is desirable."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-after-setup-control-frame-hook nil
   "*Hooks run after setting up the frame to display Ediff Control Panel.
 Can be used to move the frame where it is desired."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-startup-hook nil
   "*Hooks to run in the control buffer after Ediff has been set up."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-select-hook nil
   "*Hooks to run after a difference has been selected."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-unselect-hook nil
   "*Hooks to run after a difference has been unselected."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-prepare-buffer-hook  nil
   "*Hooks called after buffers A, B, and C are set up."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-load-hook nil
   "*Hook run after Ediff is loaded.  Can be used to change defaults."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
   
 (defcustom ediff-mode-hook nil
   "*Hook run just after ediff-mode is set up in the control buffer. 
-This is done before any windows or frames are created. One can use it to
+This is done before any windows or frames are created.  One can use it to
 set local variables that determine how the display looks like."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-keymap-setup-hook nil
   "*Hook run just after the default bindings in Ediff keymap are set up."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
   
 (defcustom ediff-display-help-hook nil
   "*Hooks run after preparing the help message."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 
 (defcustom ediff-suspend-hook (list 'ediff-default-suspend-function)
   "*Hooks to run in the Ediff control buffer when Ediff is suspended."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 (defcustom ediff-quit-hook (list 'ediff-cleanup-mess)
   "*Hooks to run in the Ediff control buffer after finishing Ediff."
   :type 'hook
-  :group 'ediff) 
+  :group 'ediff-hook) 
 (defcustom ediff-cleanup-hook nil
-  "*Hooks to run on exiting Ediff but before killing the control buffer.
-This is a place to do various cleanups, such as deleting the variant buffers.
-Ediff provides a function, `ediff-janitor', as one such possible hook."
+  "*Hooks to run on exiting Ediff but before killing the control and variant buffers."
   :type 'hook
-  :group 'ediff)
+  :group 'ediff-hook)
 
 ;; Error messages
 (defconst ediff-KILLED-VITAL-BUFFER
@@ -409,7 +455,7 @@ Ediff provides a function, `ediff-janitor', as one such possible hook."
   "Sorry, comparison of identical variants is not what I am made for...")
 (defconst ediff-BAD-DIFF-NUMBER
   ;; %S stands for this-command, %d - diff number, %d - max diff
-  "%S: Bad diff region number, %d. Valid numbers are 1 to %d")
+  "%S: Bad diff region number, %d.  Valid numbers are 1 to %d")
 (defconst ediff-BAD-INFO (format "
 *** The Info file for Ediff, a part of the standard distribution
 *** of %sEmacs, does not seem to be properly installed.
@@ -422,8 +468,8 @@ Ediff provides a function, `ediff-janitor', as one such possible hook."
 (ediff-defvar-local ediff-skip-diff-region-function 'ediff-show-all-diffs
   "Function that determines the next/previous diff region to show.
 Should return t for regions to be ignored and nil otherwise.
-This function gets a region number as an argument. The region number
-is the one used internally by Ediff. It is 1 less than the number seen
+This function gets a region number as an argument.  The region number
+is the one used internally by Ediff.  It is 1 less than the number seen
 by the user.")
 
 (ediff-defvar-local ediff-hide-regexp-matches-function
@@ -491,13 +537,14 @@ See the documentation string of `ediff-focus-on-regexp-matches' for details.")
   :group 'ediff)
 
   
-(ediff-defvar-local ediff-use-faces t 
+(ediff-defvar-local ediff-use-faces t "") 
+(defcustom ediff-use-faces t 
   "If t, differences are highlighted using faces, if device supports faces.
 If nil, differences are highlighted using ASCII flags, ediff-before-flag
 and ediff-after-flag.  On a non-window system, differences are always
-highlighted using ASCII flags.
-This variable can be set either in .emacs or toggled interactively.
-Use `setq-default' if setting it in .emacs")
+highlighted using ASCII flags."
+  :type 'boolean
+  :group 'ediff-highlighting)
 
 ;; this indicates that diff regions are word-size, so fine diffs are
 ;; permanently nixed; used in ediff-windows-wordwise and ediff-regions-wordwise
@@ -516,7 +563,7 @@ Use `setq-default' if setting it in .emacs")
 (ediff-defvar-local ediff-wide-bounds nil "")
 
 ;; Current visibility boundaries in buffers A, B, and C.
-;; This is also a list of overlays. When the user toggles narrow/widen,
+;; This is also a list of overlays.  When the user toggles narrow/widen,
 ;; this list changes from ediff-wide-bounds to ediff-narrow-bounds.
 ;; and back.
 (ediff-defvar-local ediff-visible-bounds nil "")
@@ -534,10 +581,13 @@ meaning of this variable."
   :type 'boolean
   :group 'ediff)
 
-(ediff-defvar-local ediff-highlight-all-diffs t
+(ediff-defvar-local ediff-highlight-all-diffs t "")
+(defcustom ediff-highlight-all-diffs t
   "If nil, only the selected differences are highlighted.
-This variable can be set either in .emacs or toggled interactively, using
-ediff-toggle-hilit. Use `setq-default' to set it.") 
+Otherwise, all difference regions are highlighted, but the selected region is
+shown in brighter colors."
+  :type 'boolean
+  :group 'ediff-highlighting)
 
 ;; A var local to each control panel buffer.  Indicates highlighting style
 ;; in effect for this buffer: `face', `ascii', nil -- temporarily
@@ -561,6 +611,13 @@ ediff-toggle-hilit. Use `setq-default' to set it.")
 ;; The original values of ediff-protected-variables for buffer Ancestor
 (ediff-defvar-local ediff-buffer-values-orig-Ancestor nil "")
 
+;; association between buff-type and ediff-buffer-values-orig-*
+(defconst ediff-buffer-values-orig-alist
+  '((A . ediff-buffer-values-orig-A)
+    (B . ediff-buffer-values-orig-B)
+    (C . ediff-buffer-values-orig-C)
+    (Ancestor . ediff-buffer-values-orig-Ancestor)))
+
 ;; Buffer-local variables to be saved then restored during Ediff sessions
 (defconst ediff-protected-variables '(
 				      ;;buffer-read-only 
@@ -570,25 +627,31 @@ ediff-toggle-hilit. Use `setq-default' to set it.")
 ;; represented by a vector of two overlays plus a vector of fine diffs,
 ;; plus a no-fine-diffs flag.  The first overlay spans the
 ;; difference region in the A buffer and the second overlays the diff in
-;; the B buffer. If a difference section is empty, the corresponding
+;; the B buffer.  If a difference section is empty, the corresponding
 ;; overlay's endpoints coincide.
 ;;
-;; The precise form of a difference vector for one buffer is:
+;; The precise form of a Difference Vector for one buffer is:
 ;; [diff diff diff ...]
 ;; where each diff has the form:
-;; [diff-overlay fine-diff-vector no-fine-diffs-flag state-of-difference]
+;; [diff-overlay fine-diff-vector no-fine-diffs-flag state-of-diff]
 ;; fine-diff-vector is a vector [fine-diff-overlay fine-diff-overlay ...]
 ;; no-fine-diffs-flag says if there are fine differences.
 ;; state-of-difference is A, B, C, or nil, indicating which buffer is
-;; different from the other two (used only in 3-way jobs.
+;;	different from the other two (used only in 3-way jobs.
 (ediff-defvar-local ediff-difference-vector-A nil "")
 (ediff-defvar-local ediff-difference-vector-B nil "")
 (ediff-defvar-local ediff-difference-vector-C nil "")
 (ediff-defvar-local ediff-difference-vector-Ancestor nil "")
+;; A-list of diff vector types associated with buffer types
+(defconst ediff-difference-vector-alist
+  '((A . ediff-difference-vector-A)
+    (B . ediff-difference-vector-B)
+    (C . ediff-difference-vector-C)
+    (Ancestor . ediff-difference-vector-Ancestor)))
 
 ;; [ status status status ...]
 ;; Each status: [state-of-merge state-of-ancestor]
-;; state-of-merge is default-A, default-B, prefer-A, or prefer-B. It
+;; state-of-merge is default-A, default-B, prefer-A, or prefer-B.  It
 ;; indicates the way a diff region was created in buffer C.
 ;; state-of-ancestor says if the corresponding region in ancestor buffer is
 ;; empty.
@@ -602,7 +665,7 @@ ediff-toggle-hilit. Use `setq-default' to set it.")
 ;; Buffer containing the output of diff, which is used by Ediff to step
 ;; through files.
 (ediff-defvar-local ediff-diff-buffer nil "")
-;; Like ediff-diff-buffer, but contains context diff. It is not used by
+;; Like ediff-diff-buffer, but contains context diff.  It is not used by
 ;; Ediff, but it is saved in a file, if user requests so.
 (ediff-defvar-local ediff-custom-diff-buffer nil "")
 ;; Buffer used for diff-style fine differences between regions.
@@ -629,9 +692,9 @@ ediff-toggle-hilit. Use `setq-default' to set it.")
 
 (defcustom ediff-version-control-package 'vc
   "Version control package used.
-Currently, Ediff supports vc.el, rcs.el, pcl-cvs.el, and generic-sc.el. The
-standard Emacs interface to RCS, CVS, SCCS, etc., is vc.el. However, some
-people find the other two packages more convenient. Set this variable to the
+Currently, Ediff supports vc.el, rcs.el, pcl-cvs.el, and generic-sc.el.  The
+standard Emacs interface to RCS, CVS, SCCS, etc., is vc.el.  However, some
+people find the other two packages more convenient.  Set this variable to the
 appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
   :type 'symbol
   :group 'ediff)
@@ -655,7 +718,7 @@ appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
 ;; emacs-minor-version are defined.  Otherwise, for Emacs/XEmacs 19, if the
 ;; current minor version is < 10 (xemacs) or < 23 (emacs) the return value
 ;; will be nil (when op is =, >, or >=) and t (when op is <, <=), which may be
-;; incorrect. However, this gives correct result in our cases, since we are
+;; incorrect.  However, this gives correct result in our cases, since we are
 ;; testing for sufficiently high Emacs versions.
 (defun ediff-check-version (op major minor &optional type-of-emacs)
   (if (and (boundp 'emacs-major-version) (boundp 'emacs-minor-version))
@@ -676,46 +739,15 @@ appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
 	  ((memq op '(< <=)) t))))
   
   
-;;;; warn if it is a wrong version of emacs
-;;(if (or (ediff-check-version '< 19 35 'emacs)
-;;	(ediff-check-version '< 19 15 'xemacs))
-;;    (progn
-;;      (with-output-to-temp-buffer ediff-msg-buffer
-;;	(switch-to-buffer ediff-msg-buffer)
-;;	(insert
-;;	 (format "
-;;
-;;This version of Ediff requires 
-;;
-;;\t Emacs 19.35 and higher
-;;\t OR
-;;\t XEmacs 19.15 and higher
-;;
-;;It is unlikely to work under Emacs version %s
-;;that you are using... " emacs-version))
-;;	(if noninteractive
-;;	    ()
-;;	  (beep 1)
-;;	  (beep 1)
-;;	  (insert "\n\nType any key to continue...")
-;;	  (ediff-read-event)))
-;;      (kill-buffer ediff-msg-buffer)))
-
-;; A fix for NeXT Step
-;; Should probably be eliminated in later versions.
-(if (and (ediff-window-display-p) (eq (ediff-device-type) 'ns))
-    (progn
-      (fset 'x-display-color-p (symbol-function 'ns-display-color-p))
-      (fset 'x-color-defined-p (symbol-function 'ns-color-defined-p))
-      (fset 'x-display-pixel-height (symbol-function 'ns-display-pixel-height))
-      (fset 'x-display-pixel-width (symbol-function 'ns-display-pixel-width))
-      ))
-
-
-(defsubst ediff-color-display-p ()
-  (if ediff-emacs-p
-      (x-display-color-p)
-    (eq (device-class (selected-device)) 'color)))
+(defun ediff-color-display-p ()
+  (condition-case nil
+      (if ediff-emacs-p
+	  (if (fboundp 'display-color-p)
+	      (display-color-p)
+	    (x-display-color-p))
+	(eq (device-class (selected-device)) 'color))
+    (error
+     nil)))
 
   
 (if (ediff-has-face-support-p)
@@ -723,12 +755,10 @@ appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
 	(progn
 	  (fset 'ediff-valid-color-p (symbol-function 'valid-color-name-p))
 	  (fset 'ediff-get-face (symbol-function 'get-face)))
-      ;; Temporary fix for OS/2 port of Emacs
-      ;; pm-win.el in PM-Emacs should be fixed.
-      (if (eq (ediff-device-type) 'pm)
-	  (fset 'ediff-valid-color-p 
-		(function (lambda (color) (assoc color pm-color-alist))))
-	(fset 'ediff-valid-color-p (symbol-function 'x-color-defined-p)))
+      (fset 'ediff-valid-color-p (symbol-function
+				  (if (fboundp 'color-defined-p)
+				      'color-defined-p
+				    'x-color-defined-p)))
       (fset 'ediff-get-face (symbol-function 'internal-get-face))))
 
 (if (ediff-window-display-p)
@@ -738,19 +768,39 @@ appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
 		(symbol-function 'device-pixel-width))
 	  (fset 'ediff-display-pixel-height
 		(symbol-function 'device-pixel-height)))
-      (fset 'ediff-display-pixel-width 
-	    (symbol-function 'x-display-pixel-width))
-      (fset 'ediff-display-pixel-height
-	    (symbol-function 'x-display-pixel-height))))
+      (fset 'ediff-display-pixel-width (symbol-function
+					(if (fboundp 'display-pixel-width)
+					    'display-pixel-width
+					  'x-display-pixel-width)))
+      (fset 'ediff-display-pixel-height (symbol-function
+					 (if (fboundp 'display-pixel-height)
+					     'display-pixel-height
+					   'x-display-pixel-height)))))
       
+;; A-list of current-diff-overlay symbols asssociated with buf types
+(defconst ediff-current-diff-overlay-alist
+  '((A . ediff-current-diff-overlay-A)
+    (B . ediff-current-diff-overlay-B)
+    (C . ediff-current-diff-overlay-C)
+    (Ancestor . ediff-current-diff-overlay-Ancestor)))
+  
+;; A-list of current-diff-face-* symbols asssociated with buf types
+(defconst ediff-current-diff-face-alist
+  '((A . ediff-current-diff-face-A)
+    (B . ediff-current-diff-face-B)
+    (C . ediff-current-diff-face-C)
+    (Ancestor . ediff-current-diff-face-Ancestor)))
+  
 
 (defun ediff-make-current-diff-overlay (type)
   (if (ediff-has-face-support-p)
-      (let ((overlay (intern (format "ediff-current-diff-overlay-%S" type)))
+      (let ((overlay (ediff-get-symbol-from-alist
+		      type ediff-current-diff-overlay-alist))
 	    (buffer (ediff-get-buffer type))
 	    (face (face-name
 		   (symbol-value
-		    (intern (format "ediff-current-diff-face-%S" type))))))
+		    (ediff-get-symbol-from-alist
+		     type ediff-current-diff-face-alist)))))
 	(set overlay
 	     (ediff-make-bullet-proof-overlay (point-max) (point-max) buffer))
 	(ediff-set-overlay-face (symbol-value overlay) face)
@@ -761,53 +811,27 @@ appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
   (ediff-overlay-put extent 'face face)
   (ediff-overlay-put extent 'help-echo 'ediff-region-help-echo))
  
-;; This does nothing in Emacs, since overlays there have no help-echo property
-(defun ediff-region-help-echo (extent)
-  (let ((is-current (ediff-overlay-get extent 'ediff))
-	(face (ediff-overlay-get extent 'face))
-	(diff-num (ediff-overlay-get extent 'ediff-diff-num))
+(defun ediff-region-help-echo (extent-or-window &optional overlay point)
+  (unless overlay
+    (setq overlay extent-or-window))
+  (let ((is-current (ediff-overlay-get overlay 'ediff))
+	(face (ediff-overlay-get overlay 'face))
+	(diff-num (ediff-overlay-get overlay 'ediff-diff-num))
 	face-help)
 
     ;; This happens only for refinement overlays
+    (if (stringp face)
+	(setq face (intern face)))
     (setq face-help (and face (get face 'ediff-help-echo)))
 
-    (cond ((and is-current diff-num) ; current diff region
+    (cond ((and is-current diff-num)	; current diff region
 	   (format "Difference region %S -- current" (1+ diff-num)))
-	  (face-help) ; refinement of current diff region
-	  (diff-num ; non-current
+	  (face-help)			; refinement of current diff region
+	  (diff-num			; non-current
 	   (format "Difference region %S -- non-current" (1+ diff-num)))
-	  (t ""))   ; none
+	  (t ""))			; none
     ))
 
-(defun ediff-set-face (ground face color)
-  "Set face foreground/background."
-  (if (ediff-has-face-support-p)
-      (if (ediff-valid-color-p color)
-	  (if (eq ground 'foreground)
-	      (set-face-foreground face color)
-	    (set-face-background face color))
-	(cond ((memq face
-		     '(ediff-current-diff-face-A
-		       ediff-current-diff-face-B
-		       ediff-current-diff-face-C
-		       ediff-current-diff-face-Ancestor))
-	       (copy-face 'highlight face))
-	      ((memq face
-		     '(ediff-fine-diff-face-A
-		       ediff-fine-diff-face-B
-		       ediff-fine-diff-face-C
-		       ediff-fine-diff-face-Ancestor))
-	       (copy-face 'secondary-selection face)
-	       (set-face-underline-p face t))
-	      ((memq face
-		     '(ediff-even-diff-face-A
-		       ediff-odd-diff-face-A 
-		       ediff-even-diff-face-B ediff-odd-diff-face-B
-		       ediff-even-diff-face-C ediff-odd-diff-face-C
-		       ediff-even-diff-face-Ancestor
-		       ediff-odd-diff-face-Ancestor))
-	       (copy-face 'secondary-selection face))))
-    ))
 
 (defun ediff-set-face-pixmap (face pixmap)
   "Set face pixmap on a monochrome display."
@@ -822,280 +846,293 @@ appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
   (if (and (ediff-has-face-support-p) ediff-emacs-p)
       (add-to-list 'facemenu-unlisted-faces face)))
       
-(defvar ediff-current-diff-face-A
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-current-diff-face-A)
-	(ediff-hide-face 'ediff-current-diff-face-A)
-	(or (face-differs-from-default-p 'ediff-current-diff-face-A)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face
-		    'foreground 'ediff-current-diff-face-A "firebrick")
-		   (ediff-set-face
-		    'background 'ediff-current-diff-face-A "pale green"))
-		  (t
-		   (if ediff-xemacs-p
-		       (copy-face 'modeline 'ediff-current-diff-face-A)
-		     (copy-face 'highlight 'ediff-current-diff-face-A))
-		   )))
-	'ediff-current-diff-face-A))
-  "Face for highlighting the selected difference in buffer A.")
-
-(defvar ediff-current-diff-face-B
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-current-diff-face-B)
-	(ediff-hide-face 'ediff-current-diff-face-B)
-	(or (face-differs-from-default-p 'ediff-current-diff-face-B)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face
-		    'foreground 'ediff-current-diff-face-B "DarkOrchid")
-		   (ediff-set-face
-		    'background 'ediff-current-diff-face-B "Yellow"))
-		  (t 
-		   (if ediff-xemacs-p
-		       (copy-face 'modeline 'ediff-current-diff-face-B)
-		     (copy-face 'highlight 'ediff-current-diff-face-B))
-		   )))
-	'ediff-current-diff-face-B))
-  "Face for highlighting the selected difference in buffer B.")
-    
 
-(defvar ediff-current-diff-face-C
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-current-diff-face-C)
-	(ediff-hide-face 'ediff-current-diff-face-C)
-	(or (face-differs-from-default-p 'ediff-current-diff-face-C)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face
-		    'foreground 'ediff-current-diff-face-C "Navy")
-		   (ediff-set-face
-		    'background 'ediff-current-diff-face-C "Pink"))
-		  (t 
-		   (if ediff-xemacs-p
-		       (copy-face 'modeline 'ediff-current-diff-face-C)
-		     (copy-face 'highlight 'ediff-current-diff-face-C))
-		   )))
-	'ediff-current-diff-face-C))
-  "Face for highlighting the selected difference in buffer C.")
-
-(defvar ediff-current-diff-face-Ancestor
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-current-diff-face-Ancestor)
-	(ediff-hide-face 'ediff-current-diff-face-Ancestor)
-	(or (face-differs-from-default-p 'ediff-current-diff-face-Ancestor)
-	    (copy-face 
-	     'ediff-current-diff-face-C 'ediff-current-diff-face-Ancestor))
-	'ediff-current-diff-face-Ancestor))
-  "Face for highlighting the selected difference in the ancestor buffer.")
-
-(defvar ediff-fine-diff-pixmap "gray3"
-  "Pixmap to use for highlighting fine differences.")
-(defvar ediff-odd-diff-pixmap "gray1"
-  "Pixmap to use for highlighting odd differences.")
-(defvar ediff-even-diff-pixmap "Stipple"
-  "Pixmap to use for highlighting even differences.")
-
-(defvar ediff-fine-diff-face-A
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-fine-diff-face-A)
-	(ediff-hide-face 'ediff-fine-diff-face-A)
-	(or (face-differs-from-default-p 'ediff-fine-diff-face-A)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face 'foreground 'ediff-fine-diff-face-A
-				   "Navy")
-		   (ediff-set-face 'background 'ediff-fine-diff-face-A
-				   "sky blue"))
-		  (t
-		   (set-face-underline-p 'ediff-fine-diff-face-A t)
-		   (ediff-set-face-pixmap 'ediff-fine-diff-face-A
-					  ediff-fine-diff-pixmap)
-		   )))
-	'ediff-fine-diff-face-A))
-  "Face for highlighting the refinement of the selected diff in buffer A.")
-
-(defvar ediff-fine-diff-face-B
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-fine-diff-face-B)
-	(ediff-hide-face 'ediff-fine-diff-face-B)
-	(or (face-differs-from-default-p 'ediff-fine-diff-face-B)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face 'foreground 'ediff-fine-diff-face-B "Black")
-		   (ediff-set-face 'background 'ediff-fine-diff-face-B "cyan"))
-		  (t
-		   (set-face-underline-p 'ediff-fine-diff-face-B t)
-		   (ediff-set-face-pixmap 'ediff-fine-diff-face-B
-					  ediff-fine-diff-pixmap)
-		   )))
-	'ediff-fine-diff-face-B))
-  "Face for highlighting the refinement of the selected diff in buffer B.")
-    
-(defvar ediff-fine-diff-face-C
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-fine-diff-face-C)
-	(ediff-hide-face 'ediff-fine-diff-face-C)
-	(or (face-differs-from-default-p 'ediff-fine-diff-face-C)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face 'foreground 'ediff-fine-diff-face-C "black")
-		   (ediff-set-face
-		    'background 'ediff-fine-diff-face-C "Turquoise"))
-		  (t
-		   (set-face-underline-p 'ediff-fine-diff-face-C t)
-		   (ediff-set-face-pixmap 'ediff-fine-diff-face-C
-					  ediff-fine-diff-pixmap)
-		   )))
-	'ediff-fine-diff-face-C))
-  "Face for highlighting the refinement of the selected diff in buffer C.")
-
-(defvar ediff-fine-diff-face-Ancestor
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-fine-diff-face-Ancestor)
-	(ediff-hide-face 'ediff-fine-diff-face-Ancestor)
-	(or (face-differs-from-default-p 'ediff-fine-diff-face-Ancestor)
-	    (progn
-	      (copy-face
-	       'ediff-fine-diff-face-C 'ediff-fine-diff-face-Ancestor)
-	      (ediff-set-face-pixmap 'ediff-fine-diff-face-Ancestor
-				     ediff-fine-diff-pixmap))
-	    )))
-  "Face highlighting refinements of the selected diff in ancestor buffer.
-Presently, this is not used, as difference regions are not refined in the
-ancestor buffer.")
-    
-(defvar ediff-even-diff-face-A
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-even-diff-face-A)
-	(ediff-hide-face 'ediff-even-diff-face-A)
-	(or (face-differs-from-default-p 'ediff-even-diff-face-A)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face
-		    'foreground 'ediff-even-diff-face-A "black")
-		   (ediff-set-face
-		    'background 'ediff-even-diff-face-A "light grey"))
-		  (t 
-		   (copy-face 'italic 'ediff-even-diff-face-A)
-		   (ediff-set-face-pixmap 'ediff-even-diff-face-A
-					  ediff-even-diff-pixmap)
-		   )))
-	'ediff-even-diff-face-A))
-  "Face used to highlight even-numbered differences in buffer A.")
-      
-(defvar ediff-even-diff-face-B
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-even-diff-face-B)
-	(ediff-hide-face 'ediff-even-diff-face-B)
-	(or (face-differs-from-default-p 'ediff-even-diff-face-B)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face
-		    'foreground 'ediff-even-diff-face-B "White")
-		   (ediff-set-face
-		    'background 'ediff-even-diff-face-B "Gray"))
-		  (t 
-		   (copy-face 'italic 'ediff-even-diff-face-B)
-		   (ediff-set-face-pixmap 'ediff-even-diff-face-B
-					  ediff-even-diff-pixmap)
-		   )))
-	'ediff-even-diff-face-B))
-  "Face used to highlight even-numbered differences in buffer B.")
-    
-(defvar ediff-even-diff-face-C
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-even-diff-face-C)
-	(ediff-hide-face 'ediff-even-diff-face-C)
-	(or (face-differs-from-default-p 'ediff-even-diff-face-C)
-	    (progn
-	      (copy-face 'ediff-even-diff-face-A 'ediff-even-diff-face-C)
-	      (ediff-set-face-pixmap 'ediff-even-diff-face-C
-				     ediff-even-diff-pixmap)))
-	'ediff-even-diff-face-C))
-  "Face used to highlight even-numbered differences in buffer C.")
-
-(defvar ediff-even-diff-face-Ancestor
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-even-diff-face-Ancestor)
-	(ediff-hide-face 'ediff-even-diff-face-Ancestor)
-	(or (face-differs-from-default-p 'ediff-even-diff-face-Ancestor)
-	    (progn
-	      (copy-face
-	       'ediff-even-diff-face-C 'ediff-even-diff-face-Ancestor)
-	      (ediff-set-face-pixmap 'ediff-even-diff-face-Ancestor
-				     ediff-even-diff-pixmap)))
-	'ediff-even-diff-face-Ancestor))
-  "Face highlighting even-numbered differences in the ancestor buffer.")
+
+(defface ediff-current-diff-face-A
+  '((((class color)) (:foreground "firebrick" :background "pale green"))
+    (t (:inverse-video t)))
+  "Face for highlighting the selected difference in buffer A."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-current-diff-face-A 'ediff-current-diff-face-A
+  "Face for highlighting the selected difference in buffer A.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-current-diff-face-A'
+this variable represents.")
+(ediff-hide-face 'ediff-current-diff-face-A)
+;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
+;; This means that some user customization may be trashed.
+(if (and ediff-xemacs-p
+	 (ediff-has-face-support-p)
+	 (not (ediff-color-display-p))) 
+    (copy-face 'modeline 'ediff-current-diff-face-A))
+
+
+
+(defface ediff-current-diff-face-B
+  '((((class color)) (:foreground "DarkOrchid" :background "Yellow"))
+    (t (:inverse-video t)))
+  "Face for highlighting the selected difference in buffer B."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-current-diff-face-B 'ediff-current-diff-face-B
+  "Face for highlighting the selected difference in buffer B.
+ this variable.  Instead, use the customization
+widget to customize the actual face `ediff-current-diff-face-B'
+this variable represents.")
+(ediff-hide-face 'ediff-current-diff-face-B)
+;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
+;; This means that some user customization may be trashed.
+(if (and ediff-xemacs-p
+	 (ediff-has-face-support-p)
+	 (not (ediff-color-display-p))) 
+    (copy-face 'modeline 'ediff-current-diff-face-B))
+
+
+(defface ediff-current-diff-face-C
+  '((((class color)) (:foreground "Navy" :background "Pink"))
+    (t (:inverse-video t)))
+  "Face for highlighting the selected difference in buffer C."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-current-diff-face-C 'ediff-current-diff-face-C
+  "Face for highlighting the selected difference in buffer C.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-current-diff-face-C'
+this variable represents.")
+(ediff-hide-face 'ediff-current-diff-face-C)
+;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
+;; This means that some user customization may be trashed.
+(if (and ediff-xemacs-p
+	 (ediff-has-face-support-p)
+	 (not (ediff-color-display-p))) 
+    (copy-face 'modeline 'ediff-current-diff-face-C))
+
+
+(defface ediff-current-diff-face-Ancestor
+  '((((class color)) (:foreground "Black" :background "VioletRed"))
+    (t (:inverse-video t)))
+  "Face for highlighting the selected difference in buffer Ancestor."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-current-diff-face-Ancestor 'ediff-current-diff-face-Ancestor
+  "Face for highlighting the selected difference in buffer Ancestor.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-current-diff-face-Ancestor'
+this variable represents.")
+(ediff-hide-face 'ediff-current-diff-face-Ancestor)
+;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
+;; This means that some user customization may be trashed.
+(if (and ediff-xemacs-p
+	 (ediff-has-face-support-p)
+	 (not (ediff-color-display-p))) 
+    (copy-face 'modeline 'ediff-current-diff-face-Ancestor))
+
+
+(defface ediff-fine-diff-face-A
+  '((((class color)) (:foreground "Navy" :background "sky blue"))
+    (t (:underline t :stipple "gray3")))
+  "Face for highlighting the refinement of the selected diff in buffer A."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-fine-diff-face-A 'ediff-fine-diff-face-A
+  "Face for highlighting the fine differences in buffer A.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-fine-diff-face-A'
+this variable represents.")
+(ediff-hide-face 'ediff-fine-diff-face-A)
+
+(defface ediff-fine-diff-face-B
+  '((((class color)) (:foreground "Black" :background "cyan"))
+    (t (:underline t :stipple "gray3")))
+  "Face for highlighting the refinement of the selected diff in buffer B."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-fine-diff-face-B 'ediff-fine-diff-face-B
+  "Face for highlighting the fine differences in buffer B.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-fine-diff-face-B'
+this variable represents.")
+(ediff-hide-face 'ediff-fine-diff-face-B)
+
+(defface ediff-fine-diff-face-C
+  '((((class color)) (:foreground "Black" :background "Turquoise"))
+    (t (:underline t :stipple "gray3")))
+  "Face for highlighting the refinement of the selected diff in buffer C."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-fine-diff-face-C 'ediff-fine-diff-face-C
+  "Face for highlighting the fine differences in buffer C.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-fine-diff-face-C'
+this variable represents.")
+(ediff-hide-face 'ediff-fine-diff-face-C)
+
+(defface ediff-fine-diff-face-Ancestor
+  '((((class color)) (:foreground "Black" :background "Green"))
+    (t (:underline t :stipple "gray3")))
+  "Face for highlighting the refinement of the selected diff in the ancestor buffer.
+At present, this face is not used and no fine differences are computed for the
+ancestor buffer."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-fine-diff-face-Ancestor 'ediff-fine-diff-face-Ancestor
+  "Face for highlighting the fine differences in buffer Ancestor.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-fine-diff-face-Ancestor'
+this variable represents.")
+(ediff-hide-face 'ediff-fine-diff-face-Ancestor)
+
+;; Some installs don't have stipple or Stipple. So, try them in turn.
+(defvar stipple-pixmap
+  (cond ((not (ediff-has-face-support-p)) nil)
+	((and (boundp 'x-bitmap-file-path)
+	      (locate-library "stipple" t x-bitmap-file-path)) "stipple")
+	((and (boundp 'mswindowsx-bitmap-file-path)
+	      (locate-library "stipple" t mswindowsx-bitmap-file-path)) "stipple")
+	(t "Stipple")))
+
+(defface ediff-even-diff-face-A
+  `((((class color)) (:foreground "Black" :background "light grey"))
+    (t (:italic t :stipple ,stipple-pixmap)))
+  "Face for highlighting even-numbered non-current differences in buffer A."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-even-diff-face-A 'ediff-even-diff-face-A
+  "Face for highlighting even-numbered non-current differences in buffer A.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-even-diff-face-A'
+this variable represents.")
+(ediff-hide-face 'ediff-even-diff-face-A)
+
+(defface ediff-even-diff-face-B
+  `((((class color)) (:foreground "White" :background "Grey"))
+    (t (:italic t :stipple ,stipple-pixmap)))
+  "Face for highlighting even-numbered non-current differences in buffer B."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-even-diff-face-B 'ediff-even-diff-face-B
+  "Face for highlighting even-numbered non-current differences in buffer B.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-even-diff-face-B'
+this variable represents.")
+(ediff-hide-face 'ediff-even-diff-face-B)
+
+(defface ediff-even-diff-face-C
+  `((((class color)) (:foreground "Black" :background "light grey"))
+    (t (:italic t :stipple ,stipple-pixmap)))
+  "Face for highlighting even-numbered non-current differences in buffer C."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-even-diff-face-C 'ediff-even-diff-face-C
+  "Face for highlighting even-numbered non-current differences in buffer C.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-even-diff-face-C'
+this variable represents.")
+(ediff-hide-face 'ediff-even-diff-face-C)
+
+(defface ediff-even-diff-face-Ancestor
+  `((((class color)) (:foreground "White" :background "Grey"))
+    (t (:italic t :stipple ,stipple-pixmap)))
+  "Face for highlighting even-numbered non-current differences in the ancestor buffer."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-even-diff-face-Ancestor 'ediff-even-diff-face-Ancestor
+  "Face for highlighting even-numbered non-current differences in buffer Ancestor.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-even-diff-face-Ancestor'
+this variable represents.")
+(ediff-hide-face 'ediff-even-diff-face-Ancestor)
+
+;; Association between buffer types and even-diff-face symbols
+(defconst ediff-even-diff-face-alist
+  '((A . ediff-even-diff-face-A)
+    (B . ediff-even-diff-face-B)
+    (C . ediff-even-diff-face-C)
+    (Ancestor . ediff-even-diff-face-Ancestor)))
+
+(defface ediff-odd-diff-face-A
+  '((((class color)) (:foreground "White" :background "Grey"))
+    (t (:italic t :stipple "gray1")))
+  "Face for highlighting odd-numbered non-current differences in buffer A."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-odd-diff-face-A 'ediff-odd-diff-face-A
+  "Face for highlighting odd-numbered non-current differences in buffer A.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-odd-diff-face-A'
+this variable represents.")
+(ediff-hide-face 'ediff-odd-diff-face-A)
+
+
+(defface ediff-odd-diff-face-B
+  '((((class color)) (:foreground "Black" :background "light grey"))
+    (t (:italic t :stipple "gray1")))
+  "Face for highlighting odd-numbered non-current differences in buffer B."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-odd-diff-face-B 'ediff-odd-diff-face-B
+  "Face for highlighting odd-numbered non-current differences in buffer B.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-odd-diff-face-B'
+this variable represents.")
+(ediff-hide-face 'ediff-odd-diff-face-B)
+
+(defface ediff-odd-diff-face-C
+  '((((class color)) (:foreground "White" :background "Grey"))
+    (t (:italic t :stipple "gray1")))
+  "Face for highlighting odd-numbered non-current differences in buffer C."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-odd-diff-face-C 'ediff-odd-diff-face-C
+  "Face for highlighting odd-numbered non-current differences in buffer C.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-odd-diff-face-C'
+this variable represents.")
+(ediff-hide-face 'ediff-odd-diff-face-C)
+
+(defface ediff-odd-diff-face-Ancestor
+  '((((class color)) (:foreground "Black" :background "light grey"))
+    (t (:italic t :stipple "gray1")))
+  "Face for highlighting odd-numbered non-current differences in the ancestor buffer."
+  :group 'ediff-highlighting)
+;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
+;; this variable is set to nil, then again to the appropriate face.
+(defvar ediff-odd-diff-face-Ancestor 'ediff-odd-diff-face-Ancestor
+  "Face for highlighting odd-numbered non-current differences in buffer Ancestor.
+DO NOT CHANGE this variable.  Instead, use the customization
+widget to customize the actual face object `ediff-odd-diff-face-Ancestor'
+this variable represents.")
+(ediff-hide-face 'ediff-odd-diff-face-Ancestor)
+
+;; Association between buffer types and odd-diff-face symbols
+(defconst ediff-odd-diff-face-alist
+  '((A . ediff-odd-diff-face-A)
+    (B . ediff-odd-diff-face-B)
+    (C . ediff-odd-diff-face-C)
+    (Ancestor . ediff-odd-diff-face-Ancestor)))
   
-(defvar ediff-odd-diff-face-A
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-odd-diff-face-A)
-	(ediff-hide-face 'ediff-odd-diff-face-A)
-	(or (face-differs-from-default-p 'ediff-odd-diff-face-A)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face
-		    'foreground 'ediff-odd-diff-face-A "White")
-		   (ediff-set-face
-		    'background 'ediff-odd-diff-face-A "Gray"))
-		  (t 
-		   (copy-face 'italic 'ediff-odd-diff-face-A)
-		   (ediff-set-face-pixmap 'ediff-odd-diff-face-A
-					  ediff-odd-diff-pixmap)
-		   )))
-	'ediff-odd-diff-face-A))
-  "Face used to highlight odd-numbered differences in buffer A.")
-      
-(defvar ediff-odd-diff-face-B
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-odd-diff-face-B)
-	(ediff-hide-face 'ediff-odd-diff-face-B)
-	(or (face-differs-from-default-p 'ediff-odd-diff-face-B)
-	    (cond ((ediff-color-display-p)
-		   (ediff-set-face
-		    'foreground 'ediff-odd-diff-face-B "Black")
-		   (ediff-set-face
-		    'background 'ediff-odd-diff-face-B "light grey"))
-		  (t 
-		   (copy-face 'italic 'ediff-odd-diff-face-B)
-		   (ediff-set-face-pixmap 'ediff-odd-diff-face-B
-					  ediff-odd-diff-pixmap)
-		   )))
-	'ediff-odd-diff-face-B))
-  "Face used to highlight odd-numbered differences in buffer B.")
-    
-(defvar ediff-odd-diff-face-C
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-odd-diff-face-C)
-	(ediff-hide-face 'ediff-odd-diff-face-C)
-	(or (face-differs-from-default-p 'ediff-odd-diff-face-C)
-	    (progn
-	      (copy-face 'ediff-odd-diff-face-A 'ediff-odd-diff-face-C)
-	      (ediff-set-face-pixmap 'ediff-odd-diff-face-C
-				     ediff-odd-diff-pixmap)))
-	'ediff-odd-diff-face-C))
-  "Face used to highlight odd-numbered differences in buffer C.")
-
-(defvar ediff-odd-diff-face-Ancestor 
-  (if (ediff-has-face-support-p)
-      (progn
-	(make-face 'ediff-odd-diff-face-Ancestor)
-	(ediff-hide-face 'ediff-odd-diff-face-Ancestor)
-	(or (face-differs-from-default-p 'ediff-odd-diff-face-Ancestor)
-	    (progn
-	      (copy-face 'ediff-odd-diff-face-C 'ediff-odd-diff-face-Ancestor)
-	      (ediff-set-face-pixmap 'ediff-odd-diff-face-Ancestor
-				     ediff-odd-diff-pixmap)))
-	'ediff-odd-diff-face-Ancestor))
-  "Face used to highlight even-numbered differences in the ancestor buffer.")
+;; A-list of fine-diff face symbols associated with buffer types
+(defconst ediff-fine-diff-face-alist
+  '((A . ediff-fine-diff-face-A)
+    (B . ediff-fine-diff-face-B)
+    (C . ediff-fine-diff-face-C)
+    (Ancestor . ediff-fine-diff-face-Ancestor)))
 
 ;; Help echo
 (put 'ediff-fine-diff-face-A 'ediff-help-echo
@@ -1118,23 +1155,22 @@ ancestor buffer.")
   "Overlay for the current difference region in buffer C.")
 (ediff-defvar-local ediff-current-diff-overlay-Ancestor nil
   "Overlay for the current difference region in the ancestor buffer.")
-  
+
 ;; Compute priority of ediff overlay.
 (defun ediff-highest-priority (start end buffer)
   (let ((pos (max 1 (1- start)))
 	ovr-list)
     (if ediff-xemacs-p
 	(1+ ediff-shadow-overlay-priority)
-      (ediff-eval-in-buffer buffer
+      (ediff-with-current-buffer buffer
 	(while (< pos (min (point-max) (1+ end)))
 	  (setq ovr-list (append (overlays-at pos) ovr-list))
 	  (setq pos (next-overlay-change pos)))
 	(1+ (apply '+
-		   (mapcar (function
-			    (lambda (ovr)
-			      (if ovr
-				  (or (ediff-overlay-get ovr 'priority) 0)
-				0)))
+		   (mapcar (lambda (ovr)
+			     (if ovr
+				 (or (ediff-overlay-get ovr 'priority) 0)
+			       0))
 			   ovr-list)
 		   ))
 	))))
@@ -1158,14 +1194,22 @@ This property can be toggled interactively."
 ;; if nil, this silences some messages
 (defconst ediff-verbose-p t)
 
-(ediff-defvar-local ediff-autostore-merges  'group-jobs-only
+(defcustom ediff-autostore-merges  'group-jobs-only
   "*Save the results of merge jobs automatically.
-Nil means don't save automatically. t means always save. Anything but nil or t
+Nil means don't save automatically.  t means always save.  Anything but nil or t
 means save automatically only if the merge job is part of a group of jobs, such
-as `ediff-merge-directory' or `ediff-merge-directory-revisions'.")
+as `ediff-merge-directory' or `ediff-merge-directory-revisions'."
+  :type '(choice (const nil) (const t) (const group-jobs-only))
+  :group 'ediff-merge)
+(make-variable-buffer-local 'ediff-autostore-merges)
 
-;; file where the result of the merge is to be saved. used internally
+;; file where the result of the merge is to be saved.  used internally
 (ediff-defvar-local ediff-merge-store-file nil "")
+
+(defcustom ediff-merge-filename-prefix "merge_"
+  "*Prefix to be attached to saved merge buffers."
+  :type 'string
+  :group 'ediff-merge)
   
 (defcustom ediff-no-emacs-help-in-control-buffer nil
   "*Non-nil means C-h should not invoke Emacs help in control buffer.
@@ -1173,31 +1217,37 @@ Instead, C-h would jump to previous difference."
   :type 'boolean
   :group 'ediff)
   
-(defvar ediff-temp-file-prefix
-  (let ((env (or (getenv "TMPDIR")
-		 (getenv "TMP")
-		 (getenv "TEMP")))
-	d)
-    (setq d (if (and env (> (length env) 0))
-		env
-	      (cond ((memq system-type '(vax-vms axp-vms)) "SYS$SCRATCH:")
- 		    ((eq system-type 'ms-dos) "c:/")
- 		    (t "/tmp"))))
-    ;; The following is to make sure we get something to which we can
-    ;; add directory levels on VMS.
-    (setq d (file-name-as-directory (directory-file-name d)))
-    )
+;; This is the same as temporary-file-directory from Emacs 20.3.
+;; Copied over here because XEmacs doesn't have this variable.
+(defcustom ediff-temp-file-prefix 
+  (file-name-as-directory 
+   (cond ((boundp 'temporary-file-directory) temporary-file-directory)
+	 ((fboundp 'temp-directory) (temp-directory))
+	 (t "/tmp/")))
+;;;  (file-name-as-directory 
+;;;   (cond ((memq system-type '(ms-dos windows-nt))
+;;;	  (or (getenv "TEMP") (getenv "TMPDIR") (getenv "TMP") "c:/temp"))
+;;;	 ((memq system-type '(vax-vms axp-vms))
+;;;	  (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "SYS$SCRATCH:"))
+;;;	 (t
+;;;	  (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "/tmp"))))
   "*Prefix to put on Ediff temporary file names.
-Do not start with `~/' or `~user-name/'.")  
+Do not start with `~/' or `~USERNAME/'."
+  :type 'string
+  :group 'ediff)
 
-(defvar ediff-temp-file-mode 384	; u=rw only
-  "*Mode for Ediff temporary files.")
+(defcustom ediff-temp-file-mode 384	; u=rw only
+  "*Mode for Ediff temporary files."
+  :type 'integer
+  :group 'ediff)
   
 ;; Metacharacters that have to be protected from the shell when executing
 ;; a diff/diff3 command.
-(defvar ediff-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
-  "Characters that must be quoted with \\ when used in a shell command line.
-More precisely, a regexp to match any one such character.")
+(defcustom ediff-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
+  "Regexp that matches characters that must be quoted with `\\' in shell command line.
+This default should work without changes."
+  :type 'string
+  :group 'ediff)
 
 ;; needed to simulate frame-char-width in XEmacs.
 (defvar ediff-H-glyph (if ediff-xemacs-p (make-glyph "H")))
@@ -1240,28 +1290,29 @@ More precisely, a regexp to match any one such character.")
 (defsubst ediff-background-face (buf-type dif-num)
   ;; The value of dif-num is always 1- the one that user sees.
   ;; This is why even face is used when dif-num is odd.
-  (intern (format (if (ediff-odd-p dif-num)
-		      "ediff-even-diff-face-%S"
-		    "ediff-odd-diff-face-%S")
-		  buf-type)))
+  (ediff-get-symbol-from-alist
+   buf-type (if (ediff-odd-p dif-num)
+		ediff-even-diff-face-alist
+	      ediff-odd-diff-face-alist)
+   ))
 
 
 ;; activate faces on diff regions in buffer
 (defun ediff-paint-background-regions-in-one-buffer (buf-type unhighlight)
   (let ((diff-vector 
-	 (eval (intern (format "ediff-difference-vector-%S" buf-type))))
+	 (eval (ediff-get-symbol-from-alist
+		buf-type ediff-difference-vector-alist)))
 	overl diff-num)
-    (mapcar (function
-	     (lambda (rec)
-	       (setq overl (ediff-get-diff-overlay-from-diff-record rec)
-		     diff-num (ediff-overlay-get overl 'ediff-diff-num))
-	       (if (ediff-overlay-buffer overl)
-		   ;; only if overlay is alive
-		   (ediff-set-overlay-face
-		    overl
-		    (if (not unhighlight)
-			(ediff-background-face buf-type diff-num))))
-	       ))
+    (mapcar (lambda (rec)
+	      (setq overl (ediff-get-diff-overlay-from-diff-record rec)
+		    diff-num (ediff-overlay-get overl 'ediff-diff-num))
+	      (if (ediff-overlay-buffer overl)
+		  ;; only if overlay is alive
+		  (ediff-set-overlay-face
+		   overl
+		   (if (not unhighlight)
+		       (ediff-background-face buf-type diff-num))))
+	      )
 	    diff-vector)))
 
 
@@ -1279,14 +1330,15 @@ More precisely, a regexp to match any one such character.")
 (defun ediff-highlight-diff-in-one-buffer (n buf-type)
   (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
       (let* ((buff (ediff-get-buffer buf-type))
-	     (last (ediff-eval-in-buffer buff (point-max)))
+	     (last (ediff-with-current-buffer buff (point-max)))
 	     (begin (ediff-get-diff-posn buf-type 'beg n))
 	     (end (ediff-get-diff-posn buf-type 'end n))
 	     (xtra (if (equal begin end) 1 0))
 	     (end-hilit (min last (+ end xtra)))
 	     (current-diff-overlay 
 	      (symbol-value
-	       (intern (format "ediff-current-diff-overlay-%S" buf-type)))))
+	       (ediff-get-symbol-from-alist
+		buf-type ediff-current-diff-overlay-alist))))
 	
 	(if ediff-xemacs-p
 	    (ediff-move-overlay current-diff-overlay begin end-hilit)
@@ -1305,7 +1357,8 @@ More precisely, a regexp to match any one such character.")
   (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
       (let ((current-diff-overlay 
 	     (symbol-value
-	      (intern (format "ediff-current-diff-overlay-%S" buf-type))))
+	      (ediff-get-symbol-from-alist
+	       buf-type ediff-current-diff-overlay-alist)))
 	    (overlay
 	     (ediff-get-diff-overlay ediff-current-difference buf-type))
 	    )
@@ -1326,7 +1379,8 @@ More precisely, a regexp to match any one such character.")
   (if (and (ediff-has-face-support-p) ediff-use-faces)
       (let* ((inhibit-quit t)
 	     (current-diff-overlay-var
-	      (intern (format "ediff-current-diff-overlay-%S" buf-type)))
+	      (ediff-get-symbol-from-alist
+	       buf-type ediff-current-diff-overlay-alist))
 	     (current-diff-overlay (symbol-value current-diff-overlay-var)))
 	(ediff-paint-background-regions 'unhighlight)
 	(if (ediff-overlayp current-diff-overlay)
@@ -1447,7 +1501,7 @@ More precisely, a regexp to match any one such character.")
 	    ;; Don't grab on quit, if the user doesn't want to.
 	    ;; If ediff-grab-mouse = t, then mouse won't be grabbed for
 	    ;; sessions that are not part of a group (this is done in
-	    ;; ediff-recenter). The condition below affects only terminating
+	    ;; ediff-recenter).  The condition below affects only terminating
 	    ;; sessions in session groups (in which case mouse is warped into
 	    ;; a meta buffer).
 	    (and (eq ediff-grab-mouse 'maybe)
@@ -1459,7 +1513,7 @@ More precisely, a regexp to match any one such character.")
   (setq ediff-mouse-pixel-position (mouse-pixel-position)))
 
 ;; It is not easy to find out when the user grabs the mouse, since emacs and
-;; xemacs behave differently when mouse is not in any frame. Also, this is
+;; xemacs behave differently when mouse is not in any frame.  Also, this is
 ;; sensitive to when the user grabbed mouse.  Not used for now.
 (defun ediff-user-grabbed-mouse ()
   (if ediff-mouse-pixel-position
@@ -1499,15 +1553,15 @@ More precisely, a regexp to match any one such character.")
 (defsubst ediff-empty-overlay-p (overl)
   (= (ediff-overlay-start overl) (ediff-overlay-end overl)))
 
-;; like overlay-buffer in Emacs. In XEmacs, returns nil if the extent is
-;; dead. Otherwise, works like extent-buffer
+;; like overlay-buffer in Emacs.  In XEmacs, returns nil if the extent is
+;; dead.  Otherwise, works like extent-buffer
 (defun ediff-overlay-buffer (overl)
   (if ediff-emacs-p
       (overlay-buffer overl)
     (and (extent-live-p overl) (extent-object overl))))
 
-;; like overlay-get in Emacs. In XEmacs, returns nil if the extent is
-;; dead. Otherwise, like extent-property
+;; like overlay-get in Emacs.  In XEmacs, returns nil if the extent is
+;; dead.  Otherwise, like extent-property
 (defun ediff-overlay-get (overl property)
   (if ediff-emacs-p
       (overlay-get overl property)
@@ -1557,7 +1611,7 @@ Checks if overlay's buffer exists."
       (ediff-empty-diff-region-p n buf-type)
       (let ((beg (ediff-get-diff-posn buf-type 'beg n))
 	    (end (ediff-get-diff-posn buf-type 'end n)))
-	(ediff-eval-in-buffer (ediff-get-buffer buf-type)
+	(ediff-with-current-buffer (ediff-get-buffer buf-type)
 	  (save-excursion
 	    (goto-char beg)
 	    (skip-chars-forward ediff-whitespace)
@@ -1574,7 +1628,7 @@ Checks if overlay's buffer exists."
 	 (abbreviate-file-name file t))))
 
 ;; Takes a directory and returns the parent directory.
-;; does nothing to `/'. If the ARG is a regular file,
+;; does nothing to `/'.  If the ARG is a regular file,
 ;; strip the file AND the last dir.
 (defun ediff-strip-last-dir (dir)
   (if (not (stringp dir)) (setq dir default-directory))
@@ -1596,6 +1650,9 @@ Checks if overlay's buffer exists."
       (setq substr (substring str (max 0 (- len 1 newlen))))
       (concat "..." substr))))
 
+(defsubst ediff-nonempty-string-p (string)
+  (and (stringp string) (not (string= string ""))))
+
 (defun ediff-abbrev-jobname (jobname)
   (cond ((eq jobname 'ediff-directories)
 	 "Compare two directories")
@@ -1632,8 +1689,8 @@ Checks if overlay's buffer exists."
 
     
 (defsubst ediff-get-region-contents (n buf-type ctrl-buf &optional start end)
-  (ediff-eval-in-buffer 
-      (ediff-eval-in-buffer ctrl-buf (ediff-get-buffer buf-type))
+  (ediff-with-current-buffer 
+      (ediff-with-current-buffer ctrl-buf (ediff-get-buffer buf-type))
     (buffer-substring
      (or start (ediff-get-diff-posn buf-type 'beg n ctrl-buf))
      (or end (ediff-get-diff-posn buf-type 'end n ctrl-buf)))))
@@ -1678,8 +1735,8 @@ Checks if overlay's buffer exists."
 
 ;;; Local Variables:
 ;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
-;;; eval: (put 'ediff-eval-in-buffer 'lisp-indent-hook 1)
-;;; eval: (put 'ediff-eval-in-buffer 'edebug-form-spec '(form body))
+;;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
+;;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
 ;;; End:
      
 (provide 'ediff-init)