lisp/ediff-util.el

   1 ;;; ediff-util.el --- the core commands and utilities of ediff
   2
   3 ;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
   4
   5 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22 ;; Boston, MA 02111-1307, USA.
  23
  24 ;;; Code:
  25
  26 ;; Pacify compiler and avoid the need in checking for boundp
  27 (defvar ediff-patch-diagnostics nil)
  28 (defvar ediff-patchbufer nil)
  29 (and noninteractive
  30      (eval-when-compile
  31        (let ((load-path (cons (expand-file-name ".") load-path)))
  32          (load-file "ediff-init.el")
  33          (load-file "ediff-help.el"))))
  34 ;; end pacifier
  35
  36 (require 'ediff-init)
  37 (require 'ediff-help)
  38 (require 'ediff-mult)
  39
  40 ;;(if ediff-xemacs-p
  41 ;;    (require 'ediff-tbar)
  42 ;;  (defun ediff-use-toolbar-p () nil))
  43 ;;
  44 ;; for the time being
  45 (defun ediff-use-toolbar-p () nil)
  46
  47 \f
  48 ;;; Functions
  49
  50 (defun ediff-mode ()
  51   "Ediff mode controls all operations in a single Ediff session.
  52 This mode is entered through one of the following commands:
  53         `ediff'
  54         `ediff-files'
  55         `ediff-buffers'
  56         `ebuffers'
  57         `ediff3'
  58         `ediff-files3'
  59         `ediff-buffers3'
  60         `ebuffers3'
  61         `ediff-merge'
  62         `ediff-merge-files'
  63         `ediff-merge-files-with-ancestor'
  64         `ediff-merge-buffers'
  65         `ediff-merge-buffers-with-ancestor'
  66         `ediff-merge-revisions'
  67         `ediff-merge-revisions-with-ancestor'
  68         `ediff-windows-wordwise'
  69         `ediff-windows-linewise'
  70         `ediff-regions-wordwise'
  71         `ediff-regions-linewise'
  72         `epatch'
  73         `ediff-patch-file'
  74         `ediff-patch-buffer'
  75         `epatch-buffer'
  76         `ediff-revision'
  77
  78 Commands:
  79 \\{ediff-mode-map}"
  80   (kill-all-local-variables)
  81   (setq major-mode 'ediff-mode)
  82   (setq mode-name "Ediff")
  83   (run-hooks 'ediff-mode-hook))
  84
  85
  86 (require 'ediff-diff)
  87 (require 'ediff-merg)
  88
  89 \f
  90 ;;; Build keymaps
  91
  92 (ediff-defvar-local ediff-mode-map nil
  93   "Local keymap used in Ediff mode.
  94 This is local to each Ediff Control Panel, so they may vary from invocation
  95 to invocation.")
  96
  97 ;; Set up the keymap in the control buffer
  98 (defun ediff-set-keys ()
  99   "Set up Ediff keymap, if necessary."
 100   (if (null ediff-mode-map)
 101       (ediff-setup-keymap))
 102   (use-local-map ediff-mode-map))
 103
 104 ;; Reload Ediff keymap.  For debugging only.
 105 (defun ediff-reload-keymap ()
 106   (interactive)
 107   (setq ediff-mode-map nil)
 108   (ediff-set-keys))
 109
 110
 111 (defun ediff-setup-keymap ()
 112   "Set up the keymap used in the control buffer of Ediff."
 113   (setq ediff-mode-map (make-sparse-keymap))
 114   (suppress-keymap ediff-mode-map)
 115
 116   (define-key ediff-mode-map
 117     (if ediff-emacs-p [mouse-2] [button2]) 'ediff-help-for-quick-help)
 118   (define-key ediff-mode-map "\C-m"  'ediff-help-for-quick-help)
 119
 120   (define-key ediff-mode-map "p" 'ediff-previous-difference)
 121   (define-key ediff-mode-map "\C-?" 'ediff-previous-difference)
 122   (define-key ediff-mode-map [backspace] 'ediff-previous-difference)
 123   (define-key ediff-mode-map [delete] 'ediff-previous-difference)
 124   (define-key ediff-mode-map "\C-h" (if ediff-no-emacs-help-in-control-buffer
 125                                         'ediff-previous-difference nil))
 126   (define-key ediff-mode-map "n" 'ediff-next-difference)
 127   (define-key ediff-mode-map " " 'ediff-next-difference)
 128   (define-key ediff-mode-map "j" 'ediff-jump-to-difference)
 129   (define-key ediff-mode-map "g"  nil)
 130   (define-key ediff-mode-map "ga" 'ediff-jump-to-difference-at-point)
 131   (define-key ediff-mode-map "gb" 'ediff-jump-to-difference-at-point)
 132   (define-key ediff-mode-map "q" 'ediff-quit)
 133   (define-key ediff-mode-map "D" 'ediff-show-diff-output)
 134   (define-key ediff-mode-map "z" 'ediff-suspend)
 135   (define-key ediff-mode-map "\C-l" 'ediff-recenter)
 136   (define-key ediff-mode-map "|" 'ediff-toggle-split)
 137   (define-key ediff-mode-map "h" 'ediff-toggle-hilit)
 138   (or ediff-word-mode
 139       (define-key ediff-mode-map "@" 'ediff-toggle-autorefine))
 140   (if ediff-narrow-job
 141       (define-key ediff-mode-map "%" 'ediff-toggle-narrow-region))
 142   (define-key ediff-mode-map "~" 'ediff-swap-buffers)
 143   (define-key ediff-mode-map "v" 'ediff-scroll-vertically)
 144   (define-key ediff-mode-map "\C-v" 'ediff-scroll-vertically)
 145   (define-key ediff-mode-map "^" 'ediff-scroll-vertically)
 146   (define-key ediff-mode-map "\M-v" 'ediff-scroll-vertically)
 147   (define-key ediff-mode-map "V" 'ediff-scroll-vertically)
 148   (define-key ediff-mode-map "<" 'ediff-scroll-horizontally)
 149   (define-key ediff-mode-map ">" 'ediff-scroll-horizontally)
 150   (define-key ediff-mode-map "i" 'ediff-status-info)
 151   (define-key ediff-mode-map "E" 'ediff-documentation)
 152   (define-key ediff-mode-map "?" 'ediff-toggle-help)
 153   (define-key ediff-mode-map "!" 'ediff-update-diffs)
 154   (define-key ediff-mode-map "M" 'ediff-show-meta-buffer)
 155   (define-key ediff-mode-map "R" 'ediff-show-registry)
 156   (or ediff-word-mode
 157       (define-key ediff-mode-map "*" 'ediff-make-or-kill-fine-diffs))
 158   (define-key ediff-mode-map "a"  nil)
 159   (define-key ediff-mode-map "b"  nil)
 160   (define-key ediff-mode-map "r"  nil)
 161   (cond (ediff-merge-job
 162          ;; Will barf if no ancestor
 163          (define-key ediff-mode-map "/" 'ediff-show-ancestor)
 164          ;; In merging, we allow only A->C and B->C copying.
 165          (define-key ediff-mode-map "a" 'ediff-copy-A-to-C)
 166          (define-key ediff-mode-map "b" 'ediff-copy-B-to-C)
 167          (define-key ediff-mode-map "r" 'ediff-restore-diff-in-merge-buffer)
 168          (define-key ediff-mode-map "s" 'ediff-shrink-window-C)
 169          (define-key ediff-mode-map "+" 'ediff-combine-diffs)
 170          (define-key ediff-mode-map "$" 'ediff-toggle-show-clashes-only)
 171          (define-key ediff-mode-map "&" 'ediff-re-merge))
 172         (ediff-3way-comparison-job
 173          (define-key ediff-mode-map "ab" 'ediff-copy-A-to-B)
 174          (define-key ediff-mode-map "ba" 'ediff-copy-B-to-A)
 175          (define-key ediff-mode-map "ac" 'ediff-copy-A-to-C)
 176          (define-key ediff-mode-map "bc" 'ediff-copy-B-to-C)
 177          (define-key ediff-mode-map "c" nil)
 178          (define-key ediff-mode-map "ca" 'ediff-copy-C-to-A)
 179          (define-key ediff-mode-map "cb" 'ediff-copy-C-to-B)
 180          (define-key ediff-mode-map "ra" 'ediff-restore-diff)
 181          (define-key ediff-mode-map "rb" 'ediff-restore-diff)
 182          (define-key ediff-mode-map "rc" 'ediff-restore-diff)
 183          (define-key ediff-mode-map "C"  'ediff-toggle-read-only))
 184         (t ; 2-way comparison
 185          (define-key ediff-mode-map "a"  'ediff-copy-A-to-B)
 186          (define-key ediff-mode-map "b"  'ediff-copy-B-to-A)
 187          (define-key ediff-mode-map "ra" 'ediff-restore-diff)
 188          (define-key ediff-mode-map "rb" 'ediff-restore-diff))
 189         ) ; cond
 190   (define-key ediff-mode-map "G" 'ediff-submit-report)
 191   (define-key ediff-mode-map "#"  nil)
 192   (define-key ediff-mode-map "#h"  'ediff-toggle-regexp-match)
 193   (define-key ediff-mode-map "#f"  'ediff-toggle-regexp-match)
 194   (or ediff-word-mode
 195       (define-key ediff-mode-map "##"  'ediff-toggle-skip-similar))
 196   (define-key ediff-mode-map "o"   nil)
 197   (define-key ediff-mode-map "A"  'ediff-toggle-read-only)
 198   (define-key ediff-mode-map "B"  'ediff-toggle-read-only)
 199   (define-key ediff-mode-map "w"   nil)
 200   (define-key ediff-mode-map "wa"  'ediff-save-buffer)
 201   (define-key ediff-mode-map "wb"  'ediff-save-buffer)
 202   (define-key ediff-mode-map "wd"  'ediff-save-buffer)
 203   (define-key ediff-mode-map "="   'ediff-inferior-compare-regions)
 204   (if (fboundp 'ediff-show-patch-diagnostics)
 205       (define-key ediff-mode-map "P"  'ediff-show-patch-diagnostics))
 206   (if ediff-3way-job
 207       (progn
 208         (define-key ediff-mode-map "wc" 'ediff-save-buffer)
 209         (define-key ediff-mode-map "gc" 'ediff-jump-to-difference-at-point)
 210         ))
 211
 212   (define-key ediff-mode-map "m" 'ediff-toggle-wide-display)
 213
 214   ;; Allow ediff-mode-map to be referenced indirectly
 215   (fset 'ediff-mode-map ediff-mode-map)
 216   (run-hooks 'ediff-keymap-setup-hook))
 217
 218
 219 ;;; Setup functions
 220
 221 (require 'ediff-wind)
 222
 223 ;; No longer needed: XEmacs has surrogate minibuffers now.
 224 ;;(or (boundp 'synchronize-minibuffers)
 225 ;;    (defvar synchronize-minibuffers nil))
 226
 227 ;; Common startup entry for all Ediff functions
 228 ;; It now returns control buffer so other functions can do post-processing
 229 (defun ediff-setup (buffer-A file-A buffer-B file-B buffer-C file-C
 230                              startup-hooks setup-parameters)
 231   ;; ediff-convert-standard-filename puts file names in the form appropriate
 232   ;; for the OS at hand.
 233   (setq file-A (ediff-convert-standard-filename (expand-file-name file-A)))
 234   (setq file-B (ediff-convert-standard-filename (expand-file-name file-B)))
 235   (if (stringp file-C)
 236       (setq file-C
 237             (ediff-convert-standard-filename (expand-file-name file-C))))
 238   (let* ((control-buffer-name
 239           (ediff-unique-buffer-name "*Ediff Control Panel" "*"))
 240          (control-buffer (ediff-eval-in-buffer buffer-A
 241                            (get-buffer-create control-buffer-name))))
 242     (ediff-eval-in-buffer control-buffer
 243       (ediff-mode)
 244
 245       ;; unwrap set up parameters passed as argument
 246       (while setup-parameters
 247         (set (car (car setup-parameters)) (cdr (car setup-parameters)))
 248         (setq setup-parameters (cdr setup-parameters)))
 249
 250       ;; set variables classifying the current ediff job
 251       (setq ediff-3way-comparison-job (ediff-3way-comparison-job)
 252             ediff-merge-job (ediff-merge-job)
 253             ediff-merge-with-ancestor-job (ediff-merge-with-ancestor-job)
 254             ediff-3way-job (ediff-3way-job)
 255             ediff-diff3-job (ediff-diff3-job)
 256             ediff-narrow-job (ediff-narrow-job)
 257             ediff-windows-job (ediff-windows-job)
 258             ediff-word-mode-job (ediff-word-mode-job))
 259
 260       (make-local-variable 'ediff-use-long-help-message)
 261       (make-local-variable 'ediff-prefer-iconified-control-frame)
 262       (make-local-variable 'ediff-split-window-function)
 263       (make-local-variable 'ediff-default-variant)
 264       (make-local-variable 'ediff-merge-window-share)
 265       (make-local-variable 'ediff-window-setup-function)
 266       (make-local-variable 'ediff-keep-variants)
 267
 268       ;; Don't delete variants in case of ediff-buffer-* jobs without asking.
 269       ;; This is because u may loose work---dangerous.
 270       (if (string-match "buffer" (symbol-name ediff-job-name))
 271           (setq ediff-keep-variants t))
 272
 273       (make-local-hook 'pre-command-hook)
 274       (if (ediff-window-display-p)
 275           (add-hook 'pre-command-hook 'ediff-spy-after-mouse nil t))
 276       (setq ediff-mouse-pixel-position (mouse-pixel-position))
 277
 278       ;; adjust for merge jobs
 279       (if ediff-merge-job
 280           (let ((buf
 281                  ;; If default variant is `combined', the right stuff is
 282                  ;; inserted by ediff-do-merge
 283                  ;; Note: at some point, we tried to put ancestor buffer here
 284                  ;; (which is currently buffer C. This didn't work right
 285                  ;; because the merge buffer will contain lossage: diff regions
 286                  ;; in the ancestor, which correspond to revisions that agree
 287                  ;; in both buf A and B.
 288                  (cond ((eq ediff-default-variant 'default-B)
 289                         buffer-B)
 290                        (t buffer-A))))
 291
 292             (setq ediff-split-window-function
 293                   ediff-merge-split-window-function)
 294
 295             ;; remember the ancestor buffer, if any
 296             (setq ediff-ancestor-buffer buffer-C)
 297
 298             (setq buffer-C
 299                   (get-buffer-create
 300                    (ediff-unique-buffer-name "*ediff-merge" "*")))
 301             (save-excursion
 302               (set-buffer buffer-C)
 303               (insert-buffer buf)
 304               (funcall (ediff-eval-in-buffer buf major-mode))
 305               ;; after Stig@hackvan.com
 306               (add-hook 'local-write-file-hooks 'ediff-set-merge-mode nil t)
 307               )))
 308       (setq buffer-read-only nil
 309             ediff-buffer-A buffer-A
 310             ediff-buffer-B buffer-B
 311             ediff-buffer-C buffer-C
 312             ediff-control-buffer control-buffer)
 313
 314       (setq ediff-control-buffer-suffix
 315             (if (string-match "<[0-9]*>" control-buffer-name)
 316                 (substring control-buffer-name
 317                            (match-beginning 0) (match-end 0))
 318               "")
 319             ediff-control-buffer-number
 320             (max
 321              0
 322              (1-
 323               (string-to-number
 324                (substring
 325                 ediff-control-buffer-suffix
 326                 (or
 327                  (string-match "[0-9]+" ediff-control-buffer-suffix)
 328                  0))))))
 329
 330       (setq ediff-error-buffer
 331             (get-buffer-create (ediff-unique-buffer-name "*ediff-errors" "*")))
 332
 333       (ediff-eval-in-buffer buffer-A (ediff-strip-mode-line-format))
 334       (ediff-eval-in-buffer buffer-B (ediff-strip-mode-line-format))
 335       (if ediff-3way-job
 336           (ediff-eval-in-buffer buffer-C (ediff-strip-mode-line-format)))
 337       (if (ediff-buffer-live-p ediff-ancestor-buffer)
 338           (ediff-eval-in-buffer ediff-ancestor-buffer
 339             (ediff-strip-mode-line-format)))
 340
 341       (ediff-save-protected-variables) ; save variables to be restored on exit
 342
 343       ;; ediff-setup-diff-regions-function must be set after setup
 344       ;; parameters are processed.
 345       (setq ediff-setup-diff-regions-function
 346             (if ediff-diff3-job
 347                 'ediff-setup-diff-regions3
 348               'ediff-setup-diff-regions))
 349
 350       (setq ediff-wide-bounds
 351             (list (ediff-make-bullet-proof-overlay
 352                    '(point-min) '(point-max) ediff-buffer-A)
 353                   (ediff-make-bullet-proof-overlay
 354                    '(point-min) '(point-max) ediff-buffer-B)
 355                   (ediff-make-bullet-proof-overlay
 356                    '(point-min) '(point-max) ediff-buffer-C)))
 357
 358       ;; This has effect only on ediff-windows/regions
 359       ;; In all other cases, ediff-visible-region sets visibility bounds to
 360       ;; ediff-wide-bounds, and ediff-narrow-bounds are ignored.
 361       (if ediff-start-narrowed
 362           (setq ediff-visible-bounds ediff-narrow-bounds)
 363         (setq ediff-visible-bounds ediff-wide-bounds))
 364
 365       (ediff-set-keys) ; comes after parameter setup
 366
 367       ;; set up ediff-narrow-bounds, if not set
 368       (or ediff-narrow-bounds
 369           (setq ediff-narrow-bounds ediff-wide-bounds))
 370
 371       ;; All these must be inside ediff-eval-in-buffer control-buffer,
 372       ;; since these vars are local to control-buffer
 373       ;; These won't run if there are errors in diff
 374       (ediff-eval-in-buffer ediff-buffer-A
 375         (ediff-nuke-selective-display)
 376         (run-hooks 'ediff-prepare-buffer-hook)
 377         (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
 378             (setq buffer-read-only t))
 379         ;; add control-buffer to the list of sessions--no longer used, but may
 380         ;; be used again in the future
 381         (or (memq control-buffer ediff-this-buffer-ediff-sessions)
 382             (setq ediff-this-buffer-ediff-sessions
 383                   (cons control-buffer ediff-this-buffer-ediff-sessions)))
 384         )
 385       (ediff-eval-in-buffer ediff-buffer-B
 386         (ediff-nuke-selective-display)
 387         (run-hooks 'ediff-prepare-buffer-hook)
 388         (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
 389             (setq buffer-read-only t))
 390         ;; add control-buffer to the list of sessions
 391         (or (memq control-buffer ediff-this-buffer-ediff-sessions)
 392             (setq ediff-this-buffer-ediff-sessions
 393                   (cons control-buffer ediff-this-buffer-ediff-sessions)))
 394         )
 395       (if ediff-3way-job
 396           (ediff-eval-in-buffer ediff-buffer-C
 397             (ediff-nuke-selective-display)
 398             (run-hooks 'ediff-prepare-buffer-hook)
 399             ;; add control-buffer to the list of sessions
 400             (or (memq control-buffer ediff-this-buffer-ediff-sessions)
 401                 (setq ediff-this-buffer-ediff-sessions
 402                       (cons control-buffer
 403                             ediff-this-buffer-ediff-sessions)))
 404             ))
 405
 406       (if (ediff-buffer-live-p ediff-ancestor-buffer)
 407           (ediff-eval-in-buffer ediff-ancestor-buffer
 408             (ediff-nuke-selective-display)
 409             (setq buffer-read-only t)
 410             (run-hooks 'ediff-prepare-buffer-hook)
 411             (or (memq control-buffer ediff-this-buffer-ediff-sessions)
 412                 (setq ediff-this-buffer-ediff-sessions
 413                       (cons control-buffer
 414                             ediff-this-buffer-ediff-sessions)))
 415             ))
 416
 417       ;; must come after setting up  ediff-narrow-bounds AND after
 418       ;; nuking selective display
 419       (funcall ediff-setup-diff-regions-function file-A file-B file-C)
 420       (setq ediff-number-of-differences (length ediff-difference-vector-A))
 421       (setq ediff-current-difference -1)
 422
 423       (ediff-make-current-diff-overlay 'A)
 424       (ediff-make-current-diff-overlay 'B)
 425       (if ediff-3way-job
 426           (ediff-make-current-diff-overlay 'C))
 427       (if ediff-merge-with-ancestor-job
 428           (ediff-make-current-diff-overlay 'Ancestor))
 429
 430       (ediff-setup-windows buffer-A buffer-B buffer-C control-buffer)
 431
 432       (let ((shift-A (ediff-overlay-start
 433                       (ediff-get-value-according-to-buffer-type
 434                        'A ediff-narrow-bounds)))
 435             (shift-B (ediff-overlay-start
 436                       (ediff-get-value-according-to-buffer-type
 437                        'B ediff-narrow-bounds)))
 438             (shift-C (ediff-overlay-start
 439                       (ediff-get-value-according-to-buffer-type
 440                        'C ediff-narrow-bounds))))
 441         ;; position point in buf A
 442         (save-excursion
 443           (select-window ediff-window-A)
 444           (goto-char shift-A))
 445         ;; position point in buf B
 446         (save-excursion
 447           (select-window ediff-window-B)
 448           (goto-char shift-B))
 449         (if ediff-3way-job
 450             (save-excursion
 451               (select-window ediff-window-C)
 452               (goto-char shift-C)))
 453         )
 454
 455       (select-window ediff-control-window)
 456       (ediff-visible-region)
 457
 458       (run-hooks 'startup-hooks)
 459       (ediff-refresh-mode-lines)
 460       (setq buffer-read-only t)
 461       (setq ediff-session-registry
 462             (cons control-buffer ediff-session-registry))
 463       (ediff-update-registry)
 464       (if (ediff-buffer-live-p ediff-meta-buffer)
 465           (ediff-update-meta-buffer ediff-meta-buffer))
 466       (run-hooks 'ediff-startup-hook)
 467       ) ; eval in control-buffer
 468     control-buffer))
 469
 470
 471 ;; This function assumes that we are in the window where control buffer is
 472 ;; to reside.
 473 (defun ediff-setup-control-buffer (ctl-buf)
 474   "Set up window for control buffer."
 475   (if (window-dedicated-p (selected-window))
 476       (set-buffer ctl-buf) ; we are in control frame but just in case
 477     (switch-to-buffer ctl-buf))
 478   (let ((window-min-height 2))
 479     (erase-buffer)
 480     (ediff-set-help-message)
 481     (insert ediff-help-message)
 482     (shrink-window-if-larger-than-buffer)
 483     (or (ediff-multiframe-setup-p)
 484         (ediff-indent-help-message))
 485     (ediff-set-help-overlays)
 486
 487     (set-buffer-modified-p nil)
 488     (ediff-refresh-mode-lines)
 489     (setq ediff-control-window (selected-window))
 490     (setq ediff-window-config-saved
 491           (format "%S%S%S%S%S%S%S"
 492                   ediff-control-window
 493                   ediff-window-A
 494                   ediff-window-B
 495                   ediff-window-C
 496                   ediff-split-window-function
 497                   (ediff-multiframe-setup-p)
 498                   ediff-wide-display-p))
 499     (if (not (ediff-multiframe-setup-p))
 500         (ediff-make-bottom-toolbar))    ; checks if toolbar is requested
 501     (goto-char (point-min))
 502     (skip-chars-forward ediff-whitespace)))
 503
 504
 505
 506 \f
 507 ;;; Commands for working with Ediff
 508
 509 (defun ediff-update-diffs ()
 510   "Recompute difference regions in buffers A, B, and C.
 511 Buffers are not synchronized with their respective files, so changes done
 512 to these buffers are not saved at this point---the user can do this later,
 513 if necessary."
 514   (interactive)
 515   (ediff-barf-if-not-control-buffer)
 516   (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
 517            (not (y-or-n-p "Recompute differences during merge, really? ")))
 518       (error "God forbid!"))
 519
 520   (let ((point-A (ediff-eval-in-buffer ediff-buffer-A (point)))
 521         ;;(point-B (ediff-eval-in-buffer ediff-buffer-B (point)))
 522         (tmp-buffer (get-buffer-create ediff-tmp-buffer))
 523         (buf-A-file-name
 524          (file-name-nondirectory (or (buffer-file-name ediff-buffer-A)
 525                                      (buffer-name ediff-buffer-A)
 526                                      )))
 527         (buf-B-file-name
 528          (file-name-nondirectory (or (buffer-file-name ediff-buffer-B)
 529                                      (buffer-name ediff-buffer-B)
 530                                      )))
 531         (buf-C-file-name
 532          (file-name-nondirectory (or (buffer-file-name ediff-buffer-C)
 533                                      ;; if (null ediff-buffer-C), there is
 534                                      ;; no danger, since we later check if
 535                                      ;; ediff-buffer-C is alive
 536                                      (buffer-name ediff-buffer-C)
 537                                      )))
 538         (overl-A (ediff-get-value-according-to-buffer-type
 539                   'A ediff-narrow-bounds))
 540         (overl-B (ediff-get-value-according-to-buffer-type
 541                   'B ediff-narrow-bounds))
 542         (overl-C (ediff-get-value-according-to-buffer-type
 543                   'C ediff-narrow-bounds))
 544         beg-A end-A beg-B end-B beg-C end-C
 545         file-A file-B file-C)
 546     (ediff-unselect-and-select-difference -1)
 547
 548     (setq beg-A (ediff-overlay-start overl-A)
 549           beg-B (ediff-overlay-start overl-B)
 550           beg-C (ediff-overlay-start overl-C)
 551           end-A (ediff-overlay-end overl-A)
 552           end-B (ediff-overlay-end overl-B)
 553           end-C (ediff-overlay-end overl-C))
 554
 555     (if ediff-word-mode
 556         (progn
 557           (ediff-wordify beg-A end-A ediff-buffer-A tmp-buffer)
 558           (setq file-A (ediff-make-temp-file tmp-buffer "regA"))
 559           (ediff-wordify beg-B end-B ediff-buffer-B tmp-buffer)
 560           (setq file-B (ediff-make-temp-file tmp-buffer "regB"))
 561           (if ediff-3way-job
 562               (progn
 563                 (ediff-wordify beg-C end-C ediff-buffer-C tmp-buffer)
 564                 (setq file-C (ediff-make-temp-file tmp-buffer "regC"))))
 565           )
 566       ;; not word-mode
 567       (setq file-A (ediff-make-temp-file ediff-buffer-A buf-A-file-name))
 568       (setq file-B (ediff-make-temp-file ediff-buffer-B buf-B-file-name))
 569       (if ediff-3way-job
 570           (setq file-C (ediff-make-temp-file ediff-buffer-C buf-C-file-name)))
 571       )
 572
 573     (ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
 574     (ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
 575     (ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
 576     (ediff-clear-diff-vector
 577      'ediff-difference-vector-Ancestor 'fine-diffs-also)
 578     ;; let them garbage collect. we can't use the ancestor after recomputing
 579     ;; the diffs.
 580     (setq ediff-difference-vector-Ancestor nil
 581           ediff-ancestor-buffer nil
 582           ediff-state-of-merge nil)
 583
 584     (setq ediff-killed-diffs-alist nil) ; invalidate saved killed diff regions
 585
 586     ;; In case of merge job, fool it into thinking that it is just doing
 587     ;; comparison
 588     (let ((ediff-setup-diff-regions-function ediff-setup-diff-regions-function)
 589           (ediff-3way-comparison-job ediff-3way-comparison-job)
 590           (ediff-merge-job ediff-merge-job)
 591           (ediff-merge-with-ancestor-job ediff-merge-with-ancestor-job)
 592           (ediff-job-name ediff-job-name))
 593       (if ediff-merge-job
 594           (setq ediff-setup-diff-regions-function 'ediff-setup-diff-regions3
 595                 ediff-3way-comparison-job t
 596                 ediff-merge-job nil
 597                 ediff-merge-with-ancestor-job nil
 598                 ediff-job-name 'ediff-files3))
 599       (funcall ediff-setup-diff-regions-function file-A file-B file-C))
 600
 601     (setq ediff-number-of-differences (length ediff-difference-vector-A))
 602     (delete-file file-A)
 603     (delete-file file-B)
 604     (if file-C
 605         (delete-file file-C))
 606
 607     (if ediff-3way-job
 608         (ediff-set-state-of-all-diffs-in-all-buffers ediff-control-buffer))
 609
 610     (ediff-jump-to-difference (ediff-diff-at-point 'A point-A))
 611     (message "")
 612     ))
 613
 614 ;; Not bound to any key---to dangerous. A user can do it if necessary.
 615 (defun ediff-revert-buffers-then-recompute-diffs (noconfirm)
 616   "Revert buffers A, B and C. Then rerun Ediff on file A and file B."
 617   (interactive "P")
 618   (ediff-barf-if-not-control-buffer)
 619   (let ((bufA ediff-buffer-A)
 620         (bufB ediff-buffer-B)
 621         (bufC ediff-buffer-C)
 622         (ctl-buf ediff-control-buffer)
 623         (keep-variants ediff-keep-variants)
 624         (ancestor-buf ediff-ancestor-buffer)
 625         (ancestor-job ediff-merge-with-ancestor-job)
 626         (merge ediff-merge-job)
 627         (comparison ediff-3way-comparison-job))
 628     (ediff-eval-in-buffer bufA
 629       (revert-buffer t noconfirm))
 630     (ediff-eval-in-buffer bufB
 631       (revert-buffer t noconfirm))
 632     ;; this should only be executed in a 3way comparison, not in merge
 633     (if comparison
 634         (ediff-eval-in-buffer bufC
 635           (revert-buffer t noconfirm)))
 636     (if merge
 637         (progn
 638           (set-buffer ctl-buf)
 639           ;; the argument says whether to reverse the meaning of
 640           ;; ediff-keep-variants, i.e., ediff-really-quit runs here with
 641           ;; variants kept.
 642           (ediff-really-quit (not keep-variants))
 643           (kill-buffer bufC)
 644           (if ancestor-job
 645               (ediff-merge-buffers-with-ancestor bufA bufB ancestor-buf)
 646             (ediff-merge-buffers bufA bufB)))
 647       (ediff-update-diffs))))
 648
 649
 650 ;; optional NO-REHIGHLIGHT says to not rehighlight buffers
 651 (defun ediff-recenter (&optional no-rehighlight)
 652   "Bring the highlighted region of all buffers being compared into view.
 653 Reestablish the default three-window display."
 654   (interactive)
 655   (ediff-barf-if-not-control-buffer)
 656
 657 ;;  ;; No longer needed: XEmacs has surrogate minibuffers now.
 658 ;;  (if ediff-xemacs-p (setq synchronize-minibuffers t))
 659
 660   (let (buffer-read-only)
 661     (if (and (ediff-buffer-live-p ediff-buffer-A)
 662              (ediff-buffer-live-p ediff-buffer-B)
 663              (or (not ediff-3way-job)
 664                  (ediff-buffer-live-p ediff-buffer-C)))
 665         (ediff-setup-windows
 666          ediff-buffer-A ediff-buffer-B ediff-buffer-C ediff-control-buffer)
 667       (or (eq this-command 'ediff-quit)
 668           (message ediff-KILLED-VITAL-BUFFER
 669                    (beep 1)))
 670       ))
 671
 672   ;; set visibility range appropriate to this invocation of Ediff.
 673   (ediff-visible-region)
 674   ;; raise
 675   (if (and (ediff-window-display-p)
 676            (symbolp this-command)
 677            (symbolp last-command)
 678            ;; Either one of the display-changing commands
 679            (or (memq this-command
 680                      '(ediff-recenter
 681                        ediff-dir-action ediff-registry-action
 682                        ediff-patch-action
 683                        ediff-toggle-wide-display ediff-toggle-multiframe))
 684                ;; Or one of the movement cmds and prev cmd was an Ediff cmd
 685                ;; This avoids raising frames unnecessarily.
 686                (and (memq this-command
 687                           '(ediff-next-difference
 688                             ediff-previous-difference
 689                             ediff-jump-to-difference
 690                             ediff-jump-to-difference-at-point))
 691                     (not (string-match "^ediff-" (symbol-name last-command)))
 692                     )))
 693       (progn
 694         (if (window-live-p ediff-window-A)
 695             (raise-frame (window-frame ediff-window-A)))
 696         (if (window-live-p ediff-window-B)
 697             (raise-frame (window-frame ediff-window-B)))
 698         (if (window-live-p ediff-window-C)
 699             (raise-frame (window-frame ediff-window-C)))))
 700   (if (and (ediff-window-display-p)
 701            (frame-live-p ediff-control-frame)
 702            (not ediff-use-long-help-message)
 703            (not (ediff-frame-iconified-p ediff-control-frame)))
 704       (raise-frame ediff-control-frame))
 705
 706   ;; Redisplay whatever buffers are showing, if there is a selected difference
 707   (let ((control-frame ediff-control-frame)
 708         (control-buf ediff-control-buffer))
 709     (if (and (ediff-buffer-live-p ediff-buffer-A)
 710              (ediff-buffer-live-p ediff-buffer-B)
 711              (or (not ediff-3way-job)
 712                  (ediff-buffer-live-p ediff-buffer-C)))
 713         (progn
 714           (or no-rehighlight
 715               (ediff-select-difference ediff-current-difference))
 716
 717           (ediff-recenter-one-window 'A)
 718           (ediff-recenter-one-window 'B)
 719           (if ediff-3way-job
 720               (ediff-recenter-one-window 'C))
 721
 722           (ediff-eval-in-buffer control-buf
 723             (ediff-recenter-ancestor) ; check if ancestor is alive
 724
 725             (if (and (ediff-multiframe-setup-p)
 726                      (not ediff-use-long-help-message)
 727                      (not (ediff-frame-iconified-p ediff-control-frame)))
 728                 ;; never grab mouse on quit in this place
 729                 (ediff-reset-mouse
 730                  control-frame
 731                  (eq this-command 'ediff-quit))))
 732           ))
 733
 734     (ediff-restore-highlighting)
 735     (ediff-eval-in-buffer control-buf (ediff-refresh-mode-lines))
 736     ))
 737
 738 ;; this function returns to the window it was called from
 739 ;; (which was the control window)
 740 (defun ediff-recenter-one-window (buf-type)
 741   (if (ediff-valid-difference-p)
 742       ;; context must be saved before switching to windows A/B/C
 743       (let* ((ctl-wind (selected-window))
 744              (shift (ediff-overlay-start
 745                      (ediff-get-value-according-to-buffer-type
 746                       buf-type ediff-narrow-bounds)))
 747              (job-name ediff-job-name)
 748              (control-buf ediff-control-buffer)
 749              (window-name (intern (format "ediff-window-%S" buf-type)))
 750              (window (if (window-live-p (symbol-value window-name))
 751                          (symbol-value window-name))))
 752
 753         (if (and window ediff-windows-job)
 754             (set-window-start window shift))
 755         (if window
 756             (progn
 757               (select-window window)
 758               (ediff-deactivate-mark)
 759               (ediff-position-region
 760                (ediff-get-diff-posn buf-type 'beg nil control-buf)
 761                (ediff-get-diff-posn buf-type 'end nil control-buf)
 762                (ediff-get-diff-posn buf-type 'beg nil control-buf)
 763                job-name
 764                )))
 765         (select-window ctl-wind)
 766         )))
 767
 768 (defun ediff-recenter-ancestor ()
 769   ;; do half-hearted job by recentering the ancestor buffer, if it is alive and
 770   ;; visible.
 771   (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
 772            (ediff-valid-difference-p))
 773       (let ((window (ediff-get-visible-buffer-window ediff-ancestor-buffer))
 774             (ctl-wind (selected-window))
 775             (job-name ediff-job-name)
 776             (ctl-buf ediff-control-buffer))
 777         (ediff-eval-in-buffer ediff-ancestor-buffer
 778           (goto-char (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf))
 779           (if window
 780               (progn
 781                 (select-window window)
 782                 (ediff-position-region
 783                  (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
 784                  (ediff-get-diff-posn 'Ancestor 'end nil ctl-buf)
 785                  (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
 786                  job-name))))
 787         (select-window ctl-wind)
 788         )))
 789
 790
 791 ;; This will have to be refined for 3way jobs
 792 (defun ediff-toggle-split ()
 793   "Toggle vertical/horizontal window split.
 794 Does nothing if file-A and file-B are in different frames."
 795   (interactive)
 796   (ediff-barf-if-not-control-buffer)
 797   (let* ((wind-A (if (window-live-p ediff-window-A) ediff-window-A))
 798          (wind-B (if (window-live-p ediff-window-B) ediff-window-B))
 799          (wind-C (if (window-live-p ediff-window-C) ediff-window-C))
 800          (frame-A (if wind-A (window-frame wind-A)))
 801          (frame-B (if wind-B (window-frame wind-B)))
 802          (frame-C (if wind-C (window-frame wind-C))))
 803     (if (or (eq frame-A frame-B)
 804             (not (frame-live-p frame-A))
 805             (not (frame-live-p frame-B))
 806             (if ediff-3way-comparison-job
 807                 (or (not (frame-live-p frame-C))
 808                     (eq frame-A frame-C) (eq frame-B frame-C))))
 809         (setq ediff-split-window-function
 810               (if (eq ediff-split-window-function 'split-window-vertically)
 811                   'split-window-horizontally
 812                 'split-window-vertically))
 813       (message "Buffers being compared are in different frames"))
 814     (ediff-recenter 'no-rehighlight)))
 815
 816 (defun ediff-toggle-hilit ()
 817   "Switch between highlighting using ASCII flags and highlighting using faces.
 818 On a dumb terminal, switches between ASCII highlighting and no highlighting."
 819   (interactive)
 820   (ediff-barf-if-not-control-buffer)
 821   (if (not (ediff-has-face-support-p))
 822       (if (eq ediff-highlighting-style 'ascii)
 823           (progn
 824             (message "ASCII highlighting flags removed")
 825             (ediff-unselect-and-select-difference ediff-current-difference
 826                                                   'unselect-only)
 827             (setq ediff-highlighting-style 'off))
 828         (ediff-unselect-and-select-difference ediff-current-difference
 829                                               'select-only))
 830     (ediff-unselect-and-select-difference ediff-current-difference
 831                                           'unselect-only)
 832     ;; cycle through highlighting
 833     (cond ((and ediff-use-faces ediff-highlight-all-diffs)
 834            (message "Unhighlighting unselected difference regions")
 835            (setq ediff-highlight-all-diffs nil))
 836           (ediff-use-faces
 837            (message "Highlighting with ASCII flags")
 838            (setq ediff-use-faces nil))
 839           (t
 840            (message "Re-highlighting all difference regions")
 841            (setq ediff-use-faces t
 842                  ediff-highlight-all-diffs t)))
 843
 844     (if (and ediff-use-faces ediff-highlight-all-diffs)
 845         (ediff-paint-background-regions)
 846       (ediff-paint-background-regions 'unhighlight))
 847
 848     (ediff-unselect-and-select-difference
 849      ediff-current-difference 'select-only))
 850   )
 851
 852
 853 (defun ediff-toggle-autorefine ()
 854   "Toggle auto-refine mode."
 855   (interactive)
 856   (ediff-barf-if-not-control-buffer)
 857   (if ediff-word-mode
 858       (error "No fine differences in this mode"))
 859   (cond ((eq ediff-auto-refine 'nix)
 860          (setq ediff-auto-refine 'on)
 861          (ediff-make-fine-diffs ediff-current-difference 'noforce)
 862          (message "Auto-refining is ON"))
 863         ((eq ediff-auto-refine 'on)
 864          (message "Auto-refining is OFF")
 865          (setq ediff-auto-refine 'off))
 866         (t ;; nix 'em
 867          (ediff-set-fine-diff-properties ediff-current-difference 'default)
 868          (message "Refinements are HIDDEN")
 869          (setq ediff-auto-refine 'nix))
 870         ))
 871
 872 (defun ediff-show-ancestor ()
 873   "Show the ancestor buffer in a suitable window."
 874   (interactive)
 875   (ediff-recenter)
 876   (or (ediff-buffer-live-p ediff-ancestor-buffer)
 877       (if ediff-merge-with-ancestor-job
 878           (error "Lost connection to ancestor buffer...sorry")
 879         (error "Not merging with ancestor")))
 880   (let (wind)
 881     (cond ((setq wind (ediff-get-visible-buffer-window ediff-ancestor-buffer))
 882            (raise-frame (window-frame wind)))
 883           (t (set-window-buffer ediff-window-C ediff-ancestor-buffer)))))
 884
 885 (defun ediff-make-or-kill-fine-diffs (arg)
 886   "Compute fine diffs. With negative prefix arg, kill fine diffs.
 887 In both cases, operates on the currrent difference region."
 888   (interactive "P")
 889   (ediff-barf-if-not-control-buffer)
 890   (cond ((eq arg '-)
 891          (ediff-clear-fine-differences ediff-current-difference))
 892         ((and (numberp arg) (< arg 0))
 893          (ediff-clear-fine-differences ediff-current-difference))
 894         (t (ediff-make-fine-diffs))))
 895
 896
 897 (defun ediff-toggle-help ()
 898   "Toggle short/long help message."
 899   (interactive)
 900   (ediff-barf-if-not-control-buffer)
 901   (let (buffer-read-only)
 902     (erase-buffer)
 903     (setq ediff-use-long-help-message (not ediff-use-long-help-message))
 904     (ediff-set-help-message))
 905   ;; remember the icon status of the control frame when the user requested
 906   ;; full control message
 907   (if (and ediff-use-long-help-message (ediff-multiframe-setup-p))
 908       (setq ediff-prefer-iconified-control-frame
 909             (ediff-frame-iconified-p ediff-control-frame)))
 910
 911   (setq ediff-window-config-saved "") ; force redisplay
 912   (ediff-recenter 'no-rehighlight))
 913
 914
 915 ;; If BUF, this is the buffer to toggle, not current buffer.
 916 (defun ediff-toggle-read-only (&optional buf)
 917   "Toggle read-only in current buffer.
 918 If buffer is under version control and locked, check it out first.
 919 If optional argument BUF is specified, toggle read-only in that buffer instead
 920 of the current buffer."
 921   (interactive)
 922   (ediff-barf-if-not-control-buffer)
 923   (let ((ctl-buf (if (null buf) (current-buffer)))
 924         (buf-type (ediff-char-to-buftype last-command-char)))
 925     (or buf (ediff-recenter))
 926     (or buf
 927         (setq buf (ediff-get-buffer buf-type)))
 928
 929     (ediff-eval-in-buffer buf     ; eval in buf A/B/C
 930       (let* ((file (buffer-file-name buf))
 931              (file-writable (and file
 932                                  (file-exists-p file)
 933                                  (file-writable-p file)))
 934              (toggle-ro-cmd (cond (ediff-toggle-read-only-function)
 935                                   ((ediff-file-checked-out-p file)
 936                                    'toggle-read-only)
 937                                   (file-writable 'toggle-read-only)
 938                                   (t (key-binding "\C-x\C-q")))))
 939         ;; If the file is checked in, make sure we don't make buffer modifiable
 940         ;; without warning the user. The user can fool our checks by making the
 941         ;; buffer non-RO without checking the file out. We regard this as a
 942         ;; user problem.
 943         (if (and (ediff-file-checked-in-p file)
 944                  ;; If ctl-buf is null, this means we called this
 945                  ;; non-interactively, in which case don't ask questions
 946                  ctl-buf)
 947             (cond ((not buffer-read-only)
 948                    (setq toggle-ro-cmd 'toggle-read-only))
 949                   ((and (or (beep 1) t) ; always beep
 950                         (y-or-n-p
 951                          (format
 952                           "File %s is under version control. Check it out? "
 953                           (ediff-abbreviate-file-name file))))
 954                    ;; if we checked the file out, we should also change the
 955                    ;; original state of buffer-read-only to nil.  If we don't
 956                    ;; do this, the mode line will show %%, since the file was
 957                    ;; RO before ediff started, so the user will think the file
 958                    ;; is checked in.
 959                    (ediff-eval-in-buffer ctl-buf
 960                      (ediff-change-saved-variable
 961                       'buffer-read-only nil buf-type)))
 962                   (t
 963                    (setq toggle-ro-cmd 'toggle-read-only)
 964                    (beep 1) (beep 1)
 965                    (message
 966                     "Boy, this is risky! Don't modify this file...")
 967                    (sit-for 3)))) ; let the user see the warning
 968         (if (and toggle-ro-cmd
 969                  (string-match "toggle-read-only" (symbol-name toggle-ro-cmd)))
 970             (save-excursion
 971               (save-window-excursion
 972                 (select-window (ediff-get-visible-buffer-window buf))
 973                 (command-execute toggle-ro-cmd)))
 974           (error "Don't know how to toggle read-only in buffer %S" buf))
 975
 976         ;; Check if we made the current buffer updatable, but its file is RO.
 977         ;; Signal a warning in this case.
 978         (if (and file (not buffer-read-only)
 979                  (eq this-command 'ediff-toggle-read-only)
 980                  (file-exists-p file)
 981                  (not (file-writable-p file)))
 982             (message "Warning: file %s is read-only"
 983                      (ediff-abbreviate-file-name file) (beep 1)))
 984         ))))
 985
 986 ;; checkout if visited file is checked in
 987 (defun ediff-maybe-checkout (buf)
 988   (let ((file (buffer-file-name buf))
 989         (checkout-function (key-binding "\C-x\C-q")))
 990     (if (and (ediff-file-checked-in-p file)
 991              (or (beep 1) t)
 992              (y-or-n-p
 993               (format
 994                "File %s is under version control. Check it out? "
 995                (ediff-abbreviate-file-name file))))
 996         (ediff-eval-in-buffer buf
 997           (command-execute checkout-function)))))
 998
 999
1000 ;; This is a simple-minded check for whether a file is under version control.
1001 ;; If file,v exists but file doesn't, this file is considered to be not checked
1002 ;; in and not checked out for the purpose of patching (since patch won't be
1003 ;; able to read such a file anyway).
1004 ;; FILE is a string representing file name
1005 (defun ediff-file-under-version-control (file)
1006   (let* ((filedir (file-name-directory file))
1007          (file-nondir (file-name-nondirectory file))
1008          (trial (concat file-nondir ",v"))
1009          (full-trial (concat filedir trial))
1010          (full-rcs-trial (concat filedir "RCS/" trial)))
1011     (and (stringp file)
1012          (file-exists-p file)
1013          (or
1014           (and
1015            (file-exists-p full-trial)
1016            ;; in FAT FS, `file,v' and `file' may turn out to be the same!
1017            ;; don't be fooled by this!
1018            (not (equal (file-attributes file)
1019                        (file-attributes full-trial))))
1020           ;; check if a version is in RCS/ directory
1021           (file-exists-p full-rcs-trial)))
1022        ))
1023
1024 (defun ediff-file-checked-out-p (file)
1025   (and (ediff-file-under-version-control file)
1026        (file-writable-p file)))
1027 (defun ediff-file-checked-in-p (file)
1028   (and (ediff-file-under-version-control file)
1029        (not (file-writable-p file))))
1030
1031 (defun ediff-swap-buffers ()
1032   "Rotate the display of buffers A, B, and C."
1033   (interactive)
1034   (ediff-barf-if-not-control-buffer)
1035   (if (and (window-live-p ediff-window-A) (window-live-p ediff-window-B))
1036       (let ((buf ediff-buffer-A)
1037             (values ediff-buffer-values-orig-A)
1038             (diff-vec ediff-difference-vector-A)
1039             (hide-regexp ediff-regexp-hide-A)
1040             (focus-regexp ediff-regexp-focus-A)
1041             (wide-visibility-p (eq ediff-visible-bounds ediff-wide-bounds))
1042             (overlay (if (ediff-has-face-support-p)
1043                          ediff-current-diff-overlay-A)))
1044         (if ediff-3way-comparison-job
1045             (progn
1046               (set-window-buffer ediff-window-A ediff-buffer-C)
1047               (set-window-buffer ediff-window-B ediff-buffer-A)
1048               (set-window-buffer ediff-window-C ediff-buffer-B)
1049               )
1050           (set-window-buffer ediff-window-A ediff-buffer-B)
1051           (set-window-buffer ediff-window-B ediff-buffer-A))
1052         ;; swap diff buffers
1053         (if ediff-3way-comparison-job
1054             (setq ediff-buffer-A ediff-buffer-C
1055                   ediff-buffer-C ediff-buffer-B
1056                   ediff-buffer-B buf)
1057           (setq ediff-buffer-A ediff-buffer-B
1058                 ediff-buffer-B buf))
1059
1060         ;; swap saved buffer characteristics
1061         (if ediff-3way-comparison-job
1062             (setq ediff-buffer-values-orig-A ediff-buffer-values-orig-C
1063                   ediff-buffer-values-orig-C ediff-buffer-values-orig-B
1064                   ediff-buffer-values-orig-B values)
1065           (setq ediff-buffer-values-orig-A ediff-buffer-values-orig-B
1066                 ediff-buffer-values-orig-B values))
1067
1068         ;; swap diff vectors
1069         (if ediff-3way-comparison-job
1070             (setq ediff-difference-vector-A ediff-difference-vector-C
1071                   ediff-difference-vector-C ediff-difference-vector-B
1072                   ediff-difference-vector-B diff-vec)
1073           (setq ediff-difference-vector-A ediff-difference-vector-B
1074                 ediff-difference-vector-B diff-vec))
1075
1076         ;; swap hide/focus regexp
1077         (if ediff-3way-comparison-job
1078             (setq ediff-regexp-hide-A ediff-regexp-hide-C
1079                   ediff-regexp-hide-C ediff-regexp-hide-B
1080                   ediff-regexp-hide-B hide-regexp
1081                   ediff-regexp-focus-A ediff-regexp-focus-C
1082                   ediff-regexp-focus-C ediff-regexp-focus-B
1083                   ediff-regexp-focus-B focus-regexp)
1084           (setq ediff-regexp-hide-A ediff-regexp-hide-B
1085                 ediff-regexp-hide-B hide-regexp
1086                 ediff-regexp-focus-A ediff-regexp-focus-B
1087                 ediff-regexp-focus-B focus-regexp))
1088
1089         ;; The following is needed for XEmacs, since there one can't move
1090         ;; overlay to another buffer. In Emacs, this swap is redundant.
1091         (if (ediff-has-face-support-p)
1092             (if ediff-3way-comparison-job
1093                 (setq ediff-current-diff-overlay-A ediff-current-diff-overlay-C
1094                       ediff-current-diff-overlay-C ediff-current-diff-overlay-B
1095                       ediff-current-diff-overlay-B overlay)
1096               (setq ediff-current-diff-overlay-A ediff-current-diff-overlay-B
1097                     ediff-current-diff-overlay-B overlay)))
1098
1099         ;; swap wide bounds
1100         (setq ediff-wide-bounds
1101               (cond (ediff-3way-comparison-job
1102                      (list (nth 2 ediff-wide-bounds)
1103                            (nth 0 ediff-wide-bounds)
1104                            (nth 1 ediff-wide-bounds)))
1105                     (ediff-3way-job
1106                      (list (nth 1 ediff-wide-bounds)
1107                            (nth 0 ediff-wide-bounds)
1108                            (nth 2 ediff-wide-bounds)))
1109                     (t
1110                      (list (nth 1 ediff-wide-bounds)
1111                            (nth 0 ediff-wide-bounds)))))
1112         ;; swap narrow bounds
1113         (setq ediff-narrow-bounds
1114               (cond (ediff-3way-comparison-job
1115                      (list (nth 2 ediff-narrow-bounds)
1116                            (nth 0 ediff-narrow-bounds)
1117                            (nth 1 ediff-narrow-bounds)))
1118                     (ediff-3way-job
1119                      (list (nth 1 ediff-narrow-bounds)
1120                            (nth 0 ediff-narrow-bounds)
1121                            (nth 2 ediff-narrow-bounds)))
1122                     (t
1123                      (list (nth 1 ediff-narrow-bounds)
1124                            (nth 0 ediff-narrow-bounds)))))
1125         (if wide-visibility-p
1126             (setq ediff-visible-bounds ediff-wide-bounds)
1127           (setq ediff-visible-bounds ediff-narrow-bounds))
1128         ))
1129   (if ediff-3way-job
1130       (ediff-set-state-of-all-diffs-in-all-buffers ediff-control-buffer))
1131   (ediff-recenter 'no-rehighlight)
1132   )
1133
1134
1135 (defun ediff-toggle-wide-display ()
1136   "Toggle wide/regular display.
1137 This is especially useful when comparing buffers side-by-side."
1138   (interactive)
1139   (ediff-barf-if-not-control-buffer)
1140   (or (ediff-window-display-p)
1141       (error "%sEmacs is not running as a window application"
1142              (if ediff-emacs-p "" "X")))
1143   (ediff-recenter 'no-rehighlight) ; make sure buffs are displayed in windows
1144   (let ((ctl-buf ediff-control-buffer))
1145     (setq ediff-wide-display-p (not ediff-wide-display-p))
1146     (if (not ediff-wide-display-p)
1147         (ediff-eval-in-buffer ctl-buf
1148           (modify-frame-parameters
1149            ediff-wide-display-frame ediff-wide-display-orig-parameters)
1150           ;;(sit-for (if ediff-xemacs-p 0.4 0))
1151           ;; restore control buf, since ctl window may have been deleted
1152           ;; during resizing
1153           (set-buffer ctl-buf)
1154           (setq ediff-wide-display-orig-parameters nil
1155                 ediff-window-B nil) ; force update of window config
1156           (ediff-recenter 'no-rehighlight))
1157       (funcall ediff-make-wide-display-function)
1158       ;;(sit-for (if ediff-xemacs-p 0.4 0))
1159       (ediff-eval-in-buffer ctl-buf
1160         (setq ediff-window-B nil) ; force update of window config
1161         (ediff-recenter 'no-rehighlight)))))
1162
1163 ;;;###autoload
1164 (defun ediff-toggle-multiframe ()
1165   "Switch from the multiframe display to single-frame display and back.
1166 For a permanent change, set the variable `ediff-window-setup-function',
1167 which see."
1168   (interactive)
1169   (let (set-func)
1170   (or (ediff-window-display-p)
1171       (error "%sEmacs is not running as a window application"
1172              (if ediff-emacs-p "" "X")))
1173
1174   (setq set-func (if (ediff-in-control-buffer-p) 'setq 'setq-default))
1175
1176   (cond ((eq ediff-window-setup-function 'ediff-setup-windows-multiframe)
1177          (eval
1178           (list
1179            set-func
1180            'ediff-window-setup-function ''ediff-setup-windows-plain)))
1181         ((eq ediff-window-setup-function 'ediff-setup-windows-plain)
1182          (if (ediff-in-control-buffer-p)
1183              (ediff-kill-bottom-toolbar))
1184          (eval
1185           (list
1186            set-func
1187            'ediff-window-setup-function ''ediff-setup-windows-multiframe))))
1188   (if (ediff-in-control-buffer-p)
1189       (progn
1190         (setq ediff-window-B nil)
1191         (ediff-recenter 'no-rehighlight)))))
1192
1193 ;; if was using toolbar, kill it
1194 (defun ediff-kill-bottom-toolbar ()
1195   ;; Using ctl-buffer or ediff-control-window for LOCALE does not
1196   ;; work properly in XEmacs 19.14: we have to use
1197   ;;(selected-frame).
1198   ;; The problem with this is that any previous bottom-toolbar
1199   ;; will not re-appear after our cleanup here.  Is there a way
1200   ;; to do "push" and "pop" toolbars ?  --marcpa
1201   (if (ediff-use-toolbar-p)
1202       (progn
1203         (set-specifier bottom-toolbar (list (selected-frame) nil))
1204         (set-specifier bottom-toolbar-visible-p (list (selected-frame) nil)))))
1205
1206 ;; if wants to use toolbar, make it
1207 (defun ediff-make-bottom-toolbar ()
1208   (if (ediff-use-toolbar-p)
1209       (progn
1210         (set-specifier bottom-toolbar (list (selected-frame) ediff-toolbar))
1211         (set-specifier bottom-toolbar-visible-p (list (selected-frame) t))
1212         (set-specifier bottom-toolbar-height (list (selected-frame) 34)))))
1213
1214 ;; Merging
1215
1216 (defun ediff-toggle-show-clashes-only ()
1217   "Toggle the mode where only the regions where both buffers differ with the ancestor are shown."
1218   (interactive)
1219   (ediff-barf-if-not-control-buffer)
1220   (if (not ediff-merge-with-ancestor-job)
1221       (error "This command makes sense only when merging with an ancestor"))
1222   (setq ediff-show-clashes-only (not ediff-show-clashes-only))
1223   (if ediff-show-clashes-only
1224       (message "Focus on regions where both buffers differ from the ancestor")
1225     (message "Canceling focus on regions where changes clash")))
1226
1227 ;; Widening/narrowing
1228
1229 (defun ediff-toggle-narrow-region ()
1230   "Toggle narrowing in buffers A, B, and C.
1231 Used in ediff-windows/regions only."
1232   (interactive)
1233   (if (eq ediff-buffer-A ediff-buffer-B)
1234       (error ediff-NO-DIFFERENCES))
1235   (if (eq ediff-visible-bounds ediff-wide-bounds)
1236       (setq ediff-visible-bounds ediff-narrow-bounds)
1237     (setq ediff-visible-bounds ediff-wide-bounds))
1238   (ediff-recenter 'no-rehighlight))
1239
1240 ;; Narrow bufs A/B/C to ediff-visible-bounds. If this is currently set to
1241 ;; ediff-wide-bounds, then this actually widens.
1242 ;; This function does nothing if job-name is not
1243 ;; ediff-regions-wordwise/linewise or ediff-windows-wordwise/linewise.
1244 ;; Does nothing if buffer-A  = buffer-B since we can't narrow
1245 ;; to two different regions in one buffer.
1246 (defun ediff-visible-region ()
1247   (if (or (eq ediff-buffer-A ediff-buffer-B)
1248           (eq ediff-buffer-A ediff-buffer-C)
1249           (eq ediff-buffer-C ediff-buffer-B))
1250       ()
1251     ;; If ediff-*-regions/windows, ediff-visible-bounds is already set
1252     ;; Otherwise, always use full range.
1253     (if (not ediff-narrow-job)
1254         (setq ediff-visible-bounds ediff-wide-bounds))
1255     (let ((overl-A (ediff-get-value-according-to-buffer-type
1256                     'A  ediff-visible-bounds))
1257           (overl-B (ediff-get-value-according-to-buffer-type
1258                     'B  ediff-visible-bounds))
1259           (overl-C (ediff-get-value-according-to-buffer-type
1260                     'C  ediff-visible-bounds))
1261           )
1262       (ediff-eval-in-buffer ediff-buffer-A
1263         (narrow-to-region
1264          (ediff-overlay-start overl-A) (ediff-overlay-end overl-A)))
1265       (ediff-eval-in-buffer ediff-buffer-B
1266         (narrow-to-region
1267          (ediff-overlay-start overl-B) (ediff-overlay-end overl-B)))
1268
1269       (if ediff-3way-comparison-job
1270           (ediff-eval-in-buffer ediff-buffer-C
1271             (narrow-to-region
1272              (ediff-overlay-start overl-C) (ediff-overlay-end overl-C))))
1273       )))
1274
1275
1276 ;; Window scrolling operations
1277
1278 ;; Performs some operation on the two file windows (if they are showing).
1279 ;; Traps all errors on the operation in windows A/B/C.
1280 ;; Usually, errors come from scrolling off the
1281 ;; beginning or end of the buffer, and this gives error messages.
1282 (defun ediff-operate-on-windows (operation arg)
1283
1284   ;; make sure windows aren't dead
1285   (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1286       (ediff-recenter 'no-rehighlight))
1287   (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1288                 (ediff-buffer-live-p ediff-buffer-B)
1289                 (or (not ediff-3way-job) ediff-buffer-C)
1290                 ))
1291       (error ediff-KILLED-VITAL-BUFFER))
1292
1293   (let* ((wind (selected-window))
1294          (wind-A ediff-window-A)
1295          (wind-B ediff-window-B)
1296          (wind-C ediff-window-C)
1297          (coefA (ediff-get-region-size-coefficient 'A operation))
1298          (coefB (ediff-get-region-size-coefficient 'B operation))
1299          (three-way ediff-3way-job)
1300          (coefC (if three-way
1301                     (ediff-get-region-size-coefficient 'C operation))))
1302
1303     (select-window wind-A)
1304     (condition-case nil
1305         (funcall operation (round (* coefA arg)))
1306       (error))
1307     (select-window wind-B)
1308     (condition-case nil
1309         (funcall operation (round (* coefB arg)))
1310       (error))
1311     (if three-way
1312         (progn
1313           (select-window wind-C)
1314           (condition-case nil
1315               (funcall operation (round (* coefC arg)))
1316             (error))))
1317     (select-window wind)))
1318
1319 (defun ediff-scroll-vertically (&optional arg)
1320   "Vertically scroll buffers A, B \(and C if appropriate\).
1321 With optional argument ARG, scroll ARG lines; otherwise scroll by nearly
1322 the one half of the height of window-A."
1323   (interactive "P")
1324   (ediff-barf-if-not-control-buffer)
1325
1326   ;; make sure windows aren't dead
1327   (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1328       (ediff-recenter 'no-rehighlight))
1329   (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1330                 (ediff-buffer-live-p ediff-buffer-B)
1331                 (or (not ediff-3way-job)
1332                     (ediff-buffer-live-p ediff-buffer-C))
1333                 ))
1334       (error ediff-KILLED-VITAL-BUFFER))
1335
1336   (ediff-operate-on-windows
1337    (if (memq last-command-char '(?v ?\C-v))
1338        'scroll-up
1339      'scroll-down)
1340    ;; calculate argument to scroll-up/down
1341    ;; if there is an explicit argument
1342    (if (and arg (not (equal arg '-)))
1343        ;; use it
1344        (prefix-numeric-value arg)
1345      ;; if not, see if we can determine a default amount (the window height)
1346      (let (default-amount)
1347        (setq default-amount
1348              (- (/ (min (window-height ediff-window-A)
1349                         (window-height ediff-window-B)
1350                         (if ediff-3way-job
1351                             (window-height ediff-window-C)
1352                           500)) ; some large number
1353                    2)
1354                 1 next-screen-context-lines))
1355        ;; window found
1356        (if arg
1357            ;; C-u as argument means half of default amount
1358            (/ default-amount 2)
1359          ;; no argument means default amount
1360          default-amount)))))
1361
1362
1363 (defun ediff-scroll-horizontally (&optional arg)
1364   "Horizontally scroll buffers A, B \(and C if appropriate\).
1365 If an argument is given, that is how many columns are scrolled, else nearly
1366 the width of the A/B/C windows."
1367   (interactive "P")
1368   (ediff-barf-if-not-control-buffer)
1369
1370   ;; make sure windows aren't dead
1371   (if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
1372       (ediff-recenter 'no-rehighlight))
1373   (if (not (and (ediff-buffer-live-p ediff-buffer-A)
1374                 (ediff-buffer-live-p ediff-buffer-B)
1375                 (or (not ediff-3way-job)
1376                     (ediff-buffer-live-p ediff-buffer-C))
1377                 ))
1378       (error ediff-KILLED-VITAL-BUFFER))
1379
1380   (ediff-operate-on-windows
1381    (if (= last-command-char ?<)
1382        'scroll-left
1383      'scroll-right)
1384    ;; calculate argument to scroll-left/right
1385    ;; if there is an explicit argument
1386    (if (and arg (not (equal arg '-)))
1387        ;; use it
1388        (prefix-numeric-value arg)
1389      ;; if not, see if we can determine a default amount
1390      ;; (half the window width)
1391      (if (null ediff-control-window)
1392          ;; no control window, use nil
1393          nil
1394        (let ((default-amount
1395                (- (/ (min (window-width ediff-window-A)
1396                           (window-width ediff-window-B)
1397                           (if ediff-3way-comparison-job
1398                               (window-width ediff-window-C)
1399                             500) ; some large number
1400                           )
1401                      2)
1402                   3)))
1403          ;; window found
1404          (if arg
1405              ;; C-u as argument means half of default amount
1406              (/ default-amount 2)
1407            ;; no argument means default amount
1408            default-amount))))))
1409
1410
1411 ;;BEG, END show the region to be positioned.
1412 ;;JOB-NAME holds ediff-job-name. The ediff-windows job positions regions
1413 ;;differently.
1414 (defun ediff-position-region (beg end pos job-name)
1415   (if (> end (point-max))
1416       (setq end (point-max)))
1417   (if ediff-windows-job
1418       (if (pos-visible-in-window-p end)
1419           () ; do nothing, wind is already positioned
1420         ;; at this point, windows are positioned at the beginning of the
1421         ;; file regions (not diff-regions)  being compared.
1422         (save-excursion
1423           (move-to-window-line (- (window-height) 2))
1424           (let ((amount (+ 2 (count-lines (point) end))))
1425             (scroll-up amount))))
1426     (set-window-start (selected-window) beg)
1427     (if (pos-visible-in-window-p end)
1428         ;; Determine the number of lines that the region occupies
1429         (let ((lines 0)
1430               (prev-point 0))
1431           (while ( and (> end (progn
1432                                 (move-to-window-line lines)
1433                                 (point)))
1434                        ;; `end' may be beyond the window bottom, so check
1435                        ;; that we are making progress
1436                        (< prev-point (point)))
1437             (setq prev-point (point))
1438             (setq lines (1+ lines)))
1439           ;; And position the beginning on the right line
1440           (goto-char beg)
1441           (recenter (/ (1+ (max (- (1- (window-height (selected-window)))
1442                                    lines)
1443                                 1)
1444                            )
1445                        2))))
1446     (goto-char pos)
1447     ))
1448
1449 ;; get number of lines from window start to region end
1450 (defun ediff-get-lines-to-region-end (buf-type &optional n ctl-buf)
1451   (or n (setq n ediff-current-difference))
1452   (or ctl-buf (setq ctl-buf ediff-control-buffer))
1453   (ediff-eval-in-buffer ctl-buf
1454     (let* ((buf (ediff-get-buffer buf-type))
1455            (wind (eval (intern (format "ediff-window-%S" buf-type))))
1456            (beg (window-start wind))
1457            (end (ediff-get-diff-posn buf-type 'end))
1458            lines)
1459       (ediff-eval-in-buffer buf
1460         (if (< beg end)
1461             (setq lines (count-lines beg end))
1462           (setq lines 0))
1463         lines
1464         ))))
1465
1466 ;; get number of lines from window end to region start
1467 (defun ediff-get-lines-to-region-start (buf-type &optional n ctl-buf)
1468   (or n (setq n ediff-current-difference))
1469   (or ctl-buf (setq ctl-buf ediff-control-buffer))
1470   (ediff-eval-in-buffer ctl-buf
1471     (let* ((buf (ediff-get-buffer buf-type))
1472            (wind (eval (intern (format "ediff-window-%S" buf-type))))
1473            (end (window-end wind))
1474            (beg (ediff-get-diff-posn buf-type 'beg)))
1475       (ediff-eval-in-buffer buf
1476         (if (< beg end) (count-lines beg end) 0))
1477       )))
1478
1479
1480 ;; region size coefficient is a coefficient by which to adjust scrolling
1481 ;; up/down of the window displaying buffer of type BUFTYPE.
1482 ;; The purpose of this coefficient is to make the windows scroll in sync, so
1483 ;; that it won't happen that one diff region is scrolled off while the other is
1484 ;; still seen.
1485 ;;
1486 ;; If the difference region is invalid, the coefficient is 1
1487 (defun ediff-get-region-size-coefficient (buf-type op &optional n ctl-buf)
1488   (ediff-eval-in-buffer (or ctl-buf ediff-control-buffer)
1489     (if (ediff-valid-difference-p n)
1490         (let* ((func (cond ((eq op 'scroll-down)
1491                             'ediff-get-lines-to-region-start)
1492                            ((eq op 'scroll-up)
1493                             'ediff-get-lines-to-region-end)
1494                            (t '(lambda (a b c) 0))))
1495                (max-lines (max (funcall func 'A n ctl-buf)
1496                                (funcall func 'B n ctl-buf)
1497                                (if (ediff-buffer-live-p ediff-buffer-C)
1498                                    (funcall func 'C n ctl-buf)
1499                                  0))))
1500           ;; this covers the horizontal coefficient as well:
1501           ;; if max-lines = 0 then coef = 1
1502           (if (> max-lines 0)
1503               (/ (+ (funcall func buf-type n ctl-buf) 0.0)
1504                  (+ max-lines 0.0))
1505             1))
1506       1)))
1507
1508
1509 (defun ediff-next-difference (&optional arg)
1510   "Advance to the next difference.
1511 With a prefix argument, go forward that many differences."
1512   (interactive "p")
1513   (ediff-barf-if-not-control-buffer)
1514   (if (< ediff-current-difference ediff-number-of-differences)
1515       (let ((n (min ediff-number-of-differences
1516                     (+ ediff-current-difference arg)))
1517             regexp-skip)
1518
1519         (or (>= n ediff-number-of-differences)
1520             (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1521             (ediff-install-fine-diff-if-necessary n))
1522         (while (and (< n ediff-number-of-differences)
1523                     (or
1524                      ;; regexp skip
1525                      regexp-skip
1526                      ;; skip clashes, if necessary
1527                      (and ediff-show-clashes-only
1528                           (string-match "prefer"
1529                                         (or (ediff-get-state-of-merge n) "")))
1530                      ;; skip difference regions that differ in white space
1531                      (and ediff-ignore-similar-regions
1532                           (ediff-no-fine-diffs-p n))))
1533           (setq n (1+ n))
1534           (if (= 0 (mod n 20))
1535               (message "Skipped over region %d and counting ..."  n))
1536           (or (>= n ediff-number-of-differences)
1537               (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1538               (ediff-install-fine-diff-if-necessary n))
1539           )
1540         (message "")
1541         (ediff-unselect-and-select-difference n)
1542         ) ; let
1543     (ediff-visible-region)
1544     (error "At end of the difference list")))
1545
1546 (defun ediff-previous-difference (&optional arg)
1547   "Go to the previous difference.
1548 With a prefix argument, go back that many differences."
1549   (interactive "p")
1550   (ediff-barf-if-not-control-buffer)
1551   (if (> ediff-current-difference -1)
1552       (let ((n (max -1 (- ediff-current-difference arg)))
1553             regexp-skip)
1554
1555         (or (< n 0)
1556             (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1557             (ediff-install-fine-diff-if-necessary n))
1558         (while (and (> n -1)
1559                     (or
1560                      ;; regexp skip
1561                      regexp-skip
1562                      ;; skip clashes, if necessary
1563                      (and ediff-show-clashes-only
1564                           (string-match "prefer"
1565                                         (or (ediff-get-state-of-merge n) "")))
1566                      ;; skip difference regions that differ in white space
1567                      (and ediff-ignore-similar-regions
1568                           (ediff-no-fine-diffs-p n))))
1569           (if (= 0 (mod (1+ n) 20))
1570               (message "Skipped over region %d and counting ..."  (1+ n)))
1571           (setq n (1- n))
1572           (or (< n 0)
1573               (setq regexp-skip (funcall ediff-skip-diff-region-function n))
1574               (ediff-install-fine-diff-if-necessary n))
1575           )
1576         (message "")
1577         (ediff-unselect-and-select-difference n)
1578         ) ; let
1579     (ediff-visible-region)
1580     (error "At beginning of the difference list")))
1581
1582 ;; The diff number is as perceived by the user (i.e., 1+ the internal
1583 ;; representation)
1584 (defun ediff-jump-to-difference (difference-number)
1585   "Go to the difference specified as a prefix argument.
1586 If the prefix is negative, count differences from the end."
1587   (interactive "p")
1588   (ediff-barf-if-not-control-buffer)
1589   (setq difference-number
1590         (cond ((< difference-number 0)
1591                (+ ediff-number-of-differences difference-number))
1592               ((> difference-number 0) (1- difference-number))
1593               (t -1)))
1594   ;; -1 is allowed by ediff-unselect-and-select-difference --- it is the
1595   ;; position before the first one.
1596   (if (and (>= difference-number -1)
1597            (<= difference-number ediff-number-of-differences))
1598       (ediff-unselect-and-select-difference difference-number)
1599     (error ediff-BAD-DIFF-NUMBER
1600            this-command (1+ difference-number) ediff-number-of-differences)))
1601
1602 (defun ediff-jump-to-difference-at-point (arg)
1603   "Go to difference closest to the point in buffer A, B, or C.
1604 The buffer depends on last command character \(a, b, or c\) that invoked this
1605 command. For instance, if the command was `ga' then the point value in buffer A
1606 is used.
1607 With a prefix argument, synchronize all files around the current point position
1608 in the specified buffer."
1609   (interactive "P")
1610   (ediff-barf-if-not-control-buffer)
1611   (let* ((buf-type (ediff-char-to-buftype last-command-char))
1612          (buffer (ediff-get-buffer buf-type))
1613          (pt (ediff-eval-in-buffer buffer (point)))
1614          (diff-no (ediff-diff-at-point buf-type nil (if arg 'after)))
1615          (past-last-diff (< ediff-number-of-differences diff-no))
1616          (beg (if past-last-diff
1617                   (ediff-eval-in-buffer buffer (point-max))
1618                 (ediff-get-diff-posn buf-type 'beg (1- diff-no))))
1619          ctl-wind wind-A wind-B wind-C
1620          shift)
1621     (if past-last-diff
1622         (ediff-jump-to-difference -1)
1623       (ediff-jump-to-difference diff-no))
1624     (setq ctl-wind (selected-window)
1625           wind-A ediff-window-A
1626           wind-B ediff-window-B
1627           wind-C ediff-window-C)
1628     (if arg
1629         (progn
1630           (ediff-eval-in-buffer buffer
1631             (setq shift (- beg pt)))
1632           (select-window wind-A)
1633           (if past-last-diff (goto-char (point-max)))
1634           (condition-case nil
1635               (backward-char shift) ; noerror, if beginning of buffer
1636             (error))
1637           (recenter)
1638           (select-window wind-B)
1639           (if past-last-diff (goto-char (point-max)))
1640           (condition-case nil
1641               (backward-char shift) ; noerror, if beginning of buffer
1642             (error))
1643           (recenter)
1644           (if (window-live-p wind-C)
1645               (progn
1646                 (select-window wind-C)
1647                 (if past-last-diff (goto-char (point-max)))
1648                 (condition-case nil
1649                     (backward-char shift) ; noerror, if beginning of buffer
1650                   (error))
1651                 (recenter)
1652                 ))
1653           (select-window ctl-wind)
1654           ))
1655     ))
1656
1657
1658 ;; find region most related to the current point position (or POS, if given)
1659 ;; returns diff number as seen by the user (i.e., 1+ the internal
1660 ;; representation)
1661 ;; The optional argument WHICH-DIFF can be `after' or `before'. If `after',
1662 ;; find the diff after the point. If `before', find the diff before the
1663 ;; point. If the point is inside a diff, return that diff.
1664 (defun ediff-diff-at-point (buf-type &optional pos which-diff)
1665   (let ((buffer (ediff-get-buffer buf-type))
1666         (ctl-buffer ediff-control-buffer)
1667         (max-dif-num (1- ediff-number-of-differences))
1668         (diff-no -1)
1669         (prev-beg 0)
1670         (prev-end 0)
1671         (beg 0)
1672         (end 0))
1673
1674     (ediff-eval-in-buffer buffer
1675       (setq pos (or pos (point)))
1676       (while (and (or (< pos prev-beg) (> pos beg))
1677                   (< diff-no max-dif-num))
1678         (setq diff-no (1+ diff-no))
1679         (setq prev-beg beg
1680               prev-end end)
1681         (setq beg (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer)
1682               end (ediff-get-diff-posn buf-type 'end diff-no ctl-buffer))
1683         )
1684
1685       ;; boost diff-no by 1, if past the last diff region
1686       (if (and (memq which-diff '(after before))
1687                (> pos beg) (= diff-no max-dif-num))
1688           (setq diff-no (1+ diff-no)))
1689
1690       (cond ((eq which-diff 'after) (1+ diff-no))
1691             ((eq which-diff 'before) diff-no)
1692             ((< (abs (count-lines pos (max 1 prev-end)))
1693                 (abs (count-lines pos (max 1 beg))))
1694              diff-no)       ; choose prev difference
1695             (t
1696              (1+ diff-no))) ; choose next difference
1697      )))
1698
1699 \f
1700 ;;; Copying diffs.
1701
1702 (defun ediff-diff-to-diff (arg &optional keys)
1703   "Copy buffer-X'th difference region to buffer Y \(X,Y are A, B, or C\).
1704 If numerical prefix argument, copy the difference specified in the arg.
1705 Otherwise, copy the difference given by `ediff-current-difference'.
1706 This command assumes it is bound to a 2-character key sequence, `ab', `ba',
1707 `ac', etc., which is used to determine the types of buffers to be used for
1708 copying difference regions. The first character in the sequence specifies
1709 the source buffer and the second specifies the target.
1710
1711 If the second optional argument, a 2-character string, is given, use it to
1712 determine the source and the target buffers instead of the command keys."
1713   (interactive "P")
1714   (ediff-barf-if-not-control-buffer)
1715   (or keys (setq keys (this-command-keys)))
1716   (if (eq arg '-) (setq arg -1)) ; translate neg arg to -1
1717   (if (numberp arg) (ediff-jump-to-difference arg))
1718
1719   (let* ((key1 (aref keys 0))
1720          (key2 (aref keys 1))
1721          (char1 (if (and ediff-xemacs-p (eventp key1)) (event-key key1) key1))
1722          (char2 (if (and ediff-xemacs-p (eventp key1)) (event-key key2) key2))
1723          ediff-verbose-p)
1724     (ediff-copy-diff ediff-current-difference
1725                      (ediff-char-to-buftype char1)
1726                      (ediff-char-to-buftype char2))
1727     ;; recenter with rehighlighting, but no messages
1728     (ediff-recenter)))
1729
1730 (defun ediff-copy-A-to-B (arg)
1731   "Copy ARGth difference region from buffer A to B.
1732 ARG is a prefix argument. If nil, copy the current difference region."
1733   (interactive "P")
1734   (ediff-diff-to-diff arg "ab"))
1735
1736 (defun ediff-copy-B-to-A (arg)
1737   "Copy ARGth difference region from buffer B to A.
1738 ARG is a prefix argument. If nil, copy the current difference region."
1739   (interactive "P")
1740   (ediff-diff-to-diff arg "ba"))
1741
1742 (defun ediff-copy-A-to-C (arg)
1743   "Copy ARGth difference region from buffer A to buffer C.
1744 ARG is a prefix argument. If nil, copy the current difference region."
1745   (interactive "P")
1746   (ediff-diff-to-diff arg "ac"))
1747
1748 (defun ediff-copy-B-to-C (arg)
1749   "Copy ARGth difference region from buffer B to buffer C.
1750 ARG is a prefix argument. If nil, copy the current difference region."
1751   (interactive "P")
1752   (ediff-diff-to-diff arg "bc"))
1753
1754 (defun ediff-copy-C-to-B (arg)
1755   "Copy ARGth difference region from buffer C to B.
1756 ARG is a prefix argument. If nil, copy the current difference region."
1757   (interactive "P")
1758   (ediff-diff-to-diff arg "cb"))
1759
1760 (defun ediff-copy-C-to-A (arg)
1761   "Copy ARGth difference region from buffer C to A.
1762 ARG is a prefix argument. If nil, copy the current difference region."
1763   (interactive "P")
1764   (ediff-diff-to-diff arg "ca"))
1765
1766
1767
1768 ;; Copy diff N from FROM-BUF-TYPE \(given as A, B or C\) to TO-BUF-TYPE.
1769 ;; If optional DO-NOT-SAVE is non-nil, do not save the old value of the
1770 ;; target diff. This is used in merging, when constructing the merged
1771 ;; version.
1772 (defun ediff-copy-diff (n from-buf-type to-buf-type
1773                           &optional batch-invocation reg-to-copy)
1774   (let* ((to-buf (ediff-get-buffer to-buf-type))
1775          ;;(from-buf (if (not reg-to-copy) (ediff-get-buffer from-buf-type)))
1776          (ctrl-buf ediff-control-buffer)
1777          (saved-p t)
1778          (three-way ediff-3way-job)
1779          messg
1780          ediff-verbose-p
1781          reg-to-delete reg-to-delete-beg reg-to-delete-end)
1782
1783     (setq reg-to-delete-beg
1784           (ediff-get-diff-posn to-buf-type 'beg n ctrl-buf))
1785     (setq reg-to-delete-end
1786           (ediff-get-diff-posn to-buf-type 'end n ctrl-buf))
1787
1788     (if reg-to-copy
1789         (setq from-buf-type nil)
1790       (setq reg-to-copy (ediff-get-region-contents n from-buf-type ctrl-buf)))
1791
1792     (setq reg-to-delete (ediff-get-region-contents
1793                          n to-buf-type ctrl-buf
1794                          reg-to-delete-beg reg-to-delete-end))
1795
1796     (if (string= reg-to-delete reg-to-copy)
1797         (setq saved-p nil) ; don't copy identical buffers
1798       ;; seems ok to copy
1799       (if (or batch-invocation (ediff-test-save-region n to-buf-type))
1800           (condition-case conds
1801               (progn
1802                 (ediff-eval-in-buffer to-buf
1803                   ;; to prevent flags from interfering if buffer is writable
1804                   (let ((inhibit-read-only (null buffer-read-only)))
1805
1806                     (goto-char reg-to-delete-end)
1807                     (insert reg-to-copy)
1808
1809                     (if (> reg-to-delete-end reg-to-delete-beg)
1810                         (kill-region reg-to-delete-beg reg-to-delete-end))
1811                     ))
1812                 (or batch-invocation
1813                     (setq
1814                      messg
1815                      (ediff-save-diff-region n to-buf-type reg-to-delete))))
1816             (error (message "ediff-copy-diff: %s %s"
1817                             (car conds)
1818                             (mapconcat 'prin1-to-string (cdr conds) " "))
1819                    (beep 1)
1820                    (sit-for 2) ; let the user see the error msg
1821                    (setq saved-p nil)
1822                    )))
1823       )
1824
1825     ;; adjust state of difference in case 3-way and diff was copied ok
1826     (if (and saved-p three-way)
1827         (ediff-set-state-of-diff-in-all-buffers n ctrl-buf))
1828
1829     (if batch-invocation
1830         (ediff-clear-fine-differences n)
1831       ;; If diff3 job, we should recompute fine diffs so we clear them
1832       ;; before reinserting flags (and thus before ediff-recenter).
1833       (if (and saved-p three-way)
1834           (ediff-clear-fine-differences n))
1835
1836       (ediff-refresh-mode-lines)
1837
1838       ;; For diff2 jobs, don't recompute fine diffs, since we know there
1839       ;; aren't any. So we clear diffs after ediff-recenter.
1840       (if (and saved-p (not three-way))
1841           (ediff-clear-fine-differences n))
1842       ;; Make sure that the message about saving and how to restore is seen
1843       ;; by the user
1844       (message messg))
1845     ))
1846
1847 ;; Save Nth diff of buffer BUF-TYPE \(A, B, or C\).
1848 ;; That is to say, the Nth diff on the `ediff-killed-diffs-alist'.  REG
1849 ;; is the region to save.  It is redundant here, but is passed anyway, for
1850 ;; convenience.
1851 (defun ediff-save-diff-region (n buf-type reg)
1852   (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist))
1853          (buf (ediff-get-buffer buf-type))
1854          (this-buf-n-th-diff-saved (assoc buf (cdr n-th-diff-saved))))
1855
1856     (if this-buf-n-th-diff-saved
1857         ;; either nothing saved for n-th diff and buffer or we OK'ed
1858         ;; overriding
1859         (setcdr this-buf-n-th-diff-saved reg)
1860       (if n-th-diff-saved ;; n-th diff saved, but for another buffer
1861           (nconc n-th-diff-saved  (list (cons buf reg)))
1862         (setq ediff-killed-diffs-alist  ;; create record for n-th diff
1863               (cons (list n (cons buf reg))
1864                     ediff-killed-diffs-alist))))
1865     (message "Saving old diff region #%d of buffer %S. To recover, type `r%s'"
1866              (1+ n) buf-type
1867              (if ediff-merge-job
1868                  "" (downcase (symbol-name buf-type))))
1869     ))
1870
1871 ;; Test if saving Nth difference region of buffer BUF-TYPE is possible.
1872 (defun ediff-test-save-region (n buf-type)
1873   (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist))
1874          (buf (ediff-get-buffer buf-type))
1875          (this-buf-n-th-diff-saved (assoc buf (cdr n-th-diff-saved))))
1876
1877     (if this-buf-n-th-diff-saved
1878         (if (yes-or-no-p
1879              (format
1880               "You've previously copied diff region %d to buffer %S. Confirm "
1881               (1+ n) buf-type))
1882             t
1883           (error "Quit"))
1884       t)))
1885
1886 (defun ediff-pop-diff (n buf-type)
1887   "Pop last killed Nth diff region from buffer BUF-TYPE."
1888   (let* ((n-th-record (assoc n ediff-killed-diffs-alist))
1889          (buf (ediff-get-buffer buf-type))
1890          (saved-rec (assoc buf (cdr n-th-record)))
1891          (three-way ediff-3way-job)
1892          (ctl-buf ediff-control-buffer)
1893          ediff-verbose-p
1894          saved-diff reg-beg reg-end recovered)
1895
1896     (if (cdr saved-rec)
1897         (setq saved-diff (cdr saved-rec))
1898       (if (> ediff-number-of-differences 0)
1899           (error "Nothing saved for diff %d in buffer %S" (1+ n) buf-type)
1900         (error ediff-NO-DIFFERENCES)))
1901
1902     (setq reg-beg (ediff-get-diff-posn buf-type 'beg n ediff-control-buffer))
1903     (setq reg-end (ediff-get-diff-posn buf-type 'end n ediff-control-buffer))
1904
1905     (condition-case conds
1906         (ediff-eval-in-buffer buf
1907           (let ((inhibit-read-only (null buffer-read-only)))
1908
1909             (goto-char reg-end)
1910             (insert saved-diff)
1911
1912             (if (> reg-end reg-beg)
1913                 (kill-region reg-beg reg-end))
1914
1915             (setq recovered t)
1916             ))
1917       (error (message "ediff-pop-diff: %s %s"
1918                       (car conds)
1919                       (mapconcat 'prin1-to-string (cdr conds) " "))
1920              (beep 1)))
1921
1922     ;; Clearing fine diffs is necessary for
1923     ;; ediff-unselect-and-select-difference to properly recompute them. We
1924     ;; can't rely on ediff-copy-diff to clear this vector, as the user might
1925     ;; have modified diff regions after copying and, thus, may have recomputed
1926     ;; fine diffs.
1927     (if recovered
1928         (ediff-clear-fine-differences n))
1929
1930     ;; adjust state of difference
1931     (if (and three-way recovered)
1932         (ediff-set-state-of-diff-in-all-buffers n ctl-buf))
1933
1934     (ediff-refresh-mode-lines)
1935
1936     (if recovered
1937         (progn
1938           (setq n-th-record (delq saved-rec n-th-record))
1939           (message "Diff region %d in buffer %S restored" (1+ n) buf-type)
1940           ))
1941     ))
1942
1943 (defun ediff-restore-diff  (arg &optional key)
1944   "Restore ARGth diff from `ediff-killed-diffs-alist'.
1945 ARG is a prefix argument.  If ARG is nil, restore the current-difference.
1946 If the second optional argument, a character, is given, use it to
1947 determine the target buffer instead of last-command-char"
1948   (interactive "P")
1949   (ediff-barf-if-not-control-buffer)
1950   (if (numberp arg)
1951       (ediff-jump-to-difference arg))
1952   (ediff-pop-diff ediff-current-difference
1953                   (ediff-char-to-buftype (or key last-command-char)))
1954   ;; recenter with rehighlighting, but no messages
1955   (let (ediff-verbose-p)
1956     (ediff-recenter)))
1957
1958 (defun ediff-restore-diff-in-merge-buffer (arg)
1959   "Restore ARGth diff in the merge buffer.
1960 ARG is a prefix argument. If nil, restore the current diff."
1961   (interactive "P")
1962   (ediff-restore-diff arg ?c))
1963
1964
1965 (defun ediff-toggle-regexp-match ()
1966   "Toggle between focusing and hiding of difference regions that match
1967 a regular expression typed in by the user."
1968   (interactive)
1969   (ediff-barf-if-not-control-buffer)
1970   (let ((regexp-A "")
1971         (regexp-B "")
1972         (regexp-C "")
1973         msg-connective alt-msg-connective alt-connective)
1974     (cond
1975      ((or (and (eq ediff-skip-diff-region-function
1976                    ediff-focus-on-regexp-matches-function)
1977                (eq last-command-char ?f))
1978           (and (eq ediff-skip-diff-region-function
1979                    ediff-hide-regexp-matches-function)
1980                (eq last-command-char ?h)))
1981       (message "Selective browsing by regexp turned off")
1982       (setq ediff-skip-diff-region-function 'ediff-show-all-diffs))
1983      ((eq last-command-char ?h)
1984       (setq ediff-skip-diff-region-function ediff-hide-regexp-matches-function
1985             regexp-A
1986             (read-string
1987              (format
1988               "Ignore A-regions matching this regexp (default \"%s\"): "
1989               ediff-regexp-hide-A))
1990             regexp-B
1991             (read-string
1992              (format
1993               "Ignore B-regions matching this regexp (default \"%s\"): "
1994               ediff-regexp-hide-B)))
1995       (if ediff-3way-comparison-job
1996           (setq regexp-C
1997                 (read-string
1998                  (format
1999                   "Ignore C-regions matching this regexp (default \"%s\"): "
2000                   ediff-regexp-hide-C))))
2001       (if (eq ediff-hide-regexp-connective 'and)
2002           (setq msg-connective "BOTH"
2003                 alt-msg-connective "ONE OF"
2004                 alt-connective 'or)
2005         (setq msg-connective "ONE OF"
2006               alt-msg-connective "BOTH"
2007               alt-connective 'and))
2008       (if (y-or-n-p
2009            (format
2010             "Ignore regions that match %s regexps, OK? "
2011             msg-connective alt-msg-connective))
2012           (message "Will ignore regions that match %s regexps" msg-connective)
2013         (setq ediff-hide-regexp-connective alt-connective)
2014         (message "Will ignore regions that match %s regexps"
2015                  alt-msg-connective))
2016
2017       (or (string= regexp-A "") (setq ediff-regexp-hide-A regexp-A))
2018       (or (string= regexp-B "") (setq ediff-regexp-hide-B regexp-B))
2019       (or (string= regexp-C "") (setq ediff-regexp-hide-C regexp-C)))
2020
2021      ((eq last-command-char ?f)
2022       (setq ediff-skip-diff-region-function
2023             ediff-focus-on-regexp-matches-function
2024             regexp-A
2025             (read-string
2026              (format
2027               "Focus on A-regions matching this regexp (default \"%s\"): "
2028               ediff-regexp-focus-A))
2029             regexp-B
2030             (read-string
2031              (format
2032               "Focus on B-regions matching this regexp (default \"%s\"): "
2033               ediff-regexp-focus-B)))
2034       (if ediff-3way-comparison-job
2035           (setq regexp-C
2036                 (read-string
2037                  (format
2038                   "Focus on C-regions matching this regexp (default \"%s\"): "
2039                   ediff-regexp-focus-C))))
2040       (if (eq ediff-focus-regexp-connective 'and)
2041           (setq msg-connective "BOTH"
2042                 alt-msg-connective "ONE OF"
2043                 alt-connective 'or)
2044         (setq msg-connective "ONE OF"
2045               alt-msg-connective "BOTH"
2046               alt-connective 'and))
2047       (if (y-or-n-p
2048            (format
2049             "Focus on regions that match %s regexps, OK? "
2050             msg-connective alt-msg-connective))
2051           (message "Will focus on regions that match %s regexps"
2052                    msg-connective)
2053         (setq ediff-focus-regexp-connective alt-connective)
2054         (message "Will focus on regions that match %s regexps"
2055                  alt-msg-connective))
2056
2057       (or (string= regexp-A "") (setq ediff-regexp-focus-A regexp-A))
2058       (or (string= regexp-B "") (setq ediff-regexp-focus-B regexp-B))
2059       (or (string= regexp-C "") (setq ediff-regexp-focus-C regexp-C))))))
2060
2061 (defun ediff-toggle-skip-similar ()
2062   (interactive)
2063   (ediff-barf-if-not-control-buffer)
2064   (if (not (eq ediff-auto-refine 'on))
2065       (error
2066        "Can't skip over whitespace regions: first turn auto-refining on"))
2067   (setq ediff-ignore-similar-regions (not ediff-ignore-similar-regions))
2068   (if ediff-ignore-similar-regions
2069       (message
2070        "Skipping regions that differ only in white space & line breaks")
2071     (message "Skipping over white-space differences turned off")))
2072
2073 (defun ediff-focus-on-regexp-matches (n)
2074   "Focus on diffs that match regexp `ediff-regexp-focus-A/B'.
2075 Regions to be ignored according to this function are those where
2076 buf A region doesn't match `ediff-regexp-focus-A' and buf B region
2077 doesn't match `ediff-regexp-focus-B'.
2078 This function returns nil if the region number N (specified as
2079 an argument) is not to be ignored and t if region N is to be ignored.
2080
2081 N is a region number used by Ediff internally. It is 1 less
2082 the number seen by the user."
2083   (if (ediff-valid-difference-p n)
2084       (let* ((ctl-buf ediff-control-buffer)
2085              (regex-A ediff-regexp-focus-A)
2086              (regex-B ediff-regexp-focus-B)
2087              (regex-C ediff-regexp-focus-C)
2088              (reg-A-match (ediff-eval-in-buffer ediff-buffer-A
2089                             (save-restriction
2090                               (narrow-to-region
2091                                (ediff-get-diff-posn 'A 'beg n ctl-buf)
2092                                (ediff-get-diff-posn 'A 'end n ctl-buf))
2093                               (goto-char (point-min))
2094                               (re-search-forward regex-A nil t))))
2095              (reg-B-match (ediff-eval-in-buffer ediff-buffer-B
2096                             (save-restriction
2097                               (narrow-to-region
2098                                (ediff-get-diff-posn 'B 'beg n ctl-buf)
2099                                (ediff-get-diff-posn 'B 'end n ctl-buf))
2100                               (re-search-forward regex-B nil t))))
2101              (reg-C-match (if ediff-3way-comparison-job
2102                               (ediff-eval-in-buffer ediff-buffer-C
2103                                 (save-restriction
2104                                   (narrow-to-region
2105                                    (ediff-get-diff-posn 'C 'beg n ctl-buf)
2106                                    (ediff-get-diff-posn 'C 'end n ctl-buf))
2107                                   (re-search-forward regex-C nil t))))))
2108         (not (eval (if ediff-3way-comparison-job
2109                        (list ediff-focus-regexp-connective
2110                              reg-A-match reg-B-match reg-C-match)
2111                      (list ediff-focus-regexp-connective
2112                            reg-A-match reg-B-match))))
2113         )))
2114
2115 (defun ediff-hide-regexp-matches (n)
2116   "Hide diffs that match regexp `ediff-regexp-hide-A/B/C'.
2117 Regions to be ignored are those where buf A region matches
2118 `ediff-regexp-hide-A' and buf B region matches `ediff-regexp-hide-B'.
2119 This function returns nil if the region number N (specified as
2120 an argument) is not to be ignored and t if region N is to be ignored.
2121
2122 N is a region number used by Ediff internally. It is 1 less
2123 the number seen by the user."
2124   (if (ediff-valid-difference-p n)
2125       (let* ((ctl-buf ediff-control-buffer)
2126              (regex-A ediff-regexp-hide-A)
2127              (regex-B ediff-regexp-hide-B)
2128              (regex-C ediff-regexp-hide-C)
2129              (reg-A-match (ediff-eval-in-buffer ediff-buffer-A
2130                             (save-restriction
2131                               (narrow-to-region
2132                                (ediff-get-diff-posn 'A 'beg n ctl-buf)
2133                                (ediff-get-diff-posn 'A 'end n ctl-buf))
2134                               (goto-char (point-min))
2135                               (re-search-forward regex-A nil t))))
2136              (reg-B-match (ediff-eval-in-buffer ediff-buffer-B
2137                             (save-restriction
2138                               (narrow-to-region
2139                                (ediff-get-diff-posn 'B 'beg n ctl-buf)
2140                                (ediff-get-diff-posn 'B 'end n ctl-buf))
2141                               (goto-char (point-min))
2142                               (re-search-forward regex-B nil t))))
2143              (reg-C-match (if ediff-3way-comparison-job
2144                               (ediff-eval-in-buffer ediff-buffer-C
2145                                 (save-restriction
2146                                   (narrow-to-region
2147                                    (ediff-get-diff-posn 'C 'beg n ctl-buf)
2148                                    (ediff-get-diff-posn 'C 'end n ctl-buf))
2149                                   (goto-char (point-min))
2150                                   (re-search-forward regex-C nil t))))))
2151         (eval (if ediff-3way-comparison-job
2152                   (list ediff-hide-regexp-connective
2153                         reg-A-match reg-B-match reg-C-match)
2154                 (list ediff-hide-regexp-connective reg-A-match reg-B-match)))
2155         )))
2156
2157
2158 \f
2159 ;;; Quitting, suspending, etc.
2160
2161 (defun ediff-quit (reverse-default-keep-variants)
2162   "Finish an Ediff session and exit Ediff.
2163 Unselects the selected difference, if any, restores the read-only and modified
2164 flags of the compared file buffers, kills Ediff buffers for this session
2165 \(but not buffers A, B, C\).
2166
2167 If `ediff-keep-variants' is nil, the user will be asked whether the buffers
2168 containing the variants should be removed \(if they haven't been modified\).
2169 If it is t, they will be preserved unconditionally. A prefix argument,
2170 temporarily reverses the meaning of this variable."
2171   (interactive "P")
2172   (ediff-barf-if-not-control-buffer)
2173   (if (y-or-n-p (format "Quit this Ediff session%s? "
2174                         (if (ediff-buffer-live-p ediff-meta-buffer)
2175                             " & show containing session group" "")))
2176       (progn
2177         (message "")
2178         (ediff-really-quit reverse-default-keep-variants))
2179     (message "")))
2180
2181
2182 ;; Perform the quit operations.
2183 (defun ediff-really-quit (reverse-default-keep-variants)
2184   (ediff-unhighlight-diffs-totally)
2185   (ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
2186   (ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
2187   (ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
2188   (ediff-clear-diff-vector 'ediff-difference-vector-Ancestor 'fine-diffs-also)
2189
2190   (ediff-delete-temp-files)
2191
2192   ;; Restore visibility range. This affects only ediff-*-regions/windows.
2193   ;; Since for other job names ediff-visible-region sets
2194   ;; ediff-visible-bounds to ediff-wide-bounds, the settings below are
2195   ;; ignored for such jobs.
2196   (if ediff-quit-widened
2197       (setq ediff-visible-bounds ediff-wide-bounds)
2198     (setq ediff-visible-bounds ediff-narrow-bounds))
2199
2200   ;; Apply selective display to narrow or widen
2201   (ediff-visible-region)
2202   (mapcar (function (lambda (overl)
2203                       (if (ediff-overlayp overl)
2204                           (ediff-delete-overlay overl))))
2205           ediff-wide-bounds)
2206   (mapcar (function (lambda (overl)
2207                       (if (ediff-overlayp overl)
2208                           (ediff-delete-overlay overl))))
2209           ediff-narrow-bounds)
2210
2211   ;; restore buffer mode line id's in buffer-A/B/C
2212   (let ((control-buffer ediff-control-buffer)
2213         (meta-buffer ediff-meta-buffer)
2214         ;; suitable working frame
2215         (warp-frame (if (and (ediff-window-display-p) (eq ediff-grab-mouse t))
2216                         (cond ((window-live-p ediff-window-A)
2217                                (window-frame ediff-window-A))
2218                               ((window-live-p ediff-window-B)
2219                                (window-frame ediff-window-B))
2220                               (t (next-frame))))))
2221     (condition-case nil
2222         (ediff-eval-in-buffer ediff-buffer-A
2223           (setq ediff-this-buffer-ediff-sessions
2224                 (delq control-buffer ediff-this-buffer-ediff-sessions))
2225           (kill-local-variable 'mode-line-buffer-identification)
2226           (kill-local-variable 'mode-line-format)
2227           )
2228       (error))
2229
2230     (condition-case nil
2231         (ediff-eval-in-buffer ediff-buffer-B
2232           (setq ediff-this-buffer-ediff-sessions
2233                 (delq control-buffer ediff-this-buffer-ediff-sessions))
2234           (kill-local-variable 'mode-line-buffer-identification)
2235           (kill-local-variable 'mode-line-format)
2236           )
2237       (error))
2238
2239     (condition-case nil
2240         (ediff-eval-in-buffer ediff-buffer-C
2241           (setq ediff-this-buffer-ediff-sessions
2242                 (delq control-buffer ediff-this-buffer-ediff-sessions))
2243           (kill-local-variable 'mode-line-buffer-identification)
2244           (kill-local-variable 'mode-line-format)
2245           )
2246       (error))
2247
2248     (condition-case nil
2249         (ediff-eval-in-buffer ediff-ancestor-buffer
2250           (setq ediff-this-buffer-ediff-sessions
2251                 (delq control-buffer ediff-this-buffer-ediff-sessions))
2252           (kill-local-variable 'mode-line-buffer-identification)
2253           (kill-local-variable 'mode-line-format)
2254           )
2255       (error))
2256
2257   (setq ediff-session-registry
2258         (delq ediff-control-buffer ediff-session-registry))
2259   (ediff-update-registry)
2260   ;; restore state of buffers to what it was before ediff
2261   (ediff-restore-protected-variables)
2262
2263   ;; If the user interrupts (canceling saving the merge buffer), continue
2264   ;; normally.
2265   (condition-case nil
2266       (if (ediff-merge-job)
2267           (run-hooks 'ediff-quit-merge-hook))
2268     (quit))
2269
2270   ;; good place to kill buffers A/B/C
2271   (run-hooks 'ediff-cleanup-hook)
2272   (let ((ediff-keep-variants ediff-keep-variants))
2273     (if reverse-default-keep-variants
2274         (setq ediff-keep-variants (not ediff-keep-variants)))
2275     (or ediff-keep-variants (ediff-janitor 'ask)))
2276
2277   (run-hooks 'ediff-quit-hook)
2278   (ediff-cleanup-meta-buffer meta-buffer)
2279
2280   ;; warp mouse into a working window
2281   (setq warp-frame  ; if mouse is over a reasonable frame, use it
2282         (cond ((and ediff-xemacs-p (window-live-p (car (mouse-position))))
2283                (window-frame (car (mouse-position))))
2284               ((frame-live-p (car (mouse-position)))
2285                (car (mouse-position)))
2286               (t warp-frame)))
2287   (if (frame-live-p warp-frame)
2288       (set-mouse-position (if ediff-emacs-p
2289                               warp-frame
2290                             (frame-selected-window warp-frame))
2291                           2 1))
2292
2293   (if (ediff-buffer-live-p meta-buffer)
2294       (ediff-show-meta-buffer meta-buffer))
2295   ))
2296
2297
2298 (defun ediff-delete-temp-files ()
2299   (if (stringp ediff-temp-file-A)
2300       (delete-file ediff-temp-file-A))
2301   (if (stringp ediff-temp-file-B)
2302       (delete-file ediff-temp-file-B))
2303   (if (stringp ediff-temp-file-C)
2304       (delete-file ediff-temp-file-C)))
2305
2306
2307 ;; Kill control buffer, other auxiliary Ediff buffers.
2308 ;; Leave one of the frames split between buffers A/B/C
2309 (defun ediff-cleanup-mess ()
2310   (let ((buff-A ediff-buffer-A)
2311         (buff-B ediff-buffer-B)
2312         (buff-C ediff-buffer-C)
2313         (ctl-buf  ediff-control-buffer)
2314         (ctl-frame ediff-control-frame)
2315         (three-way-job ediff-3way-job))
2316
2317     (ediff-kill-buffer-carefully ediff-diff-buffer)
2318     (ediff-kill-buffer-carefully ediff-custom-diff-buffer)
2319     (ediff-kill-buffer-carefully ediff-fine-diff-buffer)
2320     (ediff-kill-buffer-carefully ediff-tmp-buffer)
2321     (ediff-kill-buffer-carefully ediff-error-buffer)
2322     (ediff-kill-buffer-carefully ediff-patch-diagnostics)
2323     (ediff-kill-buffer-carefully ediff-msg-buffer)
2324     (ediff-kill-buffer-carefully ediff-debug-buffer)
2325
2326     (if (and (ediff-window-display-p) (frame-live-p ctl-frame))
2327         (delete-frame ctl-frame))
2328     ;; Hide bottom toolbar.  --marcpa
2329     (if (not (ediff-multiframe-setup-p))
2330         (ediff-kill-bottom-toolbar))
2331
2332     (ediff-kill-buffer-carefully ctl-buf)
2333
2334     (delete-other-windows)
2335
2336     ;; display only if not visible
2337     (condition-case nil
2338         (or (ediff-get-visible-buffer-window buff-B)
2339             (switch-to-buffer buff-B))
2340       (error))
2341     (condition-case nil
2342         (or (ediff-get-visible-buffer-window buff-A)
2343             (progn
2344               (if (ediff-get-visible-buffer-window buff-B)
2345                   (funcall ediff-split-window-function))
2346               (switch-to-buffer buff-A)))
2347       (error))
2348     (if three-way-job
2349         (condition-case nil
2350             (or (ediff-get-visible-buffer-window buff-C)
2351                 (progn
2352                   (if (or (ediff-get-visible-buffer-window buff-A)
2353                           (ediff-get-visible-buffer-window buff-B))
2354                       (funcall ediff-split-window-function))
2355                   (switch-to-buffer buff-C)
2356                   (balance-windows)))
2357           (error)))
2358     (message "")
2359     ))
2360
2361 (defun ediff-janitor (&optional ask)
2362   "Kill buffers A, B, and, possibly, C, if these buffers aren't modified.
2363 In merge jobs, buffer C is never deleted.
2364 However, the side effect of cleaning up may be that you cannot compare the same
2365 buffer in two separate Ediff sessions: quitting one of them will delete this
2366 buffer in another session as well."
2367   (or (not (ediff-buffer-live-p ediff-buffer-A))
2368       (buffer-modified-p ediff-buffer-A)
2369       (and ask
2370            (not (y-or-n-p (format "Kill buffer A [%s]? "
2371                                   (buffer-name ediff-buffer-A)))))
2372       (ediff-kill-buffer-carefully ediff-buffer-A))
2373   (or (not (ediff-buffer-live-p ediff-buffer-B))
2374       (buffer-modified-p ediff-buffer-B)
2375       (and ask
2376            (not (y-or-n-p (format "Kill buffer B [%s]? "
2377                                   (buffer-name ediff-buffer-B)))))
2378       (ediff-kill-buffer-carefully ediff-buffer-B))
2379   (if ediff-merge-job  ; don't del buf C if merging--del ancestor buf instead
2380       (or (not (ediff-buffer-live-p ediff-ancestor-buffer))
2381           (buffer-modified-p ediff-ancestor-buffer)
2382           (and ask
2383                (not (y-or-n-p (format "Kill the ancestor buffer [%s]? "
2384                                       (buffer-name ediff-ancestor-buffer)))))
2385           (ediff-kill-buffer-carefully ediff-ancestor-buffer))
2386     (or (not (ediff-buffer-live-p ediff-buffer-C))
2387         (buffer-modified-p ediff-buffer-C)
2388         (and ask (not (y-or-n-p (format "Kill buffer C [%s]? "
2389                                         (buffer-name ediff-buffer-C)))))
2390         (ediff-kill-buffer-carefully ediff-buffer-C))))
2391
2392 (defun ediff-maybe-save-and-delete-merge ()
2393   "Default hook to run on quitting a merge job.
2394 If `ediff-autostore-merges' is nil, this does nothing.
2395 If it is t, it saves the merge buffer in the file `ediff-merge-store-file'
2396 or asks the user, if the latter is nil. It then then asks the user whether to
2397 delete the merge buffer.
2398 If `ediff-autostore-merges' is neither nil nor t, the merge buffer is saved
2399 only if this merge job is part of a group, i.e., was invoked from within
2400 `ediff-merge-directories', `ediff-merge-directory-revisions', and such."
2401   (let ((merge-store-file ediff-merge-store-file))
2402     (if ediff-autostore-merges
2403         (cond ((stringp ediff-merge-store-file)
2404                ;; store, ask to delete
2405                (ediff-write-merge-buffer-then-kill
2406                 ediff-buffer-C merge-store-file 'show-file))
2407               ((eq ediff-autostore-merges t)
2408                ;; ask for file name
2409                (setq merge-store-file
2410                      (read-file-name "Save the result of the merge in: "))
2411                (ediff-write-merge-buffer-then-kill
2412                 ediff-buffer-C merge-store-file))
2413               ((and (ediff-buffer-live-p ediff-meta-buffer)
2414                     (ediff-eval-in-buffer ediff-meta-buffer
2415                       (ediff-merge-metajob)))
2416                ;; This case shouldn't occur, as the parent metajob must pass on
2417                ;; a file name, ediff-merge-store-file, where to save the result
2418                ;; of the merge.
2419                ;; Ask where to save anyway--will decide what to do here later.
2420                (setq merge-store-file
2421                      (read-file-name "The result of the merge goes into: "))
2422                (ediff-write-merge-buffer-then-kill
2423                 ediff-buffer-C merge-store-file))))
2424     ))
2425
2426 (defun ediff-write-merge-buffer-then-kill (buf file &optional show-file)
2427   (ediff-eval-in-buffer buf
2428     (if (or (not (file-exists-p file))
2429             (y-or-n-p (format "File %s exists, overwrite? " file)))
2430         (progn
2431           (write-region (point-min) (point-max) file)
2432           (if show-file
2433               (progn
2434                 (message "Merge buffer saved in: %s" file)
2435                 (sit-for 2)))
2436           (if (y-or-n-p "Merge buffer saved in file. Now kill the buffer? ")
2437               (ediff-kill-buffer-carefully buf))))))
2438
2439 ;; The default way of suspending Ediff.
2440 ;; Buries Ediff buffers, kills all windows.
2441 (defun ediff-default-suspend-function ()
2442   (let* ((buf-A ediff-buffer-A)
2443          (buf-B ediff-buffer-B)
2444          (buf-C ediff-buffer-C)
2445          (buf-A-wind (ediff-get-visible-buffer-window buf-A))
2446          (buf-B-wind (ediff-get-visible-buffer-window buf-B))
2447          (buf-C-wind (ediff-get-visible-buffer-window buf-C))
2448          (buf-patch  ediff-patchbufer)
2449          (buf-patch-diag ediff-patch-diagnostics)
2450          (buf-err  ediff-error-buffer)
2451          (buf-diff ediff-diff-buffer)
2452          (buf-custom-diff ediff-custom-diff-buffer)
2453          (buf-fine-diff ediff-fine-diff-buffer))
2454
2455     ;; hide the control panel
2456     (if (and (ediff-window-display-p) (frame-live-p ediff-control-frame))
2457         (iconify-frame ediff-control-frame)
2458       (bury-buffer))
2459     (if buf-err (bury-buffer buf-err))
2460     (if buf-diff (bury-buffer buf-diff))
2461     (if buf-custom-diff (bury-buffer buf-custom-diff))
2462     (if buf-fine-diff (bury-buffer buf-fine-diff))
2463     (if buf-patch (bury-buffer buf-patch))
2464     (if buf-patch-diag (bury-buffer buf-patch-diag))
2465     (if (window-live-p buf-A-wind)
2466         (progn
2467           (select-window buf-A-wind)
2468           (delete-other-windows)
2469           (bury-buffer))
2470       (if (ediff-buffer-live-p buf-A) (bury-buffer buf-A)))
2471     (if (window-live-p buf-B-wind)
2472         (progn
2473           (select-window buf-B-wind)
2474           (delete-other-windows)
2475           (bury-buffer))
2476       (if (ediff-buffer-live-p buf-B) (bury-buffer buf-B)))
2477     (if (window-live-p buf-C-wind)
2478         (progn
2479           (select-window buf-C-wind)
2480           (delete-other-windows)
2481           (bury-buffer))
2482       (if (ediff-buffer-live-p buf-C) (bury-buffer buf-C)))
2483
2484     ))
2485
2486
2487 (defun ediff-suspend ()
2488   "Suspend Ediff.
2489 To resume, switch to the appropriate `Ediff Control Panel'
2490 buffer and then type \\[ediff-recenter].  Ediff will automatically set
2491 up an appropriate window config."
2492   (interactive)
2493   (ediff-barf-if-not-control-buffer)
2494   (run-hooks 'ediff-suspend-hook)
2495   (message
2496    "To resume, type M-x eregistry and select the desired Ediff session"))
2497
2498
2499 (defun ediff-status-info ()
2500   "Show the names of the buffers or files being operated on by Ediff.
2501 Hit \\[ediff-recenter] to reset the windows afterward."
2502   (interactive)
2503   (ediff-barf-if-not-control-buffer)
2504   (save-excursion
2505     (ediff-skip-unsuitable-frames))
2506   (with-output-to-temp-buffer ediff-msg-buffer
2507     (raise-frame (selected-frame))
2508     (princ (ediff-version))
2509     (princ "\n\n")
2510     (ediff-eval-in-buffer ediff-buffer-A
2511       (if buffer-file-name
2512           (princ
2513            (format "File A = %S\n" buffer-file-name))
2514         (princ
2515          (format "Buffer A = %S\n" (buffer-name)))))
2516     (ediff-eval-in-buffer ediff-buffer-B
2517       (if buffer-file-name
2518           (princ
2519            (format "File B = %S\n" buffer-file-name))
2520         (princ
2521          (format "Buffer B = %S\n" (buffer-name)))))
2522     (if ediff-3way-job
2523         (ediff-eval-in-buffer ediff-buffer-C
2524           (if buffer-file-name
2525               (princ
2526                (format "File C = %S\n" buffer-file-name))
2527             (princ
2528              (format "Buffer C = %S\n" (buffer-name))))))
2529     (princ (format "Customized diff output %s\n"
2530                    (if (ediff-buffer-live-p ediff-custom-diff-buffer)
2531                        (concat "\tin buffer "
2532                                (buffer-name ediff-custom-diff-buffer))
2533                      "is not available")))
2534     (princ (format "Plain diff output %s\n"
2535                    (if (ediff-buffer-live-p ediff-diff-buffer)
2536                        (concat "\tin buffer "
2537                                (buffer-name ediff-diff-buffer))
2538                      "is not available")))
2539
2540     (let* ((A-line (ediff-eval-in-buffer ediff-buffer-A
2541                      (1+ (count-lines (point-min) (point)))))
2542            (B-line (ediff-eval-in-buffer ediff-buffer-B
2543                      (1+ (count-lines (point-min) (point)))))
2544            C-line)
2545       (princ (format "\Buffer A's point is on line %d\n" A-line))
2546       (princ (format "Buffer B's point is on line %d\n" B-line))
2547       (if ediff-3way-job
2548           (progn
2549             (setq C-line (ediff-eval-in-buffer ediff-buffer-C
2550                            (1+ (count-lines (point-min) (point)))))
2551             (princ (format "Buffer C's point is on line %d\n" C-line)))))
2552
2553     (princ (format "\nCurrent difference number = %S\n"
2554                    (cond ((< ediff-current-difference 0) 'start)
2555                          ((>= ediff-current-difference
2556                               ediff-number-of-differences) 'end)
2557                          (t (1+ ediff-current-difference)))))
2558
2559     (princ
2560      (format "\n%s regions that differ only in white space & line breaks"
2561              (if ediff-ignore-similar-regions
2562                  "Skipping" "Not skipping")))
2563     (if (and ediff-merge-job ediff-show-clashes-only)
2564         (princ
2565          "\nFocusing on regions where both buffers differ from the ancestor"))
2566
2567     (cond ((eq ediff-skip-diff-region-function 'ediff-show-all-diffs)
2568            (princ "\nSelective browsing by regexp is off\n"))
2569           ((eq ediff-skip-diff-region-function
2570                ediff-hide-regexp-matches-function)
2571            (princ
2572             "\nIgnoring regions that match")
2573            (princ
2574             (format
2575              "\n\t regexp `%s' in buffer A  %S\n\t regexp `%s' in buffer B\n"
2576              ediff-regexp-hide-A ediff-hide-regexp-connective
2577              ediff-regexp-hide-B)))
2578           ((eq ediff-skip-diff-region-function
2579                ediff-focus-on-regexp-matches-function)
2580            (princ
2581             "\nFocusing on regions that match")
2582            (princ
2583             (format
2584              "\n\t regexp `%s' in buffer A  %S\n\t regexp `%s' in buffer B\n"
2585              ediff-regexp-focus-A ediff-focus-regexp-connective
2586              ediff-regexp-focus-B)))
2587           (t (princ "\nSelective browsing via a user-defined method.\n")))
2588
2589     (princ
2590      (format "\nBugs/suggestions: type `%s' while in Ediff Control Panel."
2591              (substitute-command-keys "\\[ediff-submit-report]")))
2592     ) ; with output
2593   (if (frame-live-p ediff-control-frame)
2594       (ediff-reset-mouse ediff-control-frame))
2595   (if (window-live-p ediff-control-window)
2596       (select-window ediff-control-window)))
2597
2598
2599
2600 \f
2601 ;;; Support routines
2602
2603 ;; Select a difference by placing the ASCII flags around the appropriate
2604 ;; group of lines in the A, B buffers
2605 ;; This may have to be modified for buffer C, when it will be supported.
2606 (defun ediff-select-difference (n)
2607   (if (and (ediff-buffer-live-p ediff-buffer-A)
2608            (ediff-buffer-live-p ediff-buffer-B)
2609            (ediff-valid-difference-p n))
2610       (progn
2611         (if (and (ediff-has-face-support-p) ediff-use-faces)
2612             (progn
2613               (ediff-highlight-diff n)
2614               (setq ediff-highlighting-style 'face))
2615           (setq ediff-highlighting-style 'ascii)
2616           (ediff-place-flags-in-buffer
2617            'A ediff-buffer-A ediff-control-buffer n)
2618           (ediff-place-flags-in-buffer
2619            'B ediff-buffer-B ediff-control-buffer n)
2620           (if ediff-3way-job
2621               (ediff-place-flags-in-buffer
2622                'C ediff-buffer-C ediff-control-buffer n))
2623           (if (ediff-buffer-live-p ediff-ancestor-buffer)
2624               (ediff-place-flags-in-buffer
2625                'Ancestor ediff-ancestor-buffer
2626                ediff-control-buffer n))
2627           )
2628
2629         (ediff-install-fine-diff-if-necessary n)
2630         (run-hooks 'ediff-select-hook))))
2631
2632
2633 ;; Unselect a difference by removing the ASCII flags in the buffers.
2634 ;; This may have to be modified for buffer C, when it will be supported.
2635 (defun ediff-unselect-difference (n)
2636   (if (ediff-valid-difference-p n)
2637       (progn
2638         (cond ((and (ediff-has-face-support-p) ediff-use-faces)
2639                (ediff-unhighlight-diff))
2640               ((eq ediff-highlighting-style 'ascii)
2641                (ediff-remove-flags-from-buffer
2642                 ediff-buffer-A
2643                 (ediff-get-diff-overlay n 'A))
2644                (ediff-remove-flags-from-buffer
2645                 ediff-buffer-B
2646                 (ediff-get-diff-overlay n 'B))
2647                (if ediff-3way-job
2648                    (ediff-remove-flags-from-buffer
2649                     ediff-buffer-C
2650                     (ediff-get-diff-overlay n 'C)))
2651                (if (ediff-buffer-live-p ediff-ancestor-buffer)
2652                    (ediff-remove-flags-from-buffer
2653                     ediff-ancestor-buffer
2654                     (ediff-get-diff-overlay n 'Ancestor)))
2655                ))
2656         (setq ediff-highlighting-style nil)
2657
2658         ;; unhighlight fine diffs
2659         (ediff-set-fine-diff-properties ediff-current-difference 'default)
2660         (run-hooks 'ediff-unselect-hook))))
2661
2662
2663 ;; Unselects prev diff and selects a new one, if FLAG has value other than
2664 ;; 'select-only or 'unselect-only.  If FLAG is 'select-only, the
2665 ;; next difference is selected, but the current selection is not
2666 ;; unselected.  If FLAG is 'unselect-only then the current selection is
2667 ;; unselected, but the next one is not selected.  If NO-RECENTER is non-nil,
2668 ;; don't recenter buffers after selecting/unselecting.
2669 (defun ediff-unselect-and-select-difference (n &optional flag no-recenter)
2670   (let ((ediff-current-difference n))
2671     (or no-recenter
2672         (ediff-recenter 'no-rehighlight)))
2673
2674   (let ((control-buf ediff-control-buffer))
2675     (unwind-protect
2676         (progn
2677           (or (eq flag 'select-only)
2678               (ediff-unselect-difference ediff-current-difference))
2679
2680           (or (eq flag 'unselect-only)
2681               (ediff-select-difference n))
2682           (setq ediff-current-difference n)
2683           ) ; end protected section
2684
2685       (ediff-eval-in-buffer control-buf (ediff-refresh-mode-lines))
2686       )))
2687
2688
2689 (defun ediff-read-file-name (prompt default-dir default-file)
2690 ; This is a modified version of a similar function in `emerge.el'.
2691 ; PROMPT should not have trailing ': ', so that it can be modified
2692 ; according to context.
2693 ; If default-file is set, it should be used as the default value.
2694 ; If default-dir is non-nil, use it as the default directory.
2695 ; Otherwise, use the value of Emacs' variable `default-directory.'
2696
2697   ;; hack default-dir if it is not set
2698   (setq default-dir
2699         (file-name-as-directory
2700          (ediff-abbreviate-file-name
2701           (expand-file-name (or default-dir
2702                                 (and default-file
2703                                      (file-name-directory default-file))
2704                                 default-directory)))))
2705
2706   ;; strip the directory from default-file
2707   (if default-file
2708       (setq default-file (file-name-nondirectory default-file)))
2709   (if (string= default-file "")
2710       (setq default-file nil))
2711
2712   (let (f)
2713     (setq f (expand-file-name
2714              (read-file-name
2715               (format "%s%s "
2716                       prompt
2717                       (cond (default-file
2718                               (concat " (default " default-file "):"))
2719                             (t (concat " (default " default-dir "):"))))
2720               default-dir
2721               (or default-file default-dir)
2722               t  ; must match, no-confirm
2723               (if default-file (file-name-directory default-file))
2724               )
2725              default-dir
2726              ))
2727     ;; If user enters a directory name, expand the default file in that
2728     ;; directory.  This allows the user to enter a directory name for the
2729     ;; B-file and diff against the default-file in that directory instead
2730     ;; of a DIRED listing!
2731     (if (and (file-directory-p f) default-file)
2732         (setq f (expand-file-name
2733                  (file-name-nondirectory default-file) f)))
2734     f))
2735
2736 ;; If PREFIX is given, then it is used as a prefix for the temp file
2737 ;; name. Otherwise, `ediff_' is used. If FILE is given, use this
2738 ;; file and don't create a new one.
2739 ;; On MS-DOS, make sure the prefix isn't longer than 7 characters, or
2740 ;; else `make-temp-name' isn't guaranteed to return a unique filename.
2741 ;; Also, save buffer from START to END in the file.
2742 ;; START defaults to (point-min), END to (point-max)
2743 (defun ediff-make-temp-file (buff &optional prefix given-file start end)
2744   (let ((p (or prefix "ediff"))
2745         f)
2746     (if (and (eq system-type 'ms-dos) (> (length p) 7))
2747         (setq p (substring p 0 7)))
2748
2749     (setq f (concat ediff-temp-file-prefix p)
2750           f (cond (given-file)
2751                   ((find-file-name-handler f 'find-file-noselect)
2752                    ;; to thwart file handlers in write-region, e.g., if file
2753                    ;; name ends with .Z or .gz
2754                    ;; This is needed so that patches produced by ediff will
2755                    ;; have more meaningful names
2756                    (make-temp-name f))
2757                   ;; Prefix is most often the same as the file name for the
2758                   ;; variant. Here we are trying to use the original file name
2759                   ;; but in the temp directory.
2760                   ((and prefix (not (file-exists-p f))) f)
2761                   ;; If a file with the orig name exists, add some random stuff
2762                   ;; to it.
2763                   (t (make-temp-name f))))
2764
2765     ;; create the file
2766     (ediff-eval-in-buffer buff
2767       (write-region (if start start (point-min))
2768                     (if end end (point-max))
2769                     f
2770                     nil          ; don't append---erase
2771                     'no-message)
2772       (set-file-modes f ediff-temp-file-mode)
2773       (ediff-convert-standard-filename (expand-file-name f)))))
2774
2775 ;; Quote metacharacters (using \) when executing diff in Unix, but not in
2776 ;; EMX OS/2
2777 ;;(defun ediff-protect-metachars (str)
2778 ;;  (or (memq system-type '(emx vax-vms axp-vms))
2779 ;;      (let ((limit 0))
2780 ;;      (while (string-match ediff-metachars str limit)
2781 ;;        (setq str (concat (substring str 0 (match-beginning 0))
2782 ;;                          "\\"
2783 ;;                          (substring str (match-beginning 0))))
2784 ;;        (setq limit (1+ (match-end 0))))))
2785 ;;  str)
2786
2787 ;; Make sure the current buffer (for a file) has the same contents as the
2788 ;; file on disk, and attempt to remedy the situation if not.
2789 ;; Signal an error if we can't make them the same, or the user doesn't want
2790 ;; to do what is necessary to make them the same.
2791 ;; Also, Ediff always offers to revert obsolete buffers, whether they
2792 ;; are modified or not.
2793 (defun ediff-verify-file-buffer (&optional file-magic)
2794   ;; First check if the file has been modified since the buffer visited it.
2795   (if (verify-visited-file-modtime (current-buffer))
2796       (if (buffer-modified-p)
2797           ;; If buffer is not obsolete and is modified, offer to save
2798           (if (yes-or-no-p
2799                (format "Buffer out of sync with visited file. Save file %s? "
2800                        buffer-file-name))
2801               (condition-case nil
2802                   (save-buffer)
2803                 (error
2804                  (beep)
2805                  (message "Couldn't save %s" buffer-file-name)))
2806             (error "Buffer is out of sync for file %s" buffer-file-name))
2807         ;; If buffer is not obsolete and is not modified, do nothing
2808         nil)
2809     ;; If buffer is obsolete, offer to revert
2810     (if (yes-or-no-p
2811          (format "Buffer is out of sync with visited file. REVERT file %s? "
2812                  buffer-file-name))
2813         (progn
2814           (if file-magic
2815               (erase-buffer))
2816           (revert-buffer t t))
2817       (error "Buffer out of sync for file %s" buffer-file-name))))
2818
2819
2820 (defun ediff-save-buffer (arg)
2821   "Safe way of saving buffers A, B, C, and the diff output.
2822 `wa' saves buffer A, `wb' saves buffer B, `wc' saves buffer C,
2823 and `wd' saves the diff output.
2824
2825 With prefix argument, `wd' saves plain diff output.
2826 Without an argument, it saves customized diff argument, if available
2827 \(and plain output, if customized output was not generated\)."
2828   (interactive "P")
2829   (ediff-barf-if-not-control-buffer)
2830   (ediff-compute-custom-diffs-maybe)
2831   (ediff-eval-in-buffer
2832       (cond ((memq last-command-char '(?a ?b ?c))
2833              (ediff-get-buffer
2834               (ediff-char-to-buftype last-command-char)))
2835             ((eq last-command-char ?d)
2836              (message "Saving diff output ...")
2837              (sit-for 1) ; let the user see the message
2838              (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
2839                     ediff-diff-buffer)
2840                    ((ediff-buffer-live-p ediff-custom-diff-buffer)
2841                     ediff-custom-diff-buffer)
2842                    ((ediff-buffer-live-p ediff-diff-buffer)
2843                     ediff-diff-buffer)
2844                    (t (error "Output from `diff' not found"))))
2845             )
2846     (save-buffer)))
2847
2848 (defun ediff-compute-custom-diffs-maybe ()
2849   (let ((buf-A-file-name (buffer-file-name ediff-buffer-A))
2850         (buf-B-file-name (buffer-file-name ediff-buffer-B))
2851         file-A file-B)
2852     (if (stringp buf-A-file-name)
2853         (setq buf-A-file-name (file-name-nondirectory buf-A-file-name)))
2854     (if (stringp buf-B-file-name)
2855         (setq buf-B-file-name (file-name-nondirectory buf-B-file-name)))
2856     (setq file-A (ediff-make-temp-file ediff-buffer-A buf-A-file-name)
2857           file-B (ediff-make-temp-file ediff-buffer-B buf-B-file-name))
2858
2859     (or (ediff-buffer-live-p ediff-custom-diff-buffer)
2860         (setq ediff-custom-diff-buffer
2861               (get-buffer-create
2862                (ediff-unique-buffer-name "*ediff-custom-diff" "*"))))
2863     (ediff-exec-process
2864      ediff-custom-diff-program ediff-custom-diff-buffer 'synchronize
2865      ediff-custom-diff-options file-A file-B)
2866     (delete-file file-A)
2867     (delete-file file-B)
2868     ))
2869
2870 (defun ediff-show-diff-output (arg)
2871   (interactive "P")
2872   (ediff-barf-if-not-control-buffer)
2873   (ediff-compute-custom-diffs-maybe)
2874   (save-excursion
2875     (ediff-skip-unsuitable-frames ' ok-unsplittable))
2876   (let ((buf (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
2877                     ediff-diff-buffer)
2878                    ((ediff-buffer-live-p ediff-custom-diff-buffer)
2879                     ediff-custom-diff-buffer)
2880                    ((ediff-buffer-live-p ediff-diff-buffer)
2881                     ediff-diff-buffer)
2882                    (t
2883                     (beep)
2884                     (message "Output from `diff' not found")
2885                     nil))))
2886     (if buf
2887         (progn
2888           (ediff-eval-in-buffer buf
2889             (goto-char (point-min)))
2890           (switch-to-buffer buf)
2891           (raise-frame (selected-frame)))))
2892   (if (frame-live-p ediff-control-frame)
2893       (ediff-reset-mouse ediff-control-frame))
2894   (if (window-live-p ediff-control-window)
2895       (select-window ediff-control-window)))
2896
2897
2898 (defun ediff-inferior-compare-regions ()
2899   "Compare regions in an active Ediff session.
2900 Like ediff-regions-linewise but is called from under an active Ediff session on
2901 the files that belong to that session.
2902
2903 After quitting the session invoked via this function, type C-l to the parent
2904 Ediff Control Panel to restore highlighting."
2905   (interactive)
2906   (let ((answer "")
2907         (possibilities (list ?A ?B ?C))
2908         (zmacs-regions t)
2909         quit-now
2910         begA begB endA endB bufA bufB)
2911
2912     (cond ((ediff-merge-job)
2913            (setq bufB ediff-buffer-C)
2914            (while (cond ((memq answer '(?A ?a))
2915                          (setq bufA ediff-buffer-A)
2916                          nil)
2917                         ((memq answer '(?B ?b))
2918                          (setq bufA ediff-buffer-B)
2919                          nil)
2920                         ((equal answer ""))
2921                         (t (beep 1)
2922                            (message "Valid values are A or B")
2923                            (sit-for 2)
2924                            t))
2925              (let ((cursor-in-echo-area t))
2926                (message "Which buffer to compare to the merge buffer (A/B)? ")
2927                (setq answer (read-char-exclusive)))))
2928
2929           ((ediff-3way-comparison-job)
2930            (while (cond ((memq answer possibilities)
2931                          (setq possibilities (delq answer possibilities))
2932                          (setq bufA
2933                                (eval
2934                                 (intern (format "ediff-buffer-%c" answer))))
2935                          nil)
2936                         ((equal answer ""))
2937                         (t (beep 1)
2938                            (message
2939                             "Valid values are %s"
2940                             (mapconcat 'char-to-string possibilities " or "))
2941                            (sit-for 2)
2942                            t))
2943              (let ((cursor-in-echo-area t))
2944                (message "Enter the 1st buffer you want to compare (%s): "
2945                         (mapconcat 'char-to-string possibilities "/"))
2946                (setq answer (capitalize (read-char-exclusive)))))
2947            (setq answer "") ; silence error msg
2948            (while (cond ((memq answer possibilities)
2949                          (setq possibilities (delq answer possibilities))
2950                          (setq bufB
2951                                (eval
2952                                 (intern (format "ediff-buffer-%c" answer))))
2953                          nil)
2954                         ((equal answer ""))
2955                         (t (beep 1)
2956                            (message
2957                             "Valid values are %s"
2958                             (mapconcat 'char-to-string possibilities " or "))
2959                            (sit-for 2)
2960                            t))
2961              (let ((cursor-in-echo-area t))
2962                (message "Enter the 2nd buffer you want to compare (%s): "
2963                         (mapconcat 'char-to-string possibilities "/"))
2964                (setq answer (capitalize (read-char-exclusive))))))
2965           (t ; 2way comparison
2966            (setq bufA ediff-buffer-A
2967                  bufB ediff-buffer-B)))
2968
2969     (ediff-eval-in-buffer bufA
2970       (or (mark t)
2971           (error "You forgot to specify a region in buffer %s" (buffer-name)))
2972       (setq begA (region-beginning)
2973             endA (region-end))
2974       (goto-char begA)
2975       (beginning-of-line)
2976       (setq begA (point))
2977       (goto-char endA)
2978       (end-of-line)
2979       (or (eobp) (forward-char)) ; include the newline char
2980       (setq endA (point)))
2981     (ediff-eval-in-buffer bufB
2982       (or (mark t)
2983           (error "You forgot to specify a region in buffer %s" (buffer-name)))
2984       (setq begB (region-beginning)
2985             endB (region-end))
2986       (goto-char begB)
2987       (beginning-of-line)
2988       (setq begB (point))
2989       (goto-char endB)
2990       (end-of-line)
2991       (or (eobp) (forward-char)) ; include the newline char
2992       (setq endB (point)))
2993
2994     (ediff-unselect-and-select-difference
2995      ediff-current-difference 'unselect-only)
2996     (ediff-paint-background-regions 'unhighlight)
2997
2998     (ediff-eval-in-buffer bufA
2999       (goto-char begA)
3000       (set-mark endA)
3001       (narrow-to-region begA endA)
3002       ;; (ediff-activate-mark)
3003       )
3004     ;; (sit-for 0)
3005     (ediff-eval-in-buffer bufB
3006       (goto-char begB)
3007       (set-mark endB)
3008       (narrow-to-region begB endB)
3009       ;; (ediff-activate-mark)
3010       )
3011     ;; (sit-for 0)
3012
3013     (or (y-or-n-p
3014          "Please check the selected regions. Continue? ")
3015         (setq quit-now t))
3016
3017     (ediff-eval-in-buffer bufA
3018       (widen))
3019     (ediff-eval-in-buffer bufB
3020       (widen))
3021     (if quit-now
3022         (error "Thank you. Come back another day..."))
3023
3024     (ediff-regions-internal
3025      bufA begA endA bufB begB endB
3026      nil                        ; startup hook
3027      'ediff-regions-linewise    ; job name
3028      nil)                       ; no word mode
3029     ))
3030
3031
3032
3033 (defun ediff-remove-flags-from-buffer (buffer overlay)
3034   (ediff-eval-in-buffer buffer
3035     (let ((inhibit-read-only t))
3036       (if ediff-xemacs-p
3037           (ediff-overlay-put overlay 'begin-glyph nil)
3038         (ediff-overlay-put overlay 'before-string nil))
3039
3040       (if ediff-xemacs-p
3041           (ediff-overlay-put overlay 'end-glyph nil)
3042         (ediff-overlay-put overlay 'after-string nil))
3043       )))
3044
3045
3046
3047 (defun ediff-place-flags-in-buffer (buf-type buffer ctl-buffer diff)
3048   (ediff-eval-in-buffer buffer
3049     (ediff-place-flags-in-buffer1 buf-type ctl-buffer diff)))
3050
3051
3052 (defun ediff-place-flags-in-buffer1 (buf-type ctl-buffer diff-no)
3053   (let* ((curr-overl (ediff-eval-in-buffer ctl-buffer
3054                        (ediff-get-diff-overlay diff-no buf-type)))
3055          (before (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer))
3056          after beg-of-line flag)
3057
3058     ;; insert flag before the difference
3059     (goto-char before)
3060     (setq beg-of-line (bolp))
3061
3062     (setq flag (ediff-eval-in-buffer ctl-buffer
3063                  (if (eq ediff-highlighting-style 'ascii)
3064                      (if beg-of-line
3065                          ediff-before-flag-bol ediff-before-flag-mol))))
3066
3067     ;; insert the flag itself
3068     (if ediff-xemacs-p
3069         (ediff-overlay-put curr-overl 'begin-glyph flag)
3070       (ediff-overlay-put curr-overl 'before-string flag))
3071
3072     ;; insert the flag after the difference
3073     ;; `after' must be set here, after the before-flag was inserted
3074     (setq after (ediff-get-diff-posn buf-type 'end diff-no ctl-buffer))
3075     (goto-char after)
3076     (setq beg-of-line (bolp))
3077
3078     (setq flag (ediff-eval-in-buffer ctl-buffer
3079                  (if (eq ediff-highlighting-style 'ascii)
3080                      (if beg-of-line
3081                          ediff-after-flag-eol ediff-after-flag-mol))))
3082
3083     ;; insert the flag itself
3084     (if ediff-xemacs-p
3085         (ediff-overlay-put curr-overl 'end-glyph flag)
3086       (ediff-overlay-put curr-overl 'after-string flag))
3087     ))
3088
3089
3090 ;; Returns positions of difference sectors in the BUF-TYPE buffer.
3091 ;; BUF-TYPE should be a symbol -- `A', `B', or `C'.
3092 ;; POS is either `beg' or `end'--it specifies whether you want the position at
3093 ;; the beginning of a difference or at the end.
3094 ;;
3095 ;; The optional argument N says which difference (default:
3096 ;; `ediff-current-difference'). N is the internal difference number (1- what
3097 ;; the user sees).  The optional argument CONTROL-BUF says
3098 ;; which control buffer is in effect in case it is not the current
3099 ;; buffer.
3100 (defun ediff-get-diff-posn (buf-type pos &optional n control-buf)
3101   (let (diff-overlay)
3102     (or control-buf
3103         (setq control-buf (current-buffer)))
3104
3105     (ediff-eval-in-buffer control-buf
3106       (or n  (setq n ediff-current-difference))
3107       (if (or (< n 0) (>= n ediff-number-of-differences))
3108           (if (> ediff-number-of-differences 0)
3109               (error ediff-BAD-DIFF-NUMBER
3110                      this-command (1+ n) ediff-number-of-differences)
3111             (error ediff-NO-DIFFERENCES)))
3112       (setq diff-overlay (ediff-get-diff-overlay n buf-type)))
3113     (if (not (ediff-buffer-live-p (ediff-overlay-buffer diff-overlay)))
3114         (error ediff-KILLED-VITAL-BUFFER))
3115     (if (eq pos 'beg)
3116         (ediff-overlay-start diff-overlay)
3117       (ediff-overlay-end diff-overlay))
3118     ))
3119
3120
3121 ;; Restore highlighting to what it should be according to ediff-use-faces,
3122 ;; ediff-highlighting-style, and ediff-highlight-all-diffs variables.
3123 (defun ediff-restore-highlighting (&optional ctl-buf)
3124   (ediff-eval-in-buffer (or ctl-buf (current-buffer))
3125     (if (and (ediff-has-face-support-p)
3126              ediff-use-faces
3127              ediff-highlight-all-diffs)
3128         (ediff-paint-background-regions))
3129     (ediff-select-difference ediff-current-difference)))
3130
3131
3132
3133 ;; null out difference overlays so they won't slow down future
3134 ;; editing operations
3135 ;; VEC is either a difference vector or a fine-diff vector
3136 (defun ediff-clear-diff-vector (vec-var &optional fine-diffs-also)
3137   (if (vectorp (symbol-value vec-var))
3138       (mapcar (function
3139                (lambda (elt)
3140                  (ediff-delete-overlay
3141                   (ediff-get-diff-overlay-from-diff-record elt))
3142                  (if fine-diffs-also
3143                      (ediff-clear-fine-diff-vector elt))
3144                  ))
3145               (symbol-value vec-var)))
3146   ;; allow them to be garbage collected
3147   (set vec-var nil))
3148
3149
3150 \f
3151 ;;; Misc
3152
3153 ;; In Emacs, this just makes overlay. In the future, when Emacs will start
3154 ;; supporting sticky overlays, this function will make a sticky overlay.
3155 ;; BEG and END are expressions telling where overlay starts.
3156 ;; If they are numbers or buffers, then all is well. Otherwise, they must
3157 ;; be expressions to be evaluated in buffer BUF in order to get the overlay
3158 ;; bounds.
3159 ;; If BUFF is not a live buffer, then return nil; otherwise, return the
3160 ;; newly created overlay.
3161 (defun ediff-make-bullet-proof-overlay (beg end buff)
3162   (if (ediff-buffer-live-p buff)
3163       (let (overl)
3164         (ediff-eval-in-buffer buff
3165           (or (number-or-marker-p beg)
3166               (setq beg (eval beg)))
3167           (or (number-or-marker-p end)
3168               (setq end (eval end)))
3169           (setq overl
3170                 (if ediff-xemacs-p
3171                     (make-extent beg end buff)
3172                   ;; advance front and rear of the overlay
3173                   (make-overlay beg end buff nil 'rear-advance)))
3174
3175           ;; never detach
3176           (ediff-overlay-put
3177            overl (if ediff-emacs-p 'evaporate 'detachable) nil)
3178           ;; make vip-minibuffer-overlay open-ended
3179           ;; In emacs, it is made open ended at creation time
3180           (if ediff-xemacs-p
3181               (progn
3182                 (ediff-overlay-put overl 'start-open nil)
3183                 (ediff-overlay-put overl 'end-open nil)))
3184           (ediff-overlay-put overl 'ediff-diff-num 0)
3185           overl))))
3186
3187 (defsubst ediff-overlay-start (overl)
3188   (if (ediff-overlayp overl)
3189       (if ediff-emacs-p
3190           (overlay-start overl)
3191         (extent-start-position overl))))
3192
3193 (defsubst ediff-overlay-end  (overl)
3194   (if (ediff-overlayp overl)
3195       (if ediff-emacs-p
3196           (overlay-end overl)
3197         (extent-end-position overl))))
3198
3199
3200 ;; Like other-buffer, but prefers visible buffers and ignores temporary or
3201 ;; other insignificant buffers (those beginning with "^[ *]").
3202 ;; Gets one arg--buffer name or a list of buffer names (it won't return
3203 ;; these buffers).
3204 (defun ediff-other-buffer (buff)
3205   (if (not (listp buff)) (setq buff (list buff)))
3206   (let* ((frame-buffers (buffer-list))
3207          (significant-buffers
3208           (mapcar
3209            (function (lambda (x)
3210                        (cond ((member (buffer-name x) buff)
3211                               nil)
3212                              ((not (ediff-get-visible-buffer-window x))
3213                               nil)
3214                              ((string-match "^ " (buffer-name x))
3215                               nil)
3216                              (t x))))
3217            frame-buffers))
3218          (buffers (delq nil significant-buffers))
3219          less-significant-buffers)
3220
3221     (cond (buffers (car buffers))
3222           ;; try also buffers that are not displayed in windows
3223           ((setq less-significant-buffers
3224                  (delq nil
3225                        (mapcar
3226                         (function
3227                          (lambda (x)
3228                            (cond ((member (buffer-name x) buff) nil)
3229                                  ((string-match "^[ *]" (buffer-name x)) nil)
3230                                  (t x))))
3231                         frame-buffers)))
3232            (car less-significant-buffers))
3233           (t (other-buffer (current-buffer))))
3234     ))
3235
3236
3237 ;; Construct a unique buffer name.
3238 ;; The first one tried is prefixsuffix, then prefix<2>suffix,
3239 ;; prefix<3>suffix, etc.
3240 (defun ediff-unique-buffer-name (prefix suffix)
3241   (if (null (get-buffer (concat prefix suffix)))
3242       (concat prefix suffix)
3243     (let ((n 2))
3244       (while (get-buffer (format "%s<%d>%s" prefix n suffix))
3245         (setq n (1+ n)))
3246       (format "%s<%d>%s" prefix n suffix))))
3247
3248
3249 ;; splits at a white space, returns a list
3250 (defun ediff-split-string (string)
3251   (let ((start 0)
3252         (result '())
3253         substr)
3254     (while (string-match "[ \t]+" string start)
3255       (let ((match (string-match "[ \t]+" string start)))
3256         (setq substr (substring string start match))
3257         (if (> (length substr) 0)
3258             (setq result (cons substr result)))
3259         (setq start (match-end 0))))
3260     (setq substr (substring string start nil))
3261     (if (> (length substr) 0)
3262         (setq result (cons substr result)))
3263     (nreverse result)))
3264
3265 (defun ediff-submit-report ()
3266   "Submit bug report on Ediff."
3267   (interactive)
3268   (ediff-barf-if-not-control-buffer)
3269   (let ((reporter-prompt-for-summary-p t)
3270         (ctl-buf ediff-control-buffer)
3271         (ediff-device-type (ediff-device-type))
3272         varlist salutation buffer-name)
3273     (setq varlist '(ediff-diff-program ediff-diff-options
3274                     ediff-patch-program ediff-patch-options
3275                     ediff-shell
3276                     ediff-use-faces
3277                     ediff-auto-refine ediff-highlighting-style
3278                     ediff-buffer-A ediff-buffer-B ediff-control-buffer
3279                     ediff-forward-word-function
3280                     ediff-control-frame
3281                     ediff-control-frame-parameters
3282                     ediff-control-frame-position-function
3283                     ediff-prefer-iconified-control-frame
3284                     ediff-window-setup-function
3285                     ediff-split-window-function
3286                     ediff-job-name
3287                     ediff-word-mode
3288                     buffer-name
3289                     ediff-device-type
3290                     ))
3291     (setq salutation "
3292 Congratulations! You may have unearthed a bug in Ediff!
3293
3294 Please make a concise and accurate summary of what happened
3295 and mail it to the address above.
3296 -----------------------------------------------------------
3297 ")
3298
3299     (ediff-skip-unsuitable-frames)
3300     (ediff-reset-mouse)
3301
3302     (switch-to-buffer ediff-msg-buffer)
3303     (erase-buffer)
3304     (delete-other-windows)
3305     (insert "
3306 Please read this first:
3307 ----------------------
3308
3309 Some ``bugs'' may actually be no bugs at all. For instance, if you are
3310 reporting that certain difference regions are not matched as you think they
3311 should, this is most likely due to the way Unix diff program decides what
3312 constitutes a difference region. Ediff is an Emacs interface to diff, and
3313 it has nothing to do with those decisions---it only takes the output from
3314 diff and presents it in a way that is better suited for human browsing and
3315 manipulation.
3316
3317 If Emacs happens to dump core, this is NOT an Ediff problem---it is
3318 an Emacs bug. Report this to Emacs maintainers.
3319
3320 Another popular topic for reports is compilation messages.  Because Ediff
3321 interfaces to several other packages and runs under Emacs and XEmacs,
3322 byte-compilation may produce output like this:
3323
3324        While compiling toplevel forms in file ediff.el:
3325          ** reference to free variable pm-color-alist
3326            ........................
3327        While compiling the end of the data:
3328          ** The following functions are not known to be defined:
3329            ediff-valid-color-p, ediff-set-face,
3330            ........................
3331
3332 These are NOT errors, but inevitable warnings, which ought to be ignored.
3333
3334 Please do not report those and similar things.  However, comments and
3335 suggestions are always welcome.
3336
3337 Mail anyway? (y or n) ")
3338
3339     (if (y-or-n-p "Mail anyway? ")
3340         (progn
3341           (if (ediff-buffer-live-p ctl-buf)
3342               (set-buffer ctl-buf))
3343           (setq buffer-name (buffer-name))
3344           (require 'reporter)
3345           (reporter-submit-bug-report "kifer@cs.sunysb.edu"
3346                                       (ediff-version)
3347                                       varlist
3348                                       nil
3349                                       'delete-other-windows
3350                                       salutation))
3351       (bury-buffer)
3352       (beep 1)(message "Bug report aborted")
3353       (if (ediff-buffer-live-p ctl-buf)
3354           (ediff-eval-in-buffer ctl-buf
3355             (ediff-recenter 'no-rehighlight))))
3356     ))
3357
3358
3359 (defun ediff-deactivate-mark ()
3360   (if ediff-xemacs-p
3361           (zmacs-deactivate-region)
3362         (deactivate-mark)))
3363 (defun ediff-activate-mark ()
3364   (if ediff-emacs-p
3365       (setq mark-active t)
3366     (zmacs-activate-region)))
3367
3368 (cond ((fboundp 'nuke-selective-display)
3369        ;; XEmacs 19.12 has nuke-selective-display
3370        (fset 'ediff-nuke-selective-display 'nuke-selective-display))
3371       (t
3372        (defun ediff-nuke-selective-display ()
3373          (save-excursion
3374            (save-restriction
3375              (widen)
3376              (goto-char (point-min))
3377              (let ((mod-p (buffer-modified-p))
3378                    buffer-read-only end)
3379                (and (eq t selective-display)
3380                     (while (search-forward "\^M" nil t)
3381                       (end-of-line)
3382                       (setq end (point))
3383                       (beginning-of-line)
3384                       (while (search-forward "\^M" end t)
3385                         (delete-char -1)
3386                         (insert "\^J"))))
3387                (set-buffer-modified-p mod-p)
3388                (setq selective-display nil)))))
3389        ))
3390
3391
3392 ;; The next two are modified versions from emerge.el.
3393 ;; VARS must be a list of symbols
3394 ;; ediff-save-variables returns an association list: ((var . val) ...)
3395 (defsubst ediff-save-variables (vars)
3396   (mapcar (function (lambda (v) (cons v (symbol-value v))))
3397           vars))
3398 ;; VARS is a list of variable symbols.
3399 (defun ediff-restore-variables (vars assoc-list)
3400   (while vars
3401     (set (car vars) (cdr (assoc (car vars) assoc-list)))
3402     (setq vars (cdr vars))))
3403
3404 (defun ediff-change-saved-variable (var value buf-type)
3405   (let* ((assoc-list
3406           (symbol-value (intern
3407                          (concat "ediff-buffer-values-orig-"
3408                                  (symbol-name buf-type)))))
3409          (assoc-elt (assoc var assoc-list)))
3410   (if assoc-elt
3411       (setcdr assoc-elt value))))
3412
3413
3414 ;; must execute in control buf
3415 (defun ediff-save-protected-variables ()
3416   (setq ediff-buffer-values-orig-A
3417         (ediff-eval-in-buffer ediff-buffer-A
3418           (ediff-save-variables ediff-protected-variables)))
3419   (setq ediff-buffer-values-orig-B
3420         (ediff-eval-in-buffer ediff-buffer-B
3421           (ediff-save-variables ediff-protected-variables)))
3422   (if ediff-3way-comparison-job
3423       (setq ediff-buffer-values-orig-C
3424             (ediff-eval-in-buffer ediff-buffer-C
3425               (ediff-save-variables ediff-protected-variables))))
3426   (if (ediff-buffer-live-p ediff-ancestor-buffer)
3427       (setq ediff-buffer-values-orig-Ancestor
3428             (ediff-eval-in-buffer ediff-ancestor-buffer
3429               (ediff-save-variables ediff-protected-variables)))))
3430
3431 ;; must execute in control buf
3432 (defun ediff-restore-protected-variables ()
3433   (let ((values-A ediff-buffer-values-orig-A)
3434         (values-B ediff-buffer-values-orig-B)
3435         (values-C ediff-buffer-values-orig-C)
3436         (values-Ancestor ediff-buffer-values-orig-Ancestor))
3437     (ediff-eval-in-buffer ediff-buffer-A
3438       (ediff-restore-variables ediff-protected-variables values-A))
3439     (ediff-eval-in-buffer ediff-buffer-B
3440       (ediff-restore-variables ediff-protected-variables values-B))
3441     (if ediff-3way-comparison-job
3442         (ediff-eval-in-buffer ediff-buffer-C
3443           (ediff-restore-variables ediff-protected-variables values-C)))
3444     (if (ediff-buffer-live-p ediff-ancestor-buffer)
3445         (ediff-eval-in-buffer ediff-ancestor-buffer
3446           (ediff-restore-variables ediff-protected-variables values-Ancestor)))
3447     ))
3448
3449 ;; save BUFFER in FILE. used in hooks.
3450 (defun ediff-save-buffer-in-file (buffer file)
3451   (ediff-eval-in-buffer buffer
3452     (write-file file)))
3453
3454
3455 ;;; Debug
3456
3457 (ediff-defvar-local ediff-command-begin-time '(0 0 0) "")
3458
3459 ;; calculate time used by command
3460 (defun ediff-calc-command-time ()
3461   (let ((end (current-time))
3462         micro sec)
3463     (setq micro
3464           (if (>= (nth 2 end) (nth 2 ediff-command-begin-time))
3465               (- (nth 2 end) (nth 2 ediff-command-begin-time))
3466             (+ (nth 2 end) (- 1000000 (nth 2 ediff-command-begin-time)))))
3467     (setq sec (- (nth 1 end) (nth 1 ediff-command-begin-time)))
3468     (or (equal ediff-command-begin-time '(0 0 0))
3469         (message "Elapsed time: %d second(s) + %d microsecond(s)" sec micro))))
3470
3471 (defsubst ediff-save-time ()
3472   (setq ediff-command-begin-time (current-time)))
3473
3474 (defun ediff-profile ()
3475   "Toggle profiling Ediff commands."
3476   (interactive)
3477   (ediff-barf-if-not-control-buffer)
3478   (make-local-hook 'post-command-hook)
3479   (let ((pre-hook 'pre-command-hook)
3480         (post-hook 'post-command-hook))
3481     (if (not (equal ediff-command-begin-time '(0 0 0)))
3482         (progn (remove-hook pre-hook 'ediff-save-time)
3483                (remove-hook post-hook 'ediff-calc-command-time)
3484                (setq ediff-command-begin-time '(0 0 0))
3485                (message "Ediff profiling disabled"))
3486       (add-hook pre-hook 'ediff-save-time t t)
3487       (add-hook post-hook 'ediff-calc-command-time nil t)
3488       (message "Ediff profiling enabled"))))
3489
3490 (defun ediff-print-diff-vector (diff-vector-var)
3491   (princ (format "\n*** %S ***\n" diff-vector-var))
3492   (mapcar (function
3493            (lambda (overl-vec)
3494              (princ
3495               (format
3496                "Diff %d: \tOverlay:    %S
3497 \t\tFine diffs: %s
3498 \t\tNo-fine-diff-flag: %S
3499 \t\tState-of-diff:\t   %S
3500 \t\tState-of-merge:\t   %S
3501 "
3502                (1+ (ediff-overlay-get (aref overl-vec 0) 'ediff-diff-num))
3503                (aref overl-vec 0)
3504                ;; fine-diff-vector
3505                (if (= (length (aref overl-vec 1)) 0)
3506                    "none\n"
3507                  (mapconcat 'prin1-to-string
3508                             (aref overl-vec 1) "\n\t\t\t    "))
3509                (aref overl-vec 2) ; no fine diff flag
3510                (aref overl-vec 3) ; state-of-diff
3511                (aref overl-vec 4) ; state-of-merge
3512                ))))
3513           (eval diff-vector-var)))
3514
3515
3516
3517 (defun ediff-debug-info ()
3518   (interactive)
3519   (ediff-barf-if-not-control-buffer)
3520   (with-output-to-temp-buffer ediff-debug-buffer
3521     (princ (format "\nCtl buffer: %S\n" ediff-control-buffer))
3522     (ediff-print-diff-vector (intern "ediff-difference-vector-A"))
3523     (ediff-print-diff-vector (intern "ediff-difference-vector-B"))
3524     (ediff-print-diff-vector (intern "ediff-difference-vector-C"))
3525     (ediff-print-diff-vector (intern "ediff-difference-vector-Ancestor"))
3526     ))
3527
3528
3529 ;;; General utilities
3530
3531 ;; this uses comparison-func to decide who is a member
3532 (defun ediff-member (elt lis comparison-func)
3533   (while (and lis (not (funcall comparison-func (car lis) elt)))
3534     (setq lis (cdr lis)))
3535   lis)
3536
3537 ;; this uses comparison-func to decide who is a member, and this determines how
3538 ;; intersection looks like
3539 (defun ediff-intersection (lis1 lis2 comparison-func)
3540   (let ((result (list 'a)))
3541     (while lis1
3542       (if (ediff-member (car lis1) lis2 comparison-func)
3543           (nconc result (list (car lis1))))
3544       (setq lis1 (cdr lis1)))
3545     (cdr result)))
3546
3547
3548 ;; eliminates duplicates using comparison-func
3549 (defun ediff-union (lis1 lis2 comparison-func)
3550   (let ((result (list 'a)))
3551     (while lis1
3552       (or (ediff-member (car lis1) (cdr result) comparison-func)
3553           (nconc result (list (car lis1))))
3554       (setq lis1 (cdr lis1)))
3555     (while lis2
3556       (or (ediff-member (car lis2) (cdr result) comparison-func)
3557           (nconc result (list (car lis2))))
3558       (setq lis2 (cdr lis2)))
3559     (cdr result)))
3560
3561 ;; eliminates duplicates using comparison-func
3562 (defun ediff-set-difference (lis1 lis2 comparison-func)
3563   (let ((result (list 'a)))
3564     (while lis1
3565       (or (ediff-member (car lis1) (cdr result) comparison-func)
3566           (ediff-member (car lis1) lis2 comparison-func)
3567           (nconc result (list (car lis1))))
3568       (setq lis1 (cdr lis1)))
3569     (cdr result)))
3570
3571 (defun ediff-copy-list (list)
3572   (if (consp list)
3573       ;;;(let ((res nil))
3574       ;;;  (while (consp list) (push (pop list) res))
3575       ;;;  (prog1 (nreverse res) (setcdr res list)))
3576       (let (res elt)
3577         (while (consp list)
3578           (setq elt (car list)
3579                 res (cons elt res)
3580                 list (cdr list)))
3581         (nreverse res))
3582     (car list)))
3583
3584
3585 ;; don't report error if version control package wasn't found
3586 ;;(ediff-load-version-control 'silent)
3587
3588 (run-hooks 'ediff-load-hook)
3589
3590
3591 ;;; Local Variables:
3592 ;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
3593 ;;; eval: (put 'ediff-eval-in-buffer 'lisp-indent-hook 1)
3594 ;;; eval: (put 'ediff-eval-in-buffer 'edebug-form-spec '(form body))
3595 ;;; End:
3596
3597 (provide 'ediff-util)
3598
3599 ;;; ediff-util.el ends here