lisp/ediff-init.el

   1 ;;; ediff-init.el --- Macros, variables, and defsubsts used by Ediff
   2
   3 ;; Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   4 ;;   2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   5
   6 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software: you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Commentary:
  24
  25 ;;; Code:
  26
  27 ;; Start compiler pacifier
  28 (defvar ediff-metajob-name)
  29 (defvar ediff-meta-buffer)
  30 (defvar ediff-grab-mouse)
  31 (defvar ediff-mouse-pixel-position)
  32 (defvar ediff-mouse-pixel-threshold)
  33 (defvar ediff-whitespace)
  34 (defvar ediff-multiframe)
  35 (defvar ediff-use-toolbar-p)
  36 (defvar mswindowsx-bitmap-file-path)
  37 ;; end pacifier
  38
  39 (defvar ediff-force-faces nil
  40   "If t, Ediff will think that it is running on a display that supports faces.
  41 This is provided as a temporary relief for users of face-capable displays
  42 that Ediff doesn't know about.")
  43
  44 ;; Are we running as a window application or on a TTY?
  45 (defsubst ediff-device-type ()
  46   (if (featurep 'xemacs)
  47       (device-type (selected-device))
  48     window-system))
  49
  50 ;; in XEmacs: device-type is tty on tty and stream in batch.
  51 (defun ediff-window-display-p ()
  52   (and (ediff-device-type) (not (memq (ediff-device-type) '(tty pc stream)))))
  53
  54 ;; test if supports faces
  55 (defun ediff-has-face-support-p ()
  56   (cond ((ediff-window-display-p))
  57         (ediff-force-faces)
  58         ((ediff-color-display-p))
  59         ((featurep 'emacs) (memq (ediff-device-type) '(pc)))
  60         ((featurep 'xemacs) (memq (ediff-device-type) '(tty pc)))
  61         ))
  62
  63 ;; toolbar support for emacs hasn't been implemented in ediff
  64 (defun ediff-has-toolbar-support-p ()
  65   (if (featurep 'xemacs)
  66       (if (featurep 'toolbar) (console-on-window-system-p))))
  67
  68
  69 (defun ediff-has-gutter-support-p ()
  70   (if (featurep 'xemacs)
  71       (if (featurep 'gutter) (console-on-window-system-p))))
  72
  73 (defun ediff-use-toolbar-p ()
  74   (and (ediff-has-toolbar-support-p)    ;Can it do it ?
  75        (boundp 'ediff-use-toolbar-p)
  76        ediff-use-toolbar-p))            ;Does the user want it ?
  77
  78 ;; Defines VAR as an advertised local variable.
  79 ;; Performs a defvar, then executes `make-variable-buffer-local' on
  80 ;; the variable.  Also sets the `permanent-local' property,
  81 ;; so that `kill-all-local-variables' (called by major-mode setting
  82 ;; commands) won't destroy Ediff control variables.
  83 ;;
  84 ;; Plagiarised from `emerge-defvar-local' for XEmacs.
  85 (defmacro ediff-defvar-local (var value doc)
  86   "Defines VAR as a local variable."
  87   (declare (indent defun))
  88   `(progn
  89      (defvar ,var ,value ,doc)
  90      (make-variable-buffer-local ',var)
  91      (put ',var 'permanent-local t)))
  92
  93
  94
  95 ;; Variables that control each Ediff session---local to the control buffer.
  96
  97 ;; Mode variables
  98 ;; The buffer in which the A variant is stored.
  99 (ediff-defvar-local ediff-buffer-A nil "")
 100 ;; The buffer in which the B variant is stored.
 101 (ediff-defvar-local ediff-buffer-B nil "")
 102 ;; The buffer in which the C variant is stored or where the merge buffer lives.
 103 (ediff-defvar-local ediff-buffer-C nil "")
 104 ;; Ancestor buffer
 105 (ediff-defvar-local ediff-ancestor-buffer nil "")
 106 ;; The Ediff control buffer
 107 (ediff-defvar-local ediff-control-buffer nil "")
 108
 109 (ediff-defvar-local ediff-temp-indirect-buffer nil
 110   "If t, the buffer is a temporary indirect buffer.
 111 It needs to be killed when we quit the session.")
 112
 113
 114 ;; Association between buff-type and ediff-buffer-*
 115 (defconst ediff-buffer-alist
 116   '((?A . ediff-buffer-A)
 117     (?B . ediff-buffer-B)
 118     (?C . ediff-buffer-C)))
 119
 120 ;;; Macros
 121 (defmacro ediff-odd-p (arg)
 122   `(eq (logand ,arg 1) 1))
 123
 124 (defmacro ediff-buffer-live-p (buf)
 125   `(and ,buf (get-buffer ,buf) (buffer-name (get-buffer ,buf))))
 126
 127 (defmacro ediff-get-buffer (arg)
 128   `(cond ((eq ,arg 'A) ediff-buffer-A)
 129          ((eq ,arg 'B) ediff-buffer-B)
 130          ((eq ,arg 'C) ediff-buffer-C)
 131          ((eq ,arg 'Ancestor) ediff-ancestor-buffer)
 132          ))
 133
 134 (defmacro ediff-get-value-according-to-buffer-type (buf-type list)
 135   `(cond ((eq ,buf-type 'A) (nth 0 ,list))
 136          ((eq ,buf-type 'B) (nth 1 ,list))
 137          ((eq ,buf-type 'C) (nth 2 ,list))
 138          ))
 139
 140 (defmacro ediff-char-to-buftype (arg)
 141   `(cond ((memq ,arg '(?a ?A)) 'A)
 142          ((memq ,arg '(?b ?B)) 'B)
 143          ((memq ,arg '(?c ?C)) 'C)
 144          ))
 145
 146
 147 ;; A-list is supposed to be of the form (A . symb) (B . symb)...)
 148 ;; where the first part of any association is a buffer type and the second is
 149 ;; an appropriate symbol.  Given buffer-type, this function returns the
 150 ;; symbol.  This is used to avoid using `intern'
 151 (defsubst ediff-get-symbol-from-alist (buf-type alist)
 152   (cdr (assoc buf-type alist)))
 153
 154 (defconst ediff-difference-vector-alist
 155   '((A . ediff-difference-vector-A)
 156     (B . ediff-difference-vector-B)
 157     (C . ediff-difference-vector-C)
 158     (Ancestor . ediff-difference-vector-Ancestor)))
 159
 160 (defmacro ediff-get-difference (n buf-type)
 161   `(aref
 162     (symbol-value
 163      (ediff-get-symbol-from-alist
 164       ,buf-type ediff-difference-vector-alist))
 165     ,n))
 166
 167 ;; Tell if it has been previously determined that the region has
 168 ;; no diffs other than the white space and newlines
 169 ;; The argument, N, is the diff region number used by Ediff to index the
 170 ;; diff vector.  It is 1 less than the number seen by the user.
 171 ;; Returns:
 172 ;;              t  if the diffs are whitespace in all buffers
 173 ;;              'A (in 3-buf comparison only) if there are only whitespace
 174 ;;                 diffs in bufs B and C
 175 ;;              'B (in 3-buf comparison only) if there are only whitespace
 176 ;;                 diffs in bufs A and C
 177 ;;              'C (in 3-buf comparison only) if there are only whitespace
 178 ;;                 diffs in bufs A and B
 179 ;;
 180 ;; A Difference Vector has the form:
 181 ;; [diff diff diff ...]
 182 ;; where each diff has the form:
 183 ;; [overlay fine-diff-vector no-fine-diffs-flag state-of-difference]
 184 ;; fine-diff-vector is a vector [fine-diff fine-diff fine-diff ...]
 185 ;; no-fine-diffs-flag says if there are fine differences.
 186 ;; state-of-difference is A, B, C, or nil, indicating which buffer is
 187 ;;      different from the other two (used only in 3-way jobs).
 188 (defmacro ediff-no-fine-diffs-p (n)
 189   `(aref (ediff-get-difference ,n 'A) 2))
 190
 191 (defmacro ediff-get-diff-overlay-from-diff-record (diff-rec)
 192   `(aref ,diff-rec 0))
 193
 194 (defmacro ediff-get-diff-overlay (n buf-type)
 195   `(ediff-get-diff-overlay-from-diff-record
 196     (ediff-get-difference ,n ,buf-type)))
 197
 198 (defmacro ediff-get-fine-diff-vector-from-diff-record (diff-rec)
 199   `(aref ,diff-rec 1))
 200
 201 (defmacro ediff-set-fine-diff-vector (n buf-type fine-vec)
 202   `(aset (ediff-get-difference ,n ,buf-type) 1 ,fine-vec))
 203
 204 (defmacro ediff-get-state-of-diff (n buf-type)
 205   `(if (ediff-buffer-live-p ediff-buffer-C)
 206        (aref (ediff-get-difference ,n ,buf-type) 3)))
 207 (defmacro ediff-set-state-of-diff (n buf-type val)
 208   `(aset (ediff-get-difference ,n ,buf-type) 3 ,val))
 209
 210 (defmacro ediff-get-state-of-merge (n)
 211   `(if ediff-state-of-merge
 212        (aref (aref ediff-state-of-merge ,n) 0)))
 213 (defmacro ediff-set-state-of-merge (n val)
 214   `(if ediff-state-of-merge
 215        (aset (aref ediff-state-of-merge ,n) 0 ,val)))
 216
 217 (defmacro ediff-get-state-of-ancestor (n)
 218   `(if ediff-state-of-merge
 219        (aref (aref ediff-state-of-merge ,n) 1)))
 220
 221 ;; if flag is t, puts a mark on diff region saying that
 222 ;; the differences are in white space only.  If flag is nil,
 223 ;; the region is marked as essential (i.e., differences are
 224 ;; not just in the white space and newlines.)
 225 (defmacro ediff-mark-diff-as-space-only (n flag)
 226   `(aset (ediff-get-difference ,n 'A) 2 ,flag))
 227
 228 (defmacro ediff-get-fine-diff-vector (n buf-type)
 229   `(ediff-get-fine-diff-vector-from-diff-record
 230     (ediff-get-difference ,n ,buf-type)))
 231
 232 ;; Macro to switch to BUFFER, evaluate BODY, returns to original buffer.
 233 ;; Doesn't save the point and mark.
 234 ;; This is `with-current-buffer' with the added test for live buffers."
 235 (defmacro ediff-with-current-buffer (buffer &rest body)
 236   "Evaluates BODY in BUFFER."
 237   (declare (indent 1) (debug (form body)))
 238   `(if (ediff-buffer-live-p ,buffer)
 239        (save-current-buffer
 240          (set-buffer ,buffer)
 241          ,@body)
 242      (or (eq this-command 'ediff-quit)
 243          (error ediff-KILLED-VITAL-BUFFER))
 244      ))
 245
 246
 247 (defsubst ediff-multiframe-setup-p ()
 248   (and (ediff-window-display-p) ediff-multiframe))
 249
 250 (defmacro ediff-narrow-control-frame-p ()
 251   `(and (ediff-multiframe-setup-p)
 252         (equal ediff-help-message ediff-brief-message-string)))
 253
 254 (defmacro ediff-3way-comparison-job ()
 255   `(memq
 256     ediff-job-name
 257     '(ediff-files3 ediff-buffers3)))
 258 (ediff-defvar-local ediff-3way-comparison-job nil "")
 259
 260 (defmacro ediff-merge-job ()
 261   `(memq
 262     ediff-job-name
 263     '(ediff-merge-files
 264       ediff-merge-buffers
 265       ediff-merge-files-with-ancestor
 266       ediff-merge-buffers-with-ancestor
 267       ediff-merge-revisions
 268       ediff-merge-revisions-with-ancestor)))
 269 (ediff-defvar-local ediff-merge-job nil "")
 270
 271 (defmacro ediff-patch-job ()
 272   `(eq ediff-job-name 'epatch))
 273
 274 (defmacro ediff-merge-with-ancestor-job ()
 275   `(memq
 276     ediff-job-name
 277     '(ediff-merge-files-with-ancestor
 278       ediff-merge-buffers-with-ancestor
 279       ediff-merge-revisions-with-ancestor)))
 280 (ediff-defvar-local ediff-merge-with-ancestor-job nil "")
 281
 282 (defmacro ediff-3way-job ()
 283   `(or ediff-3way-comparison-job ediff-merge-job))
 284 (ediff-defvar-local ediff-3way-job nil "")
 285
 286 ;; A diff3 job is like a 3way job, but ediff-merge doesn't require the use
 287 ;; of diff3.
 288 (defmacro ediff-diff3-job ()
 289   `(or ediff-3way-comparison-job
 290        ediff-merge-with-ancestor-job))
 291 (ediff-defvar-local ediff-diff3-job nil "")
 292
 293 (defmacro ediff-windows-job ()
 294   `(memq ediff-job-name '(ediff-windows-wordwise ediff-windows-linewise)))
 295 (ediff-defvar-local ediff-windows-job nil "")
 296
 297 (defmacro ediff-word-mode-job ()
 298   `(memq ediff-job-name '(ediff-windows-wordwise ediff-regions-wordwise)))
 299 (ediff-defvar-local ediff-word-mode-job nil "")
 300
 301 (defmacro ediff-narrow-job ()
 302   `(memq ediff-job-name '(ediff-windows-wordwise
 303                           ediff-regions-wordwise
 304                           ediff-windows-linewise
 305                           ediff-regions-linewise)))
 306 (ediff-defvar-local ediff-narrow-job nil "")
 307
 308 ;; Note: ediff-merge-directory-revisions-with-ancestor is not treated as an
 309 ;; ancestor metajob, since it behaves differently.
 310 (defsubst ediff-ancestor-metajob (&optional metajob)
 311   (memq (or metajob ediff-metajob-name)
 312         '(ediff-merge-directories-with-ancestor
 313           ediff-merge-filegroups-with-ancestor)))
 314 (defsubst ediff-revision-metajob (&optional metajob)
 315   (memq (or metajob ediff-metajob-name)
 316         '(ediff-directory-revisions
 317           ediff-merge-directory-revisions
 318           ediff-merge-directory-revisions-with-ancestor)))
 319 (defsubst ediff-patch-metajob (&optional metajob)
 320   (memq (or metajob ediff-metajob-name)
 321         '(ediff-multifile-patch)))
 322 ;; metajob involving only one group of files, such as multipatch or directory
 323 ;; revision
 324 (defsubst ediff-one-filegroup-metajob (&optional metajob)
 325   (or (ediff-revision-metajob metajob)
 326       (ediff-patch-metajob metajob)
 327       ;; add more here
 328       ))
 329 ;; jobs suitable for the operation of collecting diffs into a multifile patch
 330 (defsubst ediff-collect-diffs-metajob (&optional metajob)
 331   (memq (or metajob ediff-metajob-name)
 332         '(ediff-directories
 333           ediff-merge-directories
 334           ediff-merge-directories-with-ancestor
 335           ediff-directory-revisions
 336           ediff-merge-directory-revisions
 337           ediff-merge-directory-revisions-with-ancestor
 338           ;; add more here
 339           )))
 340 (defsubst ediff-merge-metajob (&optional metajob)
 341   (memq (or metajob ediff-metajob-name)
 342         '(ediff-merge-directories
 343           ediff-merge-directories-with-ancestor
 344           ediff-merge-directory-revisions
 345           ediff-merge-directory-revisions-with-ancestor
 346           ediff-merge-filegroups-with-ancestor
 347           ;; add more here
 348           )))
 349
 350 (defsubst ediff-metajob3 (&optional metajob)
 351   (memq (or metajob ediff-metajob-name)
 352         '(ediff-merge-directories-with-ancestor
 353           ediff-merge-filegroups-with-ancestor
 354           ediff-directories3
 355           ediff-filegroups3)))
 356 (defsubst ediff-comparison-metajob3 (&optional metajob)
 357   (memq (or metajob ediff-metajob-name)
 358         '(ediff-directories3 ediff-filegroups3)))
 359
 360 ;; with no argument, checks if we are in ediff-control-buffer
 361 ;; with argument, checks if we are in ediff-meta-buffer
 362 (defun ediff-in-control-buffer-p (&optional meta-buf-p)
 363   (and (boundp 'ediff-control-buffer)
 364        (eq (if meta-buf-p ediff-meta-buffer ediff-control-buffer)
 365            (current-buffer))))
 366
 367 (defsubst ediff-barf-if-not-control-buffer (&optional meta-buf-p)
 368   (or (ediff-in-control-buffer-p meta-buf-p)
 369       (error "%S: This command runs in Ediff Control Buffer only!"
 370              this-command)))
 371
 372 (defgroup ediff-highlighting nil
 373   "Hilighting of difference regions in Ediff."
 374   :prefix "ediff-"
 375   :group 'ediff)
 376
 377 (defgroup ediff-merge nil
 378   "Merging utilities."
 379   :prefix "ediff-"
 380   :group 'ediff)
 381
 382 (defgroup ediff-hook nil
 383   "Hooks run by Ediff."
 384   :prefix "ediff-"
 385   :group 'ediff)
 386
 387 ;; Hook variables
 388
 389 (defcustom ediff-before-setup-hook nil
 390   "Hooks to run before Ediff begins to set up windows and buffers.
 391 This hook can be used to save the previous window config, which can be restored
 392 on ediff-quit or ediff-suspend."
 393   :type 'hook
 394   :group 'ediff-hook)
 395 (defcustom ediff-before-setup-windows-hook nil
 396   "Hooks to run before Ediff sets its window configuration.
 397 This hook is run every time when Ediff arranges its windows.
 398 This happens each time Ediff detects that the windows were messed up by the
 399 user."
 400   :type 'hook
 401   :group 'ediff-hook)
 402 (defcustom ediff-after-setup-windows-hook nil
 403   "Hooks to run after Ediff sets its window configuration.
 404 This can be used to set up control window or icon in a desired place."
 405   :type 'hook
 406   :group 'ediff-hook)
 407 (defcustom ediff-before-setup-control-frame-hook nil
 408   "Hooks run before setting up the frame to display Ediff Control Panel.
 409 Can be used to change control frame parameters to position it where it
 410 is desirable."
 411   :type 'hook
 412   :group 'ediff-hook)
 413 (defcustom ediff-after-setup-control-frame-hook nil
 414   "Hooks run after setting up the frame to display Ediff Control Panel.
 415 Can be used to move the frame where it is desired."
 416   :type 'hook
 417   :group 'ediff-hook)
 418 (defcustom ediff-startup-hook nil
 419   "Hooks to run in the control buffer after Ediff has been set up and is ready for the job."
 420   :type 'hook
 421   :group 'ediff-hook)
 422 (defcustom ediff-select-hook nil
 423   "Hooks to run after a difference has been selected."
 424   :type 'hook
 425   :group 'ediff-hook)
 426 (defcustom ediff-unselect-hook nil
 427   "Hooks to run after a difference has been unselected."
 428   :type 'hook
 429   :group 'ediff-hook)
 430 (defcustom ediff-prepare-buffer-hook  nil
 431   "Hooks run after buffers A, B, and C are set up.
 432 For each buffer, the hooks are run with that buffer made current."
 433   :type 'hook
 434   :group 'ediff-hook)
 435 (defcustom ediff-load-hook nil
 436   "Hook run after Ediff is loaded.  Can be used to change defaults."
 437   :type 'hook
 438   :group 'ediff-hook)
 439
 440 (defcustom ediff-mode-hook nil
 441   "Hook run just after ediff-mode is set up in the control buffer.
 442 This is done before any windows or frames are created.  One can use it to
 443 set local variables that determine how the display looks like."
 444   :type 'hook
 445   :group 'ediff-hook)
 446 (defcustom ediff-keymap-setup-hook nil
 447   "Hook run just after the default bindings in Ediff keymap are set up."
 448   :type 'hook
 449   :group 'ediff-hook)
 450
 451 (defcustom ediff-display-help-hook nil
 452   "Hooks run after preparing the help message."
 453   :type 'hook
 454   :group 'ediff-hook)
 455
 456 (defcustom ediff-suspend-hook nil
 457   "Hooks to run in the Ediff control buffer when Ediff is suspended."
 458   :type 'hook
 459   :group 'ediff-hook)
 460 (defcustom ediff-quit-hook nil
 461   "Hooks to run in the Ediff control buffer after finishing Ediff."
 462   :type 'hook
 463   :group 'ediff-hook)
 464 (defcustom ediff-cleanup-hook nil
 465   "Hooks to run on exiting Ediff but before killing the control and variant buffers."
 466   :type 'hook
 467   :group 'ediff-hook)
 468
 469 ;; Error messages
 470 (defconst ediff-KILLED-VITAL-BUFFER
 471   "You have killed a vital Ediff buffer---you must leave Ediff now!")
 472 (defconst ediff-NO-DIFFERENCES
 473   "Sorry, comparison of identical variants is not what I am made for...")
 474 (defconst ediff-BAD-DIFF-NUMBER
 475   ;; %S stands for this-command, %d - diff number, %d - max diff
 476   "%S: Bad diff region number, %d.  Valid numbers are 1 to %d")
 477 (defconst ediff-BAD-INFO (format "
 478 *** The Info file for Ediff, a part of the standard distribution
 479 *** of %sEmacs, does not seem to be properly installed.
 480 ***
 481 *** Please contact your system administrator. "
 482                                  (if (featurep 'xemacs) "X" "")))
 483
 484 ;; Selective browsing
 485
 486 (ediff-defvar-local ediff-skip-diff-region-function 'ediff-show-all-diffs
 487   "Function that determines the next/previous diff region to show.
 488 Should return t for regions to be ignored and nil otherwise.
 489 This function gets a region number as an argument.  The region number
 490 is the one used internally by Ediff.  It is 1 less than the number seen
 491 by the user.")
 492
 493 (ediff-defvar-local ediff-hide-regexp-matches-function
 494   'ediff-hide-regexp-matches
 495   "Function to use in determining which regions to hide.
 496 See the documentation string of `ediff-hide-regexp-matches' for details.")
 497 (ediff-defvar-local ediff-focus-on-regexp-matches-function
 498   'ediff-focus-on-regexp-matches
 499   "Function to use in determining which regions to focus on.
 500 See the documentation string of `ediff-focus-on-regexp-matches' for details.")
 501
 502 ;; Regexp that determines buf A regions to focus on when skipping to diff
 503 (ediff-defvar-local ediff-regexp-focus-A "" "")
 504 ;; Regexp that determines buf B regions to focus on when skipping to diff
 505 (ediff-defvar-local ediff-regexp-focus-B "" "")
 506 ;; Regexp that determines buf C regions to focus on when skipping to diff
 507 (ediff-defvar-local ediff-regexp-focus-C "" "")
 508 ;; connective that determines whether to focus regions that match both or
 509 ;; one of the regexps
 510 (ediff-defvar-local ediff-focus-regexp-connective 'and "")
 511
 512 ;; Regexp that determines buf A regions to ignore when skipping to diff
 513 (ediff-defvar-local ediff-regexp-hide-A "" "")
 514 ;; Regexp that determines buf B regions to ignore when skipping to diff
 515 (ediff-defvar-local ediff-regexp-hide-B "" "")
 516 ;; Regexp that determines buf C regions to ignore when skipping to diff
 517 (ediff-defvar-local ediff-regexp-hide-C "" "")
 518 ;; connective that determines whether to hide regions that match both or
 519 ;; one of the regexps
 520 (ediff-defvar-local ediff-hide-regexp-connective 'and "")
 521
 522
 523 ;;; Copying difference regions between buffers.
 524
 525 ;; A list of killed diffs.
 526 ;; A diff is saved here if it is replaced by a diff
 527 ;; from another buffer.  This alist has the form:
 528 ;; \((num (buff-object . diff) (buff-object . diff) (buff-object . diff)) ...),
 529 ;; where some buffer-objects may be missing.
 530 (ediff-defvar-local ediff-killed-diffs-alist nil "")
 531
 532 ;; Syntax table to use in ediff-forward-word-function
 533 ;; This is chosen by a heuristic. The important thing is for all buffers to
 534 ;; have the same syntax table. Which is not too important.
 535 (ediff-defvar-local ediff-syntax-table nil "")
 536
 537
 538 ;; Highlighting
 539 (defcustom ediff-before-flag-bol (if (featurep 'xemacs) (make-glyph "->>") "->>")
 540   "Flag placed before a highlighted block of differences, if block starts at beginning of a line."
 541   :type 'string
 542   :tag  "Region before-flag at beginning of line"
 543   :group 'ediff)
 544
 545 (defcustom ediff-after-flag-eol  (if (featurep 'xemacs) (make-glyph "<<-") "<<-")
 546   "Flag placed after a highlighted block of differences, if block ends at end of a line."
 547   :type 'string
 548   :tag  "Region after-flag at end of line"
 549   :group 'ediff)
 550
 551 (defcustom ediff-before-flag-mol (if (featurep 'xemacs) (make-glyph "->>") "->>")
 552   "Flag placed before a highlighted block of differences, if block starts in mid-line."
 553   :type 'string
 554   :tag  "Region before-flag in the middle of line"
 555   :group 'ediff)
 556 (defcustom ediff-after-flag-mol  (if (featurep 'xemacs) (make-glyph "<<-") "<<-")
 557   "Flag placed after a highlighted block of differences, if block ends in mid-line."
 558   :type 'string
 559   :tag  "Region after-flag in the middle of line"
 560   :group 'ediff)
 561
 562
 563 (ediff-defvar-local ediff-use-faces t "")
 564 (defcustom ediff-use-faces t
 565   "If t, differences are highlighted using faces, if device supports faces.
 566 If nil, differences are highlighted using ASCII flags, ediff-before-flag
 567 and ediff-after-flag.  On a non-window system, differences are always
 568 highlighted using ASCII flags."
 569   :type 'boolean
 570   :group 'ediff-highlighting)
 571
 572 ;; this indicates that diff regions are word-size, so fine diffs are
 573 ;; permanently nixed; used in ediff-windows-wordwise and ediff-regions-wordwise
 574 (ediff-defvar-local ediff-word-mode nil "")
 575 ;; Name of the job (ediff-files, ediff-windows, etc.)
 576 (ediff-defvar-local ediff-job-name nil "")
 577
 578 ;; Narrowing and ediff-region/windows support
 579 ;; This is a list (overlay-A overlay-B overlay-C)
 580 ;; If set, Ediff compares only those parts of buffers A/B/C that lie within
 581 ;; the bounds of these overlays.
 582 (ediff-defvar-local ediff-narrow-bounds nil "")
 583
 584 ;; List (overlay-A overlay-B overlay-C), where each overlay spans the
 585 ;; entire corresponding buffer.
 586 (ediff-defvar-local ediff-wide-bounds nil "")
 587
 588 ;; Current visibility boundaries in buffers A, B, and C.
 589 ;; This is also a list of overlays.  When the user toggles narrow/widen,
 590 ;; this list changes from ediff-wide-bounds to ediff-narrow-bounds.
 591 ;; and back.
 592 (ediff-defvar-local ediff-visible-bounds nil "")
 593
 594 (ediff-defvar-local ediff-start-narrowed t
 595   "Non-nil means start narrowed, if doing ediff-windows-* or ediff-regions-*")
 596 (ediff-defvar-local ediff-quit-widened t
 597   "*Non-nil means: when finished, Ediff widens buffers A/B.
 598 Actually, Ediff restores the scope of visibility that existed at startup.")
 599
 600 (defcustom ediff-keep-variants t
 601   "nil means prompt to remove unmodified buffers A/B/C at session end.
 602 Supplying a prefix argument to the quit command `q' temporarily reverses the
 603 meaning of this variable."
 604   :type 'boolean
 605   :group 'ediff)
 606
 607 (ediff-defvar-local ediff-highlight-all-diffs t "")
 608 (defcustom ediff-highlight-all-diffs t
 609   "If nil, only the selected differences are highlighted.
 610 Otherwise, all difference regions are highlighted, but the selected region is
 611 shown in brighter colors."
 612   :type 'boolean
 613   :group 'ediff-highlighting)
 614
 615
 616 ;; The suffix of the control buffer name.
 617 (ediff-defvar-local ediff-control-buffer-suffix nil "")
 618 ;; Same as ediff-control-buffer-suffix, but without <,>.
 619 ;; It's a number rather than string.
 620 (ediff-defvar-local ediff-control-buffer-number nil "")
 621
 622
 623 ;; The original values of ediff-protected-variables for buffer A
 624 (ediff-defvar-local ediff-buffer-values-orig-A nil "")
 625 ;; The original values of ediff-protected-variables for buffer B
 626 (ediff-defvar-local ediff-buffer-values-orig-B nil "")
 627 ;; The original values of ediff-protected-variables for buffer C
 628 (ediff-defvar-local ediff-buffer-values-orig-C nil "")
 629 ;; The original values of ediff-protected-variables for buffer Ancestor
 630 (ediff-defvar-local ediff-buffer-values-orig-Ancestor nil "")
 631
 632 ;; association between buff-type and ediff-buffer-values-orig-*
 633 (defconst ediff-buffer-values-orig-alist
 634   '((A . ediff-buffer-values-orig-A)
 635     (B . ediff-buffer-values-orig-B)
 636     (C . ediff-buffer-values-orig-C)
 637     (Ancestor . ediff-buffer-values-orig-Ancestor)))
 638
 639 ;; Buffer-local variables to be saved then restored during Ediff sessions
 640 (defconst ediff-protected-variables '(
 641                                       ;;buffer-read-only
 642                                       mode-line-format))
 643
 644 ;; Vector of differences between the variants.  Each difference is
 645 ;; represented by a vector of two overlays plus a vector of fine diffs,
 646 ;; plus a no-fine-diffs flag.  The first overlay spans the
 647 ;; difference region in the A buffer and the second overlays the diff in
 648 ;; the B buffer.  If a difference section is empty, the corresponding
 649 ;; overlay's endpoints coincide.
 650 ;;
 651 ;; The precise form of a Difference Vector for one buffer is:
 652 ;; [diff diff diff ...]
 653 ;; where each diff has the form:
 654 ;; [diff-overlay fine-diff-vector no-fine-diffs-flag state-of-diff]
 655 ;; fine-diff-vector is a vector [fine-diff-overlay fine-diff-overlay ...]
 656 ;; no-fine-diffs-flag says if there are fine differences.
 657 ;; state-of-difference is A, B, C, or nil, indicating which buffer is
 658 ;;      different from the other two (used only in 3-way jobs.
 659 (ediff-defvar-local ediff-difference-vector-A nil "")
 660 (ediff-defvar-local ediff-difference-vector-B nil "")
 661 (ediff-defvar-local ediff-difference-vector-C nil "")
 662 (ediff-defvar-local ediff-difference-vector-Ancestor nil "")
 663 ;; A-list of diff vector types associated with buffer types
 664 (defconst ediff-difference-vector-alist
 665   '((A . ediff-difference-vector-A)
 666     (B . ediff-difference-vector-B)
 667     (C . ediff-difference-vector-C)
 668     (Ancestor . ediff-difference-vector-Ancestor)))
 669
 670 ;; [ status status status ...]
 671 ;; Each status: [state-of-merge state-of-ancestor]
 672 ;; state-of-merge is default-A, default-B, prefer-A, or prefer-B.  It
 673 ;; indicates the way a diff region was created in buffer C.
 674 ;; state-of-ancestor says if the corresponding region in ancestor buffer is
 675 ;; empty.
 676 (ediff-defvar-local ediff-state-of-merge nil "")
 677
 678 ;; The difference that is currently selected.
 679 (ediff-defvar-local ediff-current-difference -1 "")
 680 ;; Number of differences found.
 681 (ediff-defvar-local ediff-number-of-differences nil "")
 682
 683 ;; Buffer containing the output of diff, which is used by Ediff to step
 684 ;; through files.
 685 (ediff-defvar-local ediff-diff-buffer nil "")
 686 ;; Like ediff-diff-buffer, but contains context diff.  It is not used by
 687 ;; Ediff, but it is saved in a file, if user requests so.
 688 (ediff-defvar-local ediff-custom-diff-buffer nil "")
 689 ;; Buffer used for diff-style fine differences between regions.
 690 (ediff-defvar-local ediff-fine-diff-buffer nil "")
 691 ;; Temporary buffer used for computing fine differences.
 692 (defconst ediff-tmp-buffer " *ediff-tmp*" "")
 693 ;; Buffer used for messages
 694 (defconst ediff-msg-buffer " *ediff-message*" "")
 695 ;; Buffer containing the output of diff when diff returns errors.
 696 (ediff-defvar-local ediff-error-buffer nil "")
 697 ;; Buffer to display debug info
 698 (ediff-defvar-local ediff-debug-buffer "*ediff-debug*" "")
 699
 700 ;; List of ediff control panels associated with each buffer A/B/C/Ancestor.
 701 ;; Not used any more, but may be needed in the future.
 702 (ediff-defvar-local ediff-this-buffer-ediff-sessions  nil "")
 703
 704 ;; to be deleted in due time
 705 ;; List of difference overlays disturbed by working with the current diff.
 706 (defvar ediff-disturbed-overlays nil "")
 707
 708 ;; Priority of non-selected overlays.
 709 (defvar ediff-shadow-overlay-priority  100 "")
 710
 711 (defcustom ediff-version-control-package 'vc
 712   "Version control package used.
 713 Currently, Ediff supports vc.el, rcs.el, pcl-cvs.el, and generic-sc.el.  The
 714 standard Emacs interface to RCS, CVS, SCCS, etc., is vc.el.  However, some
 715 people find the other two packages more convenient.  Set this variable to the
 716 appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
 717   :type 'symbol
 718   :group 'ediff)
 719
 720 (defcustom ediff-coding-system-for-read 'raw-text
 721   "The coding system for read to use when running the diff program as a subprocess.
 722 In most cases, the default will do.  However, under certain circumstances in
 723 MS-Windows you might need to use something like 'raw-text-dos here.
 724 So, if the output that your diff program sends to Emacs contains extra ^M's,
 725 you might need to experiment here, if the default or 'raw-text-dos doesn't
 726 work."
 727   :type 'symbol
 728   :group 'ediff)
 729
 730 (defcustom ediff-coding-system-for-write (if (featurep 'xemacs)
 731                                              'escape-quoted
 732                                            'emacs-internal)
 733   "The coding system for write to use when writing out difference regions
 734 to temp files in buffer jobs and when Ediff needs to find fine differences."
 735   :type 'symbol
 736   :group 'ediff)
 737
 738
 739 (defalias 'ediff-read-event
 740   (if (featurep 'xemacs) 'next-command-event 'read-event))
 741
 742 (defalias 'ediff-overlayp
 743   (if (featurep 'xemacs) 'extentp 'overlayp))
 744
 745 (defalias 'ediff-make-overlay
 746   (if (featurep 'xemacs) 'make-extent 'make-overlay))
 747
 748 (defalias 'ediff-delete-overlay
 749   (if (featurep 'xemacs) 'delete-extent 'delete-overlay))
 750
 751 ;; Assumes that emacs-major-version and emacs-minor-version are defined.
 752 (defun ediff-check-version (op major minor &optional type-of-emacs)
 753   "Check the current version against MAJOR and MINOR version numbers.
 754 The comparison uses operator OP, which may be any of: =, >, >=, <, <=.
 755 TYPE-OF-EMACS is either 'xemacs or 'emacs."
 756   (and (cond ((eq type-of-emacs 'xemacs) (featurep 'xemacs))
 757              ((eq type-of-emacs 'emacs) (featurep 'emacs))
 758              (t))
 759        (cond ((eq op '=) (and (= emacs-minor-version minor)
 760                               (= emacs-major-version major)))
 761              ((memq op '(> >= < <=))
 762               (and (or (funcall op emacs-major-version major)
 763                        (= emacs-major-version major))
 764                    (if (= emacs-major-version major)
 765                        (funcall op emacs-minor-version minor)
 766                      t)))
 767              (t
 768               (error "%S: Invalid op in ediff-check-version" op)))))
 769
 770 ;; ediff-check-version seems to be totally unused anyway.
 771 (make-obsolete 'ediff-check-version 'version< "23.1")
 772
 773 (defun ediff-color-display-p ()
 774   (condition-case nil
 775       (if (featurep 'xemacs)
 776           (eq (device-class (selected-device)) 'color) ; xemacs form
 777         (display-color-p)) ; emacs form
 778     (error nil)))
 779
 780
 781 ;; A var local to each control panel buffer.  Indicates highlighting style
 782 ;; in effect for this buffer: `face', `ascii',
 783 ;; `off' -- turned off \(on a dumb terminal only\).
 784 (ediff-defvar-local ediff-highlighting-style
 785   (if (and (ediff-has-face-support-p) ediff-use-faces) 'face 'ascii)
 786   "")
 787
 788
 789 (if (ediff-has-face-support-p)
 790     (if (featurep 'xemacs)
 791         (progn
 792           (defalias 'ediff-valid-color-p 'valid-color-name-p)
 793           (defalias 'ediff-get-face 'get-face))
 794       (defalias 'ediff-valid-color-p (if (fboundp 'color-defined-p)
 795                                          'color-defined-p
 796                                        'x-color-defined-p))
 797       (defalias 'ediff-get-face 'internal-get-face)))
 798
 799 (if (ediff-window-display-p)
 800     (if (featurep 'xemacs)
 801         (progn
 802           (defalias 'ediff-display-pixel-width 'device-pixel-width)
 803           (defalias 'ediff-display-pixel-height 'device-pixel-height))
 804       (defalias 'ediff-display-pixel-width
 805         (if (fboundp 'display-pixel-width)
 806             'display-pixel-width
 807           'x-display-pixel-width))
 808       (defalias 'ediff-display-pixel-height
 809         (if (fboundp 'display-pixel-height)
 810             'display-pixel-height
 811           'x-display-pixel-height))))
 812
 813 ;; A-list of current-diff-overlay symbols associated with buf types
 814 (defconst ediff-current-diff-overlay-alist
 815   '((A . ediff-current-diff-overlay-A)
 816     (B . ediff-current-diff-overlay-B)
 817     (C . ediff-current-diff-overlay-C)
 818     (Ancestor . ediff-current-diff-overlay-Ancestor)))
 819
 820 ;; A-list of current-diff-face-* symbols associated with buf types
 821 (defconst ediff-current-diff-face-alist
 822   '((A . ediff-current-diff-A)
 823     (B . ediff-current-diff-B)
 824     (C . ediff-current-diff-C)
 825     (Ancestor . ediff-current-diff-Ancestor)))
 826
 827
 828 (defun ediff-set-overlay-face (extent face)
 829   (ediff-overlay-put extent 'face face)
 830   (ediff-overlay-put extent 'help-echo 'ediff-region-help-echo))
 831
 832 (defun ediff-region-help-echo (extent-or-window &optional overlay point)
 833   (unless overlay
 834     (setq overlay extent-or-window))
 835   (let ((is-current (ediff-overlay-get overlay 'ediff))
 836         (face (ediff-overlay-get overlay 'face))
 837         (diff-num (ediff-overlay-get overlay 'ediff-diff-num))
 838         face-help)
 839
 840     ;; This happens only for refinement overlays
 841     (if (stringp face)
 842         (setq face (intern face)))
 843     (setq face-help (and face (get face 'ediff-help-echo)))
 844
 845     (cond ((and is-current diff-num)    ; current diff region
 846            (format "Difference region %S -- current" (1+ diff-num)))
 847           (face-help)                   ; refinement of current diff region
 848           (diff-num                     ; non-current
 849            (format "Difference region %S -- non-current" (1+ diff-num)))
 850           (t ""))                       ; none
 851     ))
 852
 853
 854 (defun ediff-set-face-pixmap (face pixmap)
 855   "Set face pixmap on a monochrome display."
 856   (if (and (ediff-window-display-p) (not (ediff-color-display-p)))
 857       (condition-case nil
 858           (set-face-background-pixmap face pixmap)
 859         (error
 860          (message "Pixmap not found for %S: %s" (face-name face) pixmap)
 861          (sit-for 1)))))
 862
 863 (defun ediff-hide-face (face)
 864   (if (and (ediff-has-face-support-p)
 865            (boundp 'add-to-list)
 866            (boundp 'facemenu-unlisted-faces))
 867       (add-to-list 'facemenu-unlisted-faces face)))
 868
 869
 870
 871 (defface ediff-current-diff-A
 872   (if (featurep 'emacs)
 873       '((((class color) (min-colors 16))
 874          (:foreground "firebrick" :background "pale green"))
 875         (((class color))
 876          (:foreground "blue3" :background "yellow3"))
 877         (t                   (:inverse-video t)))
 878     '((((type tty))    (:foreground "blue3" :background "yellow3"))
 879       (((class color)) (:foreground "firebrick" :background "pale green"))
 880       (t                     (:inverse-video t))))
 881   "Face for highlighting the selected difference in buffer A."
 882   :group 'ediff-highlighting)
 883 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 884 ;; this variable is set to nil, then again to the appropriate face.
 885 (defvar ediff-current-diff-face-A 'ediff-current-diff-A
 886   "Face for highlighting the selected difference in buffer A.
 887 DO NOT CHANGE this variable.  Instead, use the customization
 888 widget to customize the actual face object `ediff-current-diff-A'
 889 this variable represents.")
 890 (ediff-hide-face ediff-current-diff-face-A)
 891 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 892 ;; This means that some user customization may be trashed.
 893 (and (featurep 'xemacs)
 894      (ediff-has-face-support-p)
 895      (not (ediff-color-display-p))
 896      (copy-face 'modeline ediff-current-diff-face-A))
 897
 898
 899
 900 (defface ediff-current-diff-B
 901   (if (featurep 'emacs)
 902       '((((class color) (min-colors 16))
 903          (:foreground "DarkOrchid" :background "Yellow"))
 904         (((class color))
 905          (:foreground "magenta3" :background "yellow3"
 906                       :weight bold))
 907         (t                   (:inverse-video t)))
 908     '((((type tty))    (:foreground "magenta3" :background "yellow3"
 909                                     :weight bold))
 910       (((class color)) (:foreground "DarkOrchid" :background "Yellow"))
 911       (t                     (:inverse-video t))))
 912   "Face for highlighting the selected difference in buffer B."
 913   :group 'ediff-highlighting)
 914 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 915 ;; this variable is set to nil, then again to the appropriate face.
 916 (defvar ediff-current-diff-face-B 'ediff-current-diff-B
 917   "Face for highlighting the selected difference in buffer B.
 918  this variable.  Instead, use the customization
 919 widget to customize the actual face `ediff-current-diff-B'
 920 this variable represents.")
 921 (ediff-hide-face ediff-current-diff-face-B)
 922 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 923 ;; This means that some user customization may be trashed.
 924 (and (featurep 'xemacs)
 925      (ediff-has-face-support-p)
 926      (not (ediff-color-display-p))
 927      (copy-face 'modeline ediff-current-diff-face-B))
 928
 929
 930 (defface ediff-current-diff-C
 931   (if (featurep 'emacs)
 932       '((((class color) (min-colors 16))
 933          (:foreground "Navy" :background "Pink"))
 934         (((class color))
 935          (:foreground "cyan3" :background "yellow3" :weight bold))
 936         (t                   (:inverse-video t)))
 937     '((((type tty))    (:foreground "cyan3" :background "yellow3" :weight bold))
 938       (((class color)) (:foreground "Navy" :background "Pink"))
 939       (t                     (:inverse-video t))))
 940   "Face for highlighting the selected difference in buffer C."
 941   :group 'ediff-highlighting)
 942 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 943 ;; this variable is set to nil, then again to the appropriate face.
 944 (defvar ediff-current-diff-face-C 'ediff-current-diff-C
 945   "Face for highlighting the selected difference in buffer C.
 946 DO NOT CHANGE this variable.  Instead, use the customization
 947 widget to customize the actual face object `ediff-current-diff-C'
 948 this variable represents.")
 949 (ediff-hide-face ediff-current-diff-face-C)
 950 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 951 ;; This means that some user customization may be trashed.
 952 (and (featurep 'xemacs)
 953      (ediff-has-face-support-p)
 954      (not (ediff-color-display-p))
 955      (copy-face 'modeline ediff-current-diff-face-C))
 956
 957
 958 (defface ediff-current-diff-Ancestor
 959   (if (featurep 'emacs)
 960       '((((class color) (min-colors 16))
 961          (:foreground "Black" :background "VioletRed"))
 962         (((class color))
 963          (:foreground "black" :background "magenta3"))
 964         (t (:inverse-video t)))
 965     '((((type tty))    (:foreground "black" :background "magenta3"))
 966       (((class color)) (:foreground "Black" :background "VioletRed"))
 967       (t (:inverse-video t))))
 968   "Face for highlighting the selected difference in buffer Ancestor."
 969   :group 'ediff-highlighting)
 970 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 971 ;; this variable is set to nil, then again to the appropriate face.
 972 (defvar ediff-current-diff-face-Ancestor 'ediff-current-diff-Ancestor
 973   "Face for highlighting the selected difference in buffer Ancestor.
 974 DO NOT CHANGE this variable.  Instead, use the customization
 975 widget to customize the actual face object `ediff-current-diff-Ancestor'
 976 this variable represents.")
 977 (ediff-hide-face ediff-current-diff-face-Ancestor)
 978 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 979 ;; This means that some user customization may be trashed.
 980 (and (featurep 'xemacs)
 981      (ediff-has-face-support-p)
 982      (not (ediff-color-display-p))
 983      (copy-face 'modeline ediff-current-diff-face-Ancestor))
 984
 985
 986 (defface ediff-fine-diff-A
 987   (if (featurep 'emacs)
 988       '((((class color) (min-colors 16))
 989          (:foreground "Navy" :background "sky blue"))
 990         (((class color))
 991          (:foreground "white" :background "sky blue" :weight bold))
 992         (t (:underline t :stipple "gray3")))
 993     '((((type tty))    (:foreground "white" :background "sky blue" :weight bold))
 994       (((class color)) (:foreground "Navy" :background "sky blue"))
 995       (t (:underline t :stipple "gray3"))))
 996   "Face for highlighting the refinement of the selected diff in buffer A."
 997   :group 'ediff-highlighting)
 998 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 999 ;; this variable is set to nil, then again to the appropriate face.
1000 (defvar ediff-fine-diff-face-A 'ediff-fine-diff-A
1001   "Face for highlighting the fine differences in buffer A.
1002 DO NOT CHANGE this variable.  Instead, use the customization
1003 widget to customize the actual face object `ediff-fine-diff-A'
1004 this variable represents.")
1005 (ediff-hide-face ediff-fine-diff-face-A)
1006
1007 (defface ediff-fine-diff-B
1008   (if (featurep 'emacs)
1009       '((((class color) (min-colors 16))
1010          (:foreground "Black" :background "cyan"))
1011         (((class color))
1012          (:foreground "magenta3" :background "cyan3"))
1013         (t                   (:underline t :stipple "gray3")))
1014     '((((type tty))    (:foreground "magenta3" :background "cyan3"))
1015       (((class color)) (:foreground "Black" :background "cyan"))
1016       (t                     (:underline t :stipple "gray3"))))
1017   "Face for highlighting the refinement of the selected diff in buffer B."
1018   :group 'ediff-highlighting)
1019 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1020 ;; this variable is set to nil, then again to the appropriate face.
1021 (defvar ediff-fine-diff-face-B 'ediff-fine-diff-B
1022   "Face for highlighting the fine differences in buffer B.
1023 DO NOT CHANGE this variable.  Instead, use the customization
1024 widget to customize the actual face object `ediff-fine-diff-B'
1025 this variable represents.")
1026 (ediff-hide-face ediff-fine-diff-face-B)
1027
1028 (defface ediff-fine-diff-C
1029   (if (featurep 'emacs)
1030       '((((type pc))
1031          (:foreground "white" :background "Turquoise"))
1032         (((class color) (min-colors 16))
1033          (:foreground "Black" :background "Turquoise"))
1034         (((class color))
1035          (:foreground "yellow3" :background "Turquoise"
1036                       :weight bold))
1037         (t (:underline t :stipple "gray3")))
1038     '((((type tty))    (:foreground "yellow3" :background "Turquoise"
1039                                     :weight bold))
1040       (((type pc))     (:foreground "white" :background "Turquoise"))
1041       (((class color)) (:foreground "Black" :background "Turquoise"))
1042       (t (:underline t :stipple "gray3"))))
1043   "Face for highlighting the refinement of the selected diff in buffer C."
1044   :group 'ediff-highlighting)
1045 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1046 ;; this variable is set to nil, then again to the appropriate face.
1047 (defvar ediff-fine-diff-face-C 'ediff-fine-diff-C
1048   "Face for highlighting the fine differences in buffer C.
1049 DO NOT CHANGE this variable.  Instead, use the customization
1050 widget to customize the actual face object `ediff-fine-diff-C'
1051 this variable represents.")
1052 (ediff-hide-face ediff-fine-diff-face-C)
1053
1054 (defface ediff-fine-diff-Ancestor
1055   (if (featurep 'emacs)
1056       '((((class color) (min-colors 16))
1057          (:foreground "Black" :background "Green"))
1058         (((class color))
1059          (:foreground "red3" :background "green"))
1060         (t                   (:underline t :stipple "gray3")))
1061     '((((type tty))    (:foreground "red3" :background "green"))
1062       (((class color)) (:foreground "Black" :background "Green"))
1063       (t                     (:underline t :stipple "gray3"))))
1064   "Face for highlighting the refinement of the selected diff in the ancestor buffer.
1065 At present, this face is not used and no fine differences are computed for the
1066 ancestor buffer."
1067   :group 'ediff-highlighting)
1068 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1069 ;; this variable is set to nil, then again to the appropriate face.
1070 (defvar ediff-fine-diff-face-Ancestor 'ediff-fine-diff-Ancestor
1071   "Face for highlighting the fine differences in buffer Ancestor.
1072 DO NOT CHANGE this variable.  Instead, use the customization
1073 widget to customize the actual face object `ediff-fine-diff-Ancestor'
1074 this variable represents.")
1075 (ediff-hide-face ediff-fine-diff-face-Ancestor)
1076
1077 ;; Some installs don't have stipple or Stipple. So, try them in turn.
1078 (defvar stipple-pixmap
1079   (cond ((not (ediff-has-face-support-p)) nil)
1080         ((and (boundp 'x-bitmap-file-path)
1081               (locate-library "stipple" t x-bitmap-file-path)) "stipple")
1082         ((and (boundp 'mswindowsx-bitmap-file-path)
1083               (locate-library "stipple" t mswindowsx-bitmap-file-path)) "stipple")
1084         (t "Stipple")))
1085
1086 (defface ediff-even-diff-A
1087   (if (featurep 'emacs)
1088       `((((type pc))
1089          (:foreground "green3" :background "light grey"))
1090         (((class color) (min-colors 16))
1091          (:foreground "Black" :background "light grey"))
1092         (((class color))
1093          (:foreground "red3" :background "light grey"
1094                       :weight bold))
1095         (t                   (:italic t :stipple ,stipple-pixmap)))
1096     `((((type tty))    (:foreground "red3" :background "light grey"
1097                                     :weight bold))
1098       (((type pc))     (:foreground "green3" :background "light grey"))
1099       (((class color)) (:foreground "Black" :background "light grey"))
1100       (t                     (:italic t :stipple ,stipple-pixmap))))
1101   "Face for highlighting even-numbered non-current differences in buffer A."
1102   :group 'ediff-highlighting)
1103 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1104 ;; this variable is set to nil, then again to the appropriate face.
1105 (defvar ediff-even-diff-face-A 'ediff-even-diff-A
1106   "Face for highlighting even-numbered non-current differences in buffer A.
1107 DO NOT CHANGE this variable.  Instead, use the customization
1108 widget to customize the actual face object `ediff-even-diff-A'
1109 this variable represents.")
1110 (ediff-hide-face ediff-even-diff-face-A)
1111
1112 (defface ediff-even-diff-B
1113   (if (featurep 'emacs)
1114       `((((class color) (min-colors 16))
1115          (:foreground "White" :background "Grey"))
1116         (((class color))
1117          (:foreground "blue3" :background "Grey" :weight bold))
1118         (t                   (:italic t :stipple ,stipple-pixmap)))
1119     `((((type tty))    (:foreground "blue3" :background "Grey" :weight bold))
1120       (((class color)) (:foreground "White" :background "Grey"))
1121       (t                     (:italic t :stipple ,stipple-pixmap))))
1122   "Face for highlighting even-numbered non-current differences in buffer B."
1123   :group 'ediff-highlighting)
1124 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1125 ;; this variable is set to nil, then again to the appropriate face.
1126 (defvar ediff-even-diff-face-B 'ediff-even-diff-B
1127   "Face for highlighting even-numbered non-current differences in buffer B.
1128 DO NOT CHANGE this variable.  Instead, use the customization
1129 widget to customize the actual face object `ediff-even-diff-B'
1130 this variable represents.")
1131 (ediff-hide-face ediff-even-diff-face-B)
1132
1133 (defface ediff-even-diff-C
1134   (if (featurep 'emacs)
1135       `((((type pc))
1136          (:foreground "yellow3" :background "light grey"))
1137         (((class color) (min-colors 16))
1138          (:foreground "Black" :background "light grey"))
1139         (((class color))
1140          (:foreground "yellow3" :background "light grey"
1141                       :weight bold))
1142         (t                   (:italic t :stipple ,stipple-pixmap)))
1143     `((((type tty))    (:foreground "yellow3" :background "light grey"
1144                                     :weight bold))
1145       (((type pc))     (:foreground "yellow3" :background "light grey"))
1146       (((class color)) (:foreground "Black" :background "light grey"))
1147       (t                     (:italic t :stipple ,stipple-pixmap))))
1148   "Face for highlighting even-numbered non-current differences in buffer C."
1149   :group 'ediff-highlighting)
1150 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1151 ;; this variable is set to nil, then again to the appropriate face.
1152 (defvar ediff-even-diff-face-C 'ediff-even-diff-C
1153   "Face for highlighting even-numbered non-current differences in buffer C.
1154 DO NOT CHANGE this variable.  Instead, use the customization
1155 widget to customize the actual face object `ediff-even-diff-C'
1156 this variable represents.")
1157 (ediff-hide-face ediff-even-diff-face-C)
1158
1159 (defface ediff-even-diff-Ancestor
1160   (if (featurep 'emacs)
1161       `((((type pc))
1162          (:foreground "cyan3" :background "light grey"))
1163         (((class color) (min-colors 16))
1164          (:foreground "White" :background "Grey"))
1165         (((class color))
1166          (:foreground "cyan3" :background "light grey"
1167                       :weight bold))
1168         (t (:italic t :stipple ,stipple-pixmap)))
1169     `((((type tty))    (:foreground "cyan3" :background "light grey"
1170                                     :weight bold))
1171       (((type pc))     (:foreground "cyan3" :background "light grey"))
1172       (((class color)) (:foreground "White" :background "Grey"))
1173       (t (:italic t :stipple ,stipple-pixmap))))
1174   "Face for highlighting even-numbered non-current differences in the ancestor buffer."
1175   :group 'ediff-highlighting)
1176 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1177 ;; this variable is set to nil, then again to the appropriate face.
1178 (defvar ediff-even-diff-face-Ancestor 'ediff-even-diff-Ancestor
1179   "Face for highlighting even-numbered non-current differences in buffer Ancestor.
1180 DO NOT CHANGE this variable.  Instead, use the customization
1181 widget to customize the actual face object `ediff-even-diff-Ancestor'
1182 this variable represents.")
1183 (ediff-hide-face ediff-even-diff-face-Ancestor)
1184
1185 ;; Association between buffer types and even-diff-face symbols
1186 (defconst ediff-even-diff-face-alist
1187   '((A . ediff-even-diff-A)
1188     (B . ediff-even-diff-B)
1189     (C . ediff-even-diff-C)
1190     (Ancestor . ediff-even-diff-Ancestor)))
1191
1192 (defface ediff-odd-diff-A
1193   (if (featurep 'emacs)
1194       '((((type pc))
1195          (:foreground "green3" :background "gray40"))
1196         (((class color) (min-colors 16))
1197          (:foreground "White" :background "Grey"))
1198         (((class color))
1199          (:foreground "red3" :background "black" :weight bold))
1200         (t                   (:italic t :stipple "gray1")))
1201     '((((type tty))    (:foreground "red3" :background "black" :weight bold))
1202       (((type pc))     (:foreground "green3" :background "gray40"))
1203       (((class color)) (:foreground "White" :background "Grey"))
1204       (t                     (:italic t :stipple "gray1"))))
1205   "Face for highlighting odd-numbered non-current differences in buffer A."
1206   :group 'ediff-highlighting)
1207 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1208 ;; this variable is set to nil, then again to the appropriate face.
1209 (defvar ediff-odd-diff-face-A 'ediff-odd-diff-A
1210   "Face for highlighting odd-numbered non-current differences in buffer A.
1211 DO NOT CHANGE this variable.  Instead, use the customization
1212 widget to customize the actual face object `ediff-odd-diff-A'
1213 this variable represents.")
1214 (ediff-hide-face ediff-odd-diff-face-A)
1215
1216
1217 (defface ediff-odd-diff-B
1218   (if (featurep 'emacs)
1219       '((((type pc))
1220          (:foreground "White" :background "gray40"))
1221         (((class color) (min-colors 16))
1222          (:foreground "Black" :background "light grey"))
1223         (((class color))
1224          (:foreground "cyan3" :background "black" :weight bold))
1225         (t                   (:italic t :stipple "gray1")))
1226     '((((type tty))    (:foreground "cyan3" :background "black" :weight bold))
1227       (((type pc))     (:foreground "White" :background "gray40"))
1228       (((class color)) (:foreground "Black" :background "light grey"))
1229       (t                     (:italic t :stipple "gray1"))))
1230   "Face for highlighting odd-numbered non-current differences in buffer B."
1231   :group 'ediff-highlighting)
1232 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1233 ;; this variable is set to nil, then again to the appropriate face.
1234 (defvar ediff-odd-diff-face-B 'ediff-odd-diff-B
1235   "Face for highlighting odd-numbered non-current differences in buffer B.
1236 DO NOT CHANGE this variable.  Instead, use the customization
1237 widget to customize the actual face object `ediff-odd-diff-B'
1238 this variable represents.")
1239 (ediff-hide-face ediff-odd-diff-face-B)
1240
1241 (defface ediff-odd-diff-C
1242   (if (featurep 'emacs)
1243       '((((type pc))
1244          (:foreground "yellow3" :background "gray40"))
1245         (((class color) (min-colors 16))
1246          (:foreground "White" :background "Grey"))
1247         (((class color))
1248          (:foreground "yellow3" :background "black" :weight bold))
1249         (t                   (:italic t :stipple "gray1")))
1250     '((((type tty))    (:foreground "yellow3" :background "black" :weight bold))
1251       (((type pc))     (:foreground "yellow3" :background "gray40"))
1252       (((class color)) (:foreground "White" :background "Grey"))
1253       (t                     (:italic t :stipple "gray1"))))
1254   "Face for highlighting odd-numbered non-current differences in buffer C."
1255   :group 'ediff-highlighting)
1256 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1257 ;; this variable is set to nil, then again to the appropriate face.
1258 (defvar ediff-odd-diff-face-C 'ediff-odd-diff-C
1259   "Face for highlighting odd-numbered non-current differences in buffer C.
1260 DO NOT CHANGE this variable.  Instead, use the customization
1261 widget to customize the actual face object `ediff-odd-diff-C'
1262 this variable represents.")
1263 (ediff-hide-face ediff-odd-diff-face-C)
1264
1265 (defface ediff-odd-diff-Ancestor
1266   (if (featurep 'emacs)
1267       '((((class color) (min-colors 16))
1268          (:foreground "cyan3" :background "gray40"))
1269         (((class color))
1270          (:foreground "green3" :background "black" :weight bold))
1271         (t                   (:italic t :stipple "gray1")))
1272     '((((type tty))    (:foreground "green3" :background "black" :weight bold))
1273       (((class color)) (:foreground "cyan3" :background "gray40"))
1274       (t                     (:italic t :stipple "gray1"))))
1275   "Face for highlighting odd-numbered non-current differences in the ancestor buffer."
1276   :group 'ediff-highlighting)
1277 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1278 ;; this variable is set to nil, then again to the appropriate face.
1279 (defvar ediff-odd-diff-face-Ancestor 'ediff-odd-diff-Ancestor
1280   "Face for highlighting odd-numbered non-current differences in buffer Ancestor.
1281 DO NOT CHANGE this variable.  Instead, use the customization
1282 widget to customize the actual face object `ediff-odd-diff-Ancestor'
1283 this variable represents.")
1284 (ediff-hide-face ediff-odd-diff-face-Ancestor)
1285
1286 ;; Association between buffer types and odd-diff-face symbols
1287 (defconst ediff-odd-diff-face-alist
1288   '((A . ediff-odd-diff-A)
1289     (B . ediff-odd-diff-B)
1290     (C . ediff-odd-diff-C)
1291     (Ancestor . ediff-odd-diff-Ancestor)))
1292
1293 ;; A-list of fine-diff face symbols associated with buffer types
1294 (defconst ediff-fine-diff-face-alist
1295   '((A . ediff-fine-diff-A)
1296     (B . ediff-fine-diff-B)
1297     (C . ediff-fine-diff-C)
1298     (Ancestor . ediff-fine-diff-Ancestor)))
1299
1300 ;; Help echo
1301 (put ediff-fine-diff-face-A 'ediff-help-echo
1302      "A `refinement' of the current difference region")
1303 (put ediff-fine-diff-face-B 'ediff-help-echo
1304      "A `refinement' of the current difference region")
1305 (put ediff-fine-diff-face-C 'ediff-help-echo
1306      "A `refinement' of the current difference region")
1307 (put ediff-fine-diff-face-Ancestor 'ediff-help-echo
1308      "A `refinement' of the current difference region")
1309
1310 (add-hook 'ediff-quit-hook 'ediff-cleanup-mess)
1311 (add-hook 'ediff-suspend-hook 'ediff-default-suspend-function)
1312
1313
1314 ;;; Overlays
1315
1316 (ediff-defvar-local ediff-current-diff-overlay-A nil
1317   "Overlay for the current difference region in buffer A.")
1318 (ediff-defvar-local ediff-current-diff-overlay-B nil
1319   "Overlay for the current difference region in buffer B.")
1320 (ediff-defvar-local ediff-current-diff-overlay-C nil
1321   "Overlay for the current difference region in buffer C.")
1322 (ediff-defvar-local ediff-current-diff-overlay-Ancestor nil
1323   "Overlay for the current difference region in the ancestor buffer.")
1324
1325 ;; Compute priority of a current ediff overlay.
1326 (defun ediff-highest-priority (start end buffer)
1327   (let ((pos (max 1 (1- start)))
1328         ovr-list)
1329     (if (featurep 'xemacs)
1330         (1+ ediff-shadow-overlay-priority)
1331       (ediff-with-current-buffer buffer
1332         (while (< pos (min (point-max) (1+ end)))
1333           (setq ovr-list (append (overlays-at pos) ovr-list))
1334           (setq pos (next-overlay-change pos)))
1335         (+ 1 ediff-shadow-overlay-priority
1336            (apply 'max
1337                   (cons
1338                    1
1339                    (mapcar
1340                     (lambda (ovr)
1341                       (if (and ovr
1342                                ;; exclude ediff overlays from priority
1343                                ;; calculation, or else priority will keep
1344                                ;; increasing
1345                                (null (ediff-overlay-get ovr 'ediff))
1346                                (null (ediff-overlay-get ovr 'ediff-diff-num)))
1347                           ;; use the overlay priority or 0
1348                           (or (ediff-overlay-get ovr 'priority) 0)
1349                         0))
1350                     ovr-list))))))))
1351
1352
1353 (defvar ediff-toggle-read-only-function nil
1354   "*Specifies the function to be used to toggle read-only.
1355 If nil, Ediff tries to deduce the function from the binding of C-x C-q.
1356 Normally, this is the `toggle-read-only' function, but, if version
1357 control is used, it could be `vc-toggle-read-only' or `rcs-toggle-read-only'.")
1358
1359 (defcustom ediff-make-buffers-readonly-at-startup nil
1360   "Make all variant buffers read-only when Ediff starts up.
1361 This property can be toggled interactively."
1362   :type 'boolean
1363   :group 'ediff)
1364
1365
1366 ;;; Misc
1367
1368 ;; if nil, this silences some messages
1369 (defvar ediff-verbose-p t)
1370
1371 (defcustom ediff-autostore-merges  'group-jobs-only
1372   "Save the results of merge jobs automatically.
1373 With value nil, don't save automatically.  With value t, always
1374 save.  Anything else means save automatically only if the merge
1375 job is part of a group of jobs, such as `ediff-merge-directory'
1376 or `ediff-merge-directory-revisions'."
1377   :type '(choice (const nil) (const t) (const group-jobs-only))
1378   :group 'ediff-merge)
1379 (make-variable-buffer-local 'ediff-autostore-merges)
1380
1381 ;; file where the result of the merge is to be saved.  used internally
1382 (ediff-defvar-local ediff-merge-store-file nil "")
1383
1384 (defcustom ediff-merge-filename-prefix "merge_"
1385   "Prefix to be attached to saved merge buffers."
1386   :type 'string
1387   :group 'ediff-merge)
1388
1389 (defcustom ediff-no-emacs-help-in-control-buffer nil
1390   "Non-nil means C-h should not invoke Emacs help in control buffer.
1391 Instead, C-h would jump to previous difference."
1392   :type 'boolean
1393   :group 'ediff)
1394
1395 ;; This is the same as temporary-file-directory from Emacs 20.3.
1396 ;; Copied over here because XEmacs doesn't have this variable.
1397 (defcustom ediff-temp-file-prefix
1398   (file-name-as-directory
1399    (cond ((boundp 'temporary-file-directory) temporary-file-directory)
1400          ((fboundp 'temp-directory) (temp-directory))
1401          (t "/tmp/")))
1402 ;;;  (file-name-as-directory
1403 ;;;   (cond ((memq system-type '(ms-dos windows-nt))
1404 ;;;       (or (getenv "TEMP") (getenv "TMPDIR") (getenv "TMP") "c:/temp"))
1405 ;;;      (t
1406 ;;;       (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "/tmp"))))
1407   "Prefix to put on Ediff temporary file names.
1408 Do not start with `~/' or `~USERNAME/'."
1409   :type 'string
1410   :group 'ediff)
1411
1412 (defcustom ediff-temp-file-mode 384     ; u=rw only
1413   "Mode for Ediff temporary files."
1414   :type 'integer
1415   :group 'ediff)
1416
1417 ;; Metacharacters that have to be protected from the shell when executing
1418 ;; a diff/diff3 command.
1419 (defcustom ediff-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
1420   "Regexp that matches characters that must be quoted with `\\' in shell command line.
1421 This default should work without changes."
1422   :type 'string
1423   :group 'ediff)
1424
1425 ;; needed to simulate frame-char-width in XEmacs.
1426 (defvar ediff-H-glyph (if (featurep 'xemacs) (make-glyph "H")))
1427
1428
1429 ;; Temporary file used for refining difference regions in buffer A.
1430 (ediff-defvar-local ediff-temp-file-A nil "")
1431 ;; Temporary file used for refining difference regions in buffer B.
1432 (ediff-defvar-local ediff-temp-file-B nil "")
1433 ;; Temporary file used for refining difference regions in buffer C.
1434 (ediff-defvar-local ediff-temp-file-C nil "")
1435
1436
1437 (defun ediff-file-remote-p (file-name)
1438   (file-remote-p file-name))
1439
1440 ;; File for which we can get attributes, such as size or date
1441 (defun ediff-listable-file (file-name)
1442   (let ((handler (find-file-name-handler file-name 'file-local-copy)))
1443     (or (null handler) (eq handler 'dired-handler-fn))))
1444
1445
1446 (defsubst ediff-frame-unsplittable-p (frame)
1447   (cdr (assq 'unsplittable (frame-parameters frame))))
1448
1449 (defsubst ediff-get-next-window (wind prev-wind)
1450   (cond ((window-live-p wind) wind)
1451         (prev-wind (next-window wind))
1452         (t (selected-window))
1453         ))
1454
1455
1456 (defsubst ediff-kill-buffer-carefully (buf)
1457   "Kill buffer BUF if it exists."
1458   (if (ediff-buffer-live-p buf)
1459       (kill-buffer (get-buffer buf))))
1460
1461 (defsubst ediff-background-face (buf-type dif-num)
1462   ;; The value of dif-num is always 1- the one that user sees.
1463   ;; This is why even face is used when dif-num is odd.
1464   (ediff-get-symbol-from-alist
1465    buf-type (if (ediff-odd-p dif-num)
1466                 ediff-even-diff-face-alist
1467               ediff-odd-diff-face-alist)
1468    ))
1469
1470
1471 ;; activate faces on diff regions in buffer
1472 (defun ediff-paint-background-regions-in-one-buffer (buf-type unhighlight)
1473   (let ((diff-vector
1474          (eval (ediff-get-symbol-from-alist
1475                 buf-type ediff-difference-vector-alist)))
1476         overl diff-num)
1477     (mapcar (lambda (rec)
1478               (setq overl (ediff-get-diff-overlay-from-diff-record rec)
1479                     diff-num (ediff-overlay-get overl 'ediff-diff-num))
1480               (if (ediff-overlay-buffer overl)
1481                   ;; only if overlay is alive
1482                   (ediff-set-overlay-face
1483                    overl
1484                    (if (not unhighlight)
1485                        (ediff-background-face buf-type diff-num))))
1486               )
1487             diff-vector)))
1488
1489
1490 ;; activate faces on diff regions in all buffers
1491 (defun ediff-paint-background-regions (&optional unhighlight)
1492   (ediff-paint-background-regions-in-one-buffer
1493    'A unhighlight)
1494   (ediff-paint-background-regions-in-one-buffer
1495    'B unhighlight)
1496   (ediff-paint-background-regions-in-one-buffer
1497    'C unhighlight)
1498   (ediff-paint-background-regions-in-one-buffer
1499    'Ancestor unhighlight))
1500
1501
1502 ;; arg is a record for a given diff in a difference vector
1503 ;; this record is itself a vector
1504 (defsubst ediff-clear-fine-diff-vector (diff-record)
1505   (if diff-record
1506       (mapc 'ediff-delete-overlay
1507             (ediff-get-fine-diff-vector-from-diff-record diff-record))))
1508
1509 (defsubst ediff-clear-fine-differences-in-one-buffer (n buf-type)
1510   (ediff-clear-fine-diff-vector (ediff-get-difference n buf-type))
1511   (ediff-set-fine-diff-vector n buf-type nil))
1512
1513 (defsubst ediff-clear-fine-differences (n)
1514   (ediff-clear-fine-differences-in-one-buffer n 'A)
1515   (ediff-clear-fine-differences-in-one-buffer n 'B)
1516   (if ediff-3way-job
1517       (ediff-clear-fine-differences-in-one-buffer n 'C)))
1518
1519
1520 (defsubst ediff-mouse-event-p (event)
1521   (if (featurep 'xemacs)
1522       (button-event-p event)
1523     (string-match "mouse" (format "%S" (event-basic-type event)))))
1524
1525
1526 (defsubst ediff-key-press-event-p (event)
1527   (if (featurep 'xemacs)
1528       (key-press-event-p event)
1529     (or (char-or-string-p event) (symbolp event))))
1530
1531 (defun ediff-event-point (event)
1532   (cond ((ediff-mouse-event-p event)
1533          (if (featurep 'xemacs)
1534              (event-point event)
1535            (posn-point (event-start event))))
1536         ((ediff-key-press-event-p event)
1537          (point))
1538         (t (error "Error"))))
1539
1540 (defun ediff-event-buffer (event)
1541   (cond ((ediff-mouse-event-p event)
1542          (if (featurep 'xemacs)
1543              (event-buffer event)
1544            (window-buffer (posn-window (event-start event)))))
1545         ((ediff-key-press-event-p event)
1546          (current-buffer))
1547         (t (error "Error"))))
1548
1549 (defun ediff-event-key (event-or-key)
1550   (if (featurep 'xemacs)
1551       (if (eventp event-or-key) (event-key event-or-key) event-or-key)
1552     event-or-key))
1553
1554
1555 (defsubst ediff-frame-iconified-p (frame)
1556   (and (ediff-window-display-p) (frame-live-p frame)
1557        (if (featurep 'xemacs)
1558            (frame-iconified-p frame)
1559          (eq (frame-visible-p frame) 'icon))))
1560
1561 (defsubst ediff-window-visible-p (wind)
1562   ;; under TTY, window-live-p also means window is visible
1563   (and (window-live-p wind)
1564        (or (not (ediff-window-display-p))
1565            (frame-visible-p (window-frame wind)))))
1566
1567
1568 (defsubst ediff-frame-char-width (frame)
1569   (if (featurep 'xemacs)
1570       (/ (frame-pixel-width frame) (frame-width frame))
1571     (frame-char-width frame)))
1572
1573 (defun ediff-reset-mouse (&optional frame do-not-grab-mouse)
1574   (or frame (setq frame (selected-frame)))
1575   (if (ediff-window-display-p)
1576       (let ((frame-or-wind frame))
1577         (if (featurep 'xemacs)
1578             (setq frame-or-wind (frame-selected-window frame)))
1579         (or do-not-grab-mouse
1580             ;; don't set mouse if the user said to never do this
1581             (not ediff-grab-mouse)
1582             ;; Don't grab on quit, if the user doesn't want to.
1583             ;; If ediff-grab-mouse = t, then mouse won't be grabbed for
1584             ;; sessions that are not part of a group (this is done in
1585             ;; ediff-recenter).  The condition below affects only terminating
1586             ;; sessions in session groups (in which case mouse is warped into
1587             ;; a meta buffer).
1588             (and (eq ediff-grab-mouse 'maybe)
1589                  (memq this-command '(ediff-quit ediff-update-diffs)))
1590             (set-mouse-position frame-or-wind 1 0))
1591         )))
1592
1593 (defsubst ediff-spy-after-mouse ()
1594   (setq ediff-mouse-pixel-position (mouse-pixel-position)))
1595
1596 ;; It is not easy to find out when the user grabs the mouse, since emacs and
1597 ;; xemacs behave differently when mouse is not in any frame.  Also, this is
1598 ;; sensitive to when the user grabbed mouse.  Not used for now.
1599 (defun ediff-user-grabbed-mouse ()
1600   (if ediff-mouse-pixel-position
1601       (cond ((not (eq (car ediff-mouse-pixel-position)
1602                       (car (mouse-pixel-position)))))
1603             ((and (car (cdr ediff-mouse-pixel-position))
1604                   (car (cdr (mouse-pixel-position)))
1605                   (cdr (cdr ediff-mouse-pixel-position))
1606                   (cdr (cdr (mouse-pixel-position))))
1607              (not (and (< (abs (- (car (cdr ediff-mouse-pixel-position))
1608                                   (car (cdr (mouse-pixel-position)))))
1609                           ediff-mouse-pixel-threshold)
1610                        (< (abs (- (cdr (cdr ediff-mouse-pixel-position))
1611                                   (cdr (cdr (mouse-pixel-position)))))
1612                           ediff-mouse-pixel-threshold))))
1613             (t nil))))
1614
1615 (defsubst ediff-frame-char-height (frame)
1616   (if (featurep 'xemacs)
1617       (glyph-height ediff-H-glyph (frame-selected-window frame))
1618     (frame-char-height frame)))
1619
1620 ;; Some overlay functions
1621
1622 (defsubst ediff-overlay-start (overl)
1623   (if (ediff-overlayp overl)
1624       (if (featurep 'xemacs)
1625           (extent-start-position overl)
1626         (overlay-start overl))))
1627
1628 (defsubst ediff-overlay-end  (overl)
1629   (if (ediff-overlayp overl)
1630       (if (featurep 'xemacs)
1631           (extent-end-position overl)
1632         (overlay-end overl))))
1633
1634 (defsubst ediff-empty-overlay-p (overl)
1635   (= (ediff-overlay-start overl) (ediff-overlay-end overl)))
1636
1637 ;; like overlay-buffer in Emacs.  In XEmacs, returns nil if the extent is
1638 ;; dead.  Otherwise, works like extent-buffer
1639 (defun ediff-overlay-buffer (overl)
1640   (if (featurep 'xemacs)
1641       (and (extent-live-p overl) (extent-object overl))
1642     (overlay-buffer overl)))
1643
1644 ;; like overlay-get in Emacs.  In XEmacs, returns nil if the extent is
1645 ;; dead.  Otherwise, like extent-property
1646 (defun ediff-overlay-get (overl property)
1647   (if (featurep 'xemacs)
1648       (and (extent-live-p overl) (extent-property overl property))
1649     (overlay-get overl property)))
1650
1651
1652 ;; These two functions are here because XEmacs refuses to
1653 ;; handle overlays whose buffers were deleted.
1654 (defun ediff-move-overlay (overlay beg end &optional buffer)
1655   "Calls `move-overlay' in Emacs and `set-extent-endpoints' in Lemacs.
1656 Checks if overlay's buffer exists before actually doing the move."
1657   (let ((buf (and overlay (ediff-overlay-buffer overlay))))
1658     (if (ediff-buffer-live-p buf)
1659         (if (featurep 'xemacs)
1660             (set-extent-endpoints overlay beg end)
1661           (move-overlay overlay beg end buffer))
1662       ;; buffer's dead
1663       (if overlay
1664           (ediff-delete-overlay overlay)))))
1665
1666 (defun ediff-overlay-put (overlay prop value)
1667   "Calls `overlay-put' or `set-extent-property' depending on Emacs version.
1668 Checks if overlay's buffer exists."
1669   (if (ediff-buffer-live-p (ediff-overlay-buffer overlay))
1670       (if (featurep 'xemacs)
1671           (set-extent-property overlay prop value)
1672         (overlay-put overlay prop value))
1673     (ediff-delete-overlay overlay)))
1674
1675 ;; temporarily uses DIR to abbreviate file name
1676 ;; if DIR is nil, use default-directory
1677 (defun ediff-abbreviate-file-name (file &optional dir)
1678   (cond ((stringp dir)
1679          (let ((directory-abbrev-alist (list (cons dir ""))))
1680            (abbreviate-file-name file)))
1681         (t
1682          (if (featurep 'xemacs)
1683              ;; XEmacs requires addl argument
1684              (abbreviate-file-name file t)
1685            (abbreviate-file-name file)))))
1686
1687 ;; Takes a directory and returns the parent directory.
1688 ;; does nothing to `/'.  If the ARG is a regular file,
1689 ;; strip the file AND the last dir.
1690 (defun ediff-strip-last-dir (dir)
1691   (if (not (stringp dir)) (setq dir default-directory))
1692   (setq dir (expand-file-name dir))
1693   (or (file-directory-p dir) (setq dir (file-name-directory dir)))
1694   (let* ((pos (1- (length dir)))
1695          (last-char (aref dir pos)))
1696     (if (and (> pos 0) (= last-char ?/))
1697         (setq dir (substring dir 0 pos)))
1698     (ediff-abbreviate-file-name (file-name-directory dir))))
1699
1700 (defun ediff-truncate-string-left (str newlen)
1701   ;; leave space for ... on the left
1702   (let ((len (length str))
1703         substr)
1704     (if (<= len newlen)
1705         str
1706       (setq newlen (max 0 (- newlen 3)))
1707       (setq substr (substring str (max 0 (- len 1 newlen))))
1708       (concat "..." substr))))
1709
1710 (defsubst ediff-nonempty-string-p (string)
1711   (and (stringp string) (not (string= string ""))))
1712
1713 (unless (fboundp 'subst-char-in-string)
1714   (defun subst-char-in-string (fromchar tochar string &optional inplace)
1715     "Replace FROMCHAR with TOCHAR in STRING each time it occurs.
1716 Unless optional argument INPLACE is non-nil, return a new string."
1717     (let ((i (length string))
1718           (newstr (if inplace string (copy-sequence string))))
1719       (while (> i 0)
1720         (setq i (1- i))
1721         (if (eq (aref newstr i) fromchar)
1722             (aset newstr i tochar)))
1723       newstr)))
1724
1725 (defun ediff-abbrev-jobname (jobname)
1726   (cond ((eq jobname 'ediff-directories)
1727          "Compare two directories")
1728         ((eq jobname 'ediff-files)
1729          "Compare two files")
1730         ((eq jobname 'ediff-buffers)
1731          "Compare two buffers")
1732         ((eq jobname 'ediff-directories3)
1733          "Compare three directories")
1734         ((eq jobname 'ediff-files3)
1735          "Compare three files")
1736         ((eq jobname 'ediff-buffers3)
1737          "Compare three buffers")
1738         ((eq jobname 'ediff-revision)
1739          "Compare file with a version")
1740         ((eq jobname 'ediff-directory-revisions)
1741          "Compare dir files with versions")
1742         ((eq jobname 'ediff-merge-directory-revisions)
1743          "Merge dir files with versions")
1744         ((eq jobname 'ediff-merge-directory-revisions-with-ancestor)
1745          "Merge dir versions via ancestors")
1746         (t
1747          (capitalize
1748           (subst-char-in-string ?- ?\s (substring (symbol-name jobname) 6))))
1749         ))
1750
1751
1752 ;; If ediff modified mode line, strip the modification
1753 (defsubst ediff-strip-mode-line-format ()
1754   (if (member (car mode-line-format) '(" A: " " B: " " C: " " Ancestor: "))
1755       (setq mode-line-format (nth 2 mode-line-format))))
1756
1757 ;; Verify that we have a difference selected.
1758 (defsubst ediff-valid-difference-p (&optional n)
1759   (or n (setq n ediff-current-difference))
1760   (and (>= n 0) (< n ediff-number-of-differences)))
1761
1762 (defsubst ediff-show-all-diffs (n)
1763   "Don't skip difference regions."
1764   nil)
1765
1766 (defsubst ediff-message-if-verbose (string &rest args)
1767   (if ediff-verbose-p
1768       (apply 'message string args)))
1769
1770 (defun ediff-file-attributes (filename attr-number)
1771   (if (ediff-listable-file filename)
1772       (nth attr-number (file-attributes filename))
1773     -1)
1774   )
1775
1776 (defsubst ediff-file-size (filename)
1777   (ediff-file-attributes filename 7))
1778 (defsubst ediff-file-modtime (filename)
1779   (ediff-file-attributes filename 5))
1780
1781
1782 (defun ediff-convert-standard-filename (fname)
1783   (if (fboundp 'convert-standard-filename)
1784       (convert-standard-filename fname)
1785     fname))
1786
1787 (if (featurep 'emacs)
1788     (defalias 'ediff-with-syntax-table 'with-syntax-table)
1789   (if (fboundp 'with-syntax-table)
1790       (defalias 'ediff-with-syntax-table 'with-syntax-table)
1791     ;; stolen from subr.el in emacs 21
1792     (defmacro ediff-with-syntax-table (table &rest body)
1793       (let ((old-table (make-symbol "table"))
1794             (old-buffer (make-symbol "buffer")))
1795         `(let ((,old-table (syntax-table))
1796                (,old-buffer (current-buffer)))
1797            (unwind-protect
1798                (progn
1799                  (set-syntax-table (copy-syntax-table ,table))
1800                  ,@body)
1801              (save-current-buffer
1802                (set-buffer ,old-buffer)
1803                (set-syntax-table ,old-table))))))))
1804
1805
1806 (provide 'ediff-init)
1807
1808
1809
1810 ;; Local Variables:
1811 ;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1812 ;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1813 ;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1814 ;; End:
1815
1816 ;; arch-tag: fa31d384-1e70-4d4b-82a7-3e96307c46f5
1817 ;;; ediff-init.el ends here