lisp/ediff-util.el

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