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