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